Alokacja pamięci

W języku C++ istnieje możliwość przydzielania (alokowanie) pamięci – możemy ją przydzielać w czasie wykonywania programu zmiennej lub tablicy. Proces ten jest znany pod nazwą dynamiczna alokacja pamięci.

Zapoznaj się z kodem:

int* wskaznik = new int;

• Deklarujemy zmienną wskaznik jako wskaźnikwskaźnikwskaźnik do zmiennej typu int.

• Używamy operatora new, by zaalokować dynamicznie pamięć RAM dla pojedynczej zmiennej typu int.

• Przypisujemy adresadres pamięciadres nowo zaalokowanej pamięci do zmiennej wskaźnikowej wskaznik.

W efekcie zmienna wskaznik przechowuje adres nowo zaalokowanej pamięci, gdzie może być przechowywana wartość typu int.

W poprzednim kroku zadeklarowaliśmy zmienną o nazwie wskaznik. Jak wyjaśniliśmy, wskazuje ona na fragment pamięci, w której przechowywana jest liczba całkowita. Jeżeli chcemy przypisać wartość liczbową do zmiennej wskaźnikowej, nie możemy wykorzystać do tego prostej operacji przypisania. Zrobimy to, wykorzystując następującą instrukcję:

*wskaznik = 24;

• Używamy operatora dereferencji * przed zmienną wskaznik, co oznacza, że chcemy odwołać się do wartości przechowywanej pod adresem wskazywanym przez zmienną wskaznik.

• Przypisujemy wartość 24 do zmiennej, do której wskazuje wskaźnik wskaznik.

W efekcie, wartość 24 jest przypisywana do zmiennej przechowywanej pod adresem wskazywanym przez wskaznik, czyli do dynamicznie zaalokowanej zmiennej typu int.

Podsumowując, te dwie linijki kodu alokują dynamicznie pamięć dla zmiennej typu int, a następnie przypisują wartość 24 do tej zmiennej poprzez wskaźnik.

Operator new w języku C++ jest używany do dynamicznej alokacji pamięci. Jego głównym zadaniem jest zaalokowanie odpowiedniej ilości pamięci na stosie i zwrócenie wskaźnika do tej pamięci. Pamięć zaalokowana przez operator new pozostaje zarezerwowana do momentu jej jawnego zwolnienia. Operator new nie tylko alokuje pamięć, ale także automatycznie wywołuje konstruktor obiektu, jeśli jest to obiekt klasy.

Zarządzanie pamięcią

Specyfikacja języka C++ nie mówi o przydzielaniu pamięci na stosie czy stercie. Zamiast tego miejsce, w którym dany obiekt (dane zdefiniowane w programie) jest przechowywany w pamięci, zależy od kontekstu, według którego obiekt został zdefiniowany. W języku C++ każdy obiekt może mieć jeden z czterech poniższych cyklów istnienia:

1. Automatyczny - pamięć przydzielana jest obiektowi w momencie utworzenia go dla lokalnego zakresu, a zwalniana na koniec zakresu. Zwykle automatyczny cykl życia jest obsługiwany przez stos wywołań działający według zasady LIFOLIFO (ang. Last In, First Out)LIFO. Zakres rozumiemu jako blok programu (to, co znajduje się między nawiasami klamrowymi).

2. Dynamiczny - blok pamięci jest rezerwowany dla obiektu słowem kluczowym new, a zwalniany operatorem delete lub delete[]. Zaalokowana pamięć pozostaje zarezerwowana do końca działania programu lub do momentu gdy jej nie zwolnimy. W większości programów obsługiwany jest przez stertę.

3. Statyczny - miejsce w pamięci dla obiektu jest automatycznie rezerwowane przy uruchomieniu programu, a zwalniane gdy program zakończy działanie.

4. Wątkowy (od C++11) - rezerwuje blok pamięci dla obiektu, gdy wątek zostaje rozpoczęty, a dealokuje automatycznie pod koniec wątku.

Zwalnianie pamięci

W przeciwieństwie do języków takich jak Java lub Python , język C++ nie ma wbudowanego kolektora śmieci automatycznie zarządzającego pamięcią. Z tego powodu musimy samodzielnie zwolnić dynamicznie zarezerwowaną pamięć dla każdej zmiennej, która nie będzie już potrzebna.

