Notatki do obiektowego

//ARGUMENTY DOMNIEMANE
    float fun (char, float=10, float=1); //deklaracja funkcji
    //możliwe wywołania funckji
    float fun('a');
    float fun('a', 1);
    float fun('a', 1, 2);

//PRZECIĄŻANIE FUNKCJI
    int fun(int);
    int fun(int, int);
    int fun(float);
    //w main:
    int a = 1;
    int b = 1;
    float f = 3.5;
    //mozliwe wywolania:
    fun(a);
    fun(a, b);
    fun(f);

//FUNKCJE INLINE
    //do małych, krótkich funkcji
    inline int zaokraglij (float liczba){
        return (liczba+0.5);
    }
    //w main
    float x = 3.23;
    cout << zaokraglij(x) << endl;

//PRZEKAZYWANIE ARGUMENTOW
    void f1 (int, int);
    void f2 (int*, int*);
    void f3 (int&, int&);
    //w main
    int a = 3;
    int b = 4;
    f1(a,b); //argumenty przekazane przez wartosc - funkcja operuje na kopii
    f2(&a,&b); //argumenty przekazane przez wskaźnik - funkcja operuje na adresach
    f3(a,b); //argumenty przekazane przez referencję - funkcja operuje na tych zmiennych (nie są tworzone kopie)

//WSKAZNIKI TYPU VOID
    int *wskI; //wskazuje na adres zmiennej typu int
    float *wskF; //wskazuje na adres zmiennej typu float
    void *wskV; //wskazuje na adres jeszcze nie wiemy jakiej zmiennej, można mu przypisać wskaźnik każdego dowolnego typu (bez przydomka const)
    w = wskI;
    w = wskF;
    //ale
    wskF = (float*) wskV;
    wskI = (int*) wskV;

//DYNAMICZNE PRZYDZIELANIE PAMIĘCI
    char *wsk;
    wsk = new char; //adres nowego obiektu typu char przekazany do wskaźnika
    delete wsk; //usunięcie obiektu pokazwyanego przez wskaźnik wsk

    float *tab;
    tab = new float[15];
    delete []w; //usunięcie tablicy pokazywanej przez w
    //obiekty utworzone przez "new" są dynamiczne, dlatego przed przypisaniem wartości są w nich śmieci


//KLASY
    class mojaKlasa{
        //pola klasy - zmienne
        //metody klasy - funkcje
    };

    //Aby odnieść się do pola:
    //obiekt.składnik
    //wskaźnik->składnik
    //referencja.składnik

    //różne klasy mogą posiadać tak samo nazwane funkcje

    //DEFINICJA METODY POZA CIAŁEM KLASY
    class punkt{
        float x;
        float y;
    public:
        void wypisz();
    };

    void punkt::wypisz()
    {
        cout << "x=" << x << "\ty=" << y << "\n";
        //alternatywnie:
        //cout << "x=" << this->x << "\ty=" << this->y << "\n";
    }

    //WSKAŹNIK THIS
    // wskaźnikiem this nie można poruszać (jest typu "klasa const")

    //KONSTRUKTOR
    class punkt{
        float x;
        float y;
    public:
        punkt(); //konstruktor bezargumenotwy
        punkt(float a, float b){x=a; y=b}; //konstruktor dwuargumentowy
    };
    //w main
    punkt p1 = punkt(2,4);
    punkt p2(2, 4);
    punkt p3; //domyślnie wywoła się konstruktor bezargumenotwy
    //- można go przeładować
    //- nie zwraca żadnej wartości
    //- nie tworzy obiektu, ale nadaje mu wartości początkowe
    //- wywoływany tylko raz - w momencie, gdy obiekt powoływany jest do życia
    //- gdy nie napiszemy żadnego konstruktora, będzie domyślny konstruktor bezargumenotwy (nie będzie on widoczny w kodzie programu, ale będzie obecny)
    //- wiele obiektów tymczasowych może pojawić się w sposób niejawny (aby zobaczyć do konstorów dodać linię wypisującą, że wywołano konstruktor)
    //- klasa może mieć tylko jeden konstruktor domniemany
    //- konstruktor domniemany można wywołać bez żadnych argumentów (nie koniecznie jest to konstruktor bezargumentowy), czyli ze wszystkimi argumentami domniemanymi

    class demo
    {
        int x, y;
    public:
        demo(int xx=1, int yy=0) //konstruktor z 0,1 bądź 2 argumentami
        {
            x = xx;
            y = yy;
        }
        demo(demo &d) //konstruktor kopiujący
        {
            x = d.x;
            y = d.y;
        }
    };

    //DESTRUKTOR
    ~nazwa_klasy(){};
    //- bezargumentowy
    //- nie zwraca żadnej wartości
    //- nie jest konieczny
    //- jawne wywołanie nie likwiduje obiektu, on ciągle istnieje, jedynie został zmodyfikowany

