19 Wzorce Projektowe

SOLID (R.C. Martin)
(założenia programowania obiektowego)

Single responsibility - Klasa powinna mieć tylko jedną odpowiedzialność

Open - Klasy (encje) powinny być otwarte na rozszerzenia i zamknięte na modyfikacje.

Liskov podstawianie - Funkcje z wskaźnikami (referen) do klas bazowych, muszą być w stanie używać również obiektów klas dziedziczących po klasach bazowych (bez ich znajomości) LINK

Interface segregation - Wiele dedykowanych interfejsów jest lepsze niż jeden ogólny

Dependency inversion - Wysokopoziomowe moduły nie powinny zależeć od modułów niskopoziomowych. Tworzymy interfejsy których używają wysokopoziomowe i wstrzykujemy wysokim w konstruktorze adres obiektu niskiego poziomu. Dzięki czemu wysoki nie jest zależna od konkretnego niskiego ale zależy od abstrakcji (interfejs). Abstrakcja reprezentowana przez zmienna składową inicjalizowaną konstruktorem.

Books:

Gang of Four - in software development 

(Wzorce projektowe - obiektowe  oprogramowanie wielokrotnego użytku )

Zostań architektem oprogramowania
PWN Link 

UML soft:
Darmowe narzędzie online do tworzenia diagramów
UML z zastosowaniem plantuml



WZORCE:

0 Wstrzykiwanie zależności (dependency injection ) - nie opisana w Gang of Four.

1 Konstrukcyjne

2 Strukturalne

3 Operacyjne (czynnościowe )


4 Architectural Patterns

5 Anti-Patterns

6 Okreslenia

7 Czysty Kod

1

                                                        Creational patterns    - Konstrukcyjne (tworzenie)

Singleton s130 *   kod
gwarantuje, że klasa będzie miała tylko jeden egzemplarz i zapewnia globalny dostęp do jej obiektu             

Factory Method  s110 * (czysty kod s 250)     kod
określa interface do tworzenia obiektów, umozliwia klasom przekazanie tworzenia egzemplarzy PODLKASOM

Abstract Factory  s101 
udostepnia interface do tworzenia rodzin powiazanych ze soba obiektów bez okreslania ich klas konkretnych     

Builder s92 *    kod 
oddziela tworzenie obiektu od jego reprezentacji

2

                                                 Structural Patterns      -strukturalne   (relacje )

Adapter s141 * (czysty kod s 231)  kod 
przeksztalca interface klasy na oczekiwany przez klienta, umozliwia wspoldzialanie klasom, które nie moga

Decorator s152
dolacza dodatkowe obowiazki do obiektu (tworzenie podklas o wzbogaconych funkcjach)

Bridge s181
oddziela abstrakcję od jej implementacji (mozna je modyfikowac niezaleznie)

Facade s161 * (czysty kod s252)    kod 
udostępnia jednolity interface dla zbioru interfejsów z podsystemu. Fasada określa interfejs wyższego poziomu ułatwiając korzystanie z podsystemów.

Flyweight s201 (pyłek) ?
Wykorzystuje współdzielenie do wydajnej obsługi dużej liczby małych obiektów.

Composite s170  (czysty kod s 242)
Składa obiekty w struktury drzewiaste odzwierciedlające hierarchię typu część-całość. Wzorzec ten umożliwia klientom traktowanie poszczególnych obiektów i ich założeń w ten sam sposób.

3

                                               Behavioral Patterns        -operacyjne(czynnościowe ):

Chain of Responsibility s244 
pozwala unikac nadawcy wiazania go z odbiorca poniewaz umozliwia obsluzenie zadania wiecej niz jednemu obiektowi

Template Method s264
okresla szkielet algorytmu i pozostawia doprecyzowanie niektorych jego krokow podklasom

Observer s269 * (czysty kod s 245)  kod 
okresla zależność "jeden do wieli" między obiektami, kiedy zmieni sie stan jednego, reszta wie

Strategy s321 (czysty kod s 233)
okresla rodzine algorytmow, kapsulkuje kazdy z nich i umozliwia ich zamienne stosowanie

Command (polecenie ) s302 (czysty kod s237)
Kapsułkuje żądanie w formie obiektu. Umożliwia to parametryzację klienta przy użyciu różnych żądań oraz umieszczanie żądań w kolejnych dziennikach, a także zapewnia obsługę cofania operacji.

4

 Architectural Patterns 

LINK
Layered pattern
Client-server pattern
Master-slave pattern
Pipe-filter pattern
Broker pattern
Peer-to-peer pattern
Event-bus pattern
Model-view-controller pattern
Blackboard pattern
Interpreter pattern

5

                                                                     -Anti-Patterns: 

Singleton - wszystkie klasy które z niego korzystają mają bezpośrednie odwołanie do niego. Obiekt singleton w programowaniu obiektowym jest jak  zmienna globalnia w programowaniu proceduralnym.
Możesz używać tego obiektu w dowolnym miejscu, ale jest to widoczne tylko w miejscu użycia a nie w interfejsie!!

6

Okreslenia:

delegacja - dostarczanie przez argument
asocjacje:
agregacja - obiekt posiada pole z innym obiektem (składaSieZ, na UML pusty romb i czarna strzałka)
kompozycja - silna asocjacja, całość posiada część i odpowiada za nią, gdy usuwamy całość, części też są usuwane (zawiera, na UML pełny romb i czarna strzałka)
.
funkcja wyższego poziomu - przyjmuje jedną lub więcej funkcji jako argumenty lub zwraca funkcję.
KISS (zasada projektowa)- keep it simple stupid
DRY(zasada projektowa)- don't repeat yourself

7

Czysty Kod C++17:

Nazwy          (oczywiste,bez zagadkowych skrótów, bez węgierskiej, z dziedziny)

Komentarze (bez oczywistych, bez blokowych, nie dezaktywuj kodu komentarzem)

Funkcje:        
-pojedyncze zadanie
-niewielkie
-max 3 argumenty ale w proceduralnym może być więcej
-unikaj argumentów typów złożonych (klasy - podnosi zależność )
-unikaj argumentów w postaci flag (2 ścieżki funkcji) lepiej 2 funkcje
-unikaj parametrów wyjściowych (czyli argumentów przez referencje które funkcja zmienia, chaotyczne, lepiej zwracać, jeśli funkcje zwracają tylko jedną wartość można łatwo łączyć je w łańcuchy wywołań, jeśli musisz zwrócić kilka wartości zwróć std::tuple lub std::pair
-nie zwracaj NULL ani nullptr jesli funkcja zwraca zwykły wskaźnik, przerzucasz na jednostkę wywołującą obsługę pojawienia się takiej sytuacji, nie jest też jasne co się stało, czy nie znalazł, czy błąd itp...
-unikaj zwykłych wskaźników, stos nie sterta, argument przez referencję nie wskaźnik, jeśli musisz użyć wskaźników użyj smartptr
-używaj const jak najczęściej w celu ochrony danych

C a C++       (nowoczesne zamiast char*, nie uzywaj printf itp, kontenery stl nie tablice, stosuj rzutowanie c++, unikaj MAKR)

C++ zaawansowane: 
-stosuje smartptr
-unikaj new i delete - alokuj na stosie lub std::make, korzystaj z kontenerów które zarządzają pamięcią
-używaj semantyki przenoszenia r-value ale nie wszędzie RVO copy-elision
-stosuj regułę zera!
-auto - automatyczna dedukcja typu
-obliczenia na etapie kompilacji czyli constexpr(wyrażenie stałe)
-używaj algorithm



Obiektowe    (SOLID, unikaj statycznych składowych klas)

RAII (ang. Resource Acquisition Is Initialization) - popularny wzorzec projektowy, którego zadaniem jest przejęcie kontroli nad zasobem w chwili tworzenia obiektu (w konstruktorze) i zagwarantowanie, że zasób zostanie automatycznie zwolniony (w destruktorze).

TDD               (zamiast dopisywania testów jednostkowych pisz TDD, zadanie TDD LINK)

Wzorce projektowe (używaj :-)

artykuł w Programista:
Czysty kod w embedded                Programista nr 78 str36


                                                                             KOD:

0 Wstrzykiwanie zależności (dependency injection ) 

Zamiast tworzyć singletony, utwórz tylko jeden obiekt i wstrzykuj go tam gdzie jest potrzebny.
Obiekty kliencie  nie muszą samodzielnie zarzącać potrzebnymi obiektami ani rządać ich od np fabryki.
Cel:
Oddzielenie komponentów od wymaganych przez nie usług, tak by komponenty nie musiały znać nazwy tych usług ani sposobu ich zapewniania.
Wykorzystanie przy stosowaniu jednego z założen programowania obiektowego, czyli odwróconej zależności, dependency inversion - wysokopoziomowe moduły nie powinny zależeć od modułów niskopoziomowych. Dlatego Tworzymy interfejsy których używają wysokopoziomowe obiekty i wstrzykujemy im w konstruktorze adres obiektu którym steruje ten interface (które dziedziczą po interfejsie). Dzięki czemu wysokopoziomowy obiekt nie jest zależny od konkretnej instancji obiektu niskiego poziomu ale zależy od abstrakcji (interfejs). Abstrakcja reprezentowana przez zmienna składową inicjalizowaną konstruktorem.

Wzrasta również łatwość testowania, nie występują ukryte zależności od singletonów. Teraz można łatwo zastapić rzeczywistą usługę atrapą. 
Dobry obiektowy projekt powinien gwarantować, że używana moduły są możliwie luźno powiązane a wstrzykiwanie zależności to droga do tego. 

Odpowiedzialność za tworzenie obiektu i konsolidowanie go z innymi jest przenoszona z obiektów do scentralizowanego komponentu infrastrukturalnego - assemblera który działa na poziomie rozruchu programu. 

Strzałki pełne, asocjacje idą z dołu do góry, czyli moduł wyższego rzędu CustomerRepository nie zależy od niższych. Wyższa korzysta z LogingFacility (interface) po którym z kolei dziedziczą  obiekty niższego rzędu (strzałka pusta - Generalizacja/dziedziczenie) Standard i File Logger.
Relacja pomiędzy modułem wyższego rzędu a interfejstem (pełny romb i czarna strzałka ) to kompozycja - silna agregacja, moduł wyższy posiada pole z adresem obiektu (typu interface, inicjalizowane w konstruktorze) i odpowiada za nią .

Jeśli nie ma możliwości wstrzykiwania za pomocą konstruktora, obiekt musi udostępniac setter obiektu usługowego

1 Konstrukcyjne

Singleton s130 (konstrukcyjny)

Klasa z implementacją singletona zawiera:
-statyczną zmienną przechowującą instancję tej klasy,
-prywatny „pusty” konstruktor (aby nie można było utworzyć nowego obiektu tej klasy z wykorzystaniem operatora „new”),

-publiczną statyczną metodę „getInstance” bez żadnych parametrów.

class Singleton {
    static Singleton instance;
    Singleton() {}
public:
    static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
            }
        return instance;
        }
};