Blok pamięci, który nie został zwolniony w trakcie uruchomiania, pozostaje zajęty przez cały okres działania programu. W niektórych przypadkach (gdy wyciek jest szczególnie duży) może doprowadzić to do obniżenia wydajności innych aplikacji lub systemu operacyjnego.

Operator delete zwalnia pamięć i wywołuje destruktor dla pojedynczego obiektu utworzonego za pomocą operatora new.

int* wskaznik = new int;
delete wskaznik;

Operator delete[] zwalnia pamięć i wywołuje destruktory dla tablicy obiektów utworzonych za pomocą new[].

int* wskaznik = new int[4];
delete[] wskaznik;

Zmienne dynamiczne i statyczne

Zmienna dynamiczna to pewien rodzaj zmiennej, której przestrzeń w pamięci komputera jest alokowana w trakcie działania programu (a nie w momencie kompilacji). Dostęp do tej przestrzeni pamięci jest możliwy poprzez wskaźnik. Alokacja pamięci dla zmiennej dynamicznej odbywa się za pomocą operatora new, a zwolnienie pamięci przy użyciu operatora delete. Dzięki zmiennym dynamicznym program może elastycznie zarządzać pamięcią, alokując i zwalniając ją w zależności od bieżących potrzeb.

Zmienna statyczna to taka zmienna, której przestrzeń w pamięci jest alokowana na etapie kompilacji programu i pozostaje zaalokowana przez cały czas jego działania. Zmienne statyczne mogą być deklarowane na poziomie globalnym, w przestrzeni nazw, wewnątrz klas jako składowe statyczne lub lokalnie wewnątrz funkcji jako zmienne lokalne statyczne. W przeciwieństwie do zmiennych dynamicznych dostęp do zmiennych statycznych odbywa się bezpośrednio przez ich nazwy, a nie poprzez wskaźniki.

Wskaźnik przechowuje adres w pamięci komputera, gdzie zapisana jest jakaś wartość lub obiekt.

Wskaźnik to zmienna, która zamiast przechowywać bezpośrednio daną wartość (jak liczba czy znak), przechowuje adres, pod którym ta wartość się znajduje w pamięci komputera. Dzięki temu za pomocą wskaźnika możemy wskazać na miejsce, gdzie coś jest zapisane, co jest szczególnie przydatne w przypadku pracy z zmiennymi dynamicznymi.

Alokacja i dealokacja pamięci dla zmiennych statycznych jest zarządzana automatycznie, co oznacza, że programista nie musi jawnie alokować lub zwalniać pamięci za pomocą operatorów new i delete. Zmienne statyczne zadeklarowane poza funkcjami (na poziomie globalnym lub jako składowe klas) są inicjalizowane do wartości zerowych (dla typów podstawowych) lub konstruktorów domyślnych (dla obiektów) jeśli nie są jawnie inicjalizowane.

Przykład zastosowania wskaźnika, zmiennej statycznej i zmiennej dynamicznej:

#include <iostream>
using namespace std;

int main() {
    int liczba = 10; // Zmienna statyczna liczba z wartością 10.
    int *wskaznikNaLiczbe = &liczba; // Tworzymy wskaźnik wskaznikNaLiczbe, który przechowuje adres zmiennej liczba.
    
    // Przykład użycia wskaźnika do dostępu do zmiennej
	// (przed wskaźnikiem należy użyć operatora *):
    cout << *wskaznikNaLiczbe << endl; // Drukuje wartość przechowywaną pod adresem, na który wskazuje wskaźnik, czyli 10.
    
    // Demonstracja użycia zmiennej dynamicznej:
    int *dynamicznaZmienna = new int(20); // Alokacja zmiennej dynamicznej z wartością 20.
    cout << "Wartość zmiennej dynamicznej: " << *dynamicznaZmienna; // Dostęp do wartości zmiennej dynamicznej przez wskaźnik.
    delete dynamicznaZmienna; // Zwolnienie pamięci przydzielonej dla zmiennej dynamicznej.
    
    return 0;
}

Wynik działania programu:

10
Wartość zmiennej dynamicznej: 20

