// egzamin.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
#include <string>

using namespace std;



class abstract{
public:
    virtual void pokaz() = 0;

};



class A: public abstract {
private:
    int liczba;
public:
    static int licznik;
    friend void funkcyjka(A &o1);

    A(){
        liczba = 0;
        licznik++;

      }

    A(int liczba) { this->liczba = liczba; licznik++;}

    virtual void pokaz(){cout <<"liczba: " <<  this->liczba <<endl;}

    int& get_liczba(void){ return liczba;}
    void set_liczba(int argument) { this->liczba = argument;}


    // PRZYPISANIE
     A * operator=(A &o1)
    {
        liczba = o1.liczba;
        return this;
    }

     // MNOZENIE
     A * operator*(A &o1)
     {
         A *nowy;
         nowy = new A;
         nowy->get_liczba() = liczba*o1.liczba;
         return nowy;
     }

     // NAWIASY []

     int* operator[] (int x)
     {

         return &this->liczba;              //zwarac adres na liczbe
     }

     // NAWIASY ()

     int operator() ()
     {
         return this->liczba;               // zwraca liczbe
     }

     // STRZALKA ->

     string operator-> ()
     {
         string z = " jestem juz zmeczony ";
         return z;
     }

     ~A(){};

};


class B: virtual public A{
public:
    friend class C;
    int liczbaB;
    A *wskazniczek1;

    B(){liczbaB = 0;
        wskazniczek1 = new A;}

    B(int liczbaB) {this->liczbaB = liczbaB;
                    wskazniczek1 = new A;}

    void pokaz(){cout <<"liczba: " <<  this->liczbaB <<endl;}

    int zwroc_z(){return z;}

    B(B *o1)
    {
        this->liczbaB = o1->liczbaB;
        this->wskazniczek1 = new A;
        this->wskazniczek1 = o1->wskazniczek1 ;
    }

     ~B(){ delete wskazniczek1; }

private:
    int z;

};


class C {
public:
    C();
    void static zmien_wartosc_B(int x, B &o1){ o1.z = x;}

    ~C(){};

};





// WYJSCIE
ostream & operator<< (ostream &wyjscie, B &o1)
{

    return wyjscie << o1.liczbaB <<endl;

}
//WEJSCIE
istream &operator>>(istream &wejscie, A &o1)
{
    int nowa_liczba;
    cout<<"podaj nowa liczbe: ";
    cin >> nowa_liczba;
    o1.get_liczba() = nowa_liczba;
    return wejscie;
}

// DODAWANIE
A *operator+(A o1, A o2)
{

    A *nowy;
    nowy = new A;

    nowy->get_liczba() = o1.get_liczba() + o2.get_liczba();

    return nowy;
}

int A::licznik = 0; // STATIC



void funkcyjka(A &o1) // zaprzyjazniona funkcja ma dostep do zmiennych prywatnych
{
    o1.liczba = o1.liczba *2;

}


int _tmain(int argc, _TCHAR* argv[])
{


    A jeden;
    jeden.get_liczba() = 3;
    cout<< jeden.get_liczba() <<endl;
    A dwa(2);
    cout << dwa.get_liczba() <<endl;

    cout <<"------------sterta------------------"<<endl;
    A *wsk;
    wsk = new A;

    for(int i =0; i <5; i++)
    {
        wsk[i].get_liczba() = i*2;
    }
    for(int i =0; i <5; i++)
    {
        cout << wsk[i].get_liczba()<<endl;
    }
    cout <<"------------stos--------------------"<<endl;

        A wsk2[5];

    for(int i =0; i <5; i++)
    {
        wsk2[i].get_liczba() = i*3;
    }
    for(int i =0; i <5; i++)
    {
        cout << wsk2[i].get_liczba()<<endl;
    }

    cout <<"---------sterta wskaznikow-------------"<<endl;

    A **wsk3 ;
    wsk3 = (A**)(malloc(sizeof(A*)*10));


    for(int a=0; a<10; a++)
    {
    //*(wsk3+a) = new A[10];               //moze byc to
    *(wsk3+a) = (A*)malloc(sizeof(A)*10);  // albo to
    }


    for (int i=0; i<10; i++)
    {
    for (int n=0; n<10; n++)
        {
      wsk3[i][n].get_liczba() = i*n+1;
      cout << wsk3[i][n].get_liczba() << "  " ;
        }
    cout<<endl;
    }

    cout<<endl <<"---------------2------------------"<<endl<<endl;

    cout <<"---------konstruktor kopiujacy-------------"<<endl;
    cout <<"---------przeciazony operator wyjscia-------------"<<endl<<endl;
    B *loool;
    loool = new B;
    B trzy(loool);


    cout << *loool <<endl;
    cout << trzy <<endl<<endl;
    cout <<"---------przeciazony operator wejscia-------------"<<endl<<endl;

    A przyklad1;

    cin >> przyklad1;

    cout <<"liczba: " << przyklad1.get_liczba()<<endl<<endl;

    cout <<"---------przeciazony operator przypisania-------------"<<endl<<endl;
     A przyklad2;
    // cout <<"przed " << &przyklad2 <<endl;
     przyklad2=przyklad1;
    // cout <<"po " << &przyklad2 <<endl;
     cout << przyklad2.get_liczba()<<endl;

     cout <<"---------przeciazony operator mnozenia-------------"<<endl<<endl;
     A *przyklad3;
     przyklad3 = new A;
     przyklad3 = przyklad2*przyklad1;
     cout << przyklad3->get_liczba()<<endl;


     cout <<"---------przeciazony operator dodawania-------------"<<endl<<endl;
      A *przyklad4;
     przyklad4 = new A;
     A cos1, cos2;
     cos1.get_liczba() = 5;
     cos2.get_liczba() = 6;

     przyklad4 = cos1+cos2;

     cout << przyklad4->get_liczba() << endl;


     cout <<"---------przeciazony operator () i []-------------"<<endl<<endl;

     int wartosc;
     int *adres;
     adres = cos1[1];
     wartosc = cos1();

     cout << "adres: " << adres << "  wartosc: " << wartosc <<endl;

     cout <<"---------przeciazony operator -> -------------"<<endl<<endl;
     A *smth;
     string spac;
     string *spac2;

     //->spac;
     // NIE MAM POJECIA JAK TO SIE ROBI
     //cout << "przeciazona strzalka: " << smth->get_liczba()<<endl;
     cout <<"---------dziedziczenie po abstrakcyjnej-------------"<<endl<<endl;

     B cos3;
     cos3.liczbaB = 5;

     cos1.pokaz();
     cos3.pokaz();

     cout <<"---------zaprzyjaznienie klas-------------"<<endl<<endl;




     C::zmien_wartosc_B(2, cos3);

     cout << "zmiana: " << cos3.zwroc_z() << endl;   // zmiana zmiennej prywatnej ktora jest deklarowana w innej klasie



     cout <<"---------w kontener + polimorfizm-------------"<<endl<<endl;

     abstract *tablica[3];

     tablica[0] = &cos1;
     tablica[1] = &cos2;
     tablica[2] = &cos3;


     tablica[0]->pokaz();
     tablica[1]->pokaz();
     tablica[2]->pokaz();

    cout << " zakonczono! " <<endl;
    system ("pause");
    return 0;
}