#include <iostream>
#include <string>
class CT_Wypisz
{
friend std::string& operator>>( const CT_Wypisz& obj_A , std::string& string_Ref_A ); //:: ( 1 )
protected:
std::string tekst {}; //:: ( 2 )
public:
CT_Wypisz() = default;
CT_Wypisz( const std::string& tekst_A ) : tekst( tekst_A ) {}
void wypiszTekst() { std::cout << "Aktualny tekst to: " << tekst << std::endl; }
CT_Wypisz& operator= ( const std::string& tekst_A ) //:: ( 3 )
{
tekst = tekst_A;
return *this;
}
std::string operator+ ( const std::string& tekst_A ) //:: ( 4 )
{
return ( tekst + tekst_A );
}
CT_Wypisz& operator+= ( const std::string& tekst_A ) //:: ( 5 )
{
tekst += tekst_A;
return *this;
}
} wypisywacz = std::string{ "fff" }; //:: ( 6 )
std::string& operator>>( const CT_Wypisz& obj_A , std::string& string_Ref_A ) //:: ( 7 )
{
string_Ref_A = obj_A.tekst;
return string_Ref_A;
}
int main()
{
wypisywacz. wypiszTekst();
std::string tekstString {};
wypisywacz = "Hello"; //:: ( 8 )
wypisywacz. wypiszTekst();
wypisywacz = wypisywacz + " World"; //:: ( 9 )
wypisywacz. wypiszTekst();
( wypisywacz += "!" ). wypiszTekst(); //:: ( 10 )
wypisywacz >> tekstString;
std::cout << "String to teraz: " << tekstString << std::endl; //:: ( 11 )
return 0;
}
//:: *( 1 )* - Deklaracja przyjazni z operatorem>>. Dzięki deklaracji przyjaźni operator będzie mógł korzystać z private i protected składników klasy. Operator>> jest dwuargumentowy, a jego wywołanie wygląda tak "arg1 >> arg2", a jeżeli chcemy aby działał też tak " string& >> const CT_Wypisz& ", to należy napisać jeszcze jedno przeładowanie.
//:: *( 2 )* - Ta zmienna jest protected, czyli może być używana bezpośrednio tylko przez funkcje składowe i funkcje zaprzyjaźnione.
//:: *( 3 )* - Operator=( arg2 ) - Operator dwuargumentowy. Mimo iż jako argument ma zapisany tylko "const std::string&" to jego użycie wymagha dwóch argumentów " CT_Wypisz& = const std::string& )
//:: *( 4 )* - CT_Wypisz& + const std::string& -> Rezultatem bedzie nowoutworzony obiekt tymczasowy typu string, którego w ( 9 ) od razu przypiszemy do wypisywacza korzystając z dodanej już możliwości przypisywania stringów.
//:: *( 5 )* - CT_Wypisz& += const std::string& -> Rezultatem będzie referencja do obiektu CT_Wypisz&, w naszym przypadku to referencja do siebie "& *this", ale równie dobrze może to być referencja do innego obiektu.
//:: *( 6 )* - Tutaj to nie przypisanie za pomocą operatora= ! Tutaj to wywołanie konstruktora.
//:: *( 7 )* - Niektóre operatory można tworzyć poza klasą, jako funcja nieskładowa.
//:: *( 8 )* - Skorzystanie z dobrodziejstwa operatora=.
//:: *( 9 )* - Najpierw wywołanie operatora+ a nastepnie operatora=. Kolejność wywołania operatorów zależy od ich priorytetów. Priorytety dzielą się na 19 grup w których znajdują się dane operatory.
//:: *( 10 )* - Użycie operatora+= i dowód na to, że rezultatem jest "CT_Wypisz&" ponieważ bezpośrednio po zakonczeniu wywołania operatora jest wywoływana funkcja składowa.
//:: *( 11 )* - Nasz oberator, który został zdefiniowany jako funkcja nie składowa.
To było tylko kilka przykładów użycia. Zanim zaczniesz używać ich w swoich projektach zalecam dogłębne poznanie ich działania, każdego operatora z osobna. Rezultatem mojej odpowiedzi nie miało być dogłębne wyczerpania tematu operatorów lecz tylko pokazanie ich praktycznego użycia, oraz to jak można skorzystać ze zwróconej przez operator referencji do obiektu.
