C++ Academy · Lektion

Heapallokering med new/delete

Hantera dynamiskt minne

Lektion 2 av 413 steg

Heapallokering med new/delete är en gratis lektion i C++ Academy på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för C++ Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C++ Academy innehåller totalt 4 lektioner.

Dynamiskt minne med new

Operatorn new allokerar ett objekt på heapen (free store) och returnerar en pekare till det. Heapobjekt finns kvar tills du uttryckligen frigör dem.

#include <iostream>

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

Frigöring med delete

Varje new måste matchas av exakt ett delete. Om du glömmer det uppstår en minnesläcka; om du gör det två gånger skadas heapen.

#include <iostream>

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

Arrayer: new[] och delete[]

Använd new[] och motsvarande delete[] för arrayer. Att blanda new[] med vanligt delete ger odefinierat beteende.

#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 [ ]
}

Varför använda heapen

Använd heapen när ett objekt måste överleva funktionen som skapade det, eller när storleken bara är känd vid körning. Föredra annars stacken.

Heapens livslängd är manuell

Till skillnad från stacken frigör heapen inte objekt automatiskt. Du bestämmer exakt när minnet ska frigöras — och du ansvarar för det.

#include <iostream>

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

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

Sätt pekare till nullptr efter delete

Efter borttagningen ska du sätta pekaren till nullptr, så att ett oavsiktligt återanvändande misslyckas tydligt i stället för att komma åt frigjort minne.

#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 misslyckas

Om systemet har slut på minne kastar new ett undantag av typen std::bad_alloc. Vid mycket stora allokeringar är detta en verklig möjlighet.

Buffertar med storlek vid körning

Heaparrayer kan använda en storlek som beräknas vid körning — något som stackarrayer inte kan göra portabelt.

#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;
}

Föredra smarta pekare

Modern C++ undviker rå new/delete. std::unique_ptr och std::make_unique frigör minnet automatiskt när pekaren lämnar sitt scope.

#include <iostream>
#include <memory>

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

Kostnaden för heapen

Heapallokering är långsammare än stacken: den söker efter ett ledigt block och uppdaterar administrativa data. Många små allokeringar kan försämra prestandan.

Matcha varje new

Grundregeln är: varje new behöver ett delete, och varje new[] behöver ett delete[]. Ännu bättre är att låta smarta pekare hantera detta åt dig.

Snabb kontroll

Testa dina kunskaper om heapallokering.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du har lärt dig att allokera på heapen med new/new[] och frigöra med delete/delete[]. Heapobjekt överlever sitt scope men kräver manuell städning. Matcha varje allokering, sätt frigjorda pekare till null och föredra std::unique_ptr i modern kod.

Gratis att börja

Lär dig C++ med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 51
Lektioner: 203

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Heapallokering med new/delete” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen C++ Academy, inklusive ”Heapallokering med new/delete”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i C++ Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Heapallokering med new/delete”?

Hantera dynamiskt minne Ni övar på C++ Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig C++ Academy?

Du behöver inga förkunskaper. Utbildningen i C++ Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Heapallokering med new/delete”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här C++ Academy-lektionen?

Ja. Varje C++ Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till C++ Academy