thinking in C++

Różnice pomiędzy C a C++:

   1. W definicji funkcji w C nazwy są wymagane, w C++ - nie. (Jak nie ma nazwy 
nieużywanego argumentu to nie ma irytującego warninga kompilatora).
   2. Funkcja może przyjmować dowolną ilość argumentów:
         1. W C: zapis f(); W C++: zapis f(…).
         2. W C++, zapis f() oznacza, że funkcja nie przyjmuje argumentów.
         3. W C i C++, zapis f(void) oznacza to co zapis f() w C++.
   3. Zwracana wartość: jak nie ma podanej, to w C domyślnie jest to int. W C++ 
musi być podana zwracana wartość.
   4. W C++ zmienne mogą być deklarowane w locie (w C nie).
   5. Stałe w C, to po prostu zwykłe zmienne, których wartości nie mogą być 
zmieniane. W C++ stałe czasem nie stają się zmiennymi, i są łączone wewnętrznie.
   6. W C++ stała zawsze musi być od razu inicjalizowana, w przeciwieństwie do 
C.
   7. W C++, w odróżnieniu od C przypisanie wartości typu void* nie jest możliwe
bez rzutowania.

Różne:

    * W deklaracji funkcji nie są potrzebne nazwy argumentów.
    * Wyrażenie w while(<tu>) może być dowolnie skomplikowane, dopóki zwraca 
wartość logiczną.
    * W switch(selektor) selektor jest wyrażeniem dającym wartość całkowitą.
    * Limits.h, float.h – maksymalne i minimalne wartości możliwe do wyrażenia w
rozmaitych typach danych.
    * Zmienne można też definiować wewnątrz if(<tu>), while i for i switch, ale 
są problemy wtedy z nawiasami – nie można „onawiasować” takiej definicji.
    * Łączenie wewnętrzne – zmienne i funkcje łączone wewnętrznie są widoczne 
tylko w obrębie pliku, w przeciwieństwie do łączonych zewnętrznie.
    * l-wartość - musi być pojedynczą, nazwaną zmienną (fizycznym miejscem 
przeznaczonym do przechowywania danych)
    * p-wartość – dowolna stała, zmienna lub wyrażenie zwracające wartość.
    * ‘\’ w makroinstrukcji pozwala przejść do następnej linii
    * ~ - bitowy operator negacji.
    * Jeżeli wartość argumentu znajdującego się po prawej stronie operatora 
przesunięcia bitowego jest większa od jego ilości bitów, to wynik jest 
nieokreślony. Jeżeli po prawej stronie jest liczba ze znakiem, to zachowanie 
operatora jest niezdefiniowane.
    * Operator trójargumentowy: i1 ? i2 : i3. jeżeli i1 == true, to wykonywane 
jest i2. Zwracaną wartością jest wartość wykonanego wyrażenia
    * Słowo asm – można wstawić do programu C++ kod asemblerowy.
    * typedef opis-istniejącego-typu nowa-nazwa. W C wykorzystywane przy 
deklaracji struktur.
    * Identyfikator tablicy nie jest l-wartością. Identyfikator tablicy można 
traktować jako wskaźnik do jej początku przeznaczony tylko do odczytu.
    * int main(int argc, char* argv[]) – lista argumentów main(), pierwszy to 
nazwa programu. Te identyfikatory nie muszą mieć takich nazw.
    * Konwersje z biblioteki <cstdlib>
          o atoi() – konwersja tablicy znaków na int, wpisanie do funkcji 
stringa liczby zmiennoprzecinkowej spowoduje, że atoi() uwzględni wyłącznie 
cyfry znajdujące się przed kropką. Jeżeli zostaną znaki nie będące cyframi, to 
atoi() zwróci zero.
          o atol() – na long
          o atof() – na double
    * W <cassert> jest makroinstrukcja assert(). Jako argument podaje się 
wyrażenie, które deklaruje się jako prawdziwe. Jak nie jest prawdziwe, to assert
wywala program i informuje o błędzie.
    * Wskaźniki do funkcji: void (*funcPtr)(); - wskaźnik do funkcji 
bezargumentowej nic nie zwracającej. Nazwa funkcji jest jej adresem, tak 
następuje inicjalizacja wskaźnika.

Jawne rzutowanie w C++:

Składnia:

zmienna1 = rodzaj_cast<typ>(zmienna2);

Strona 1

thinking in C++

- zmiennej 1 zostaje przypisana zmienna 2 rzutowana ta typ ‘typ’.

static_cast – typowe konwersje niewymagające rzutowania, przekształcenia 
zmniejszające rozmiar danych, wymuszenie rzutowania typu void*, niejawne 
konwersje typów, statyczne poruszanie się w obrębie hierarchii klas.

const_cast - jeżeli potrzebujemy konwersji z typu oznaczonego modyfikatorem 
const lub volatile do typu nie posiadającego takiego modyfikatora. Uwaga: można 
przez const_cast dokonać rzutowania tylko takiego rodzaju (mogą być błędy, gdy w
<typ> będzie potrzebne jakieś inne rzutowanie). Rzutuje się poprzez zrzutowanie 
wskaźnika do obiektu, a nie samego obiektu.

