c++: klasy i przeciazanie operatorow

[Undre]

a drugi najpierw daje pobrac swoja wartosc, a potem dopiero sie powieksza

I twoja identyczna dla obu operatorów implementacja prowadzi do różnorodnego zachowania przy wykorzystaniu ich np poprzez cout

[czacha]

Jest mi niezmiernie przykro za zatwardziale utrzymywanie sie w blednym przekonaniu i przepraszam. Operatory zachowuja sie identycznie. Baczac na to ze proboje sie 3. raz dowiedziec dlaczego operator przyrostkowy jest definiowany w taki wlasnie sposob jak to przedstawiles pozostawie to pytanie wlasnym przemysleniom. Serdecznie dziekuje za caly poswiecony czas i pozdrawiam.

[Undre]

Wyczuwam nutę irytacji. Przejdźmy do kodu. Twoja nieco zmodyfikowana przeze mnie klasa :

main.cpp

Kod: Zaznacz cały

#include <iostream>
#include "class.h"
using namespace std;
int main()
{
    Counter i(2);
    Counter a(3);
    cout<<i;
    cout<<i++;
    cout<<++i;
    
    system("PAUSE");
    return EXIT_SUCCESS;
}

class.h

Kod: Zaznacz cały

#ifndef COUNTER_H
#define COUNTER_H
#include <iostream>
using namespace std;

class Counter
{
             int itsVal;
    public:
                 Counter();
                 Counter(int initVal);
                 Counter(const Counter&);
                ~Counter();
             int GetItsVal()const { return itsVal; };
            void SetItsVal(int val) { itsVal = val; };
         Counter operator+(const Counter&);
         Counter operator-(const Counter&);
        Counter& operator=(const Counter&);
        Counter& operator++();
        Counter& operator++(int);
        Counter& operator--();
        Counter& operator--(int);
 friend ostream& operator<<(ostream&,Counter&);
};
#endif

class.cpp

Kod: Zaznacz cały

#include <iostream>
#include "class.h"
using namespace std;

Counter::Counter()  { itsVal = 0; };
Counter::Counter(int initialVal)  { itsVal = initialVal; };
Counter::Counter(const Counter& rhs)  { itsVal = rhs.GetItsVal(); };
Counter::~Counter(){};

Counter& Counter::operator++()  {
    ++itsVal;
    return *this;};
Counter& Counter::operator++(int theFlag1)  {
    ++itsVal;
    return *this;};
Counter& Counter::operator--()  {
    --itsVal;
    return *this;};
Counter& Counter::operator--(int theFlag2)  {
    --itsVal;
    return *this;};
Counter Counter::operator+(const Counter& rhs)  {
    return Counter(itsVal + rhs.GetItsVal());};
Counter Counter::operator-(const Counter& rhs)  {
    return Counter(itsVal - rhs.GetItsVal());};
Counter& Counter::operator=(const Counter& rhs)  {
    if (this == &rhs)
        return *this;
    else   
        itsVal = rhs.GetItsVal();
        return *this;};
ostream& operator<< (ostream& out, Counter &obj)  {
  out << obj.GetItsVal();
  return out;
}

Wynik działania programu : 2 3 4

Sam utrzymujesz, że operatory przedrostkowy i przyrostkowy powinny działać inaczej względem siebie ( konkretnie nie działać tak samo ), co jednak obala wynik tego programu. Jako że jestem i upierdliwy i cierpliwy, odpowiem może tym razem adekwatnie :
Piszesz sobie cout

[czacha]

Z grubsza rozumiem Dziekuje.