ukazatele.cpp

#include <iostream>
#include <conio.h>

// ukazkova struktura
struct s {
    float * a;
    int b;

    // nazvěme to MAGIC, když to pošlu na výstup tak se to prostě vypíše obsah struktury
    // když je a NULL tak to tam místo toho napíše NaN
    friend std::ostream& operator<<(std::ostream& os, s& o) {
        os << "struktura ( a = " << ((o.a == nullptr) ? NAN : *(o.a)) << ", b = " << o.b << ")";
        return os;
    };

    // tomu se říká konstruktor, další magic
    // misto:
    // a neco;
    // neco.a = 5;
    // neco.b = new float(3.14);
    // lze:
    // a neco(5, 3.14);
    s(int ib) : b(ib) {
        a = nullptr;
    };

    s(int ib, float ia) : b(ib) {
        a = new float(ia);
    };

    s() {
        a = nullptr;
    }
};


int main()
{
    // prvni - lokalni, ukazatel ve strukture neiniciovany
    s prvni(1);

    // druhy - lokalni, vše zadáno
    s druha(2, 3.14f);

    // treti - ukazatel, ukazatel ve strukture neiniciovany
    s * treti = new s(3);

    // ctvrta - ukazatel, vše zadáno
    s * ctvrta = new s(4, 1.14f);

    // pata, po staru, ukazatel na float nechane prazdny
    s * pata;
    pata = new s();
    (*pata).b = 5;
    pata->a = nullptr;

    // sesta, použitý malloc, vše zadáno
    s * sesta;
    sesta = (s*)malloc(sizeof(s));
    sesta->a = new float(1.01f);
    (*sesta).b = 6;

    // exemplárně vypíšeme všechno co máme
    std::cout << prvni << std::endl << druha << std::endl;
    std::cout << treti << std::endl << ctvrta << std::endl;
    std::cout << *treti << std::endl << *ctvrta << std::endl;
    std::cout << pata << std::endl << sesta << std::endl;
    std::cout << *pata << std::endl << *sesta << std::endl;

    // rozdil mezi new a malloc
    // vždy kombinace new + delete nebo malloc(existuje ještě calloc, ale to je nepodstatný, FIY,) + free
    // když cokoli ziniciuješ přes new/malloc, tak to tam zustane, dokud to neuvolníš
    // nebo dokud nevypneš program. pokud něco neuvolníš bude to tam strašit. a může to dělat bordel.
    // ukázka špatnýho chování

    int * cislo = new int(1); // iniciace ukazatele na int, s hodonou 1
    std::cout << "adresa: " << cislo << " hodnota: " << *cislo << std::endl; // muzeme ho vypsat
    cislo = new int(2); // nová iniciace ukaaztele, hodnota 2, timhle se ztrati ukazatel na ten predchozi, navzdy
    std::cout << "adresa: " << cislo << " hodnota: " << *cislo << std::endl; // jina adresa
    delete(cislo);
    // ve vysledku jsi ztratil do konce programu (přibližně) 4B paměti, který už nikdy nezíkáš zpátky

    // teď k těm dereferencim. pouzivat budu jen jednu strukturu, ktera je cela zaplnena
    // ve vysledku je jedno jak se ta struktura iniciaovala
    // bude to ve tvaru "vyraz" - "vysledek"

    // sesta - adresa
    std::cout << "sesta - " << sesta << std::endl;

    // *sesta - struktura (tady se zavolá ta magic funkce a vypíše co v ní je)
    std::cout << "*sesta - " << *sesta << std::endl;

    // (*sesta).b - cislo 6
    std::cout << "(*sesta).b - " << (*sesta).b << std::endl;

    // sesta->b - cislo 6 - shodne s predchozim
    std::cout << "sesta->b - " << sesta->b << std::endl;

    // *sesta.b - cislo 6 - toto je chyba, nejde zkompilovat!
    //std::cout << "*sesta.b - " << *sesta.b << std::endl;

    // sesta->b - cislo 6 - shodne s predchozim
    std::cout << "sesta->b - " << sesta->b << std::endl;

    // (*sesta).a - adresa ukazatele ve strukture
    std::cout << "(*sesta).a - " << (*sesta).a << std::endl;

    // sesta->a - adresa ukazatele ve strukture - shodne s predchozim
    std::cout << "sesta->a - " << sesta->a << std::endl;

    // *(*sesta).a - cislo 1.01
    std::cout << "*(*sesta).a - " << *(*sesta).a << std::endl;

    // *sesta->a - cislo 1.01 - shodne s predchozim
    std::cout << "*sesta->a - " << *sesta->a << std::endl;

    // (*sesta).*a - toto nefunguje!, hvezdicku uplne na zacatek.
    //std::cout << "*(*sesta).a - " << (*sesta).*a << std::endl;

    // sesta->*a - toto tez nefunguje!
    //std::cout << "sesta->*a - " << sesta->*a << std::endl;

    // a magie nakonec, [] funguje jako dereference
    // sesta[n] === *(sesta + n*sizeof(s)), pro n = 0 je to jen *(sesta)
    // to n to posune o n délek té struktury v paměti, (zvýší se adresa)
    // a formálně jsme iniciovali pole o velikosti 1, takže
    // sesta[0].a[0] - cislo 1.01
    std::cout << "sesta[0].a[0] - " << sesta[0].a[0] << std::endl;
    _getch();
}