8. Wskaźniki
Temat jako całość jest bardzo obszerny, skomplikowany i po prostu trudny. Dlatego opiszę jak bardzo prosto potrafię. Materiały które dokładniej wyjaśniają zagadnienie (które nie będzie Ci potrzebne do kontynuowania nauki) podam na koniec tego rozdziału

8.1 Czym jest wskaźnik

Wskaźnik to takie coś co wskazuje na cos innego. Wyobraź sobie taką sytuację. W klasie podstawowej, Jasio rzucił papierkiem w Zosię. Zosia się odwróciła i zobaczyła, że Marysia pokazuje palcem na Jasia.
Marysia w tym opisie jest wskaźnikiem.
Jest to zmienna która istnieje w pamięci (tak samo jak istnieje Marysia) której zadaniem jest pokazywanie na coś innego (np. na Jasia). Przeważnie są to zmienne, ale też może być to funkcja!
Definiujemy wskaźnik w następujący sposób

TYP *nazwa

na przykład

int *pointer;
Foo *object;
Bar *test;

Ważne jest to, że TYP to nie jest typ wskaźnika, ale jest to typ na jaki ma pokazywać wskaźnik. Jeżeli mamy obiekt Foo to musimy zdefiniować nasz wskaźnik na obiekt Foo.

8.2 Do czego uzywa sie wskaznikow

Wskaźników używamy praktycznie wszędzie. Jedynym wyjątkiem są typy proste. Rzadko chcemy pokazywać na int, czy na float. Przeważnie pokazujemy na jakiś obiekt. Dlaczego? Więcej o tym w 8.2.2

8.2.1 Wyjasnienie stosu i sterty (bez szczegółów)

Wszystko w "" jest wielkim uproszczeniem. Możesz w ten sposób myśleć, ale to nie działa tak jak jest opisane w "". Nadal, nie przeszkodzi Ci to w niczym by pisać programy.

Nasz program ma do dyspozycji dwie(*) sekcje pamięci. "Lokalną" oraz "Globalną". Lokalna jest stosem. Posiada ona mało pamięci (okolo 1mb (*)). Gdy potrzebujemy zdefiniować duży obiekt, to program wyrzuci nam błąd(*) StackOverflowExpcetion.
Wszystkie lokalne zmienne oraz wywołania funkcji znajdują się na stosie. Obiekty tworzone za pomocą new zostaną stworzone na stercie.
Operator new zwróci nam **wskaźnik**. Dlatego potrzebujemy znać wskaźniki gdy chcemy zdefiniować większe obiekty(a nawet jakiekolwiek obiekty).

Ok, zapytasz mnie jak to jest z std::string? Przecież normalnie definiujemy zmienna (bez żadnego operatora) i działa bez problemów. Nawet pliki kilkudziesięcio megabajtowe można wczytać do std::string. To jak to w końcu jest?
std::string operuje na tablicy char. Klasa sama dba o alokowanie pamięci na stercie. Klasa do użytku ma być wygodna! Co to jest tablica pokaże w następnym rozdziale.

8.2.2 Uzywanie new i delete

Przy wywoływaniu operatora new zostaje wywołany konstruktor. Przy wywołaniu operatora delete. zostaje wywołany destruktor.

Złota zasada. Ma być tyle samo delete co new. Gdy nie zwolnimy pamięci której zarezerwowaliśmy powstanie wyciek pamięci! Na przykładzie

class Foo
{
	Foo();
	~Foo();
	void Bar();
};

Foo::Foo()
{
	cout << "Constructor was called\n";
}

~Foo::Foo()
{
	cout << "Destructor was called\n";
}

void Foo::Bar()
{
	cout << "a function";
}

int main()
{
	Foo *firstObject; // stworzylismy sam wskaznik!
	firstObject = new Foo(); // dzieki new tworzymy nowy obiekt i przypisujemy go do wskaznika (wskaznik pokazuje teraz gdzie on sie znajduje)
	firstObject->Bar(); // tutaj jest juz pierwsza wielka roznica. Zeby dostac sie do zmiennych/funkcji klasy uzywamy strzalki zamiast kropki!
	delete firstObject; // usuwamy obiekt i dzieki temu zwalniamy miejsce w pamieci. Jezeli tego nie zrobimy bedziemy miec wyciek pamieci
}

8.3 Dlaczego warto unikac wskaznikow
Problem ze wskaźnikami jest taki, że są one dość trudne do zrozumienia na początek jak dokładnie one działaja. Przez to wielu początkujących popełnia błędy z których nawet sobie nie zdają sprawy. Od C++11 weszły mechanizmy do standardowego języka które bardzo ułatwiają pracę z dynamicznym alokowaniem pamięci
8.3.1 wyjasnienie UB oraz pokazanie kilku zlych praktyk
UB - Undefined Behaviour. Standard języka nie precyzuje jak dana instrukcja będzie się zachowywać. Także znane pojęcie pod hasłem "demony nosa" ponieważ w teorii UB może doprowadzić, że demony wylecą z Twojego nosa ;) Jeżeli przeczytasz/usłyszysz, że Twój kod to UB. To nie ma żadnego znaczenia, że dla Ciebie działa. Musisz go zmienić. Dziś może działać, ale kiedyś może po prostu się beż zadnych objawów wyłączyć.