.

Factory (konstrukcyjny)

Za każdym razem gdy używamy w kodzie operatora new, uzależniamy się od konkretnej implementacji zamiast od interfejsu. Jedna z zasad programowania obiektowego (reguła odwracania zależności / dependency inversion principle) mówi:
Uzależniaj kod od abstrakcji, a nie od klas rzeczywistych.
druga zasada open/closed mówi:
System powinien być otwarty na rozbudowę, ale zamknięty na modyfikacje.

Simple Factory

Przeważnie wywoływana przez klienta przez statyczną metodę (przeważnie parametryzowaną) i zwraca jeden z wielu obiektów tego samego interfejsu.

jeśli mamy w klasie część kodu która w przyszłości może być rozbudowywana, np tworzenie roznych
wersji nowych obiektow na podstawie roznych argumentow, to przenosimy ten fragment kodu do osobnej klasy:

class SimpleFactory {
public:
Product createProduct(String type) {
     if (type.equals("round")) {
         Product product = new RoundProduct();
         } 
            else if (type.equals("square")) {
         Product product = new SquareProduct();
         }
     return product;
 } 
};

.

Teraz pierwotna klasa zawierająca tą metodę będzie wyglądać następująco:

class ProductProcess {
SimpleFactory factory;

public:
ProductProcess(SimpleFactory factory) {      //konstruktor, ale mozna by tworzyc fabryke samodzielnie
  this.factory = factory; }    //tyle, ze ty mozemy podac zmodyfikowana
 
void doAction(String type) {
  Product product = factory.createProduct(type);
...
 }
};

.
Prosta fabryka wywoływana jest bezpośrednio przez klasę która chce utworzyć nowy obiekt. Wywołana metoda fabryki zwraca jeden z wielu obiektów dziedziczących po wspólnej klasie bazowej lub implementujących wspólny interfejs.

Factory Method s110

Wykorzystuje mechanizm dziedziczenia. Implementacja polega na stworzeniu metody abstrakcyjnej która zostanie zaimplementowana w klasie po niej dziedziczącej.

Wzorzec ten definiuje dwie równoległe hierarchie klas (interfejsy):
-Klasy produktów (np. RoundProduct, SquareProduct).
-Klasy fabryki (np. PolishFactory, GermanFactory).

Metoda fabrykująca definiuje  interfejs pozwalający na tworzenie obiektów, równocześnie pozwalając klasom podrzędnym decydować jakiej klasy obiekt zostanie stworzony. Odpowiedzialność za tworzenie obiektów zostaje przekazana klasom podrzędnym.

Implementacja wzorca dla napisanej wcześniej klasy ProductProcess kozystajacej z fabryki
może wyglądać tak:

class AbstractProductProcess {
public:
void doAction(String type) {
  Product product = createProduct(type);
 }
 
protected:
virtual Product createProduct(String type)=0;
};

.

NIE MA TUTAJ OSOBNEJ KLASY FABRYKI Metodą fabrykującą jest abstrakcyjna metoda:
virtual Product createProduct(type);

ktora nadpiszemy  i stworzymy fabryke!:

Załóżmy, że chcemy teraz przygotować możliwość przetwarzania produktów w dwóch wersjach:
Wersja dla lokalizacji w Polsce.
Wersja dla lokalizacji w Niemczech.

polska fabryka:

class PolishProductProcess: public AbstractProductProcess {
protected: 
createProduct(String type) override {

     if (type.equals("round")) {
         Product product = new PolishRoundProduct();
     } 
            else if (type.equals("square")) {
         Product product = new PolishSquareProduct();
     }
 return product;
 }
};

.

niemiecka fabryka:

class GermanProductProcess: public AbstractProductProcess {
protected: 
createProduct(String type) override {

     if (type.equals("round")) {
         Product product = new GermanRoundProduct();
     } else if (type.equals("square")) {
         Product product = new GermanSquareProduct();
     }
 return product;
 }
};

.

przykład uzycia:

AbstractProductProcess factory;
factory = new PolishProductProcess();
factory.doAction("round"); //zostaną wykonane operacje na utworzonym obiekcie PolishRoundProduct
 
factory = new GermanProductProcess();
factory.doAction("square"); //zostaną wykonane operacje na utworzonym obiekcie GermanSquareProduct

.
Metoda fabrykująca pozwala klientom podrzędnym decydować jakiej klasy obiekt zostanie utworzony.

Abstract Factory s101 (konstrukcyjny)

Wykorzystuje kompozycję. Zwraca całą rodzinę powiązanych ze sobą obiektów.
Ideą fabryki abstrakcyjnej jest tworzenie rodzin spokrewnionych ze sobą obiektów. Ten wzorzec tak jak poprzednie pozwalają na tworzenie kodu, który będzie uzależniony od abstrakcji, a nie od implementacji konkretnych klas.

warstwowo pierwsza fabryka komponenty typu pierwszego, druga drugiego
kolejna warstwa fabryka korzystajaca z pierwszej warstwy
przykład:
link

Builder s92 (konstrukcyjny)

Należy rozważyć użycie wzorca budowniczy gdy:
-obiekt, który tworzymy jest złożony i nie da się go uprościć
-nie da się utworzyć instancji obiektu poprzez jednorazową operację (wieloetapowa inicjalizacja)
-obiekt, którzy tworzymy, będzie budowany wiele razy w różny sposób

słożony z:
-budowniczy (CarBuilder) – dostarcza abstrakcyjny interfejs służący do budowania finalnego produktu
-konkretny budowniczy (SmallCarBuilder) – dostarcza implementację metodom budowniczego
-kierownik (CarDirector) – konstruuje obiekt z wykorzystaniem jakiegoś budowniczego (logika)
-produkt (Product) – finalny złożony obiekt, dostarczony przez kierownika, zbudowany za pomocą budowniczego

// budowniczy - interfejs implementacji (abstrakcyjna klasa)

class CarBuilder
{
Car* car;                           //zmienna gdzie bedzie tyworzony samochod
public:
    virtual void BuildWheels()=0;
    virtual void BuildAddons()=0;
    virtual void BuildEngine()=0;

    Car* GetResult
    {
        return this.car; 
    }
};

.

// konkretny budowniczy - implementacja

class SmallCarBuilder : CarBuilder
{
public:
    SmallCarBuilder()  //konstruktor
    {
        this.car = new Car();
    }

    void BuildWheels() override
    {
        car.Wheels = "Steel rims 15 inches";
    }

    void BuildAddons() override
    {
        car.Addons = new List<string>();
        car.Addons.Add("CD radio with MP3");
        car.Addons.Add("CD radio");
    }

    void BuildEngine() override
    {
        car.Engine = EngineFactory.CreateEngine("120 HP engine");
    }
};

.

// kierownik - logika inicjalizacji obiektu

class CarDirector
{
public:
 void ConstructCar(CarBuilder builder)
    {
        builder.BuildWheels();
        builder.BuildAddons();
        builder.BuildEngine();
    }
};

.

tworzenie:

void Main(string[] args)
{
    CarDirector carDirector = new CarDirector();           //kierownik
    CarBuilder smallCarBuilder = new SmallCarBuilder();    //konkretny budowniczy

    // buduj według logiki kierownika używając implementacji z konkretnego budowniczego
    carDirector.ConstructCar(smallCarBuilder);

    Car* smallCar = smallCarBuilder.GetResult;     //przypisz produkt do zmiennej
}

.
  //mozliwa wersja, getresult w kierowniku zamiast w budowniczym,

