[C++] Zarządzanie pamięcią

czerwca 18, 2012

Język C / C++ daje nam możliwość dynamicznego zarządzania pamięcią. Możemy zatem przydzielać i zwalniać pamięć kiedy będzie to konieczne. W C służą do tego operatory malloc oraz free, których można użyć także w C++, jednak bardziej wskazane jest użycie operatorów new oraz delete, o których będzie mowa w tym wpisie.

Przydzielanie pamięci

Najpierw kilka słów o wyżej wymienionych operatorach new i delete. Pierwszy z nich służy do przydzielania pamięci, a drugi do jej zwalniania.

Przykład przydzielania pamięci dla jednego elementu:

int * pointer;
pointer = new int;

Przykład przydzielania pamięci dla tablicy elementów:


int * pointer;
pointer = new int[5];

Powyższe przykłady różnią się od siebie tym, że w drugim z nich po typie zmiennej podaliśmy w nawiasach kwadratowych ilość elementów.

Zwalnianie pamięci

Jak już wspomniałem wyżej - do zwalniania pamięci służy operator delete, a jego użycie wygląda tak:

delete pointer; - dla pojedynczych elementów;
delete[] pointer; - dla tablic elementów;

Jak widać, aby zwolnić pamięć przydzieloną dla jednego elementu zapisujemy operator delete i zaraz za nim nazwę wskaźnika. Jeśli zaś chcemy zwolnić pamięć przydzieloną tablicy, dopisujemy do operatora delete nawiasy kwadratowe.

Pora na jakiś konkretny przykład. Stwórzmy program, który umożliwi użytkownikowi tworzenie dynamicznej tablicy liczb całkowitych i manipulacje nią:

#include <iostream>

class DynamicallyAllocatedArray {

private:

    int* data;
    int size;

public:

    DynamicallyAllocatedArray(int n) : size(n) {
        
        data = new int[size]; // Alokacja pamięci
        for(int i = 0; i < size; ++i) {
        
            data[i] = 0; // Inicjalizacja wartościami 0
            
        }
        
        std::cout << "Alokowano tablicę o rozmiarze " << size << std::endl;
        
    }


    ~DynamicallyAllocatedArray() {
    
        delete[] data; // Zwalnianie pamięci
        std::cout << "Zwolniono pamięć dla tablicy o rozmiarze " << size << std::endl;
        
    }

    // Operator indeksowania
    int& operator[](int index) {
    
        if(index < 0 || index >= size) {
        
            throw std::out_of_range("Indeks poza zakresem tablicy");
            
        }
        
        return data[index];
        
    }
    
    int getSize() const {
    
        return size;
        
    }
    
};

int main() {

    int n;

    std::cout << "Podaj rozmiar tablicy: ";
    std::cin >> n;

    try {
    
        DynamicallyAllocatedArray array(n);
        
        for(int i = 0; i < array.getSize(); ++i) {
        
            array[i] = i + 1;
            
        }

        // Wyświetlanie wartości w tablicy
        std::cout << "Wartości w tablicy: ";
        
        for(int i = 0; i < array.getSize(); ++i) {
        
            std::cout << array[i] << " ";
            
        }
        
        std::cout << std::endl;

    }
    
    catch(const std::exception& e) {
    
        std::cerr << "Wystąpił błąd: " << e.what() << std::endl;
        
    }

    return 0;
    
}

Powyższy program prosi użytkownika o podanie rozmiaru tablicy, tworzy obiekt DynamicallyAllocatedArray, wypełnia tablicę wartościami od 1 do n i wyświetla je.

◢ⓊⓀⓄⒹⓄⓌⒶⓃⒾ◣ blog programistyczny