Języki Programowania – Zajęcia 4

Ćwiczenie 3

4. Klasyczne zarządzanie pamięcią

Obiekty w C++ zajmują pamięć przez czas swojego życia. W wielu przypadkach pamięcią zarządza język lub biblioteka standardowa. Możemy jednak również jawnie utworzyć obiekt w pamięci dynamicznej.

W starszym kodzie C++ często wykorzystuje się do tego operator new. Zwraca on wskaźnik do utworzonego obiektu. Po zakończeniu korzystania z obiektu programista musi zwolnić zajmowaną przez niego pamięć za pomocą operatora delete.

Przykład:

#include <iostream>

int main()
{
    double* p = new double(3.14);

    std::cout << *p << std::endl;

    delete p;
    p = nullptr;

    return 0;
}

Wyjaśnienie:

• new tworzy obiekt w pamięci dynamicznej i zwraca do niego wskaźnik;
• delete kończy czas życia obiektu utworzonego przez pojedyncze new i zwalnia zajmowaną przez niego pamięć;
• po wykonaniu delete p zmienna p nadal istnieje, ale nie wolno już używać jej do dostępu do usuniętego obiektu;
• przypisanie p = nullptr ustawia wskaźnik na wartość pustą.

5. Nowoczesne zarządzanie pamięcią – inteligentne wskaźniki

W klasycznym podejściu programista odpowiada za zwalnianie pamięci za pomocą delete. W przypadku bardziej złożonych programów łatwo o pomyłkę, np. pominięcie zwolnienia pamięci lub wielokrotne zwolnienie tego samego obiektu.

Nowoczesny C++ oferuje inteligentne wskaźniki zdefiniowane w bibliotece <memory>. Inteligentne wskaźniki automatycznie zarządzają czasem życia obiektów. W przypadku std::unique_ptr obiekt jest usuwany, gdy kończy się czas życia zarządzającego nim wskaźnika lub gdy wskaźnik przestaje być jego właścicielem. W przypadku std::shared_ptr obiekt jest usuwany, gdy znika ostatni współdzielący go właściciel.

std::unique_ptr

std::unique_ptr reprezentuje wyłączną własność obiektu. Nie można skopiować go do innego std::unique_ptr, ponieważ oznaczałoby to dwóch niezależnych właścicieli. Własność można natomiast przenieść.

Przykład:

#include <iostream>
#include <memory>

int main()
{
    std::unique_ptr<double> p = std::make_unique<double>(3.14);
    std::cout << *p << std::endl;

    *p = 2.71;
    std::cout << *p << std::endl;

    return 0;
}   // p przestaje istnieć

Wyjaśnienie:

• unique_ptr alokuje pamięć dla liczby typu double o wartości 3.14;
• zmiana *p modyfikuje wartość wskazywanego obiektu, ale sam wskaźnik nadal zarządza tym samym obiektem;
• w momencie skończenia działania programu (dojścia do końcowej klamry instrukcji main wskaźnik zostaje automatycznie usunięty, a pamięć zwolniona.

std::shared_ptr

W przeciwieństwie do std::unique_ptr, który reprezentuje własność wyłączną, std::shared_ptr implementuje własność współdzieloną. Kilka wskaźników może wskazywać na ten sam obiekt w pamięci.

Przykład:

#include <iostream>
#include <memory>

int main()
{
    auto p1 = std::make_shared<double>(3.14);

    {   // wejście do bloku, gdzie zajdzie współdzielenie
        std::shared_ptr<double> p2 = p1;   // stworzenie p2, który będzie współdzielić adres z p1

        std::cout << *p2 << std::endl;
        std::cout << p1.use_count() << std::endl;   // use_count() zwraca liczbę właścicieli współdzielących zarządzany obiekt
    } // p2 przestaje istnieć

    std::cout << p1.use_count() << std::endl;

    return 0;
}   // p1 przestaje istnieć

Przykładowy output:

3.14
2
1

Wyjaśnienie:

• wskaźnik p2 wskazuje na ten sam adres, co wskaźnik p1;
• w bloku ze współdzieleniem istnieją dwa wskaźniki do tego samego adresu;
• po wyjściu z bloku ze współdzieleniem wskaźnik p2 znika;
• wskaźnik p1 znika dopiero po zakończeniu działania programu.

std::shared_ptr należy stosować wtedy, gdy kilka części programu rzeczywiście muszą współdzielić własność obiektu. Jeśli wystarcza jeden właściciel, lepszym rozwiązaniem jest std::unique_ptr.

Zadanie 1 – Analiza wyników pomiarów

Podczas eksperymentu fizycznego wykonano pięć pomiarów tej samej wielkości. Otrzymano następujące wyniki:

10.1, 10.3, 9.9, 10.2, 10.0

Ze względu na błąd kalibracji przyrządu do wybranych wyników należy dodać poprawkę o wartości 0.2.

Napisz program w C++, który przechowuje wyniki pomiarów w tablicy utworzonej w pamięci dynamicznej i wykonuje poniższe operacje.

1. Utworzenie tablicy dynamicznej.
   Zadeklaruj wskaźnik typu double*, początkowo ustawiony na nullptr. Następnie utwórz dynamiczną tablicę pięciu elementów i zainicjalizuj ją podanymi wynikami pomiarów.
   Wskazówka: Tablicę dynamiczną tworzymy za pomocą operatora new[], podając typ elementów i liczbę elementów, np. double* array = new double[3];. Pamięć zwalniamy za pomocą delete[] array;.
2. Przekazywanie argumentu przez wartość.
   Napisz funkcję correctByValue, która przyjmuje pojedynczy wynik pomiaru i wartość poprawki. Funkcja powinna zwracać wynik po dodaniu poprawki, nie zmieniając oryginalnego elementu tablicy. Wywołaj ją dla pierwszego pomiaru i wyświetl wynik funkcji oraz niezmienioną wartość elementu tablicy.
3. Przekazywanie argumentu przez wskaźnik.
   Napisz funkcję correctByPointer, która przyjmuje wskaźnik do elementu typu double oraz wartość poprawki. Funkcja powinna zmodyfikować wskazywany element tablicy. Wywołaj ją dla drugiego pomiaru i wyświetl zmienioną wartość.
4. Przekazywanie argumentu przez referencję.
   Napisz funkcję correctByReference, która przyjmuje element typu double przez referencję oraz wartość poprawki. Funkcja powinna zmodyfikować oryginalny element tablicy. Wywołaj ją dla trzeciego pomiaru i wyświetl zmienioną wartość.
5. Utworzenie skorygowanej kopii pomiarów.
   Napisz funkcję correctMeasurements, która przyjmuje wskaźnik do tablicy pomiarów, liczbę elementów oraz wartość poprawki. Funkcja powinna utworzyć nową tablicę dynamiczną, skopiować do niej pomiary, a następnie dodać poprawkę 0.2 do każdego elementu. Funkcja powinna zwracać wskaźnik do nowej tablicy. Tablica wejściowa nie może zostać zmodyfikowana. Należy wykorzystać początkowe wartości pomiarów, a nie te, które zostały zmodyfikowane w poprzednich podpunktach.
6. Porównanie tablic.
   Wyświetl zawartość tablicy oryginalnej i skorygowanej, aby sprawdzić, czy funkcja correctMeasurements poprawnie utworzyła kopię i nie zmieniła danych wejściowych.
7. Wyszukiwanie największego pomiaru.
   Napisz funkcję findLargestMeasurement, która przyjmuje wskaźniki do tablicy oryginalnej i skorygowanej oraz liczbę elementów. Funkcja powinna zwracać wskaźnik do elementu tablicy skorygowanej, który odpowiada największemu pomiarowi w tablicy oryginalnej. Wyświetl wartość wskazywaną przez zwrócony wskaźnik.
8. Zwolnienie pamięci.
   Po zakończeniu obliczeń zwolnij pamięć zajmowaną przez obie tablice za pomocą odpowiednich operatorów delete[]. Pamiętaj, że tablice są niezależnymi obiektami i każdą z nich należy zwolnić osobno.

Zadanie 2 – Inteligentne wskaźniki

Zmodyfikuj program z Zadania 1 tak, aby do zarządzania dynamicznie alokowaną pamięcią wykorzystywał inteligentne wskaźniki std::unique_ptr zamiast wskaźników klasycznych.

Podczas modyfikacji programu spełnij następujące wymagania:

1. Zastąp wskaźniki zarządzające dynamicznie utworzonymi tablicami odpowiednimi obiektami typu std::unique_ptr<double[]>.
   Wskazówka: Inteligentny wskaźnik do tablicy można utworzyć za pomocą std::make_unique<double[]>(5). Inteligenty wskaźnik utworzy tablicę i zainicjalizuje ją zerami. Żeby wypełnić tablicę potrzebnymi wartościami, trzeba wpisać je jeden po drugim jak w przypadku standardowej tablicy.
2. Dostosuj funkcje correctMeasurements i findLargestMeasurement tak, aby przyjmowały referencje do inteligentnych wskaźników tablic. Funkcja correctMeasurements powinna zwracać inteligentny wskaźnik do nowej tablicy. Funkcja findLargestMeasurement powinna zwracać indeks elementu odpowiadającego największemu pomiarowi w tablicy oryginalnej. Wartość tego elementu odczytaj z tablicy skorygowanej za pomocą zwróconego indeksu.
   Wskazówka: Inteligentny wskaźnik std::unique_ptr zarządza pamięcią, ale nie wolno go kopiować przez zwykłe przypisanie. Aby funkcja mogła korzystać z istniejącego inteligentnego wskaźnika bez przejmowania jego własności, można przekazać go przez referencję z const, np. const std::unique_ptr<double[]>& data. W tym przypadku const uniemożliwia zmianę samego inteligentnego wskaźnika za pośrednictwem tej referencji, ale nie blokuje modyfikowania elementów tablicy, np. przez data[0] = 1.0;. Dostęp do elementów tablicy jest taki sam jak w przypadku zwykłej tablicy.

Punktacja