C++ Academy · Lektion

Heap-allokering med new/delete

Administrér dynamisk hukommelse

Lektion 2 af 413 trin

Heap-allokering med new/delete er en gratis C++ Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i C++ Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. C++ Academy-kurset indeholder 4 lektioner i alt.

Dynamisk hukommelse med new

Operatoren new allokerer et objekt på heapen (det frie lager) og returnerer en pointer til det. Objekter på heapen lever, indtil du eksplicit frigiver dem.

#include <iostream>

int main() {
    int* p = new int(42);   // heap allocation
    std::cout << *p << "\n";
    delete p;               // release it
}

Frigivelse med delete

Hvert new skal matches af præcis ét delete. Hvis du glemmer det, opstår der en hukommelseslækage; hvis du gør det to gange, ødelægges heapen.

#include <iostream>

int main() {
    double* d = new double(3.5);
    std::cout << *d << "\n";
    delete d;     // exactly once
}

Arrays: new[] og delete[]

Brug new[] og det tilsvarende delete[] til arrays. Hvis du blander new[] med almindelig delete, får du udefineret adfærd.

#include <iostream>

int main() {
    int* arr = new int[3]{1, 2, 3};
    for (int i = 0; i < 3; ++i) std::cout << arr[i] << "\n";
    delete[] arr;   // note the [ ]
}

Hvorfor bruge heapen?

Brug heapen, når et objekt skal leve længere end den funktion, der oprettede det, eller når størrelsen først kendes under kørsel. Ellers bør du foretrække stakken.

Levetiden på heapen er manuel

I modsætning til stakken frigiver heapen ikke objekter automatisk. Du bestemmer præcis, hvornår hukommelsen frigives — og du har ansvaret for det.

#include <iostream>

int* makeCounter() {
    return new int(0);   // survives the function
}

int main() {
    int* c = makeCounter();
    std::cout << *c << "\n";
    delete c;
}

Sæt pointere til nullptr efter delete

Efter sletning skal du sætte pointeren til nullptr, så utilsigtet genbrug fejler tydeligt i stedet for at tilgå frigivet hukommelse.

#include <iostream>

int main() {
    int* p = new int(9);
    delete p;
    p = nullptr;     // now p is safe to check
    if (!p) std::cout << "freed\n";
}

Allokering kan mislykkes

Hvis systemet løber tør for hukommelse, kaster new std::bad_alloc. Ved meget store allokeringer er det en reel mulighed.

Buffere med størrelse bestemt under kørsel

Arrays på heapen kan bruge en størrelse, der beregnes under kørsel — det kan arrays på stakken ikke gøre på en portabel måde.

#include <iostream>

int main() {
    int n = 5;
    int* buf = new int[n];
    for (int i = 0; i < n; ++i) buf[i] = i * i;
    std::cout << buf[4] << "\n";
    delete[] buf;
}

Foretræk smarte pointere

Moderne C++ undgår rå new/delete. std::unique_ptr og std::make_unique frigiver automatisk hukommelsen, når pointeren forlader sit virkeområde.

#include <iostream>
#include <memory>

int main() {
    auto p = std::make_unique<int>(42);
    std::cout << *p << "\n";
}   // freed automatically

Omkostningerne ved heapen

Allokering på heapen er langsommere end på stakken: Den leder efter en ledig blok og opdaterer administrationsoplysninger. Hyppige, små allokeringer kan skade ydeevnen.

Match hvert new

Den vigtigste regel er: Hvert new kræver ét delete, og hvert new[] kræver ét delete[]. Endnu bedre er det at lade smarte pointere håndtere det for dig.

Hurtigt tjek

Test din forståelse af allokering på heapen.

Besvar den i den interaktive lektion

Opsamling

Du har lært at allokere på heapen med new/new[] og frigive med delete/delete[]. Objekter på heapen lever længere end deres virkeområde, men kræver manuel oprydning. Match hver allokering, sæt frigivne pointere til nullptr, og foretræk std::unique_ptr i moderne kode.

Gratis at komme i gang

Lær C++ med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 51
Lektioner: 203

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Heap-allokering med new/delete” gratis?

Ja — alle 3 lektioner i læringssporet C++ Academy, inklusive “Heap-allokering med new/delete”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. C++ Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Heap-allokering med new/delete”?

Administrér dynamisk hukommelse Du øver dig i C++ Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på C++ Academy?

Der kræves ingen tidligere erfaring. C++ Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Heap-allokering med new/delete”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne C++ Academy-lektion?

Ja. Alle C++ Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til C++ Academy