Przeciążanie operatorów

0

Witam! Mam na przykładowo napisanym stosie przeciążyć 3 operatory.
Pierwszy << tak aby dodawał elementy na stos i można go wywołać w sposób

stack<<4<<5;

Drugi >>, tak aby ściągał wierzchołek, a można go wywołać w sposób

stack>>x>>y>>z;

Trzeci [], tak aby zwracał n-ty element na stosie.

Działa mi tylko ten trzeci, pierwszy i drugi działa tylko dla pojedyńczych operacji. Rozumiem, że w tej chwili program wywołując

stack<<4<<5;

to << między 4, a 5 program traktuje jako normalny operator wyjścia? Jak więc to zmienić? Proszę o pomoc!

#include <iostream>

using namespace std;



class Stack {
public:
    Stack(): MAX_SIZE(100), elements(new float[MAX_SIZE]), size(0){}

    Stack(int MAX_SIZE): MAX_SIZE(MAX_SIZE), elements(new float[MAX_SIZE]), size(0){}

    Stack(float tab[], int size) : MAX_SIZE(100), elements(new float[MAX_SIZE]), size(size) {
        for (int i = 0; i < size; i++)
            elements[i] = tab[i];
    }

      Stack(float tab[], int size, int MAX_SIZE) : MAX_SIZE(MAX_SIZE), elements(new float[MAX_SIZE]), size(size) {
        for (int i = 0; i < size; i++)
            elements[i] = tab[i];
    }


    //OPERATOR PIERWSZY
    std::ostream & operator << (const float e){if (!full()) elements[size++] = e; }

   //OPERATOR DRUGI
    float & operator >> (const float x){return elements[--size]; }

   //OPERATOR TRZECI
    float operator[](int k){
        return elements[size-k];
        };

    ~Stack() { delete[] elements; }

    bool full() { return size >= MAX_SIZE; }
    void push(float e) { if (!full()) elements[size++] = e; }
    float pop() { return elements[--size]; }
    bool empty() { return size == 0; }




private:
    int MAX_SIZE;
    float *elements;
    int size;
};

int main ()
{
    float tab[]={1,2,3,4,5};
    Stack s(tab,5,100);
    float x,y,z;
    
    float u=s[3];
    cout<<u<<endl;  //Tutaj wszystko ładnie działa


    s<<4; //Dokłada na wierzchołek 4 wszystko działa
    s<<4<<5; //I tutaj już nie działa


    s>>x; //Również działa ściąga wierzchołek
    s>>x>>y; // I tu się znów sypie


      while(!s.empty())
    {
        cout<<s.pop()<<endl;
    }



return 0;
}
3

żeby tu działało:

 s<<4<<5; //I tutaj już nie działa 

to operator winien wyglądać tak:

 Stack & operator << (const float e){if (!full()) elements[size++] = e; return *this;}
0

Dzięki, działa >> zmieniłem podobnie i również działa. Jednak nie wiem dlaczego, mógłbyś mi to jeszcze wytłumaczyć jakoś?

1

Wyrażenie stack<<x zwraca referencję na stos, więc zabawa ciągnie się dalej.

2
s << 4

to inaczej

s.operator<<(4)

Nietrudno zatem zgadnąć, że

s << 4 << 5

to inaczej

(s.operator<<(4)).operator<<(5)

Żeby to działało, to s.operator<<(4) musi zwrócić coś, na czym można znowu wywołać operator<<. W tym przypadku musi zwrócić s, czyli obiekt który to wywołał, stąd return *this.

1 użytkowników online, w tym zalogowanych: 0, gości: 1