// long* l – const_cast<long*>(&i); - błąd, gdy i jest const int.
reinterpret_cast – najmniej bezpieczne, można traktować obiekt jakby był 
zupełnie innego typu. Przykład:

Struct X { int a[sz]; };
...
X x; int* xp = reinterpret_cast<int*>(&x);
For(int* i = xp; i < xp+sz; ++i)*i = 0;

Rozdział 4 – Abstrakcja danych

• W C++ nie można bez rzutowania przypisać jakiemuś wskaźnikowi wskaźnika typu 
void*.
• Można utworzyć strukturę bez składowych, ma ona jednak niezerowy rozmiar.
• Kompilator traktuje podwójne deklaracje klas i struktur jako błąd.
• Nie używać nigdy dyrektyw typu using w plikach nagłówkowych. W praktyce dla 
każdego typu lub grupy typów jest osobny plik nagłówkowy i plik z definicjami 
funkcji.
• Można zagnieżdżać w sobie struktury.
Rozdział 5 – ukrywanie implementacji

Przyjaciele:
1. Przyjacielem może być:
• funkcja globalna: friend deklaracja_funkcji;
• składowa funkcja innej klasy: friend zwr_typ klasa::funkcja();
• cała inna klasa: friend klasa; (jest to również niepełna specyfikacja przy 
okazji…)
2. Utworzenie struktury zagnieżdżonej nie zapewnia jej automatycznie prawa 
dostępu do składowych prywatnych. Aby to osiągnąć, należy: najpierw zadeklarować
strukturę zagnieżdżoną, następnie zadeklarować ją używając słowa kluczowego 
friend i wreszcie wtedy ją zdefiniować. Definicja musi być oddzielona od friend,
bo kompilator nie uznałby jej za składową struktury.

Różne:
• Niepełna specyfikacja typu – class nazwa_klasy;
• Funkcja memset(adres, wartość, rozmiar(bajty)) – wypełnia wskazany obszar 
pamięci zadaną wartością, w bibliotece <cstring>
• Kompilator nie musi umieszczać danych w strukturze z różnymi specyfikatorami 
dostępu w jednym bloku kolejno.

Klasy uchwyty:

Jeżeli zmieniam coś w pliku nagłówkowym klasy, to muszę przekompilować (a nie 
łączyć jeszcze raz) wszystkie pliki, do których go dołączam. Rozwiązanie – klasy
uchwyty: wszystko, co dotyczy wewnętrznej implementacji znika i pozostaje 
pojedynczy wskaźnik – uśmiech - do struktury zawierającej wewnętrzną 
implementację, zawartej w pliku zawierającym implementacje funkcji:

Class Handle
{
   Struct Cheshire;
   Cheshire* smile;  // wewnętrzna implementacja
Public:
  ...
};

Strona 2

thinking in C++

W pliku implementacyjnym:

Struct Handle::Cheshire { int i; };
Trzeba w funkcji inicjalizującej zainicjalizować:
Smile = new Cheshire; np. smile->i = 0; // no i o zwolnieniu pamięci trzeba 
pamiętać

Rozdział 6 – inicjalizacja i końcowe porządki

• Instrukcja dalekiego goto, zaimplementowana w postaci funkcji setjmp() i 
longjmp(), zawartych w standardowej bibliotece C, nie powoduje wywołania 
destruktorów.
• C99 pozwala na definicje zmiennych w dowolnym miejscu zasięgu, podobnie jak w 
C++.
• Kompilator sprawdza, czy definicja obiektu (a zatem i wywołanie konstruktora) 
nie została umieszczona w miejscu, w którym sterowanie tylko warunkowo 
przechodzi przez punkt sekwencyjny, jak na przykład w switch, lub w takim które 
może przeskoczyć goto. Przykład:

Switch(i)
{
            Case 1: X x2; break; // tu jeszcze działa
Case 2:... //tu już nie działa, bo możemy odwołać się do nie zainicjalizowanego 
x2
}

Inicjalizacja agregatowa:
• tablicy elementów typu wbudowanego: int a[5] = { 1,2,3,4,5 };
• Jeżeli zostanie podanych za mało argumentów, to kompilator użyje pierwszych 
inicjatorów do zainicjowania pierwszych elementów, a resztę wyzeruje
• Automatyczne zliczanie – nie trzeba podawać rozmiaru, kompilator sam ustali.
• struktury (bez konstruktora, wszystko publiczne): Analogicznie: np. X x2[3] = 
{ {2,3,4}, {4,5,6} }; // trzeci jest zerowany.
• jeżeli jest konstruktor, trzeba przy inicjalizacji jawnie go wywołać: Y y1[] =
{ Y(1), Y(2), Y(3) };
Rozdział 7: Przeciążenie nazw funkcji i argumenty domyślne

