#include<iostream>



using namespace std;



class array {

    private:

        double *d;

        int len;



    public:

    // Konstruktor inicjalizujący dwie zmienne klasy

    // zerem (d(0)) i rozmiarem size z wartości domyślną

    // 0, czyli można jej nie podawać (void).

    array(int size=0) : d(0),len(size) {

        if(size>0) {

            // Wskaźnik na tablicę o rozmiarze size

            d = new double [size];

            // zerowanie elementów tablicy

            for(int i=0;i<len;i++) d[i]=0;

        }

        // Wyświetlanie napisy 'array'.

        cout <<"array\n";

    }



    // Konstruktor z argumentem jako referencją do obiektu

    // klasy array (array inicjalizowany array-em)

    // Wskaźnik na double'a znów zerowany.

    array(const array& a) : d(0) {

        if(a.len>0) {

            // Jak array, którym inicjalizujemy (z argumentu)

            // ma niezerową długość, to klonujemy.

            len=a.len;

            d=new double[a.len];

            for(int i=0;i<len;i++) d[i]=a.d[i];    //look's good

        }

    }



    // Konstruktor kopiujący?

    // Zwraca referencją, czyli można pisać

    // arr1 = arr2 = arr3.

    // załóżmy, że w kodzie jest arr1 = arr2

    array& operator=(const array& a) {

        cout <<"=";

        if(a.len>0) { // jeżli arr2 niezerowe, to

            if(len>0) delete [] d; // ???? Kasowanie d z arr1, a potem

            // Klonowanie

//DAREK: a co z dlugoscia? musisz ja najpierw skopiowac :)
            d= new double [len=a.len];

            for(int i=0; i<len; i++) d[i]=a.d[i];

        }

        // Zwrot adresu tablicy, czyli referencji do niej

        return  *this;

    }



    // Dekonstruktor

    ~array() {

        // jesli dlugosc jest wieksza ode zera (gwoli ścisłości, niezerowy to <>0) ;P

        if(len>0) delete [] d;

        // Wyświetlenie "~array"

        cout <<"\n~array";

    }



    // Przeciążanie operatora indeksowania

    double& operator[](int i) {

        // Wyświetlenie i-tego elementu tablicy, na którą wskazuje d

        // w nawiasach kwadratowych

        cout<<"["<<i<<"]";

        // i zwrot tego elementu

        return d[i];

    }



    // Przeciązamy operator <<

    // do strumienia po _prawej_ stronie << wysyłamy wszystkie

    // elementy tablicy, na którą wskazuje d.

    // Czyli możemy napisać "arr1 << cout" :-)

    ostream& operator<<(ostream & out) {

        for(int i=0; i<len;i++) out<<d[i]<<" ";

        // Zwracamy referencję, czyli możemy napisać

        // arr2 << arr << cout;

        return out;

    }



    // Casting vel rzutowanie.

    // Zwracamy długość, czyli int(arr1) === arr1.len

    operator int() {return len;}

};



array g;

int main() {

    try {

        cout<<"main:\n";    // main\n

        array a(2);         // array\n (a ma długość 2)

        array b=a;          // nic (zostanie wywolany kontruktor array(const array& a)

        double c=a;         // nic (c jest 2 /długość a/ - TAK MI SIĘ WYDAJE)

        b[0]=3;             // [0]

        a[1]=4;             // [1]

        b<<(cout<<c);       // 23 0 (najpierw c, bez spacji b[0], spacja i b[1]

        cout<<"\n";         // nowy wiersz

        cout<<b[0]<<" "<<b[1]; // [1][0]3 0

        cout<<"\nend";      // nowy wiersz i end

    } catch(exception e) {

        system("pause");

    }

    return 0;               // ~array
                            // ~array
                            // ~array

}