Перегрузка операторов Опции

[ammaximus]

#include <iostream.h>

class a {
	double x;
public:
		void operator++(){
			this->x = x+9;
			return;
		};
		friend a operator--(a &b){
			b.x = b.x-9;
			return b;
		};
		a operator+(a &c){
			(this->x)+=(c.x);
			return *this;
			
		};
		friend a operator-(a &b, a &c){
					a temp;
					temp.x=(b.x)-(c.x);
			return temp;
		};

		print(){
			cout<<x;
			cout<<endl;
		};	

		a(){
			x=1;
		};
};

int main() {
	a kot;
	kot.print();
	++kot;
	cout << endl;
	kot.print();
	--kot;
	kot.print();
	a rot, mot;
	++rot;
	mot = kot+rot;
	mot.print();


	return 1;
} 

Просто перегрузка операторов. При этом минусы - друзья, плюсы - функции члены. Я делаю функции встраиваемыми просто для удобства.

В принципе все работает, но функция Принт вызывает warning. Насколько эффективна программа, нет ли каких других неточностей?

Да, вот еще, как реализуется постфиксная запись? Можно ли делать кардинально разные реализации для разных типов вызова операторов?

[volvo]

Хорошо... Что говорит MSVC вот на такой код?

#include <iostream.h>
class a {
    friend ostream& operator << (ostream& os, const a& obj) { // Заметь, здесь const !!!
        os << obj.x;
        return os;
    }

private:
    double x;
public:
    a& operator++() {
        this->x += 9;
        return *this;
    }

    a operator++(int) {
        a copy(*this);
        this->x += 9;
        return copy;
    }

    a() {
        x = 1;
    }
};
int main() {
	a kot;
	cout << ++kot << endl;
	cout << kot << endl;
	cout << kot++ << endl;
	cout << kot << endl;

	return 0;
}

(это каноническая форма перегрузки пре/пост-фиксного инкремента, взято из книги "C++ Coding Standards" Саттера и Александреску)...

Если при перегрузке операции вывода убрать const, программа тут же перестанет компилироваться... Что теперь выводится?

Кстати, цитата оттуда:

In calling code, prefer using the prefix form unless you actually need the original value returned by the postfix version. The prefix form is semantically equivalent, just as much typing, and often slightly more efficient by creating one less object. This is not premature optimization; it is avoiding premature pessimization