Druga linia wyniku, Wartość zmiennej dynamicznej: 20, jest rezultatem utworzenia zmiennej dynamicznej za pomocą operatora new, inicjalizacji jej wartością 20, a następnie wypisania tej wartości. W tym przypadku wskaźnik dynamicznaZmienna przechowuje adres zmiennej dynamicznej alokowanej w pamięci sterty, a używając tego wskaźnika z operatorem dereferencji (*dynamicznaZmienna), program wypisuje jej wartość. Następnie pamięć alokowana dynamicznie jest zwalniana za pomocą operatora delete, co jest kluczowe dla uniknięcia wycieków pamięci.

Pierwsza linia wyniku, czyli 10, jest wynikiem wypisania wartości zmiennej liczba, do której dostęp uzyskano za pomocą wskaźnika wskaznikNaLiczbe. Oznacza to, że korzystamy z samego adresu pamięci przechowywanego przez wskaźnik, aby uzyskać dostęp do danych zapisanych pod tym adresem. Wskaźnik służy jako pośrednik do odniesienia się do miejsca w pamięci, gdzie przechowywane są dane, zamiast przechowywać same dane bezpośrednio.

Wskaźnik ten został zainicjowany adresem zmiennej liczba, a następnie użyto go do odczytania wartości tej zmiennej (*wskaznikNaLiczbe), co pokazuje, jak wskaźniki mogą być używane do bezpośredniego dostępu i manipulacji wartościami zmiennych.

Pokazaliśmy w ten sposób dwa podstawowe zastosowania wskaźników w języku C++, czyli dostęp do zmiennych oraz zarządzanie pamięcią dynamiczną. Wskaźniki pozwalają na bezpośrednią manipulację pamięcią i adresami, co jest szczególnie ważne w kontekście zarządzania zasobami i optymalizacji. Niepoprawne użycie wskaźników może prowadzić do błędów takich jak wycieki pamięci, naruszenia dostępu do pamięci (z ang. segmentation faults) lub nieprzewidywalne zachowanie programu.

Sytuacje, gdy używamy wskaźników:

• Chcemy zmieniać wartości zmiennych z innych funkcji (ponieważ przekazujemy do funkcji adres, a nie kopię wartości).

• Zarządzamy pamięcią dynamicznie – kiedy chcemy sami decydować, kiedy coś zajmuje miejsce w pamięci i kiedy to miejsce zwalniamy.

• Pracujemy z tablicami i innymi strukturami danych, gdzie wskaźniki pozwalają na efektywną manipulację danymi.

Rodzaje tablic

Tablice statyczne