//ZMIENNE STATYCZNE
    int funkcja(){
        static int ile_wywolan = 0;
        ile++;
        return ile;
    }
    //za n-tym wywołaniem funkcja zwróci n;
    //- nie są ponownie inicjalizowane podczas ponownego użycia funckcji
    //- przechowywane na stercie w segmencie danych, a nie na stosie
    //- inicjalizowane wartością 0 (jeśli nie są inicjalizowane jawnie)
    //- nie powinny być deklarowane wewnątrz struktury (kompilator C wymaga ciągłego obszaru pamięci dla struktur)

//KLASY C.D.
    //ZMIENNE STATYCZNE W KLASIE
    //- wspólne dla wszystkich obiektów
    //- nie można ich inicjalizować za pomocą konstruktorów
    //- może być prywatna, a i tak można ją inicjalizować
    //- mają do niej dostęp także metody "nie-statyczne"

    class punkt{
        int x, y;
        static int ile; //deklaracja składnika statycnzego
    public:
        punkt(int, int);
        ~punkt();
        void wyswietl();
    };

    int punkt::ile = 0; //definicja bez static
    void punkt::punkt(int a, int b)
    {
        x = a;
        y = b;
        ile++; //metody "nie-statyczne" mają dostęp do pól statycznych
    }

    //METODY STATYCZNE
    //- mogą uzyskiwać dostęp tylko do statycznych składników lub innych statycznych metod klasy
    //- nie mogą uzyskiwać dostępu do niestatycznych składników lub metod
    //- muszą być definiowane w ciele klasy

    //LISTA INICJALIZACYJNA KONSTRUKTORA
    class abc
    {
        const int N;
        float x;
        char c;
        //nie wolno inicjalizować składnika stałego w taki sposób:
        //consr int N = 100;
        //konstruktor z listą inizjalizacyjną
        abc(float liczba, int rozmiar, char znak):N(rozmiar),c(znak)
        {
            x = liczba;
        }
    };
    //- składnikowy nie-const możemy nadać wartość przez:
        //-> zwykłe podstawienie w ciele konstruktora
        //-> listę inicjalizacyjną konstruktora
    //- składnikowi const można nadać wartość jedynie za pomocą listy inicjalizacyjnej
    //- lista inicjalizacyjna nie może inicjalizować składnika static

    //FUNKCJE ZAPRZYJAŹNIONE
    //- funkcja spoza klasy, która ma dostęp do wszystich składowych prywatnych klasy
    //- zwykle funkcja zaprzyjaźniona albo przyjmuje jako argument obiekt klasy albo zwraca obiekt klasy

    //funkcja zaprzyjaźniona z klasą
    class example
    {
        int pole1;
    public:
        friend int fun(example);
    };

    int fun(example myE)
    {
        //...
    }

    //funkcja klasy A zaprzyjaźniona z klasą B
    class B; //musi pojawić się definicja klasy B
    class A
    {
        friend int B:fun(A);
        //friend typ B:fun(argumenty);
    };
    class B
    {
    public:
        int fun(A myA);
    };

    //wszystkie funkcje klasy B zaprzyjaźnione z klasą ARGUMENTOW
    class B;
    class A
    {
        friend class B;
    };
    class B
    {
        //...
    };

//PRZECIĄŻANIE OPERATORÓW
    //- co najmniej jeden z argumentów przyjmuje obiekt danej klasy (musi być obiekt, a nie wskaźnik do obiektu)
    //- mechanizm przeciążania operatorów:
        //-> w postaci funkcji składowej
            // a @ b (równoważne) a.operator@(b);
        //-> w postaci niezależnej funckji (zwykle zaprzyjaźnionej z klasą/klasami)
            // a @ b (równoważne) operator@(a,b);
    //przeładowany operator+ jako funkcja składowa klasy
    class wektor3w
    {
        float x, y, z;
    public:
        wektor3w(float a=0.0,float b=0.0, float c=0.0);
        wektor3w operator+(wektor3w &v);
    };

    wektor3w wektor3w::operator+(wektor3w &v)
    {
        wektor3w wynik;
        wynik.x = x+v.x;
        wynik.y = y+v.y;
        wynik.z = z+v.z;
        return wynik;
    }