Opis:
najważniejszymi elementami wzorca jest kierownik oraz konkretny budowniczy. Kierownik skupia logikę budowania, konkretny budowniczy skupia implementację tej logikii
budowniczy jest nic nieznaczącym interfejsem (w przykładzie klasa abstrakcyjna) aby zapewnić wspólny interfejs polimorficzny dla konkretnych implementacji budowniczych (spełnienie 4 zasady SOLID odwrócenie zależności)
dzięki oddzieleniu logiki od implementacji, możemy zmienić logikę budowania obiektu w jednym miejscu (kierownik) i zostanie ona zmieniona w całym systemie – w każdym budowniczym.

2 Strukturalne

Adapter s141 * (czysty kod s 231)
Przeksztalca interface klasy na oczekiwany przez klienta. Bardzo często stosowany, dostosowuje niezgodne interfejsy.
Dodajemy klasę dziedziczącą po interfejsie (adapter który dziedziczy po interfejsie a potrafi obsługiwać nasz niekompatybilny objekt). Tak naprawdę adapter to nowa implementacja interfejsu.
Jeśli interfejsy bardzo się różnią komplikuje to adapter.

.

#include<iostream>
#include<string>

using namespace std;

class IPlayer //Client wants to use this.
{
public:
 virtual void Play() = 0; //This is function client wants to use
};

class OldPlayer //What we have
{
 string _song;
public:
 OldPlayer(string song) :_song(song){}

 void OldPlay(int volume) //This is function we got
 {
  cout << "\nPlaying song : " << _song << " at volume :" << volume << "\n";
 }
};

class Adapter : public IPlayer, public OldPlayer
{
 int _volume;
public:
 Adapter(string song, int volume) :_volume(volume), OldPlayer(song){}

 void Play()  //Comes from public inheritance
 {
  OldPlay(_volume); //Comes from private inheritance
 }
};

int main()
{
 IPlayer* newStuffDad = new Adapter("Good Ole Boy Like Me", 50);
 newStuffDad->Play(); //The call to the interface function is routed by the adapter to the LegacyCode.
 cout << "\n";
        delete newStuffDad;
 return 0;
}

Facade s161 * (czysty kod s252) strukturalny

Zapewnienie jednolitego interfejsu dla zbioru interfejsow podsystemu. Definiuje interface wyższego poziomu.

Tworzenie struktury dużego systemu prowadzi do powstania większych komponentów i modułów. Należy ukryć przed klientami wewnętrzną strukturę. Niewskazane by klient podsystemu mógł znać jego wewnętrzną strukturę. Wzorzec fasada reguluje dostęp do złożonego systemu, zapewniając prosty interface. Dostęp wyłącznie za jego pomocą.

#include <iostream>

// Subsystem 1
class SubSystemOne
{
public:
 void MethodOne(){ std::cout << "SubSystem 1" << std::endl; };
};

// Subsystem 2
class SubSystemTwo
{
public:
 void MethodTwo(){ std::cout << "SubSystem 2" << std::endl; };
};

// Subsystem 3
class SubSystemThree
{
public:
 void MethodThree(){ std::cout << "SubSystem 3" << std::endl; }
};


// Facade
class Facade
{
public:
    Facade()
    {
 pOne = new SubSystemOne();
 pTwo = new SubSystemTwo();
 pThree = new SubSystemThree();
    }

    void MethodA()
    {
 std::cout << "Facade::MethodA" << std::endl;
 pOne->MethodOne();
 pTwo->MethodTwo();
    }

    void MethodB()
    {
 std::cout << "Facade::MethodB" << std::endl;
 pTwo->MethodTwo();
 pThree->MethodThree();
    }

private:
    SubSystemOne *pOne;
    SubSystemTwo *pTwo;
    SubSystemThree *pThree;
};

int main()
{
    Facade *pFacade = new Facade();

    pFacade->MethodA();
    pFacade->MethodB();

    return 0;
}

 3 Behavioral Patterns        -operacyjne(czynnościowe ):

Observer s269 * (czysty kod s 245)

Definiowanie zależności jeden do wielu między obiektami w taki sposób, że gdy jeden obiekt
zmienia stan, wszystkie zależne obiekty są powiadamiane i automatycznie aktualizowane.

Pomyśl o arkuszu kalkulacyjnym, który jest typowym składnikiem wielu pakietów oprogramowania biurowego. W takiej aplikacji dane mogą być wyświetlane w arkuszu roboczym, na wykresie kołowym i w wielu innych formach. Są to widoki, które można tworzyć, a następnie ponownie zamykać.
Przede wszystkim potrzebna jest klasa abstrakcyjna reprezentująca widoki — Observer.
Obserwatory obserwują podmiot. Na potrzeby obserwacji można je zarejestrować w podmiocie.
Możliwe jest też wyrejestrowanie obserwatora.

Najważniejsza jest tu funkcja składowa notifyAllObservers(). Opatrzona jest ona specyfikatorem
protected, ponieważ ma być wywoływana przez klasy konkretne z rodziny Subject dziedziczące po danej klasie. Ta funkcja pobiera wszystkie zarejestrowane obserwatory i wywołuje ich funkcję składową update().

Oprócz korzystnego luźnego powiązania (klasa konkretna podmiotu nie wie nic na temat obserwatorów) ten wzorzec dobrze wspomaga też zasadę otwarte – zamknięte. Teraz można łatwo dodawać klasy konkretne obserwatorów.

Obserwatorzy dziedziczą po jednej klasie, dzięki czemu kontener je rejestrujący może być jednego typu.


Zastosowanie: W MVC  chodzi m.in. o to, by oddzielić przechowywane w modelu wyświetlane dane od różnych wizualnych reprezentacji tych danych, czyli widoków.
We wzorcu MVC powiązanie między widokami a modelem powinno być tak luźne jak to możliwe.
To luźne powiązanie jest zwykle realizowane za pomocą wzorca obserwator.
.

#include <vector>
#include <iostream>

using namespace std;

class Observer
{
  public:
    virtual void update(int value) = 0;
};

class Subject
{
    int m_value;
    vector<Observer *> m_views;
  public:
    void attach(Observer *obs)
    {
        m_views.push_back(obs);
    }
    void set_val(int value)
    {
        m_value = value;
        notify();
    }
    void notify()
    {
        for (int i = 0; i < m_views.size(); ++i)
          m_views[i]->update(m_value);
    }
};

class DivObserver: public Observer
{
    int m_div;
  public:
    DivObserver(Subject *model, int div)
    {
        model->attach(this);
        m_div = div;
    }
     /* virtual */void update(int v)
    {
        cout << v << " div " << m_div << " is " << v / m_div << '\n';
    }
};

class ModObserver: public Observer
{
    int m_mod;
  public:
    ModObserver(Subject *model, int mod)
    {
        model->attach(this);
        m_mod = mod;
    }
     /* virtual */void update(int v)
    {
        cout << v << " mod " << m_mod << " is " << v % m_mod << '\n';
    }
};

int main()
{
  Subject subj;
  DivObserver divObs1(&subj, 4);
  DivObserver divObs2(&subj, 3);
  ModObserver modObs3(&subj, 3);
  subj.set_val(14);
}

Przykładowy Kod innych wzorców projektowych

Wzorce skrótowo:

Adapter:

dostosowuje niezgodne interfejsy
jeśli mamy dwa interfejsy tworzymy klasę dziedziczącą po obu i tworzymy metodę która łączy i wywołuje oba interfejsu.

Facory:

bazowa: Car  (produkt)
dziedziczą: Fiat, Mercedes

bazowa:  AbstractProductProcess   (fabryka)
która ma 2 metody:
void doAction(String type) {
  Product product = createProduct(type);
 }
i virtualną (nadpisywaną w konkretnej fabryce)
virtual Product createProduct(String type)=0;
dziedziczy:
PolishProductProcess
(nadpisuje virtualną createProduct)
if (typ1)
  Car* car1=new Fiat();
if else (typ2)
  Car* car2=new Polonez();
itp:

Fasada:

Zapewnienie jednolitego interfejsu dla zbioru interfejsow podsystemu
większe moduły (zbiory obiektów) ukryte i tylko stworzona fasada(obiekt) do komunikacji z nimi:

class Facade
{
konstruktor (albo tworzy obiekty/instancje interfacow z modułu, albo sa wstrzykiwane)

Metoda1dlaKlienta(uruchamia ukryte metody powyzszych obiektow)

Metoda2dlaKlienta(uruchamia inne ukryte metody powyzszych obiektow)
}

Observer:

jeden do wielu między obiektami w taki sposób, że gdy jeden obiekt zmienia stan,
wszystkie zależne obiekty(obserwatorzy) są powiadamiane i automatycznie aktualizowane.

Obserwatorzy dziedziczą po jednej klasie(Obserwer), dzięki czemu kontener w Subject je rejestrujący może być jednego typu.
Observer interface ma jedną metodę visrtualną, update, którą uruchamia Subject jak chce poinformować.

klasa konkretna Subject nie wie nic na temat obserwatorów ten wzorzec dobrze wspomaga wiec zasadę otwarte na rozszerzanie– zamknięte na modyfikacje

Subject ma:
-kontener na obserwery
-dodaj (*observer)
dodaje do kontenera observery
-notyfy
iteruje po kontenerze i uruchamia update na observerach

Budowniczy:

słożony z:
-budowniczy (CarBuilder) – abstrakcyjny interfejs do budowania finalnego produktu
-konkretny budowniczy (SmallCarBuilder) – implementacja budowniczego
-kierownik (CarDirector) – konstruuje obiekt/uruchamia metody budowniczego
-produkt (Product) – Car, tworzony przez kirownika z wykorzystaniem budowniczego