Przypomnijmy sobie najważniejsze informacje na temat tablic statycznych (możesz również wrócić do e‑materiału Podstawowe struktury danych: tablicaP1HRyIBljPodstawowe struktury danych: tablica.

Tablice statyczne to jedna z podstawowych struktur danych w języku C++, która pozwala przechowywać zbiory elementów tego samego typu w ciągłym bloku pamięci. Są one nazywane statycznymi, ponieważ ich rozmiar musi być znany już w momencie kompilacji programu i nie może się zmieniać w trakcie jego działania.

Gdy deklarujesz tablicę statyczną, musisz określić jej rozmiar. Język C++ alokuje miejsce w pamięci na całą tablicę jako ciągły blok. Każdy element tablicy ma swój unikalny indeks, zaczynając od 0 dla pierwszego elementu, 1 dla drugiego i tak dalej. Umożliwia to prostu dostęp do każdego elementu tablicy.

#include <iostream>

using namespace std;

int main() {
    int mojaTablica[5]; // Deklaracja tablicy statycznej o rozmiarze 5.
    
    // Wypełnienie tablicy wartościami.
    for (int i = 0; i < 5; i++) {
        mojaTablica[i] = i * 10;
    }
    
    // Wypisanie wartości przechowywanych w tablicy.
    for (int i = 0; i < 5; i++) {
        cout << "Element [" << i << "]: " << mojaTablica[i] << endl;
    }
    
    return 0;
}

W tym przykładzie zmienna mojaTablica jest pięcioelementową tablicą liczb całkowitych. Najpierw wypełniamy ją wartościami za pomocą pętli for, a następnie iterujemy przez tablicę, aby wypisać jej zawartość.

Wynik działania programu:

Element [0]: 0
Element [1]: 10
Element [2]: 20
Element [3]: 30
Element [4]: 40

W kontekście zmiennych statycznych w tablicach statycznych, pamięć jest zarządzana na zasadach bardzo podobnych do tych dla pojedynczych zmiennych statycznych. Jest jednak kilka istotnych różnic.

Podobnie jak pojedyncze zmienne statyczne, pamięć dla tablic statycznych jest alokowana na etapie kompilacji programu. Rozmiar tablicy musi być znany w czasie kompilacji, co oznacza, że nie można go zmienić w czasie działania programu.

Tablica statyczna zajmuje ciągły obszar w pamięci, który jest wystarczająco duży, aby pomieścić wszystkie jej elementy. Pamięć ta jest zwykle alokowana na stosie (dla tablic zadeklarowanych lokalnie w funkcji) lub w sekcji danych programu (dla tablic globalnych lub statycznych w klasach).

Elementy tablicy statycznej są automatycznie inicjalizowane na wartości domyślne (np. 0 dla typów liczbowych, false dla bool, null dla wskaźników) jeśli nie są jawnie inicjalizowane w kodzie. Programista może jawnie zainicjować tablicę przy jej deklaracji, określając wartości dla niektórych lub wszystkich jej elementów.

Tablice statyczne zadeklarowane lokalnie w funkcji są dostępne tylko w obrębie tej funkcji, ale ich wartości są zachowywane między kolejnymi wywołaniami funkcji, w przeciwieństwie do zmiennych automatycznych. Dla tablic globalnych lub statycznych w klasach, pamięć jest alokowana na cały czas działania programu, a więc tablice te są dostępne przez cały czas jego wykonania.

Pamięć zajmowana przez tablice statyczne jest automatycznie zwalniana przez środowisko wykonawcze C++ po zakończeniu działania programu lub przy wyjściu z bloku, w którym tablica została zadeklarowana (dla tablic lokalnych).

Tablice dynamiczne

Wskaźnik może nie tylko przechowywać adres pojedynczej zmiennej, ale również pozwala deklarować tablice o rozmiarze określanym w trakcie działania programu.

typ* nazwa_tablicy = new typ[rozmiar];

delete[] nazwa_tablicy;

Operator new umożliwia alokację pamięci dla tablic obiektów dowolnego typu. Aby zadeklarować tablicę dynamiczną typu int, należy przy deklaracji umieścić rozmiar tablicy wewnątrz nawiasów kwadratowych. Przy deklaracji tablicy dynamicznej operator new zwraca adres pierwszego elementu tablicy.

int n = 10;
int* tablica = new int[n]; // tablica dynamiczna o n wyrazach

Do wyrazów tablic dynamicznych odwołujemy się identycznie, jak w przypadku tablic statycznych.

tablica[4] = 6
cout << tablica[4]; // wynik = 6

Dynamicznie można deklarować nie tylko tablice jednowymiarowe, ale także tablice dwu i więcej wymiarowe. Wtedy wskaźnik do tablicy dwuwymiarowej będzie typu int**, a dla każdego elementu tablicy (typu int*) należy zadeklarować nową tablicę dynamiczną.

int n = 10;
int** tablica = new int*[n]; // tablica dynamiczna wskaźników
for(int i = 0; i < n; i++)
{
    tablica[i] = new int[n]; // deklaracja i-tej tablicy
}

#include <iostream>
using namespace std;

int main()
{
    int n = 10;
    int** tablica = new int*[n]; // tablica dynamiczna wskaźników

    for(int i = 0; i < n; i++)
    {
        tablica[i] = new int[n]; // deklaracja i-tej tablicy
    }

    tablica[4][4] = 6; // przypisanie wartości 6 do elementu tablicy o indeksach (4,4)
    cout << tablica[4][4]; // wynik = 6
    
    // Zwolnienie pamięci zaalokowanej dla tablicy dynamicznej
    for(int i = 0; i < n; i++)
    {
        delete[] tablica[i];
    }
    delete[] tablica;

    return 0;
}

6

Obiekty dynamiczne

Podobnie do tego, jak tworzymy zmienne dynamiczne, możemy tworzyć obiekty dynamiczne. Obiekty dynamiczne w języku C++ to instancje klas lub struktury, które są alokowane w czasie wykonywania programu na stercie zamiast na stosie.

Alokacja obiektów dynamicznych odbywa się za pomocą operatora new, który rezerwuje odpowiednią ilość pamięci na stercie dla obiektu danej klasy i zwraca wskaźnik do tego obszaru pamięci. Aby zwolnić zajmowaną pamięć, kiedy obiekt nie jest już potrzebny, używa się operatora delete. Dzięki temu mechanizmowi, programista ma kontrolę nad cyklem życia obiektów.

#include <iostream>

using namespace std;

class Samochod {
private:
    string marka;
public:
    Samochod(string m) : marka(m) {} // Konstruktor
    void pokaz() {
        cout << "Marka samochodu: " << marka << endl;
    }
    ~Samochod() {}
};

int main() {
    Samochod* mojSamochod = new Samochod("Toyota"); // Alokacja dynamiczna
    mojSamochod->pokaz(); // Dostęp do metody przez wskaźnik
    
    delete mojSamochod; // Zwolnienie pamięci
    return 0;
}

W tym przykładzie tworzymy dynamicznie obiekt klasy Samochod na stercie za pomocą operatora new. Obiekt jest dostępny przez wskaźnik mojSamochod, a jego metody są dostępne za pomocą operatora strzałki (->). Pola są prywatne. Po zakończeniu używania obiektu, zwalniamy pamięć za pomocą delete.

Dlaczego używamy obiektów dynamicznych? Obiekty dynamiczne mogą być tworzone i usuwane w dowolnym momencie działania programu, co daje możliwość kontroli nad zarządzaniem pamięcią.

W przypadku dużych obiektów lub zmiennej liczby obiektów, alokacja dynamiczna pozwala na efektywniejsze wykorzystanie zasobów.

Obiekty dynamiczne istnieją aż do momentu ich jawnego usunięcia, co oznacza, że mogą przetrwać dłużej niż zasięg bloku kodu, w którym zostały utworzone.

Jakie jest ryzyko?

Programista jest odpowiedzialny za zwolnienie pamięci zajmowanej przez obiekty dynamiczne, co może prowadzić do wycieków pamięci, jeśli zostanie to zaniedbane.

Alokacja i dealokacja na stercie są zazwyczaj kosztowniejsze pod względem wydajności niż operacje na stosie.

Podsumowując, obiekty dynamiczne w C++ oferują dużą elastyczność i kontrolę nad zarządzaniem pamięcią, ale wymagają od programistów staranności w zarządzaniu cyklem życia obiektów i pamięcią, aby unikać wycieków i innych problemów.

#include <iostream>
using namespace std;

int main() {
    // Załóżmy, że mamy dynamicznie alokowaną tablicę tab o określonym rozmiarze
    int rozmiar = 10;
    int* tab = new int[rozmiar];

    // Wypełniamy tablicę danymi
    for (int i = 0; i < rozmiar; i++) {
        tab[i] = i;
    }

    // Jeśli potrzebujemy więcej miejsca, tworzymy nową, większą tablicę
    int nowyRozmiar = 2 * rozmiar;
    int* nowa_tab = new int[nowyRozmiar];
    
     // Przekopiowujemy dane ze starej tablicy do nowej
    for (int i = 0; i < rozmiar; i++) {
        nowa_tab[i] = tab[i];
    }

     // Zwalniamy pamięć starej tablicy
    delete[] tab;
    // Ustawiamy wskaźnik tab na nową tablicę
    tab = nowa_tab;
    // Wskaźnik tab wskazuje na nową, większą tablicę

    for (int i = 0; i < rozmiar; i++) {
        cout << nowa_tab[i] << " "; 
    }
    cout << endl;

    for (int i = 0; i < nowyRozmiar; i++) {
        cout << nowa_tab[i] << " ";
    }
    cout << endl;

    delete[] tab; // Zwolnienie pamięci

    return 0;
}

// Wypisujemy pierwsze 10 elementów nowej tablicy (dane przekopiowane)
0 1 2 3 4 5 6 7 8 9

// Wypisujemy całą nową tablicę, włącznie z niezainicjowanymi elementami
0 1 2 3 4 5 6 7 8 9 0 0 0 0 0 0 0 0 0 0

Słownik

int liczba = 7; // Pierwotna zmienna
int &ref_liczba = liczba; // Zmienna referencyjna

int liczba = 7;