Bardzo częstym błędem jest taka praktyka
int main()
{
	Foo *firstObject; // stworzylismy sam wskaznik!
	firstObject->Bar(); // wskaznik nie zostal przypisany na nic więc ten kod... jest UB. W wiekszosci wypadkow powinien powodowac Access Violation, ale czasami bedzie dzialal (jezeli wskaznik bedzie pokazywal na obiekt PRZEZ PRZYPADEK)
}

Na przykladzie realnym
Mamy Jasia który rzuca papierkiem w Zosie, Zosia się odwraca i patrzy na Marysię. Marysia pokazuję na lampę która jest na suficie (gdy wskaźnik jest co dopiero stworzony to pokazuję na losowe miejsce w pamięci). Zosia obwinia lampę, że rzuciła papierkiem po czym próbuje rozmawiać z lampą i powiedzieć jej, że to nieładnie rzucać papierkiem w kogoś.

Zawsze gdy tworzysz obiekt (niezależnie jaki), jeżeli możesz to ustaw mu wartość na taką jaką powinien posiadać. Na przykładzie wskaźnika:

int main()
{
	Foo *firstObject = new Foo(); // definicja i inicjalizacja wskaznika w jednym
	firstObject->Bar();
	delete firstObject;
}

- praca na wskaźniku na którym zostało wywołane delete.

int main()
{
	Foo *firstObject = new Foo();
	firstObject->Bar();
	delete firstObject;
	firstObject->Bar(); // UB!
}

8.3.2 przedstawienie smart pointerow

Dzięki C++11 w standardzie przyszły nam "mądre wskaźniki". Jako że polskie tłumaczenie jest po prostu słabe to będę je nazywał smart pointer'ami.
Smart Pointer sam dba o tworzenie i usuwanie obiektu! W większości wypadków nie musisz się w ogóle przejmować odnosnie alokowania i zwalniania pamięci. Smart pointer'y zrobią to za Ciebie!

Teraz troszkę wywodu dlaczego ta zmiana jest świetna dla C++. Wielu zwolenników tak zwanego C z klasami powie "eee to bez sensu, może jeszcze dodadzą Garbage Collector do C++! Przecież to jest wolniejsze oraz wyręcza programistę z myślenia o swoim programie i jego zasobach!"
Rozłoże, to na części pierwsze.
C z klasami - Są to ludzie (w tym ja kiedy zaczynałem) którzy traktują C++ nie jako język obiektowy tylko jako rozszerzenie języka C. Co jest po prostu błędem. C oraz C++ to są dwa różne języki. Mają dwie rózne filozofie pisania programów. Jeden potrafi być przetłumaczony do Asemblera 1 do 1 (chodzi o C) natomiast drugi ma dość duży narzut (z jednej instrukcji powstaje wiele w asm). Jeżeli ktoś zargumentuje "No hej, ale przecież C jest kompatybyline z C++ wiec są podobne!" jest to kolejny nietrafiony argument. W C jak i w C++ możemy pisać w asemblerze. Czy asember jest zatem podobny do tych dwóch języków? A co z C++.NET? (tak zwanym CLI). Przeciez można łączyć platforme .NET z C++ a dzięki temu można dość łatwo mieszać C++ z C#. Czy te języki są podobne? Szczególnie od standardu C++11, język jest dużo bardziej nastawiony na obiektowość oraz by pomóc programiście nie przejmować się takimi rzeczami jak zasoby komputera. Programista ma być oczywiście ich świadom, ale przecież nie musi na samym początku nauki walić głową w mur właśnie przez zarządzaniem zasobami.
Smart Pointery sa wolniejsze - Tak maja delikatny narzut jeżeli chodzi o pamięć i szybkość. Ten narzut jest tak mały, że w większości wypadków jest pomijalny. W grach (oraz w silnikach gier) smart pointer'y są powszechnie stosowane. Co samo w sobie dowodzi, że ten narzut jest pomijalny (w większości wypadków)
No i ostatnie, Programista powinien wiedzieć wszystko co dokładnie dzieję się w jego programie. Mój kontr argument. Czy programisci wiedzą jaki dokładnie kod asemblerowy zostanie wygenerowany z ich kodu? Czy to też powinien programista wiedzieć? Jeżeli tak, to co z danymi architekturami procesora? Czy powinien wiedzieć również jak wykonaja sie instrukcje na nim? Gdzie jest granica która jest wystarczająca do programowania?
Moim zdaniem (tak samo jak na początku kursu o tym wspomniałem) najpierw uczymy się jak używać młotka, później jak jest zbudowany.

