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

[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]

функция Принт вызывает warning

На более жестком компиляторе это предупреждение тут же становится ошибкой: нельзя описывать функцию без типа возвращаемого значения. Ничего не возвращает - значит void...

Да, вот еще, как реализуется постфиксная запись?

Ты имеешь в виду, как реализуется постфиксный инкремент/декремент? Очень просто, в префиксном нет параметров, а в постфиксном в качестве параметра передается int (просто, чтобы отличить одно от другого, так принято делать), то есть, если префиксный был:

void operator++();
// то постфиксный - 
void operator ++(int);
// или
friend a operator++(a &b, int);

А вот теперь - касательно ответа на вопрос:

Насколько эффективна программа, нет ли каких других неточностей?

А как, прости, ты будешь различать префикс и постфикс, если префиксный вариант ++ у тебя ничего не возвращает? Весь смысл-то и есть в различии, что префикс возвращает измененное значение, а постфикс - НЕизмененное. Сделай вот так, например:

#include <iostream.h>
class a {
    friend ostream& operator << (ostream& os, a& obj) {
        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;
    }

    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;
    }
    void print() {
        cout<<x<<endl;
    }

    a() {
        x = 1;
    }
};

int main() {
	a kot;
	// kot.print();
	cout << ++kot << endl;
	cout << kot << endl;
	cout << kot++ << endl;
	cout << kot << endl;

	// kot.print();
	--kot;
	kot.print();
	a rot, mot;
	++rot;
	mot = kot+rot;
	mot.print();
	return 0; // no errors
}

, и поиграйся с этой реализацией, посмотри, на что она способна...