Dyskusja:C++/Przeciążanie operatorów

Tu jest chyba blad

class Student {

  int nr_indeksu;
  float srednia_ocen; 
  public:
     Student(int nr=0, float sr=0) {nr_indeksu=nr; srednia_ocen=sr;};  // konstruktor
     friend ostream & operator<< (ostream &wyjscie, const Student &s);

};

ostream & operator<< (ostream &wyjscie, const Student &s) {

  wyjscie << "Nr indeksu : " <<s.nr_indeksu << endl << "Srednia ocen : " <<s.srednia_ocen<<endl;
  return wyjscie;

}

Powinno byc chyba iostream, nie znam sie biegle na c++, wiec na wszelki wypadek napisalem tutaj.

iostream to nazwa biblioteki, a ostream to nazwa typu zmiennej

biblioteka ostream też istnieje, iostream działa w dwie strony a ostream ma tylko funkcje output.

operator jako member klasy

Operatory ==, <, > zdefiniowane w przykładach jako membry powinny przyjmować tylko jeden argument (rhs - right-hand side), gdyz drugim, niejawnym argumentem jest "this".

NIE WIEM KTO PISAŁ ORYGINALNY ARTYKUŁ ALE MOŻE NIECH Z ŁASKI SWOJEJ WIĘCEJ NIC NIE PISZE!!!

Błąd w operatorze[]

Nie jestem tego na 100% pewien, ale chyba błędne jest w kodzie użycie stałego operatora[] . Autor napisał kod w sposób, jaki sugeruje że drugie wywołanie operatora [] jest właśnie przez stały operator, gdzie wcale nie jest to prawdą. Używany jest ciągle pierwszy przeciążony operator. Ogólnie poniższy kod obrazuje dobrze ktory operator kiedy jest używany:

 int & operator[](int el) { cout<<"NON-CONST\n"; return Tab[el]; }
 const int & operator[](int el) const { cout<<"CONST\n"; return Tab[el]; }

/* ... */

int main()
{
  int n = 5;
  const TablicaInt tab(n);
  TablicaInt tab2(n);

  for(int i = 0; i < n; ++i)
  {
      cout << tab[i] << endl;
      cout << tab2[i] <<endl;
  }
  return 0;
}

Tu oryginalny fragment kodu:

int main()
{
  int n = 5;
  TablicaInt tab(n);

  for(int i = 0; i < n; ++i)
    {
      tab[i] = i;
      cout << tab[i] << endl; //tu właśnie używany jest niestały operator!
    }
  return 0;
}

• "sugeruje, że drugie wywołanie operatora [] jest właśnie przez stały operator" - wydaje mi się, że to nadinterpretacja. Ogólnie błąd jako taki nie występuje w kodzie, po prostu tylko jeden operator jest przykładowo użyty, moim zdaniem. --Lethern (dyskusja) 20:31, 15 lip 2010 (CEST)

Nadmiarowy materiał

Wyciąłem z modułu ten materiał, są to zbyt rzadkie i szczegółowe informacje żeby znajdowały się w głównym module - najlepiej przenieść to do jakiegoś Dodatku etc. --Lethern (dyskusja) 07:34, 16 gru 2014 (CET)

<-- WYCIĘTE -->

/== Rzadko przeciążany operator ->* ==

Patrząc na listę operatorów możliwych do przeciążenia widzimy też ten operator, ale nie wiemy jak go przeciążyć, ani często nawet jak go użyć. Dlatego jako ciekawostkę zamieszczę te informacje. Zacznę od normalnego działania tego operatora (bez przeciążania); jest to operator wywołujący funkcje wskazaną wskaźnikiem do funkcji wewnątrz klasy

#include <iostream>
using namespace std;

class Normalna
{
public:
    void spie()
    {
        cout << "Jestem normalna i spie..." << endl;
    }
    
    void ideSpac()
    {
        cout << "Jestem normalna i ide do spanka..." << endl;
    }
};

int main()
{
    Normalna *przykladNormalnosci = new Normalna; // nalezy zwrocic uwage ze na obiekt wskazujemy wskaznikiem!!!
    
    void (Normalna::*wskaznikDoNormalnosci)(); // utworzenia wskaźnika do składowych klasy
    wskaznikDoNormalnosci = &Normalna::spie; // przypisanie mu adresu funkcji składowej klasy
    
    (przykladNormalnosci->*wskaznikDoNormalnosci)(); // wywołanie takie jak: przykladNormalnosci->spie();
    delete przykladNormalnosci;
}

Znając cel tego operatora nie mamy przeszkód zdefiniować go ciut inaczej niż są założenia:

#include <iostream>
using namespace std;

class A
{
public:
    void operator->*(int a)
    {
        cout << "Podano liczbe: " << a << endl;
    }
};

int main()
{
    A a;
    a->*4;
}
// wydruk będzie taki: Podano liczbe: 4

Możemy też skomplikować w jeszcze inny sposób:

#include <iostream>
using namespace std;

class Niezdecydowana
{
public:
    int (Niezdecydowana::*niezdecydowanaFunkcja)(int i);
    
    int operator->*(int i)
    {
        cout << "Wywoluje operator ->*\t";
        return (this->*niezdecydowanaFunkcja)(i);
    }
    
    int razy2(int i)
    {
        return i*2;
    }
    int razy3(int i)
    {
        return i*3;
    }
};

int main()
{
    Niezdecydowana niezdecydowana;
    niezdecydowana.niezdecydowanaFunkcja = &Niezdecydowana::razy3;
    cout << "Wynik niezdecydowania: " << (niezdecydowana->*3) << endl;
}
// wydruk będzie: Wywoluje operator ->*    Wynik niezdecydowania: 9

<-- /WYCIĘTE -->