====== C++ ======

===== Skrývání dat =====

Data označená klíčovým slovem **private** jsou dostupná jen metodám z téže třídy.

Ukážeme si, že to je ochrana proti neúmyslnému porušení přístupových práv. 

Pokud si někdo připraví strukturu s podobnými proměnnými, která jsou označena jako **public** \\ 
(a případně s podobnými virtuálními metodami, aby překladač použil podobné umístění proměnných uvnitř třídy), \\
lze se po přetypování ukazatele dostat k privátním datům.

<code C++>
class Private
{
private:
    int x, y, z;
public:
    Private ( ) : x (1), y (2), z (3) { }
};

class Spy
{
public:
    int x, y,  z;
};

void privateFields ()
{
    Private * p = new Private;
    Spy * s = (Spy *) p; // ukazatel na tridu Private pretypujeme na ukazatel na tridy Spy
    cout << "x = " << s->x << endl;
    cout << "y = " << s->y << endl;
    cout << "z = " << s->z << endl;
}
</code>

<code>
x = 1
y = 2
z = 3
</code>

===== Virtuální metody =====

Mějme třídu **Base** s vituální metodou **info**

<code C++>
class Base
{
protected:
    string name;
public:
    Base (string name0) : name (name0) { }
    virtual void info () { cout << "Base (name=" << name << ")" << endl; }
};
</code>

Z ní odvozenou třídu **Derived**

<code C++>
class Derived : public Base
{
private:
    int number;
public:
    Derived (string name0, int number0) : Base (name0), number (number0) { }
    void info () { cout << "Derived (name=" << name << ", number=" << number << ")" << endl; }
};
</code>

Vytvoříme instance obou tříd a oba ukazatele uložíme do proměnné typu ukazatel na **Base**.

<code C++>
void baseAndDerived ()
{
    Base * a = new Base ("alpha");
    Base * b = new Derived ("beta", 7);
    a->info ();
    b->info ();
}
</code>

Jelikož je metoda //info// virtuální je jedou zavolána metoda info ze třídy Base (**Base::info**) a podruhé **Derived::info**

<code>
Base (name=alpha)
Derived (name=beta, number=7)
</code>


===== Nahrazení metod obyčejnými funkcemi =====

