C++ Academy · Lekcja

Alokacja na stercie z new/delete

Zarządzaj pamięcią dynamiczną

Alokacja na stercie z new/delete to bezpłatna lekcja C++ Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C++ Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C++ Academy zawiera 4 lekcji w sumie.

Pamięć dynamiczna za pomocą new

Operator new alokuje obiekt na stercie (wolnym obszarze pamięci) i zwraca do niego wskaźnik. Obiekty na stercie istnieją do chwili ich jawnego zwolnienia.

#include <iostream>

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

Zwalnianie za pomocą delete

Każdemu new musi odpowiadać dokładnie jedno delete. Pominięcie tego powoduje wyciek pamięci, a wykonanie tego dwa razy uszkadza stertę.

#include <iostream>

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

Tablice: new[] i delete[]

W przypadku tablic używaj new[] i odpowiadającego mu delete[]. Połączenie new[] ze zwykłym delete prowadzi do niezdefiniowanego działania.

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

Dlaczego używać sterty

Używaj sterty, gdy obiekt musi żyć dłużej niż funkcja, która go utworzyła, albo gdy jego rozmiar jest znany dopiero w czasie działania programu. W przeciwnym razie preferuj stos.

Czas życia obiektów na stercie jest zarządzany ręcznie

W przeciwieństwie do stosu sterta nie zwalnia obiektów automatycznie. To Ty dokładnie kontrolujesz moment zwolnienia pamięci — i ponosisz za to odpowiedzialność.

#include <iostream>

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

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

Ustawiaj wskaźniki na nullptr po delete

Po usunięciu obiektu ustaw wskaźnik na nullptr, aby przypadkowe ponowne użycie kończyło się wyraźnym błędem, zamiast odwoływać się do zwolnionej pamięci.

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

Alokacja może się nie powieść

Jeśli systemowi zabraknie pamięci, new zgłasza wyjątek std::bad_alloc. W przypadku bardzo dużych alokacji jest to realna możliwość.

Bufory o rozmiarze ustalanym w czasie działania

Tablice na stercie mogą mieć rozmiar obliczany w czasie działania programu — czego tablice na stosie nie mogą robić w sposób przenośny.

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

Preferuj inteligentne wskaźniki

Współczesny C++ unika bezpośredniego używania new/delete. std::unique_ptr i std::make_unique automatycznie zwalniają pamięć, gdy wskaźnik wyjdzie poza zakres.

#include <iostream>
#include <memory>

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

Koszt korzystania ze sterty

Alokacja na stercie jest wolniejsza niż na stosie: wyszukuje wolny blok i aktualizuje informacje zarządcze. Częste alokowanie bardzo małych obiektów może pogorszyć wydajność.

Dopasuj każde new

Złota zasada: każdemu new potrzebne jest jedno delete, a każdemu new[] — jedno delete[]. Jeszcze lepiej pozwolić, aby zajęły się tym inteligentne wskaźniki.

Szybki test

Sprawdź swoją wiedzę na temat alokacji na stercie.

Podsumowanie

Nauczyłeś się alokować pamięć na stercie za pomocą new/new[] i zwalniać ją za pomocą delete/delete[]. Obiekty na stercie żyją dłużej niż ich zakres, ale wymagają ręcznego sprzątania. Dopasowuj każde zwolnienie do alokacji, ustawiaj zwolnione wskaźniki na wartość pustą i we współczesnym kodzie preferuj std::unique_ptr.

Często zadawane pytania

Czy lekcja „Alokacja na stercie z new/delete” jest bezpłatna?

Tak — pełny tekst „Alokacja na stercie z new/delete” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C++ Academy, przejdź na CoddyKit PRO. Kurs C++ Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Alokacja na stercie z new/delete”?

Zarządzaj pamięcią dynamiczną Ćwiczysz C++ Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C++ Academy?

Nie wymagamy żadnego doświadczenia. C++ Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Alokacja na stercie z new/delete”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C++ Academy?

Tak. Każda lekcja C++ Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do C++ Academy