• Unie mogą również posiadać: konstruktory, destruktory i kontrolę dostępu
• Unia anonimowa – gdy nie podano nazwy typu ani nazwy zmiennej unii – rezerwuje
ona pamięć dla unii, nie wymaga jednak podawania nazwy zmiennej i kropki przy 
dostępie do jej elementów.
• Domyślne argumenty są umieszczane wyłącznie w deklaracji funkcji.
• Funkcja memcpy(&gdzie,&skąd,ile) – kopiuje pamięć z jednego do drugiego 
obszaru (efektywnie)
Rozdział 8 – Stałe

• Zrobione za pomocą #define – nie ma żadnej informacji o typie, co może 
prowadzić do błędów.
• Składanie stałych – kompilator upraszcza złożone wyrażenia złożone ze stałych 
podczas kompilacji.
• Stałe są domyślnie łączone wewnętrznie, więc aby móc używać takiej stałej we 
wszystkich plikach trzeba w nagłówkowym umieścić deklarację ze słowem extern. 
Jednak wymusza się wtedy przydzielenie stałej pamięci. Nie dokonuje się wtedy 
składanie stałych.
• Można robić stałe agregaty, wtedy jednak prawie na pewno zostanie im 
przydzielona pamięć, nie można używać też wartości zmiennych z takiego agregatu 
w trakcie kompilacji (np. do wyznaczania rozmiaru tablicy)
• Różnice w stosunku do C: w C stałe to po prostu zmienne, które nie mogą być 
zmieniane, przez co nie można ich wykorzystać np do size’owania tablic.
• Jeżeli pobierany jest adres stałej (nawet niejawnie np podczas pobierania 
referencji w funkcji) albo stała zostanie zdefiniowana z użyciem słowa extern, 
to jest jej przydzielana pamięć. Stałe można umieścić w pliku nagłówkowym nie 
martwiąc się o kolizje w trakcie łączenia.

Wskaźniki do stałych:
• Const int* u; - zapobiega zmianom elementu, na który wskazuje, można zmienić 

Strona 3

thinking in C++

adres takiego wskaźnika. Taki zapis jest równoważny: int const* u;

Stały wskaźnik:

Int d = 1; 
Int* const w = &d; // można zmieniać wskazywany element, ale nie można zmieniać 
adresu – stały wskaźnik zawsze wskazuje na to samo.

• Można utworzyć stały wskaźnik do stałej
• Można przypisać wskaźnikowi do stałej zmienną nie będącą stałą, ale nie 
odwrotnie.
• Niezmienniczość jest bezwzględnie egzekwowana w literałach napisowych 
(literały będące tablicami znakowymi).

• Można napisać: char* cp = „czesc”; Jednak technicznie jest to błąd, ponieważ 
literały napisowe są tworzone przez kompilator jako stałe tablice znakowe, a 
wartością zwracaną przez tablicę znaków ujętych w cudzysłów jest adres początku 
jej w pamięci. Modyfikacja jakiegokolwiek znaku, znajdującego się w takiej 
tablicy jest błędem wykonania programu, chociaż nie wszystkie kompilatory 
egzekwują to w poprawny sposób. Zmiana znaku w takim stałym literale jest 
niezdefiniowana i nie jest błędem tylko przez mus zgodności z C. Jeżeli chce się
modyfikować łańcuch powinno się go umieścić w tablicy: char cp[] = „czesc”;
• Przekazywanie stałej przez wartość – można dowolną zmienną wrzucić, ale nie 
można zmieniać w funkcji wartości jej kopii.;
• Zwracanie stałej przez wartość – zwracana kopia nie może być zmieniana, przez 
co funkcji zwracającej stałą nie można użyć jako l-wartości
• Do funkcji pobierającej referencje lub wskaźnik nie można przekazywać obiektu 
tymczasowego(np. wartości zwracanej przez inną funkcję), chyba że funkcja 
pobiera referencję do stałej.
• Obiekty tymczasowe – są automatycznie tworzone jako stałe.
• Zapis f() = wartość nie jest błędny, gdyż następuje inicjalizacja wartością 
stałego obiektu tymczasowego, który i tak jest za chwilę niszczony.
• Ilekroć przekazuje do funkcji obiekt przez referencję lub wskaźnik, powinienem
dać modyfikator const, żeby móc wrzucać do funkcji stałe.
• Return „napis”; - zwraca adres do stałej (litarału znakowego), zapisanego w 
danych statycznych (nie jest to obiekt tymczasowy)
• Jak funkcja f() zwraca np const int* const, to jest możliwe przypisanie const 
int* x= f(); - Nie trzeba pisać drugiego const, gdyż kopiowana jest wartość 
(którą jest adres przechowywany we wskaźniku), zapewnienie że wskazywana przez 
nią wartość pozostanie nienaruszona jest automatycznie podtrzymywane, tak więc 
ten specyfikator ma znaczenie tylko jeżeli chodzi o używanie jako l-wartości.
• Lista inicjatorów konstruktora – stałe tylko tu można inicjalizować za pomocą 
ich konstruktorów (dlatego też wbudowanym typom danych „wbudowano” 
konstruktory).
• Na stałych obiektach można wykonywać tylko stałe funkcje składowe. Aby zrobic 
stałą funkcję składową, trzeba const napisać tuż przed średnikiem (otwierającym 
nawiasem klamrowym). Trzeba powtórzyć słowo const w definicji funkcji, następnie
kompilator wymusza dla takiej funkcji nienaruszalność składowych.