class Car                                                                             (produkt)

class Budownioczy{                                                           (interface z metodami budowania)
virtual stworzNoweAuto()
virtual zrobKoła();
virtual zróbSilnik();

class KonkretnyBudowniczy : Budowniczy {                   (implementacja metod budowania )
stworzNoweAuto override
zrobKola ovveride
zróbSilnik ovveride

class Kierownik                                                                     (logika, kolejność uruchamiania metod )
Car stworzauto(budowniczy)                                                 (uruchamiane w metodzie stwórzauto)
{
stworzNoweAuto
uruchom robKola
uruchom zróbSilnik
get result {zwróc stworzone auto Car}
}


main()

Budownioczy* budowniczy = new KonkretnyBudowniczy1
Kierownik * kierownik = new Kierownik ()

Car autko1 = kierownik->stworzNoweAuto(budowniczy)


Kierownik skupia logikę budowania, konkretny budowniczy skupia implementację tej logikii
jeden kierownik, kulka rodzaji budowniczych.

przykład budowniczego z shared_ptr

#include<iostream>
#include<memory>
using namespace std;

struct Car
{
    int maxspeed;
    int wielkosc;
};

struct AbstractBuilder
{
    std::shared_ptr<Car> tempauto;

    virtual void predkosc()=0;
    virtual void rozmiar()=0;
    virtual void create()=0;
    virtual std::shared_ptr<Car> zwroc()=0;
};

struct Builder1 : AbstractBuilder
{

   void create()
    {
        tempauto.reset(new Car());
    }

    void predkosc()override
    {
        tempauto->maxspeed=1;
    }

    void rozmiar()override
    {
        tempauto->wielkosc=1;
    }

