Operátorok (C++)

A C++ fordítóban minden operátort hagyományos függvényalakra hoz a fordításkor előtt, így például az a+b alakból a.operator+(b) vagy operator+(a,b) lesz, attól függően, hogy tag vagy globális függvényként van deklarálva.

Az operátorok másik speciális tulajdonsága a precedenciájuk valamint az (bal vagy jobb) asszociativitásuk, ez határozza meg a kifejezések kiértékelési sorrendjét valamint az implicit zárójelezés irányát.

Konverziós operátorok

A C++ a hagyományos (type)arg alakú, C-stílusú konverzión túl alkalmaz három, ennél speciálisabb konverziós operátort, amivel egyértelműbbé tehetjük, hogy mit szeretnénk, és a fordító szólhat, ha az nem lehetséges, valamint hosszuk következtében kiugranak a kódból, könnyebbé téve a konverziók megtalálását, amelyek a pointerek után elsőszámú hibaforrásnak tekinthetők.

Alakjuk: operátornév<új-típus>(objektum);

static_cast

Konverzió egymásba konvertálható típusok között, fordítási hibát okoz, ha nem konvertálható oda-vissza a két típus.

reinterpret_cast

Erős átalakítás, gyakorlatilag tetszőleges típusok közötti átalakítást enged, veszélyes, kerülendő.

dynamic_cast

Pointerek és referenciák közötti futásidejű átalakítás, amely downcastra használható, azaz bázispointerből származtatott osztályra mutatót ad vissza. A konverzió mutatók esetén nullpointerrel tér vissza, referenciáknál (egyéb opciók híján) bad_cast kivételt dob, ha nem lehetséges az átalakítás, azaz a mutatott objektum típusa nem az elvárt.

const_cast

A konverzió leveszi a const vagy a volatile jelzőt egy változóról, szintén veszélyes lehet.

Tagként deklarált operátorok

A C++ lehetővé teszi konstruktorszerű szintaxissal konverziós operátorok használatát felhasználói típusoknál is.

Ekkor minden adott típust kívánó környezetben a normális konverziós szabályok szerint képesek konvertálódni. Az egyparaméterű (nem-explicit) konstruktorok és ezek az operátorok könnyen többértelműséget okozhatnak, mivel mindkettő képes implicit konverzióként viselkedni.

struct A{  operator int()  { return 4; }};struct B{  operator A()  { return A(); }};int main(){  int aint = A();  //aint értéke ekkor 4  A b = B();       //B() konvertálódik A-vá  int bint = b;    //bint is négy}

Operátorok túlterhelése

A közönséges függvényekhez hasonlóan a legtöbb operátort is túl lehet terhelni, amely a felhasználói típusok kényelmesebb használatát teszi lehetővé(jellemző például az <<(eltoló) operátor túlterhelése, melyet a kimeneti folyamok használnak kimenetként). Értékadó(=, += stb.), &(címe) operátort csak tagfüggvényként lehet megírni, minden mást érdemesebb globálisként deklarálni, ha lehet(ha nem kell hozzáférniük a tagokhoz).

struct Complex{ //Barátfüggvény deklarációja, hogy hozzáférjen a tagokhoz friend std::ostream& operator<<(std::ostream& stream, const Complex& z); //Konstruktor, taginicializációs listával Complex(double a, double b): re(a), im(b) { } Complex& operator+=(const Complex& rhs)         //hozzáadó operátor tagfüggvény... {re += rhs.re; im += rhs.im; return *this;} private:  double re, im;};Complex operator+(const Complex& lhs, const Complex& rhs)  //összeadó operátor viszont globális{return Complex(lhs) += rhs;}//az ostream definíciójához nem férünk hozzá, de//operator<<(ostream&, const complex&)-t definiálhatunkstd::ostream& operator<<(std::ostream& stream, const Complex& z){ return (stream << '(' << z.re << ", " << z.im << ')');}//Ezután az operátort egyszerűen használhatjuk:Complex c(1.0, 4.6);std::cout << c; //A kimeneten megjelenik: (1.0, 4.6)