Operators overloading, C++ (vc++)

Operators overloading

#include <iostream>

class Int
{
    int Value;
public:
    Int operator+(const Int &Obj) //W nawiasach podajemy prawy argument,
    {                             //lewy jest naszym obiektem w ktorym wywolujemy metode
        Int Ret;
        Ret.Value=Value+Obj.Value;
        return Ret;
    }
    Int& operator=(const Int &Obj) //Przypisujemy wartosci do naszego obiektu z obiektu Obj (z tego po prawej stronie znaku '=')
    {
        Value = Obj.Value;
        return *this; //'this' zwraca wskaznik na nasz obiekt.. tak wiec *this zwroci po prostu nasz obiekt
    }
    Int &operator=(int NewValue) //A tutaj przeladowanie dla systuacji: Int A; A=5;
    {
        Value = NewValue;
        return *this;
    }
    bool operator==(const Int &Obj) //Tym razem zwracamy typ bool gdyz chcemy znac rezultat porownania dwoch obiektow (czy sa lub nie sa takie same)
    {
        return Value==Obj.Value;
    }

//Teraz cos bardziej skomplikowanego.. tak wiec focus ^^
    //std::cout to nie jest nic innego jak obiekt (instancja klasy std::ostream)
    //Tworzy sie on globalnie gdy tylko dodamy do naszego programu plik naglowkowy <iostream>
    //Posiada on kilka przeladowan operatora strumienia wyjscia '<<'
    //A dziala w taki sposob:
    //Wezmy sobie dla przykladu taki fragment kodu:
    //std::cout<<"Jakis tekst"<<123<<' '<<"text again"<<'\n';
    //Najpierw wykonuje sie przeladowanie '<<' dla klasy ostream po lewej i tekstu po prawej czyli to:
    //(std::cout<<"Jakis tekst") <<123<<' '<<"text again"<<'\n';
    //Nastepnie przeladowanie to zwraca nasz obiekt typu std::ostream (czyli w tym wypadku nasz cout)
    //Mamy zatem:
    //std::cout<<123<<' '<<"text again"<<'\n';
    //Tak będą wygladac kolejne kroki:
    //std::cout<<' '<<"text again"<<'\n';
    //std::cout<<"text again"<<'\n';
    //std::cout<<'\n';
    //std::cout;
    //Gdy cout nie bedzie mial juz niczego po prawej to wypisuje w konsoli cala zawartosc jaka "pochlonal"
    //W przypadku jednak gdy bysmy my chcieli przeladowac strumien wyjscia dla cout'a to musimy posluzyc sie
    //przeladowaniem globalnym (nie mozliwe jest by bez tworzenia przeladowania w klasie cout przeladowac
    //operator tak by cos bylo po prawej, a cout po lewej.
    //To tyle z teorii..
    //Zrobmy sobie zatem taki zapis:
    friend std::ostream& operator<< (std::ostream &Out, const Int &Obj); //Nasz Out nie jest niczym innym jak naszym cout'em
    //Tutaj mowimy kompilatorowi, ze klasa Int przyjazni sie z GLOBALNA funkcja (przeladowaniem):
    //std::ostream& operator<< (std::ostream &Out, const &Int Obj);
    //innymi slowy mowimy, ze prywatne skladowe (u nas Value) obiektow klasy Int (u nas Obj) moga zostac
    //wykorzystane wewnatrz tej metody bez uzywania dodatkowych meted (#Gettery & #Settery)
    //Jednak NIE JEST to deklaracja, ze taka funkcja bedzie istniec
    //(mowimy tylko, ze jak bedzie to klasa Int ma sie z ta funkcja przyjaznic)
};

//Tutaj dopiero tworzymy definicje naszej funkcji (przeladowania globalnego):

std::ostream& operator<< (std::ostream &Out, const Int &Obj)
{
    Out<<Obj.Value; //Out to cout czyli zapis zrozumialy..
                    //Natomiast na zapis Obj.Value mozemy sobie pozwolic tylko dzieki zadeklarowanej wczesniej przyjazni
                    //klasy Int z ta funkcja (bedaca jednoczesnie przeladowaniem operatora '<<')
    return Out; //Nastepnie po prostu zwracamy naszego cout'a by mogl dalej kontynuowac swoje "pochlanianie" ^^
}

int main()
{
    Int A, B;
    A = 5;
    B = 10;
    Int C = A + B;
    std::cout<<A<<" + "<<B<<" = "<<C<<'\n';
}


run \| edit \| history \| help	0