W jaki sposób można zmienić składowe obiektu będącego stałą:
1. Pobiera się wskaźnik this i rzutuje się go na wskaźnik do obiektu bieżącego 
typu (this jest domyślnie wskaźnikiem do stałej, więc trzeba rzutować). Nie jest
to jednak zalecane.
2. Słowo kluczowe mutable przed odpowiednimi składowymi.

Modyfikator volatile – składnia identyczna jak w przypadku const (też np funkcje
volatile), oznacza że zmienna może być modyfikowana bez wiedzy 
programu/kompilatora.
Rozdział 9 – funkcje inline

• Preprocesor nie ma prawa dostępu do prywatnych składowych klas.
• W makroinstrukcjach trzeba uważać na nawiasowanie.
• Podczas każdego użycia argumentu w makroinstrukcji jest obliczana jego 
wartość. Jest to problem, gdy obliczanie wartości wiąże się ze skutkami 
ubocznymi.
• Definicje funkcji inline prawie zawsze muszą być umieszczane w plikach 
nagłówkowych – kompilator umieszcza w tablicy symboli typ funkcji oraz ciało 
funkcji. Funkcja taka ma szczególny status, gdyż nie powoduje to błędu 

Strona 4

thinking in C++

wielokrotnej definicji funkcji (definicja musi być jednak identyczna we 
wszystkich miejscach, gdzie jest dołączana funkcja inline).
• Kompilator nie jest w stanie dokonać rozwinięcia funkcji gdy: są w niej pętle 
lub rekurencja, Gdy bezpośrednio lub pośrednio jest pobierany adres takiej 
funkcji (tylko tam funkcja nie będzie rozwijana).

Specjalne instrukcje preprocesora w makroinstrukcjach:
- łańcuchowanie
- łączenie łańcuchów: łączy w jedną dwie sąsiednie tablice znakowe
- sklejanie symboli: dyrektywa ## - skleja dwa symbole, tworząc nowy 
identyfikator:
Np: #define FIELD(a) char* a##_string;
Rozdział 10 – zarządzanie nazwami

• Ilekroć są projektowane są funkcje zawierające zmienne statyczne, należy 
pamiętać o kwestiach dotyczących wielowątkowości
• Statyczne zmienne w funkcjach, jeżeli nie zostały zainicjalizowane, to są 
automatycznie inicjalizowane zerami.
• Funkcja exit() – zakończenie pracy programu, są wszystkie destruktory 
wywoływane( najczęściej funkcja main() ją domyślnie wywołuje) – wywołanie w 
destruktorze może doprowadzić do nieskończonej rekurencji.
• Funkcja abort() – zakończenie pracy, nie są wywoływane destruktory obiektów 
statycznych
• Funkcja atexit() – można ustalić działania które nastąpią po opuszczeniu maina
(wywołana exit()) – funkcja zarejestrowana przez atexit() moze zostać wywołana 
przed destrukotarmi wszelkich obiektów, utworzonych przed opuszczeniem funkcji 
main().
• Podobnie jak w przypadku zwykłego niszczenia obiektów, niszczenie obiektów 
statycznych następuje w kolejności odwrotnej do kolejności ich inicjalizacji.
• Obiekty globalne – tworzone zawsze przed wejściem do funkcji main(), a usuwane
po jej zakończeniu.
• Natomiast konstruktor globalnego obiektu statycznego jest uruchamiany jeszcze 
przed wywołaniem funkcji main() – można wykonywać kod przed wejściem do main() i
po wyjściu (destruktor jest uruchamiany po wyjściu z main())
• Słowo kluczowe extern określa w jawny sposób, że widoczność nazwy obejmuje 
wszystkie jednostki translacji. Jeżeli zmienną, która wygląda na zmienną 
lokalną, zadeklaruje się przy użyciu słowa kluczowego extern, oznacza , że jest 
ona przechowywana w jakimś innym miejscu pamięci (jest więc ona w rzeczywistości
globalna w stosunku do funkcji).
• Słowa static można też używać w stosnku do funkcji

Przestrzenie nazw:

• Namespace myLib { deklaracje } – składnia, przestrzeń musi być w zasięgu 
globalnym, ew. zagnieżdżone w innym namespace
• Definicja przestrzeni nazw może być „kontynuowana” w wielu plikach 
nagłówkowych, za pomocą „powtórnej” definicji.*
• Można utworzyć synonim nazwy przestrzeni nazw: namespace nowa_nazwa = 
stara_nazwa;
• Bezimienne przestrzenie nazw – ograniczają tak jak static widoczność do 
zasięgu pliku.
• Do przestrzeni nazw można „wstrzyknąć” nazwę funkcji poprzez umieszczenie 
wewnątrz przestrzeni klasy z deklaracją friend do tej funkcji:

Namespace me
{
Class us { ... friend void f(); };
}  // teraz f() należy też do przestrzeni nazw me

• Sposoby odwoływania się do nazw z przestrzeni:
1. pomocą operatora zasięgu, nazwa_przestrzeni::nazwaZTejPrzestrzeni
2. using namespace nazwa – zaimportowanie od razu całej przestrzeni nazw – można
za pomocą tego przenieść wszystkie nazwy z jednej przestrzeni do drugiej. Można 
stosować wewnątrz funkcji. Uwaga – przez takie używanie using, można zrobić 
kolizje nazw, które są wykryte dopiero przy korzystaniu z funkcji.
3. deklaracja using: jest deklaracją w obrębie bierzącego pliku, może zasłonić 
dyrektywę using, składnia intuicyjna: using nazwa. (nawet przy funkcji – nie 
podajemy np. nawiasów). Oznacza to, że jeżeli są przeciążane funkcje, to 

Strona 5

thinking in C++

wszystkie uaktywniamy.

• Nie ma czegoś takiego jak problem wielokrotnej deklaracji za pomocą using.
• Składowe statyczne – definicja najczęściej w pliku implementacyjnym
• Przykład definicji dla static int A::i: int A::i = 0; (lub wywołanie 
konstruktora)
• Tablice statyczne – definicja taka jak przy inicjalizacji agregatowej
• Stałe statyczne całkowitych typów – definicji można dokonać wewnątrz klasy.
• Statyczne dane nie mogą być definiowane w klasach definiowanych lokalnie
• Można tworzyć statyczne funkcje składowe – wywołuje się je często nie na 
konkretnym elemencie, tylko z wykorzystaniem operatora zasięgu: X::f(); mogą 
operować tylko na statycznych składowych, nie jest im przekazywany this.
• Można umieścić wewnątrz klasy statyczną składową o typie tym samym co klasa.
• Obiekty statyczne (w sensie zajmowanej pamięci a nie widoczności) umieszczone 
w jednostce translacji są inicjalizowane przed pierwszym wywołaniem funkcji 
znajdującej się w tej jednostce.
• Nie istnieją żadne ustalenia dotyczące kolejności inicjalizacji obiektów 
statycznych znajdujących się w różnych jednostkach translacji. Może to 
doprowadzić do poważnych problemów, gdy nasze obiekty statyczne są wzajemnie od 
siebie uzależnione.
• Zanim następuje dynamiczna inicjalizacja obiektow statycznych (wywołanie np. 
konstruktora), wywoływana jest statyczna inicjalizacja polegająca na wyzerowaniu
zawartości pamięci, nie zawsze jednak to wystarcza, nie zawsze ma znaczenie.
Jak to rozwiązać:
1. tworzy się statyczny obiekt specjalnej klasy służącej do inicjalizowania 
zmiennych statycznych – ma ona domyślny konstruktor i destruktor, które 
przesuwają licznik, tak że inicjalizacja i kasowanie zmiennych globalnych odbywa
się tylko na początku lub na końcu działania programu. Definicja tej klasy 
znajduje się w pewnym pliku nagłówkowym, w pliku implementacyjnym znajduje się 
inicjalizacja licznika i definicje zmiennych globalnych. Działa nie tylko w 
stosunku do typów wbudowanych, jednak aby obiekty w ten sposób zainicjalizować, 
muszą one posiadać jakieś funkcje inicjalizujące i sprzątające zamiast 
konstruktorów i destruktorów (o innych nazwach), lub robi się wskaźniki do 
obiektów i wykonuje się new w klasie initializer.
2. W przypadku każdej zależności dotyczącej inicjalizacji, obiekt statyczny jest
umieszczany wewnątrz funkcji, zwracającej referencję do tego obiektu, Dzięki 
temu jedynym sposobem uzyskania dostępu do statycznego obiektu jest wywołanie 
funkcji, a w przypadku gdy obiekt ten musi odwoływać się do innego obiektu, od 
którego zależy, musi wywołać funkcję tego obiektu, dzięki czemu kolejność 
inicjalizacji jest na pewno właściwa. Uwaga – nie można robić tych funkcji 
inline

• Nie można wywołać globalnie funkcji, chyba że jest ona używana do 
inicjalizacji zmiennych.
Rozdział 11 – Referencje i konstruktor kopiujący

Referencje przypominają stałe wskaźniki, które są automatycznie wyłuskiwane, 
referencja musi być od razu zaninicjalizowana
Można zrobić referencję do wskaźnika: int*& i – dobre przy przekazywaniu 
wskaźnika do funkcji, która ma na celu zmodyfikowanie jego adresu.

