przeciazanieOperatorowF

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

#include "stdafx.h"
#include <iostream>
#include <ctime>
#include <assert.h>

using namespace std;

//#define assert(ignore) ((void)0) // odkomentowanie tej lini sprawi, ze asercje nie beda sprawdzane

class Tablica
{
private:
    int *tab;
    int rozmiar;
    static int iloscTablic; // kolejne instancje obiektu Tablica inkrementuja iloscTablic (parametr wspolny tworzonych obiektow)
    friend ostream& operator<<(ostream&, const Tablica&); // <<
    friend istream& operator>>(istream&, Tablica&);       // >>
    friend Tablica& operator||(Tablica&, const Tablica&); // ||
public:
    Tablica(int = 5);
    Tablica(const Tablica&);
    ~Tablica(void);
    int getRozmiar() const;
    Tablica& operator=(const Tablica&);                   // =
    int operator==(const Tablica&) const;                 // ==
    int operator!=(const Tablica&) const;                 // !=
    int operator+(const Tablica&) const;                  // +
    int& operator[](int);                                 // []
    int& operator()(int);                                 // ()
    Tablica* operator->();                                // ->
    void przypiszLosoweWartosci(int = -100, int = 100);
    static int getIloscObiektowTypuTablica();
};

int Tablica::iloscTablic = 0;

Tablica::Tablica(int rozmiarTab)
{
    ++iloscTablic;
    rozmiar = rozmiarTab;
    tab = new int[rozmiar];
    assert(tab != 0);
    for (int i = 0; i<rozmiar; i++)
        tab[i] = 0;
}
Tablica::Tablica(const Tablica& Tab)
{
    cout << "Konstruktor kopiujacy wywolany!" << endl;
    ++iloscTablic;
    rozmiar = Tab.rozmiar;
    tab = new int[rozmiar];
    assert(tab != 0);
    for (int i = 0; i<rozmiar; i++)
        tab[i] = Tab.tab[i];
}
Tablica::~Tablica(void)
{
    --iloscTablic;
    delete[] tab;
}
int Tablica::getRozmiar() const
{
    return rozmiar;
}
Tablica& Tablica::operator=(const Tablica& zPrawejStrony)
{
    cout << "Przeciazony operator =" << endl;
    if (this != &zPrawejStrony)
    {
        delete[] tab;
        rozmiar = zPrawejStrony.rozmiar;
        tab = new int[rozmiar];
        assert(tab != 0);
        for (int i = 0; i<rozmiar; i++)
            tab[i] = zPrawejStrony.tab[i];
    }
    return *this;
}
int Tablica::operator==(const Tablica& zPrawejStrony) const
{
    if (rozmiar != zPrawejStrony.rozmiar)
        return 0;
    for (int i = 0; i<rozmiar; i++)
        if (tab[i] != zPrawejStrony.tab[i])
            return 0;
    return 1;
}
int Tablica::operator!=(const Tablica& zPrawejStrony) const
{
    if (rozmiar != zPrawejStrony.rozmiar)
        return 1;
    for (int i = 0; i<rozmiar; i++)
        if (tab[i] != zPrawejStrony.tab[i])
            return 1;
    return 0;
}
int Tablica::operator+(const Tablica &zPrawejStrony) const
{
    int suma = 0;
    int rozmiarMaks = rozmiar <= zPrawejStrony.rozmiar ? rozmiar : zPrawejStrony.rozmiar;
    for (int i = 0; i < rozmiarMaks; i++)
    {
        tab[i] += zPrawejStrony.tab[i];
        suma += tab[i];
    }
    return suma;
}
int& Tablica::operator[](int index) // wyluskanie elementu i zwrocenie o numerze index
{
    cout << "Przeciazony operator [] dziala" << endl;
    assert(0 <= index && index < rozmiar);
    return tab[index];
}
int& Tablica::operator()(int index) // wyluskanie elementu (i zwrocenie) o indeksie rozmiar-index-1
{                                   // a(0) - spowoduje wyluskanie (i zwrocenie) ostatniej wartosci z tab
    cout << "Przeciazony operator () dziala" << endl;
    index = rozmiar - index - 1;
    assert(0 <= index && index < rozmiar);
    return tab[index];
}
Tablica* Tablica::operator->() // zamiast do wlasciwosci/metod odwolywac sie przy pomocy kropki (.)
{                              // mozemy to zrobic przy pomocy strzalki (->) - a->
    return this;
}
void Tablica::przypiszLosoweWartosci(int odW, int doW)
{
    int il = doW - odW;
    for (int i = 0; i < rozmiar; i++)
        tab[i] = rand() % (il + 1) + odW;
}
int Tablica::getIloscObiektowTypuTablica()
{
    return iloscTablic;
}
Tablica& operator||(Tablica &zLewej, const Tablica &zPrawej) // c || a ;przepisywanie do tablicy obiektu c, tablicy obiektu a w odwrotnej kolejnosci
{
    if (zLewej.getRozmiar() != zPrawej.getRozmiar())
        return zLewej;
    int r = zLewej.getRozmiar();
    for (int i = 0; i < r; i++)
    {
        zLewej.tab[i] = zPrawej.tab[r - i - 1];
    }
    return zLewej; // zwracana jest referencja do obiektu, dla ktorego zostal przeciazony operator
}
istream& operator>>(istream& wejscie, Tablica& t)
{
    for (int i = 0; i < t.rozmiar; i++)
    {
        cout << "Podaj " << i + 1 << ". element [" << i << "]: ";
        wejscie >> t.tab[i];
    }
    return wejscie;
}
ostream& operator<<(ostream& wyjscie, const Tablica& t)
{
    for (int i = 0; i < t.rozmiar; i++)
        wyjscie << t.tab[i] << (i < t.rozmiar-1 ? ", " : "");
    return wyjscie;
}