    std::shared_ptr<Car> zwroc()
    {
        return std::move(tempauto);
    }
};


struct Kierownik
{
    std::shared_ptr<Car> makeCar(AbstractBuilder* obj)
    {
    obj->create();
    obj->predkosc();
    obj->rozmiar();
    return obj->zwroc();
    }
};


int main ()
{
AbstractBuilder* builder1=new Builder1();
Kierownik kierownik;

std::shared_ptr<Car> auto1a=kierownik.makeCar(builder1);
std::shared_ptr<Car> auto1b=kierownik.makeCar(builder1);

std::cout<<auto1a->maxspeed<<" "<<auto1a->wielkosc<<std::endl;
std::cout<<auto1b->maxspeed<<" "<<auto1b->wielkosc<<std::endl;

// wypisz wewnętrzne dane wskaźnika auto1a
cout << "auto1a use_count: " << auto1a.use_count () << endl;

// wypisz wewnętrzne dane wskaźnika auto1b
cout << "auto1b use_count: " << auto1b.use_count () << endl;

return 0;
}

http://hilite.me/
monokai

18 Zawartość Książek i Magazynów

C++ compiler support Link

Magazyny

Programista:

C:
C niezdefiniowane zachowania Pr35 str16
C i C21                                      P59 str12 i 22
C pułapki                                   Pr84 str34
C 18                                           Pr68 str4
C dla mikronontr. Cortex-M0   Pr75 str12


C++:
c++ Concepts Lite (szablony)   Pr21 str36
c++ coverity jakosc kodu          Pr21 str46
c++ Zarządca zalezności           Pr36 str14
c++ string algo                          Pr38
c++ wyjątki                               Pr40 str52
c++/c#                                       Pr42 str4
c++ kompilacja z podziałem     Pr41 str40
c++ wady                                  Pr44 str58
c++ vs C szablony cz1              Pr45 str6
c++ vs C szablony cz2              Pr46 str18
c++ komunikacja wieloproc     Pr46 str32
c++ RAII                                  Pr55 str22
c++ rule of 0                             Pr60 str16
c++ przetwarzanie kodu clang Pr63 str8
c++ modernizacja kodu            Pr64 str18
c++ zarz.pamięcia                    Pr70 str18
c++ moduły                              Pr72 str18
c++ disassembly                       Pr73 str28
c++ rust                                     Pr74 str4
c++ make_unique                     Pr76 str16
c++20 pamięć tranzakcyjna      Pr77 str40
c++20 ranges                            Pr78 str16
c++ wyrównywanie pamięci    Pr80 str10
c++20 korutyny                        Pr81 str32
c++ wyjątki                              Pr84 str30
c++20 moduły                          Pr85 str36
c++ std::launder                       Pr89 str36
c++20 trzęsienie ziemi             Pr89 str 26


Systemowe:
zależności DLL                          Pr 81 str 10
protocol buffers:                        Pr 82 str 6
debugowanie                             Pr82 str 24
bariery pamieci (cache)             Pr66 str 34
przerwania                                 Pr67 str 20
XML                                          Pr39 str62
czysty kod embedded                Pr78 str36

Siec:
siec i ARP                                  Pr86 str 6
prog. kar sieciowych                 Pr79 str 28
Ether CAT- przemysłowy          Pr78 str 26
OPC-UA przemyslowa siec      Pr83 str 12


Bootloader:                               
Bootloader!                               Pr35  str28
własny RTOS                            Pr42  str14
Linux na nowej plafrotmie       Pr33  str20
botloader1                                 Pr82 str 16
wlasny Linux PI                        Pr84 str 38

Różne:
Unity wprowadzenie                 Pr71 str 36


WPF

Pr 20,21,22,25

LinuxMagazyn

unision i SSH               - LinuxMagazyn 193 str 62

gitk                               - LinuxMagazyn 185 str 17

virtualb                         - LinuxMagazyn 182 str 8

ssh magickWormhole   - LinuxMagazyn 182 str 70

siec nutty                       - LinuxMagazyn 182 str 71

siec arpscaner                - LinuxMagazyn 188 str 57

DOSbox                        - LinuxMagazyn 187str 81

LinuxJądro                   - LinuxMagazyn 187 str 32

C/C++ kompilatory      -LinuxMagazyn 169 str 13,18

terminal multi  mtm     -LinuxMagazyn 160 str 79

IRC                              -LinuxMagazyn 160 str 82

Profilowanie kodu       -LinuxMagazyn 165 str 67

Exa rozbudowane ls    -LinuxMagazyn 166 str 78

DiscRescue                   -LinuxMagazyn 169 str 79

Książki

Rozdział 1. Zadania matematyczne 19
1. Suma liczb naturalnych podzielnych przez 3 lub 5 19
2. Największy wspólny dzielnik 19
3. Najmniejsza wspólna wielokrotność 19
4. Największa liczba pierwsza mniejsza od podanej 19
5. Liczby pierwsze szóstkowe 19
6. Liczby obfite 20
7. Liczby zaprzyjaźnione 20
8. Liczby Armstronga 20
9. Czynniki pierwsze liczby 20
10. Kod Graya 20
11. Przekształcanie liczb arabskich na rzymskie 20
12. Najdłuższy ciąg Collatza 20
13. Wyznaczanie liczby Pi 20
14. Sprawdzanie numerów ISBN 20

Rozdział 2. Funkcje języka 35
15. Typ danych IPv4 35
16. Wyliczanie zakresu adresów IPv4 35
17. Utworzenie dwuwymiarowej tablicy z podstawowymi operacjami 35
18. Funkcja wyznaczająca minimum dla dowolnej liczby argumentów 36
19. Dodawanie zakresu wartości do kontenera 36
20. Dowolny, wszystkie lub żaden argument w kontenerze 36
21. Klasa opakowująca dla uchwytu systemowego 36
22. Wyświetlanie różnych skal temperatur 36

Rozdział 3. Łańcuchy i wyrażenia regularne 53
23. Zamiana typu binarnego na łańcuch 53
24. Zamiana typu łańcuchowego na binarny 53
25. Wielkie litery w tytule artykułu 54
26. Łączenie łańcuchów oddzielanych separatorem 54
27. Dzielenie łańcucha na tokeny z listą możliwych separatorów 54
28. Najdłuższy podciąg palindromiczny 54
29. Sprawdzanie tablic rejestracyjnych 54
30. Wyodrębnianie elementów adresu URL 55
31. Przekształcanie dat w łańcuchach 55

Rozdział 4. Strumienie i systemy plików 67
32. Trójkąt Pascala 67
33. Lista procesów w postaci tabeli 67
34. Usuwanie pustych wierszy z pliku tekstowego 68
35. Obliczanie rozmiaru katalogu 68
36. Usuwanie plików starszych od określonej daty 68
37. Wyszukiwanie w katalogu plików, które pasują do wyrażenia regularnego 68
38. Tymczasowe pliki logów 68

Rozdział 5. Data i czas 79
39. Pomiar czasu wykonania funkcji 79
40. Liczba dni zawartych między dwiema datami 79
41. Dzień tygodnia 79
42. Numer dnia i tygodnia w roku 79
43. Czasy spotkań dla wielu stref czasowych 80
44. Kalendarz miesięczny 80

Rozdział 6. Algorytmy i struktury danych 89
45. Kolejka priorytetowa 89
46. Bufor cykliczny 90
47. Podwójne buforowanie 90
48. Najczęściej występujący element w zbiorze danych 90
49. Histogram tekstu 90
50. Filtrowanie listy numerów telefonów 91
51. Przekształcanie listy numerów telefonów 91
52. Generowanie wszystkich permutacji ciągu znaków 91
53. Średnia ocena filmów 91
54. Algorytm tworzenia par 91
55. Algorytm scalania 92
56. Algorytm wyboru 92
57. Algorytm sortowania 92
58. Najkrótsza ścieżka między węzłami 92
59. Program Weasel 93
60. Gra w życie 93

Rozdział 7. Współbieżność 127
61. Algorytm przekształcania współbieżnego 127
62. Algorytmy wyszukiwania współbieżnego minimalnych i maksymalnych elementów w zbiorze przy użyciu wątków 127
63. Algorytmy wyszukiwania współbieżnego minimalnych i maksymalnych elementów w zbiorze przy użyciu funkcji asynchronicznych 128
64. Algorytm sortowania współbieżnego 128
65. Wyświetlanie komunikatów w konsoli w sposób bezpieczny dla wątków 128
66. System obsługi klienta 128

Rozdział 8. Wzorce projektowe 141
67. Sprawdzanie poprawności haseł 141
68. Generowanie losowych haseł 141
69. Generowanie numerów ubezpieczenia socjalnego 141
70. System zatwierdzania 142
71. Obserwowany kontener typu wektorowego 142
72. Obliczanie ceny zamówienia z rabatami 143

Rozdział 9. Serializacja danych 169
73. Serializacja danych do pliku XML i deserializacja ich z niego 169
74. Pobieranie danych z pliku XML przy użyciu języka XPath 170
75. Serializacja danych do formatu JSON 170
76. Deserializacja danych z formatu JSON 170
77. Tworzenie pliku PDF z listą filmów 171
78. Tworzenie pliku PDF na podstawie zbioru obrazów 171

Rozdział 10. Archiwa, obrazy i bazy danych 187
79. Wyszukiwanie plików w archiwum ZIP 187
80. Pakowanie plików do archiwum ZIP i wypakowywanie ich z tego archiwum 187
81. Pakowanie plików do archiwum ZIP i wypakowywanie ich z tego archiwum z zastosowaniem hasła 188
82. Tworzenie pliku PNG z flagą narodową 188
83. Tworzenie obrazu PNG zawierającego tekst weryfikacyjny 188
84. Generator kodów kreskowych EAN-13 189
85. Odczytywanie informacji o filmach z bazy SQLite 189
86. Wstawianie w sposób transakcyjny informacji o filmach do bazy danych SQLite 189
87. Obsługa multimediów w bazie danych SQLite 190

Rozdział 11. Kryptografia 225
88. Szyfr Cezara 225
89. Szyfr Vigenere'a 225
90. Kodowanie i dekodowanie base64 225
91. Sprawdzanie poprawności uwierzytelniania użytkowników 226
92. Wyznaczanie skrótów dla plików 226
93. Szyfrowanie i deszyfrowanie plików 226
94. Podpisywanie plików 226

Rozdział 12. Praca w sieci i usługi 247
95. Znajdowanie adresu IP dla hosta 247
96. Gra Fizz-Buzz klient-serwer 247
97. Kursy wymiany bitcoinów 248
98. Pobieranie wiadomości e-mailowych przy użyciu protokołu IMAP 248
99. Tłumaczenie tekstu na dowolny język 248
100. Wykrywanie twarzy na obrazie 248
Rozwiązania 249
95. Znajdowanie adresu IP dla hosta 249
96. Gra Fizz-Buzz klient-serwer 250
97. Kursy wymiany bitcoinów 255
98. Pobieranie wiadomości e-mailowych przy użyciu protokołu IMAP 258
99. Tłumaczenie tekstu na dowolny język 263
100. Wykrywanie twarzy na obrazie 267






2. Przechowywanie danych w listach i listach wiązanych
Wymagania techniczne
Tablice
Tworzenie ADT listy
Zwracanie elementu z listy
Wstawianie elementu do listy
Wyszukiwanie indeksu wybranego elementu w liście
Usuwanie elementu z listy
Implementacja listy
Wprowadzenie do węzłów
Tworzenie ADT listy jednokierunkowej
Zwracanie elementu z listy wiązanej
Wstawianie elementu do listy wiązanej
Wyszukiwanie indeksu wybranego elementu w liście wiązanej
Usuwanie elementu z listy wiązanej
Implementacja listy wiązanej
Tworzenie ADT listy dwukierunkowej
Refaktoryzacja typu danych Node
Refaktoryzacja kilku operacji LinkedList
Usuwanie elementu
Wstawianie elementu
Implementacja ADT listy dwukierunkowej
Wykorzystanie typów List i LinkedList przy użyciu STL
std::vector
std::list

3. Tworzenie stosów i kolejek
Wymagania techniczne
Tworzenie ADT stosu
Pobieranie wartości elementu z ADT stosu
Umieszczanie elementów na ADT stosu
Usuwanie elementów z ADT stosu
Implementacja ADT stosu
Inny przykład implementacji ADT stosu
Tworzenie ADT kolejki jednokierunkowej
Pobieranie wartości elementu z ADT kolejki
Wstawianie elementu do ADT kolejki
Usuwanie elementu z ADT kolejki
Implementacja ADT kolejki
Tworzenie ADT kolejki dwukierunkowej
Pobieranie wartości elementu z ADT kolejki dwukierunkowej
Dodawanie elementu do ADT kolejki dwukierunkowej
Usuwanie elementu z ADT kolejki dwukierunkowej
Implementacja ADT kolejki dwukierunkowej


4. Porządkowanie elementów przy użyciu algorytmów sortowania
Wymagania techniczne
Sortowanie bąbelkowe
Sortowanie przez wybieranie
Sortowanie przez wstawianie
Sortowanie przez scalanie
Sortowanie szybkie
Sortowanie przez zliczanie
Sortowanie pozycyjne


5. Wyszukiwanie elementów przy użyciu algorytmów wyszukiwania
Wymagania techniczne
Wyszukiwanie liniowe
Opracowanie algorytmu wyszukiwania liniowego
Implementacja algorytmu wyszukiwania liniowego
Wyszukiwanie binarne
Opracowanie algorytmu wyszukiwania binarnego
Implementacja algorytmu wyszukiwania binarnego
Wyszukiwanie ternarne
Opracowanie algorytmu wyszukiwania ternarnego
Zastosowanie algorytmu wyszukiwania ternarnego
Wyszukiwanie interpolacyjne
Opracowanie algorytmu wyszukiwania interpolacyjnego
Zastosowanie algorytmu wyszukiwania interpolacyjnego
Wyszukiwanie skokowe
Opracowanie algorytmu wyszukiwania skokowego
Zastosowanie algorytmu wyszukiwania skokowego
Wyszukiwanie wykładnicze
Opracowanie algorytmu wyszukiwania wykładniczego
Wywołanie funkcji ExponentialSearch()
Wyszukiwanie podlisty
Opracowanie algorytmu wyszukiwania podlisty
Wykorzystanie algorytmu wyszukiwania podlisty

6
Używanie znakowego typu danych
Wymagania techniczne
Ciąg znakowy C++
Tworzenie ciągu znaków przy użyciu tablicy znaków
Dodatkowe funkcje std::string
Zabawa słowami
Tworzenie anagramów
Wykrywanie palindromów
Tworzenie ciągu z cyfr binarnych
Konwertowanie liczb dziesiętnych na binarne
Konwertowanie ciągu binarnego na dziesiętny
Ciąg podsekwencji
Generowanie podsekwencji z ciągu
Sprawdzanie, czy ciąg jest podsekwencją innego ciągu
Wyszukiwanie wzorca


7. Tworzenie hierarchicznej struktury drzewa
Wymagania techniczne
Tworzenie ADT drzewa binarnego
Tworzenie ADT binarnego drzewa poszukiwań
Wstawianie nowego klucza do BST
Przechodzenie po BST po kolei
Sprawdzanie obecności klucza w BST
Zwracanie minimalnych i maksymalnych wartości kluczy
Wyszukiwanie następnika klucza w BST
Wyszukiwanie poprzednika klucza w BST
Usuwanie węzła według podanego klucza
Implementacja ADT BST
Tworzenie ADT zrównoważonego BST (AVL)
Rotacja węzłów
Wstawianie nowego klucza
Usuwanie wskazanego klucza
Implementacja ADT AVL
Tworzenie ADT kopca binarnego
Sprawdzanie, czy kopiec jest pusty
Wstawianie nowego elementu do kopca
Pobieranie elementu o największej wartości
Usuwanie elementu o największej wartości
Implementacja stosu binarnego jako kolejki priorytetowej

8. Zestawianie wartości z kluczem w tablicy mieszającej
Wymagania techniczne
Wprowadzenie do tablic mieszających
Dużo danych w małych komórkach
Przechowywanie danych w tablicy mieszającej
Obsługa kolizji
Implementacja metody łańcuchowej
Generowanie klucza mieszającego
Opracowanie operacji Insert()
Opracowanie operacji Search()
Opracowanie operacji Remove()
Opracowanie operacji IsEmpty()
Zastosowanie ADT HashTable wykorzystującego metodę łańcuchową
Implementacja techniki adresowania otwartego
Opracowanie operacji Insert()
Opracowanie operacji Search()
Opracowanie operacji Remove()
Opracowanie operacji IsEmpty()
Opracowanie operacji PrintHashTable()
Wdrożenie ADT HashTable wykorzystującego technikę szukania liniowego

9. Implementacja algorytmów w praktyce
Wymagania techniczne
Algorytmy zachłanne
Rozwiązanie problemu wydawania reszty
Zastosowanie kodowania Huffmana
Algorytmy dziel i zwyciężaj
Rozwiązywanie problemów selekcyjnych
Mnożenie macierzy
Programowanie dynamiczne
Ciąg Fibonacciego
Programowanie dynamiczne i problem wydawania reszty
Algorytmy siłowe
Wyszukiwanie i sortowanie siłowe
Wady i zalety algorytmów siłowych
Algorytmy zrandomizowane
Klasyfikacja algorytmów zrandomizowanych
Generatory liczb losowych
Zastosowania algorytmów zrandomizowanych
Algorytmy z nawrotami
Meblowanie nowego mieszkania
Kółko i krzyżyk




1 Dedukcja typów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Punkt 1: Dedukcja typów w szablonach. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Przypadek 1: ParamType to odwołanie lub wskaźnik, ale nie
odwołanie uniwersalne . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Przypadek 2: ParamType jest odwołaniem uniwersalnym . . . . . . . . . . . 13
Przypadek 3: ParamType nie jest ani wskaźnikiem, ani odwołaniem . . 14
Argumenty tablicowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Argumenty funkcyjne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Punkt 2: Dedukcja typu auto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Punkt 3: decltype . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Punkt 4: Jak wyświetlać wydedukowane typy . . . . . . . . . . . . . . . . . . . . . . . 34
Edytory IDE 34
Diagnostyka kompilatora. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Wyniki czasu wykonania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

2 auto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Punkt 5: Preferuj deklarację auto zamiast jawnych deklaracji typów. . . . 41
Punkt 6: Stosuj idiom jawnego inicjatora typu, gdy deklaracja auto
powoduje dedukcję niepożądanych typów . . . . . . . . . . . . . . . . . 48

3 Droga do nowoczesnego języka C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Punkt 7: Rozróżniaj między () a {} podczas tworzenia obiektów . . . . . . 55
Punkt 8: Preferuj nullptr zamiast 0 i NULL . . . . . . . . . . . . . . . . . . . . . . . . . . 67
Punkt 9: Preferuj deklaracje aliasów zamiast typedef. . . . . . . . . . . . . . . . . 72
Punkt 10: Preferuj wyliczenia enum z zasięgiem zamiast bez zasięgu . . . . . 77
Punkt 11: Preferuj funkcje usunięte zamiast prywatnych
niezdefiniowanych. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Punkt 12: Deklaruj funkcje nadpisujące jako override. . . . . . . . . . . . . . . . . 91
Punkt 13: Preferuj iteratory const_iterator zamiast iterator . . . . . . . . . . . 99
Punkt 14: Deklaruj funkcje jako noexcept, jeśli nie zgłaszają wyjątków. . 104
Punkt 15: Stosuj constexpr, kiedy to tylko możliwe . . . . . . . . . . . . . . . . . . 112
Punkt 16: Dbaj o bezpieczeństwo wątkowe funkcji składowych const . . 120
Punkt 17: Generowanie specjalnych funkcji składowych . . . . . . . . . . . . . 127

4 Wskaźniki inteligentne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .137
Punkt 18: Stosuj wskaźniki std::unique_ptr do zarządzania
zasobami posiadanymi wyłącznie . . . . . . . . . . . . . . . . . . . . . . . . 139
Punkt 19: Stosuj wskaźniki std::shared_ptr w przypadku
zarządzania zasobami o współdzielonym posiadaniu . . . . . . . 146
Punkt 20: Stosuj typ std::weak_ptr dla wskaźników
przypominających std::shared_ptr, które mogą zawisnąć . . . 157
Punkt 21: Preferuj funkcje std::make_unique i std::make_shared
zamiast bezpośredniego używania instrukcji new . . . . . . . . . . . 163
Punkt 22: Podczas używania idiomu Pimpl definiuj specjalne
funkcje składowe w pliku implementacji . . . . . . . . . . . . . . . . . . 173

5 Odwołania do r-wartości, semantyka przenoszenia i przekazywanie
doskonałe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .185
Punkt 23: std::move i std::forward . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
Punkt 24: Odróżniaj odwołania uniwersalne od odwołań do r-wartości 193
Punkt 25: Stosuj std::move w przypadku odwołań do r-wartości,
a std::forward w przypadku odwołań uniwersalnych . . . . . . . 199
Punkt 26: Unikaj przeciążania w przypadku odwołań uniwersalnych. . . 209
Punkt 27: Zapoznaj się z alternatywami przeciążania odwołań
uniwersalnych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
Rezygnacja z przeciążania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
Przekazywanie przez const T& . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
Przekazywanie przez wartość . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
Technika tag dispatch. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
Ograniczanie szablonów przyjmujących odwołania uniwersalne . . . 223
Kompromisy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
Punkt 28: Zwijanie odwołań. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
Punkt 29: Załóż, że operacje przenoszenia nie są ani obecne, ani
tanie, ani używane . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
Punkt 30: Zapoznaj się z przypadkami niepowodzeń przenoszenia
doskonałego . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
Inicjatory klamrowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
0 lub NULL jako wskaźniki null . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
Sama deklaracja całkowitoliczbowych danych składowych
o kwalifikatorach static const . . . . . . . . . . . . . . . . . . . . . 249
Przeciążone nazwy funkcji i nazwy szablonów. . . . . . . . . . . . . . . . . . . 251
Pola bitowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
Podsumowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255

6 Wyrażenia lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .257
Punkt 31: Unikaj domyślnych trybów przechwytywania. . . . . . . . . . . . . . 259
Punkt 32: Stosuj przechwytywanie inicjujące do przenoszenia
obiektów do domknięć . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
Punkt 33: Stosuj decltype do parametrów auto&&, aby
je przekazywać za pomocą std::forward. . . . . . . . . . . . . . . . . . . 275
Punkt 34: Preferuj wyrażenia lambda zamiast std::bind. . . . . . . . . . . . . . 278
7 Interfejs API współbieżności . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .289
Punkt 35: Preferuj programowanie oparte na zadaniach zamiast
opartego na wątkach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
Punkt 36: Określ zasadę std::launch::async, jeśli asynchoniczność
jest istotna . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
Punkt 37: Doprowadź wątki std::thread do stanu
nieprzyłączalnego na wszystkich ścieżkach . . . . . . . . . . . . . . . . 300
Punkt 38: Uważaj na różnorodne działanie destruktorów
uchwytów wątków . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Punkt 39: Rozważ obiekty future typu void do komunikacji zdarzeń
jednorazowych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
Punkt 40: Stosuj std::atomic dla współbieżności, a volatile dla
pamięci specjalnej . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325

8 Szlify. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .335
Punkt 41: Rozważ przekazywanie przez wartość parametrów, które
można kopiować i tanio przenosić – o ile są zawsze
kopiowane. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
Punkt 42: Rozważ umieszczanie zamiast wstawiania . . . . . . . . . . . . . . . . . 348



.

Rozdział 1. Nowe funkcje w C++17 (21)
Użycie strukturalnych wiązań do rozpakowania wartości zwrotnej (22)
Ograniczanie zasięgu zmiennej do konstrukcji if i switch (26)
Zalety stosowania nowych reguł inicjalizacji z użyciem składni opartej na nawiasach (29)
Umożliwienie konstruktorowi automatycznego określenia typu klasy szablonu (31)
Użycie wyrażenia constexpr-if do uproszczenia decyzji podejmowanych podczas kompilacji (33)
Włączenie bibliotek w postaci samych nagłówków z użyciem osadzonych zmiennych (37)
Implementowanie za pomocą wyrażeń fold przydatnych funkcji pomocniczych (40)

Rozdział 2. Kontenery STL (47)
Magazyn danych znajdujących się obok siebie (48)
Magazyn danych w postaci listy (49)
Drzewo wyszukiwania (49)
Tabela wartości hash (50)
Adapter kontenera (50)
Użycie stylu usuń - wymaż w kontenerze std::vector (50)
Usuwanie w czasie O(1) elementów z nieposortowanego kontenera std::vector (54)
Uzyskanie bezpiecznego dostępu do egzemplarzy std::vector (58)
Sortowanie egzemplarzy std::vector (60)
Warunkowe wstawianie elementów do kontenera std::map (63)
Stosowanie nowej semantyki podpowiedzi podczas wstawiania elementów za pomocą std::map::insert (66)
Efektywne modyfikowanie kluczy elementów std::map (69)
Użycie kontenera std::unordered_map z niestandardowymi typami danych (73)
Filtrowanie duplikatów w danych wejściowych użytkownika i wyświetlanie ich w kolejności alfabetycznej za pomocą kontenera std::set (76)
Implementowanie za pomocą kontenera std::stack prostego kalkulatora RPN (79)
Implementowanie za pomocą kontenera std::map licznika częstotliwości występowania słów (85)
Implementowanie za pomocą kontenera std::set narzędzia pomocniczego przeznaczonego do wyszukiwania bardzo długich zdań w tekście (88)
Implementowanie za pomocą kontenera std::priority_queue listy rzeczy do zrobienia (93)

Rozdział 3. Iteratory (97)
Kategorie iteratorów (99)
Tworzenie własnego zakresu, który można iterować (101)
Tworzenie własnych iteratorów zgodnych z kategoriami iteratora STL (104)
Użycie adapterów iteratora do wypełniania ogólnych struktur danych (107)
Implementowanie algorytmów w kategoriach iteratorów (110)
Iteracja w drugą stronę za pomocą adaptera iteratora odwrotnego (114)
Zakończenie działania iteratora w zakresie za pomocą wartownika iteratora (116)
Automatyczne sprawdzanie kodu iteratora (119)
Tworzenie własnego adaptera iteratora łączenia na zakładkę (123)

Rozdział 4. Wyrażenia lambda (131)
Definiowanie funkcji opartej na wyrażeniu lambda (133)
Dodawanie polimorfizmu poprzez opakowanie wyrażenia lambda egzemplarzem std::function (138)
Łączenie funkcji za pomocą konkatenacji (141)
Tworzenie skomplikowanych predykatów z logiczną koniunkcją (144)
Wywoływanie wielu funkcji dla tych samych danych wejściowych (146)
Implementowanie funkcji transform_if() za pomocą algorytmu std::accumulate i wyrażeń lambda (150)
Generowanie w trakcie kompilacji iloczynu kartezjańskiego par dla dowolnych danych wejściowych (155)

Rozdział 5. Podstawy algorytmów biblioteki STL (161)
Kopiowanie elementów między kontenerami (163)
Sortowanie kontenera (167)
Usuwanie określonych elementów z kontenera (171)
Przekształcanie zawartości kontenera (174)
Wyszukiwanie elementów w uporządkowanych i nieuporządkowanych wektorach (176)
Ograniczanie za pomocą std::clamp wartości wektora do określonego zakresu liczbowego (182)
Wyszukiwanie za pomocą std::search wzorca w ciągu tekstowym i wybór optymalnej implementacji (186)
Próbkowanie ogromnego wektora (189)
Generowanie permutacji sekwencji danych wejściowych (193)
Implementowanie narzędzia łączenia słowników (195)

Rozdział 6. Zaawansowane przykłady użycia algorytmów biblioteki STL (199)
Implementowanie klasy drzewa trie za pomocą algorytmów STL (201)
Implementowanie za pomocą drzewa trie generatora sugestii danych wejściowych używanych podczas wyszukiwania (206)
Implementowanie wzoru przekształcenia Fouriera za pomocą algorytmów STL (211)
Obliczanie błędu sumy dwóch wektorów (218)
Implementowanie procedury generującej dane ASCII dla zbioru Mandelbrota (221)
Opracowanie własnego algorytmu - podział danych (227)
Połączenie użytecznych algorytmów biblioteki STL - zbieranie danych (231)
Usuwanie nadmiarowych białych znaków znajdujących się między słowami (235)
Kompresja i dekompresja ciągów tekstowych (238)

Rozdział 7. Ciągi tekstowe, klasy strumieni i wyrażenia regularne (243)
Tworzenie, konkatenacja i przekształcanie ciągów tekstowych (245)
Usuwanie białych znaków z początku i końca ciągu tekstowego (248)
Komfortowe użycie klasy std::string bez kosztów związanych z tworzeniem obiektów std::string (251)
Odczyt wartości z danych wejściowych dostarczonych przez użytkownika (254)
Zliczanie wszystkich słów w pliku (258)
Formatowanie danych wyjściowych za pomocą manipulatorów strumienia wejścia - wyjścia (260)
Inicjalizacja skomplikowanych obiektów na podstawie pliku źródłowego (266)
Wypełnianie kontenera za pomocą iteratorów std::istream (269)
Proste wyświetlanie danych za pomocą iteratorów std::ostream (273)
Przekierowywanie sekcji kodu do pliku danych wyjściowych (277)
Tworzenie własnych klas ciągu tekstowego za pomocą dziedziczenia po klasie std::char_traits (281)
Tokenizowanie danych wejściowych za pomocą biblioteki wyrażeń regularnych (287)
Wygodne formatowanie liczb w locie w zależności od kontekstu (291)
Przechwytywanie na podstawie błędów std::iostream wyjątków możliwych do odczytania (293)

Rozdział 8. Klasy narzędziowe (297)
Konwertowanie między różnymi jednostkami czasu za pomocą std::ratio (298)
Konwertowanie między bezwzględnymi i względnymi wartościami czasu za pomocą std::chrono (304)
Bezpieczne sygnalizowanie awarii za pomocą typu std::optional (307)
Użycie funkcji wraz z krotkami (311)
Szybkie opracowywanie struktur danych za pomocą std::tuple (313)
Zastąpienie void* przez std::any dla zwiększenia bezpieczeństwa typu (320)
Przechowywanie różnych typów za pomocą std::variant (323)
Automatyczna obsługa zasobów za pomocą std::unique_ptr (329)
Automatyczna obsługa współdzielonej pamięci na stercie za pomocą std::shared_ptr (333)
Praca ze słabymi wskaźnikami do współdzielonych obiektów (338)
Uproszczenie obsługi zasobów przestarzałych API za pomocą sprytnych wskaźników (342)
Współdzielenie różnych wartości składowych tego samego obiektu (345)
Generowanie liczb losowych i wybór odpowiedniego silnika do generowania tego rodzaju liczb (348)
Generowanie liczb losowych i umożliwienie bibliotece STL określenia szczegółów rozkładu (354)

Rozdział 9. Programowanie równoległe i współbieżność (361)
Automatyczne stosowanie programowania równoległego w kodzie utworzonego za pomocą standardowych algorytmów (363)
Uśpienie programu na podany okres czasu (369)
Uruchamianie i zatrzymywanie wątków (371)
Przeprowadzanie bezpiecznego pod względem wyjątków nakładania blokady współdzielonej za pomocą std::unique_lock i std::shared_lock (375)
Zapobieganie zakleszczeniom dzięki stosowaniu algorytmu std::scoped_lock (381)
Synchronizacja jednoczesnego użycia algorytmu std::cout (384)
Bezpieczne odkładanie inicjalizacji za pomocą std::call_once (388)
Przesunięcie zadania do wykonywania w tle za pomocą std::async (390)
Implementacja wzorca producent - konsument za pomocą std::condition_variable (395)
Implementacja wzorca producent - konsument za pomocą std::condition_variable (400)
Równoległe generowanie za pomocą std::async danych ASCII dla zbioru Mandelbrota (406)
Implementacja za pomocą std::future niewielkiej biblioteki automatycznej programowania Rozdział

Rozdział10. System plików (419)

Implementowanie programu przeprowadzającego normalizację ścieżki dostępu (420)
Pobieranie kanonicznej ścieżki dostępu na podstawie względnej ścieżki dostępu (423)
Wyświetlanie wszystkich plików znajdujących się w danym katalogu (426)
Implementowanie programu wyszukującego dane i działającego podobnie jak narzędzie grep (431)
Implementowanie programu automatycznie zmieniającego nazwy plików (434)
Implementowanie programu obliczającego wielkość katalogu (437)
Obliczanie danych statystycznych dotyczących typów plików (440)
Implementowanie narzędzia zmniejszającego wielkość katalogu poprzez zastąpienie powielonych plików dołączeniami symbolicznymi (442)




Rozdział 2. Tworzenie siatki bezpieczeństwa (23)
Konieczność przeprowadzania testów (23)
Wprowadzenie do testów (25)
Testy jednostkowe (26)
A co z kontrolą jakości? (28)
Reguły tworzenia dobrych testów jednostkowych (29)
Jakość kodu testów (29)
Nazwy testów jednostkowych (29)
Niezależność testów jednostkowych (31)
Jedna asercja na test (31)
Niezależne inicjowanie środowisk testów jednostkowych (32)
Pomijanie testów getterów i setterów (32)
Pomijanie testów kodu innych programistów (32)
Pomijanie testów zewnętrznych systemów (33)
A co zrobić z bazą danych? (33)
Nie łącz kodu testów z kodem produkcyjnym (33)
Testy muszą działać szybko (36)
Zaślepki (36)

Rozdział 3. Postępuj zgodnie z zasadami (39)
Czym są zasady? (39)
Zachowaj prostotę, głupku (KISS) (40)
Nie będziesz tego potrzebować (YAGNI) (40)
Nie powtarzaj się (DRY) (41)
Ukrywanie informacji (41)
Wysoka spójność (44)
Luźne powiązanie (46)
Nie przesadzaj z optymalizacją (49)
Zasada minimalizowania zaskoczenia (50)
Reguła harcerza (50)

Rozdział 4. Podstawy czystego C++ (53)
Dobre nazwy (54)
Nazwy powinny być oczywiste (55)
Stosuj nazwy z dziedziny (56)
Dobieraj nazwy na odpowiednim poziomie abstrakcji (57)
Unikaj nadmiarowości, gdy wymyślasz nazwę (58)
Unikaj zagadkowych skrótów (58)
Unikaj notacji węgierskiej i przedrostków (59)
Unikaj używania tej samej nazwy do różnych celów (60)
Komentarze (60)
Niech kod opowiada historię (60)
Nie komentuj oczywistych rzeczy (61)
Nie dezaktywuj kodu za pomocą komentarzy (61)
Nie pisz komentarzy blokowych (62)
Rzadkie scenariusze, w których komentarze są przydatne (64)
Funkcje (67)
Jedna rzecz - nie więcej! (70)
Twórz małe funkcje (70)
Nazwy funkcji (71)
Stosuj nazwy opisujące intencje (72)
Argumenty i zwracane wartości (72)
Liczba argumentów (73)
Projekty C++ w dawnym stylu specyficznym dla C (82)
Przedkładaj łańcuchy znaków i strumienie z C++ nad dawne łańcuchy char* w stylu języka C (82)
Unikaj instrukcji printf(), sprintf(), gets() itd. (84)
Przedkładaj kontenery z biblioteki standardowej nad proste tablice w stylu języka C (87)
Używanie rzutowania z języka C++ zamiast dawnego rzutowania w stylu języka C (89)
Unikaj makr (90)

Rozdział 5. Zaawansowane aspekty współczesnego C++ (93)
Zarządzanie zasobami (93)
Idiom RAII (95)
Inteligentne wskaźniki (95)
Unikanie bezpośrednich wywołań new i delete (100)
Zarządzanie niezależnymi zasobami (101)
Warto się czasem gdzieś przenieść (102)
Czym jest semantyka przenoszenia? (102)
Czym są l-wartości i r-wartości? (103)
Referencje do r-wartości (104)
Nie wymuszaj wszędzie semantyki przenoszenia (106)
Reguła zera (106)
Kompilator to Twój współpracownik (110)
Automatyczna dedukcja typów (110)
Obliczenia na etapie kompilacji (113)
Szablony zmiennych (115)
Nie dopuszczaj do niezdefiniowanych skutków (116)
Programowanie z użyciem typów semantycznych (117)
Poznaj używane biblioteki (123)
Korzystaj z pliku nagłówkowego (123)
Korzystaj z biblioteki Boost (128)
Inne biblioteki, które powinieneś znać (129)
Prawidłowa obsługa wyjątków i błędów (130)
Lepiej zapobiegać niż leczyć (130)
Wyjątek jest wyjątkiem - dosłownie (134)
Jeśli nie możesz przywrócić stanu, szybko zamknij program (135)
Definiuj specyficzne typy wyjątków (135)
Zgłaszanie przez wartość i przechwytywanie za pomocą stałej referencji (137)
Zwracaj uwagę na właściwą kolejność klauzul catch (137)

Rozdział 6. Podejście obiektowe (139)
Myślenie obiektowe (140)
Abstrakcja - klucz do opanowania złożoności (141)
Zasady poprawnego projektowania klas (141)
Twórz niewielkie klasy (141)
Zasada jednej odpowiedzialności (142)
Zasada otwarte - zamknięte (143)
Zasada podstawiania Liskov (144)
Zasada podziału interfejsu (154)
Zasada zależności acyklicznych (156)
Zasada odwracania zależności (158)
Nie rozmawiaj z nieznajomymi (prawo Demeter) (162)
Unikaj "anemicznych" klas (166)
Mów zamiast pytać (167)
Unikaj statycznych składowych klasy (169)

Rozdział 7. Programowanie funkcyjne (171)
Czym jest programowanie funkcyjne? (172)
Czym jest funkcja? (173)
Funkcje czyste i "nieczyste" (174)
Programowanie funkcyjne w nowoczesnym C++ (175)
Programowanie funkcyjne z użyciem szablonów języka C++ (175)
Obiekty podobne do funkcji (funktory) (177)
Mechanizm wiązania i nakładki na funkcje (183)
Wyrażenia lambda (185)
Generyczne wyrażenia lambda (C++14) (187)
Funkcje wyższego poziomu (187)
Mapowanie, filtrowanie i redukcja (189)
Czysty kod w programowaniu funkcyjnym (192)

Rozdział 8. Programowanie sterowane testami (195)
Wady zwykłych dawnych testów jednostkowych (196)
Podejście TDD jako rewolucja (197)
Proces pracy w TDD (197)
TDD na przykładzie - kata dotyczące liczb rzymskich (200)
Zalety TDD (216)
Kiedy nie stosować TDD? (217)

Rozdział 9. Wzorce projektowe i idiomy (219)
Zasady projektowe a wzorce projektowe (220)
Wybrane wzorce i sytuacje, w których warto je stosować (220)
Wstrzykiwanie zależności (221)
Adapter (231)
Strategia (233)
Polecenie (237)
Procesor poleceń (240)
Kompozyt (242)
Obserwator (245)
Fabryka (250)
Fasada (252)
Klasa Money (253)
Obiekt reprezentujący specjalny przypadek (obiekt NULL) (256)
Czym jest idiom? (260)
Przydatne idiomy języka C++ (260)

Dodatek A. Krótki przewodnik po UML-u (271)
Diagramy klas (271)
Klasa (271)
Interfejs (273)
Asocjacja (275)
Generalizacja (277)
Zależność (278)
Komponenty (279)
Stereotypy (279)




1. Strategie rozwiązywania problemów (15)
Klasyczne łamigłówki (17)
Lis, gęś i kukurydza (17)
Łamigłówki z przesuwanymi elementami (22)
Sudoku (26)
Zamek Quarrasi (30)
Ogólne techniki rozwiązywania problemów (32)
Miej zawsze jakiś plan (32)
Ponownie zaprezentuj problem (33)
Podziel problem (34)
Rozpocznij z wiedzą, którą posiadasz (35)
Uprość problem (36)
Szukaj analogii (37)
Eksperymentuj (38)
Nie popadaj we frustrację (38)
Ćwiczenia (40)

2. Prawdziwe łamigłówki (41)
Elementy języka C++ wykorzystywane w tym rozdziale (42)
Tworzenie wzorów na wyjściu (42)
Przetwarzanie danych wejściowych (48)
Analiza problemu (49)
Łączenie wszystkich elementów w całość (58)
Śledzenie stanu (60)
Podsumowanie (73)
Ćwiczenia (74)

3. Rozwiązywanie problemów za pomocą tablic (77)
Podstawowe informacje o tablicach (78)
Przechowywanie danych (79)
Kopiowanie (79)
Odczytywanie i przeszukiwanie (80)
Sortowanie (81)
Obliczenia statystyczne (84)
Rozwiązywanie problemów za pomocą tablic (85)
Optymalizacja (89)
Tablice ze stałymi wartościami (91)
Tablice z wartościami nieskalarnymi (94)
Tablice wielowymiarowe (96)
Kiedy należy używać tablic (99)
Ćwiczenia (104)

4. Rozwiązywanie problemów za pomocą wskaźników i pamięci dynamicznej (107)
Podstawowe informacje o wskaźnikach (108)
Korzyści z używania wskaźników (109)
Struktury danych o wielkości definiowanej w trakcie działania programu (109)
Struktury danych o zmiennych rozmiarach (110)
Współdzielenie pamięci (110)
Kiedy należy używać wskaźników? (111)
Pamięć ma znaczenie (112)
Stos i sterta (113)
Rozmiar pamięci (116)
Czas życia (118)
Rozwiązywanie problemów za pomocą wskaźników (119)
Łańcuchy o zmiennej długości (119)
Listy powiązane (130)
Wnioski i następne działania (139)
Ćwiczenia (139)

5. Rozwiązywanie problemów za pomocą klas (143)
Przegląd podstawowych informacji o klasach (144)
Cele użycia klas (146)
Enkapsulacja (146)
Ponowne użycie kodu (147)
Dzielenie problemu (147)
Hermetyzacja (148)
Czytelność (150)
Wyrazistość (150)
Tworzenie przykładowej klasy (151)
Podstawowy schemat klasy (152)
Metody wspierające (156)
Klasy z danymi dynamicznymi (160)
Dodawanie węzła (162)
Reorganizacja listy (165)
Destruktor (169)
Kopiowanie głębokie (170)
Obraz całości dla klas z pamięcią dynamiczną (175)
Błędy, jakich należy unikać (176)
Klasa fikcyjna (176)
Jednozadaniowce (177)
Ćwiczenia (178)

6. Rozwiązywanie problemów za pomocą rekurencji (181)
Przegląd podstawowych informacji o rekurencji (182)
Rekurencja nieogonowa i ogonowa (182)
Wielki Pomysł Rekurencyjny (191)
Często popełniane błędy (194)
Zbyt wiele parametrów (195)
Zmienne globalne (196)
Używanie rekurencji w dynamicznych strukturach danych (198)
Rekurencja i listy powiązane (198)
Rekurencja i drzewa binarne (201)
Funkcje opakowujące (204)
Kiedy należy wybierać rekurencję? (207)
Argumenty przeciwko rekurencji (207)
Ćwiczenia (211)

7. Rozwiązywanie problemów za pomocą ponownego wykorzystania kodu (213)
Poprawne i niewłaściwe wykorzystanie kodu (214)
Przegląd podstawowych informacji o komponentach (215)
Blok kodu (215)
Algorytmy (216)
Wzorce (216)
Abstrakcyjne typy danych (217)
Biblioteki (218)
Zdobywanie wiedzy o komponentach (219)
Eksploracyjne zdobywanie wiedzy (219)
Zdobywanie wiedzy w razie potrzeby (223)
Wybór typu komponentu (232)
Wybór komponentu w praktyce (234)
Porównanie wyników (238)
Ćwiczenia (239)

8. Myślenie jak programista (241)
Tworzenie własnego planu głównego (242)
Uwzględnienie mocnych i słabych stron (242)
Budowanie planu głównego (248)
Rozwiązywanie każdego problemu (250)
Opracowywanie metody oszukiwania (252)
Wymagane podzadania dla metody oszukiwania w grze wisielec (254)
Wstępny projekt (256)
Kodowanie wstępne (257)
Analiza wstępnych wyników (266)
Sztuka rozwiązywania problemów (267)