Jak kompilator wywołuje funkcję:
1) argumenty są najpierw umieszczane na stosie – od prawej strony do lewej, a 
następnie jest wywoływana funkcja. Kod wywołujący funkcję jest odpowiedzialny za
usunięcie argumentów ze stosu. W trakcie wykonywania instrukcji call asemblera, 
procesor umieszcza na stosie adres kodu programu, spod którego nastąpiło 
wywołanie funkcji, dzięki czemu instrukcja return asemblera może wykorzystać ten
adres w celu powrotu do miejsca wywołania.
2) Wartość zwracana przez funkcję jest umieszczana w rejestrze (nie na stosie!) 
W przypadku dużych obiektów, które mogą się nie zmieścić w rejestrze, jest 
przesyłany adres miejsca, gdzie taką wartość należy zapisać(ukryty argument 
funkcji)

Konstruktor kopiujący, składnia: X(const X& x)
Jeżeli wartość zwracana jest ignorowana, to i tak jest tworzony obiekt 
tymczasowy, który ją przechowuje.
W przypadku kompozycji, konstruktor kopiujący wywołuje konstruktory kopiujące 
składowych.

Strona 6

thinking in C++

Wskaźniki do składowych:
Zdefiniowanie: typSkładowej Klasa::*wskaźnikSkładowej = &KlasaObiektu::składowa
Używanie: wskaźnikObiektu->*wskaźnikSkładowej = wartość;
Obiekt.*wskaźnikSkładowej = wartość;
W rzeczywistości nie istnieje coś takiego jak adres składowej, tak więc 
wyrażenie &KlasaObiektu::składowa może być użyte tylko w kontekście wskaźnika do
składowej.
Tych wskaźników nie można inkrementować ani porównywać, można robić wskaźniki do
funkcji składowych. Podobne do normalnego wskaźnika do funkcji, tylko trzeba 
dodać operator zasięgu, oraz w trakcie przypisywania trzeba dodać operator 
zasięgu.,
Rozdział 12 – przeciążenie operatorów

Operatory można przeciążać operatory w postaci funkcji globalnych 
(zaprzyjaźnionych, niebędących składowymi), jak i funkcji składowych

Operatory jednoargumentowe (+,-,~,&,!,++,—)
W klasie Klasa trzeba zadeklarować:
Friend const Klasa& operator@(const Klasa& a);// dla przyrostkowego —,++: 
jeszcze ,int
W przypadku operatorów typu ++ - bez const
Zwraca się *this;
Następnie jest definicja odpowiednich funkcji.
Funkcje składowe – analogicznie, tylko nie dajemy dodatkowego argumentu Klasa& 
a.

Operatory dwuargumentowe – analogicznie, tylko dwa argumenty. Dla funkcji 
modyfikujących, lewy argument nie może być stałą (dla arg. Typu +=)
Operatory warunkowe zwracają int będący wartością logiczną.
W operatorach modyfikujących należy dopisać: if(&left == &right) { ewentulana 
obsługa przypisania do samego siebie }. W funkcjach składowych jest tylko right.

Operator = może być tylko funkcją składową.
Możliwe jest przeciążanie operatorów działających na różnych typach danych 
(dodawanie gruszek do jabłek)

Ogólne uwagi:
1) jeżeli nie zamierza się modyfikować argumentów operatora, to należy je 
przekazać jako referencje do stałej
2) Typ wartości zwracanej powinien zależeć od spodziewanego znaczenia operatora
3) Nie należy zwracać referencji do stałej, żeby wyrażenie mogło wystąpic jako 
l-wartość
4) Dla przyrostkowego operatora in(de)krementacji, konieczne jest zwrócenie 
wartości przez wartość, trzeba się dobrze zastanowić czy to ma być stała, czy 
nie
Return X(x); - nie jest to wywołanie konstruktora, tylko utworzenie obiektu 
tymczasowego, dlatego efektywniejsze to jest od: X x1(x); return x1;
Dlatego efektywniejsze, gdyż gdy kompilator widzi taką instrukcję, to wie, że 
obiekt jest tworzony wyłącznie w celu jego zwrócenia, więc tworzy obiekt 
bezpośrednio w miejscu przeznaczonym na zwróconą wartość, nie ma też 
konieczności wywołania destruktora, gdyż nie jest tworzony obiekt lokalny.

Nietypowe operatory:
- operator[] – musi być funkcją składową, i wymaga jednego argumentu, używamy 
gdy chcemy, żeby obiekt zachowywał się jak tablica
- operator przecinkowy, nie jest raczej używany.
- operator -> - używany, gdy chcemy, żeby obiekt zachowywał się jak wskaźnik, 
musi być funkcją składową klasy, ma dodatkowe ograniczenie: musi zwracać obiekt 
(albo referencję), również posiadający operator wyłuskania wskaźnika, albo 
zwracać wskaźnik, który może zostać użyty do wybrania tego, co wskazuje strzałka
operatora.

Operator *-> - operator dwuargumentowy, naśladowanie wskaźnika do składowej
Funkcja ta musi zwracać obiekt, dla którego można wywołać funkcję operator() z 
argumentami przeznaczonymi dla wywoływanej funkcji składowej.