int main()
{
    srand(time(NULL));
    // Zarowno do wlasciwosci i metod obiektow a, b i c moge odwolywac sie przy pomocy strzalki (->) - operator ten zostal przeciazony
    Tablica a;
    a->przypiszLosoweWartosci(0, 10);
    Tablica b(a);
    cout << "Obiekt a w tablicy tab zawiera nastepujace elementy: " << a << endl;
    cout << "Aktualnie tablica obiektu b ma nastepujace wartosci: " << b << endl;
    cout << "Do stworzonego obiektu b podaj " << b->getRozmiar() << " liczb" << endl;
    cin >> b;
    cout << "Teraz tablica obiektu b wyglada nastepujaco: " << b << endl;
    cout << "Wyswietl 1. element a[0]: " << a[0] << endl;
    cout << "Wyswietl 1. element od konca a(0): " << a(0) << endl;
    cout << "Wyswietl 1. element b[0]: " << b[0] << endl;
    cout << "Wyswietl 1. element od konca b(0): " << b(0) << endl;
    cout << a << endl;
    system("pause");
    system("cls");
    { // stworzono scope (zasieg) w celu szybszego wywolania destruktora obiektu c
        cout << "Stworzono obiekt c(b)" << endl;
        Tablica c = b; // i wywolano konstruktor kopiujacy, podajac jako parametr obiekt b; zapis tozsamy - c(b)
        cout << c << endl; // wypisujemy zawartosc tablicy powstalej poprzez skopiowanie obiektu b
        int suma = a + c; // przed zniszczeniem obiektu c powiekszymy wszystkie wartosci znajdujace sie w tablicy obiektu a, o wartosci z tablicy obiektu c
        cout << "Suma wartosci tablicy a: " << suma << endl; // dodatkowo operacja a + c zwroci nam sume powstala z dodania tablic obiektow a i c
    } // jezeli konstruktor kopiujacy zadzialal poprawnie podczas tworzenia obiektu c, to po zniszczeniu tego obiektu
    cout << "Zawartosc tablicy obiektu a: " << a << endl;
    cout << "Zawartosc tablicy obiektu b: " << b << endl; // bedzie mozliwe wyswietlenie tablicy obiektu b, w przeciwnym razie proba odczytu danych z tej tablicy
                       // doprowadzi do bledu, a wyswietlone liczby beda "liczbami z kosmosu" ^^
    system("pause");
    system("cls");
    cout << "Przypisujemy wszystie wartosci z obiektu b do obiektu a (a = b)" << endl;
    cout << "Aktulna ilosc obiektow: " << a->getIloscObiektowTypuTablica() << endl;
    cout << "Aktulna ilosc obiektow ((a = b)->getIloscObiektowTypuTablica()): " << ((a = b)->getIloscObiektowTypuTablica()) << endl; // a = b nie wywoluje konstruktora kopiujacego!
    cout << "Tak wyglada teraz tablica obiektu a: " << a << endl;
    cout << "Z kolei tablica obiektu b wyglada tak: " << b << endl; // musi byc taka sama ze wzgledu na powyzsze wyrazenie a = b; a = b zwraca referencje na samego siebie
    cout << "a == b - " << ((a == b) ? "Prawda" : "Falsz") << endl; // prosty test logiczny
    cout << "a != b - " << ((a != b) ? "Prawda" : "Falsz") << endl;
    Tablica c; // ponownie tworzymy obiekt o nazwie c (wczesniejszy zostal zniszczony automatycznie po tym, jak skonczyl sie jego zasieg)
    cout << "Pusta tablica obiektu c wyglada tak: " << c << endl;
    c || a; // (c || a)-> ; po strzalce mozliwe jest odwolanie sie do jakiejkolwiek wlasciwosci lub metody obiektu (musza byc publiczne); nalezy pamietac o nawiasie
    // w przeciwnym razie odwolamy sie do obiektu a, zamiast do obiektu c, ktory w tym przypadku jest zwracany (referencja do obiektu c)
    cout << "Przepisana tablica obiektu a od konca do tablicy obiektu c: " << c << endl;
    cout << "Liczba stworzonych tablic: " << a->getIloscObiektowTypuTablica() << endl;
    system("pause");
    return 0;
}