Zkusme si představit jak probíhá překlad předchozího příkladu. \\
Třídy a metody přepíšeme na neobjektové struktury a funkce. \\
(Přepis jakoby do jazyka C, ale stále budu používat //new//, //string// a //cout// )

Prozatím nezvládneme virtuální metody.

Vytvoříme si strukturu **BaseStruct**. 

Metodu Base::info bez parametrů předěláme na funkci  **base_info** s parametrem ukazatel na BaseStruct. \\
Parametr pojmenujem **self** a bude náhradou za **this** v C++. \\
K členským datům se musíme dostávat přes self (např. **self->name**) \\
Volání metody **a->info()** nahradíme **base_info (a)**

<code C++>
struct BaseStruct
{
    string name;
};

void base_info (BaseStruct * self)
{
    cout << "Base (name=" << self->name << ")" << endl;
}
</code>

Konstruktor nahradí funkce **base_create**. \\
Inicializaci proměnných budu potřebovat i v konstruktoru odvozené třídy, tak si připravím funkci **base_init**

<code C++>
void base_init (BaseStruct * self, string name0)
{
    self->name = name0;
}

BaseStruct * base_create (string name0)
{
    BaseStruct * self = new BaseStruct;
    base_init (self, name0);
    return self;
}
</code>

Pro odvozenou třídu naprogramujeme **DerivedStruct**. \\
Třída z které jsme naši třídu odvodili se skrývá v položce **base** typu BaseStruct.

<code C++>
struct DerivedStruct
{
    BaseStruct base;
    int number;
};
</code>

Inicializace proměnných **derived_init** zavolá **base_init**. \\
Parametrem je adresa vnořené struktury **base**.

<code C++>
void derived_init (DerivedStruct * self, string name0, int number0)
{
    base_init (&(self->base), name0);
    self->number = number0;
}
</code>

Konstruktor přejde na **derived_create**

<code C++>
DerivedStruct * derived_create (string name0, int number0)
{
    DerivedStruct * self = new DerivedStruct;
    derived_init (self, name0, number0);
    return self;
}
</code>

Metoda info přistupuje k proměnným pomocí **self->number** nebo **self->base.name**

<code C++>
void derived_info (DerivedStruct * self)
{
    cout << "Derived (name=" << self->base.name << ", number=" << self->number << ")" << endl;
}
</code>

A zde je ekvivalent původní funkce baseAndDerived

<code C++>
void withoutVirtual ()
{
    BaseStruct * b = base_create ("first");
    DerivedStruct * t = derived_create ("second", 2);
    base_info (b);
    derived_info (t);
}
</code>

[[https://gitlab.fjfi.cvut.cz/culikzde/uop/-/blob/5f6f7e90/CPlusPlus/main.cc|program na gitlabu odpovídající právě popsané situaci]]

===== Virtuální metody pomocí ukazatelů na funkce =====

Přípravíme si předběžné deklarace struktury a funkce //base_info//

<code C++>
struct BaseStruct;
void base_info (BaseStruct * self);
</code>

Zavedeme typ **BaseMethod** - ukazatel na funkci s jedním parameterem a to ukazatelem na //BaseStruct//. \\
Tedy ukazatel na funkci stejného typu jako //base_info//.
(Pokud je virtuálních metod více, připravíme několik typů)

<code C++>
typedef void (*BaseMethod) (BaseStruct *);
</code>

Do struktury //BaseStruct// přidáme ukazatel na původně virtuélní metodu.

<code C++>
struct BaseStruct
{
    string name;
    BaseMethod info_method;
};
</code>

Při inicializaci proměnných nastavíme ukazatel **info_method** na **base_info**.

<code C++>
void base_init (BaseStruct * self, string name0)
{
    self->name = name0;
    self->info_method = base_info;
}

BaseStruct * base_create (string name0)
{
    BaseStruct * self = new BaseStruct;
    base_init (self, name0);
    return self;
}

void base_info (BaseStruct * self)
{
    cout << "Base (name=" << self->name << ")" << endl;
}
</code>

Odvozená třída se nezmění.

<code C++>
struct DerivedStruct
{
    BaseStruct base;
    int number;
};
</code>

Jen při inicializace přepíšeme **info_method** na derived_info

<code C++>
void derived_info (DerivedStruct * self);

void derived_init (DerivedStruct * self, string name0, int number0)
{
    base_init (& (self->base), name0);
    self->base.info_method = (BaseMethod) derived_info; // přetypujeme - parametr je jiného typu
    self->number = number0;
}
</code>

Další funkce se nezmění

<code C++>
DerivedStruct * derived_create (string name0, int number0)
{
    DerivedStruct * self = new DerivedStruct;
    derived_init (self, name0, number0);
    return self;
}

void derived_info (DerivedStruct * self)
{
    cout << "Derived (name=" << self->base.name << ", number=" << self->number << ")" << endl;
}
</code>

Volání **b->info()** nahradíme **b->info_method(b)**

Do proměnné **t** uložíme novou instanci odvozené třídy. \\
Při volání metody info se musíme dostat k vnořenámu objektu základní třídy a také musíme přetypovat parametr funce.

Pokud **t** uložíme do proměnné **v** typu ukazatel na základní třídu,  \\
můžeme metodu info zavolat pomocí **v->info_method(v)** a přitom se zavolá //info// z odvozené třídy.

<code C++>
void withVirtual ()
{
    BaseStruct * b = base_create ("first");
    b->info_method (b);

    DerivedStruct * t = derived_create ("second", 2);
    t->base.info_method (& t->base);

    BaseStruct * v = & t->base;
    v->info_method (v);
}
</code>

<code>
Base (name=first)
Derived (name=second, number=2)
Derived (name=second, number=2)
</code>

[[https://gitlab.fjfi.cvut.cz/culikzde/uop/-/blob/def3aaf1/CPlusPlus/main.cc|gitlab]]