Operator() – też musi być funkcją składową, dopuszcza dowolną liczbę argumentów,
obiekt wygląda tak, jak by był funkcją

Strona 7

thinking in C++

Operatory, których nie można przeciążać: wyboru składowej (.), wyłuskania 
wskaźnika do składowej (.*), nie ma operatorów definiowanych przez użytkownika, 
nie można zmieniać reguł dotyczących priorytetów operatorów.

Funkcja składowa, czy nie? Zalecenia:
Wszystkie operatory jednoargumentowe funkcje składowe
=,(),[],->,->* muszą być składowe
+=,-=,/=,*=,^=,&=,|=,%=,»=,«= składowe
Wszystkie pozostałe operatory dwuargumentowe nie składowe

Technika zwiększająca szybkość: przy kopiowaniu obiektu zwiększamy tylko licznik
obiektów, tworzymy nowy dopiero przy zapisie.

Automatyczna konwersja typów

Konwersja za pomocą konstruktora: (odpowiedzialna klasa docelowa)
Definiujemy konstruktor, pobierający jako jedyny argument obiekt (lub 
referencję) innego typu, niejawnie jest on wywoływany. Jeżeli nie chcemy do tego
doprowadzać, należy przed konstruktorem dodać słowo kluczowe explict – wtedy 
będzie trzeba jawnie wywoływać
Przeciążenie operatora: (odpowiedzialna klasa źródłowa)
Składania: operator Typ() const { defincja }, też można explict użyć

Jednym z najważniejszych powodów stosowania globalnych przeciążonych operatorów 
jest fakt, że w ich przypadku konwersja może być zastosowana w odniesieniu do 
każdego argumentu (np wyrażenie 1 + a przy składowym nie będzie się kompilować)

Może być tylko jedna konwersja z danego typu do drugiego, w przeciwnym wypadku 
będzie dwuznaczność.
Rozdział 13 – dynamiczne tworzenie obiektów

1.Pamięć może zostać przydzielona, zanim rozpocznie się praca programu – w 
obrębie obszaru danych statycznych, obszar ten istnieje przez cały czas 
działania programu.
2. Pamięć moża zostać przydzielona na stosie
3. Pamięć może zostać przydzielona na stercie. W celu przydzielenia tej pamięci 
w trakcie pracy programu, wywoływana jest funkcja.

Obsługa sterty w C:
Funkcje: malloc(), calloc(), realloc() – przydzielają pamięć
Free() – zwalnia pamięć.
Przykład użycia malloc(): Obj* obj – (Obj*)malloc(sizeof(Obj)); free(obj);
Malloc() zwraca void*. Malloc() zwraca wartość zerową, gdy nie uda się jej 
przydzielić pamięci.
Jeżeli zrobimy pamięć przez malloc() i zwolnimy przez free(), to wynik jest 
niezdefiniowany (prawdopodobnie będzie działać, tylko destruktor nie zostanie 
wywołany)
Jeżeli wskaźnik usuwany za pomocą delete jest zerowy, to nic się nie stanie.
Jak to działa:
1) wywoływana jest funkcja malloc(), zgłaszająca żądanie przydziału pamięci
2) przeszukiwana jest pula pamięci w celu znalezienia wystarczająco dużego bloku
– działa to w różnym czasie, jest wolniejsze od stosu.

Usuwanie wskaźnika void* jest prawdopodobnie błędem – delete musi wiedzieć, jaki
jest typ usuwanego obiektu. Należy uważać, żeby nie usunąć przez delete czegoś, 
co nie jest na stercie

Gdy operator new nie potrafi znaleźć pamięci, to wywoływana jest funkcja obsługi
operatora new (sprawdzany jest wskaźnik do tej funkcji i jeżeli nie jest zerowy,
to funkcja jest wywoływana).
Domyślnym zachowaniem funkcji obsługi operatora new jest zgłoszenie wyjątku.
Aby wymienić funkcję obsługi operatora new, należy dołączyć do programu plik 
nagłówkowy new.h i wywołać funkcję set_new_handler(), podając jej adres funkcji,
która ma zostać zainstalowana. Funkcja ta nie może pobierać argumentów ani 
zwracać wartości.

Przeciążanie argumentów new i delete:

Strona 8

thinking in C++

Przeciążony operator musi pobierać argument typu size_t. Argument ten jest 
generowany i przekazywany funkcji przez kompilator. Funkcja musi zwrócić albo 
wskaźnik do obiektu żądanej wielkości (lub większej) – void*, albo wartość 
zerową, w przypadku gdy nie można znaleźć wolnej pamięci (wtedy nie zostanie 
wywołany konstruktor)
Uwaga na przeciążanie podczas dziedziczenia!
Gdy robimy tablicę operatorem new, to rozmiar jej jest 4 bajty większy – w nich 
jest zapisana m.in. informacja o rozmiarze tablicy.
Rozdział 14 – dziedziczenie i kompozycja