8.3.2.1 Wyjasnienie std::unique_ptr
pełna dokumentacja znajduję sie pod tym linkiem http://en.cppreference.com/w/cpp/memory/unique_ptr
Ja wymienie te najważniejsze rzeczy
- używamy gdy obiekt jest unikalny (nie potrzebujemy go w dwoch miejscach, pamietaj ze kopia to jest inny obiekt!)
- Usunie obiekt który zawiera gdy zasięg unique_ptr wyjdzie poza zakres (pokaże na przykładzie)

#include <iostream>
#include <memory>

class Foo
{
public:
    Foo()      { std::cout << "Foo::Foo\n";  }
    ~Foo()     { std::cout << "Foo::~Foo\n"; }
    void bar() { std::cout << "Foo::bar\n";  }
};

int main()
{
    std::unique_ptr<Foo> p1(new Foo());  // jak widzisz, w <> podajemy jaki typ obiektu chcemy stworzyc nastepnie w nawiasach uzywamy new Foo.
    p1->bar(); // wywolujemy funkcje bar, zauwaz ze nie uzywamy kropki a strzalki. To bardzo wazne.
    // zaraz za ta linijka zostanie wywolany destruktor. dla p1
}

Inny przyklad

#include <iostream>
#include <memory>
#include <string>

class Foo
{
public:
	std::string text;
    Foo(std::string t)
	{
		text = t;
		std::cout << "Constructor! of ";
		std::cout << text <<"\n";
	}
    ~Foo()
	{
		std::cout << "Destructor! of ";
		std::cout << text <<"\n";
	}
    void bar()
	{
		std::cout << "Foo::bar\n";
	}
};

int main()
{
    std::unique_ptr<Foo> p1(new Foo("I have bigger scope"));
	{ // tworzymy lokalny zasieg. Robimy to teraz by pokazac jak cos dziala.
		std::unique_ptr<Foo> p2 = std::make_unique<Foo>("Hey I am local scope"); // jest to inny sposob tworzenia obiektów. Moim zdaniem ten sposob jest duzo wygodniejszy i czytelniejszy
		p2->bar();
	} // w tym miejscu zostanie zniszczony obiekt p2 oraz zwolni zasoby obiektu ktory trzyma
    p1->bar(); // wywolujemy funkcje bar, zauwaz ze nie uzywamy kropki a strzalki. To bardzo wazne.
    // zaraz za ta linijka zostanie wywolany destruktor. dla p1
}


8.3.2.2 Wyjasnienie std::shared_ptr
Pełna dokumentacja znajduję sie pod linkiem http://en.cppreference.com/w/cpp/memory/shared_ptr
Najważniejsze cechy
- używamy gdy chcemy żeby obiekt był dzielony (był w kilku miejscach na raz. Ten sam obiekt a nie jego kopia)
- obiekt który jest przypisany do shared_ptr zostaje zniszczony gdy ostatnia referencja (jego ostatnie wystąpienie) przestanie istnieć

Nie będzie przykładów. Zasada działania jest podobna do unique_ptr. Użycie shared_ptr na początku raczej nie będzie nam potrzebne. Ale może Tobie się przyda. Funkcja która można tworzyć shared_ptr to std::make_shared

8.4 Zadania (w tym napisanie bardzo prostej listy)
- Przerób wszystkie dotychczasowe programy by używały smart pointerów gdy tworzymy obiekt jakieś klasy
- przy smart pointerach uzyj kropki, zobacz co Ci podpowie IDE (jakie funkcje)
-* napisz kontener dla stringów(tylko i wyłącznie. Można zrobić dla każdego typu, ale to dopiero za kilka rozdziałów). Powinien on bazować na smart pointer'ach. W rozdziale 10 pokaże jak to zrobić. Jest to bardzo trudne zadanie, ale bardzo dużo można sie przy nim nauczyć.
- Pobaw się z std::move , oraz z funkcjami dostępnymi tutaj http://en.cppreference.com/w/cpp/memory/unique_ptr .Jeżeli będzie coś za trudnego to możesz napisać w komentarzu lub po prostu to zostawić. Najważniejsze są (na ten moment): swap, reset, release

8.5 Materiał dodatkowy
Gdybys chciał wiedzieć więcej już teraz o wskaźnikach polecam Ci ten filmik. https://www.youtube.com/watch?v=bewTJaboGIw Polecam oglądnać wszystkie 9 części. Do tego kursu ta wiedza nie jest wymagana, ale na pewno ta wiedza jest wymagana gdy będziesz pracował. Niestety bardzo często trzeba poprawiać stary kod który korzysta po prostu ze wskaźników.