Składnia dziedziczenia: class Son : public/private/protected Parent { … };
Wszystkie składowe klasy Parent stają się składowymi klasy potomnej. W 
rzeczywistości następuje coś podobnego do kompozycji: klasa Son zawiera obiekt 
podrzędny klasy Parent.
Klasa potomna nie ma dostępu bezpośredniego dostępu do składowych prywatnych, ma
za to do protected i publicznych. Można w klasie potomnej tworzyć nowe funkcje, 
składowe o nazwach takich samych jak w podstawowej – zasłaniają one poprzednie. 
Aby wygrzebać poprzednią, trzeba to zrobić operatorem zasięgu.
Trzeba wywołać konstruktor klasy podstawowej w liście inicjatorów konstruktora.
Zawsze wywoływane są wszystkie konstruktory i destruktory klas podrzędnych – 
konstruktory od dołu do góry, destruktory odwrotnie. Kolejność wywołań nie jest 
związana z kolejnością na liście inicjatorów, kolejność ta jest wyznaczona przez
kolejność obiektów w klasie. Przedefiniowanie jednej funkcji, zasłania wszystkie
funkcje przeciążone z klasy podrzędnej.

Funkcje, które nie są automatycznie dziedziczone:
- operator przypisania
- konstruktory i destruktory
Statyczne funkcje składowe tak samo są dziedziczone.

Domyślnie, dziedziczenie jest typu private ( gdy nie użyje się specyfikatora)

Rzutowanie w górę (upcasting) – konwersja wskaźnika lub referencji do klasy 
potomnej na wskaźnik/referencję klasy podstawowej, nie trzeba używać jawnych 
rzutowań.

Każdy komunikat, który może być wysłany do klasy podstawowej, może być też 
wysłany do klasy potomnej.
Ilekroć tworzymy konstruktor kopiujący, powinniśmy pamiętać o poprawnym 
wywołaniu konstruktora klasy podstawowej.
Rozdział 15 – polimorfizm

Wiązanie wywołania funkcji – połączenie wywołania funkcji z jej ciałem.
Kiedy wiązanie jest dokonywane przez kompilator lub program łączący – wtedy jest
to wczesne wiązanie.
Późne wiązanie – wiązanie jest wykonywane w trakcie wykonywania programu na 
podstawie informacji o typie obiekt – kompilator co prawda nie wie, jaki jest 
rzeczywisty typ obiektu, ale wstawia kod umożliwiający odnalezienie i wywołanie 
odpowiedniego ciała funkcji.

Składnia do użycia późnego wiązania – słowo kluczowe virtual w deklaracji 
funkcji, znajdującej się w klasie podstawowej (wyłącznie w deklaracji). Jeżeli 
funkcja została zadeklarowana jako wirtualna w klasie podstawowej, to 
automatycznie wszystkie funkcje w klasach pochodnych są wirtualne. Zasłanianie –
przedefiniowanie funkcji wirtualnej w klasie pochodnej.

W jaki sposób C++ realizuje późne wiązanie:
Typowy sposób:
Kompilator dla każdej klasy zawierającej funkcje wirtualne tworzy pojedynczą 
tablicę, nazywaną VTABLE, gdzie umieszcza adresy funkcji wirtualnych zawartych w
klasie. W każdej klasie posiadającej funkcje wirtualne niejawnie jest 
umieszczany wskaźnik wirtualny (VPTR), wskazujący na VTABLE tej klasy. Gdy za 
pomocą wskaźnika obiektu klasy podstawowej wywołuje się funkcję wirtualną, 
kompilator niejawnie wstawia kod, pobierający wskaźnik VPTR i odnajdujący adres 
funkcji w tablicy VTABLE.

W każdej klasie z f. wirtualnymi jest ukryta informacja o typie. W przypadku 
umieszczenia w klasie bez składowych informacji o typie, zasłania ona „ślepą” 

Strona 9

thinking in C++

składową.

Wszystkie obiekty klasy podstawowej i klas pochodnych tej klasy, posiadają 
wskaźniki VPTR w tym samym miejscu. Konstruktor inicjalizuje VPTR.

Klasa abstrakcyjna - jest taka wtedy, gdy tworzy się w niej chociaż jedną 
funkcję czysto wirtualną.
Funkcja czysto wirtualna – też słowo kluczowe virtual, ale na jej końcu 
występuje = 0;
Nie można tworzyć obiektów takiej klasy, aby klasa pochodna nie była 
abstrakcyjna, musi mieć zasłonięte wszystkie czysto wirtualne funkcje z 
podstawowej. Nie trzeba pisać definicji funkcji wirtualnych, wystarczy napisać 
=0;
Przez to nie da się przez wartość przekazać obiektu klasy abstrakcyjnej np. 
poprzez rzutowanie. Funkcja czysto wirtualna może jednak zawierać definicję, 
która np. może mieć wspólny kawałek kodu dla reszty funkcji.

Jeżeli dokona się rzutowania w górę obiektu, a nie wskaźnika lub referencji, to 
zostanie on okrojony.

Strona 10