Перегрузка оператора

[RuVarez]

Здраствуйте всем ! Подкажите пожалуйста:
Есть код

//---------------------------------------------------------------------------

#pragma hdrstop
#pragma argsused

#include <iostream.h>

class TAge
{
private:
  int FData;
public:
  int operator+(int Value);
  int operator+(TAge Value);
  int operator=(int Value);
};

/* TAge */

int TAge::operator+(TAge Value)
{
  return (this->FData + Value.FData);
};

int TAge::operator=(int Value)
{
  this->FData = Value;
  return this->FData;
};

int TAge::operator+(int Value)
{
  return (this->FData + Value);
};

/* Main module */

int temp;
TAge Me, Mom;

int main(int argc, char* argv[])
{
  Me = 19;
  Mom = 30;
  temp = Me + Mom;
  temp = Me;
  cout << temp << endl;
  cin >> temp;

  return 0;
}

На строчку temp = Me ругается мол разные типы! Какой оператор перегрузить и как чтоб не ругался?

[rmv240899]

У Me тип TAge, Вы пытаетесь присвоить этот объект переменной типа int. А у Вас оператор присваивания со вторым целым параметром перегружен для класса TAge. Перегружать операции для базовых типов нельзя, так что пишите get методы для класса TAge.

[RuVarez]

Т.с. я не смогу перегрузить оператор, только через метод?

[rmv240899]

Не совсем. Напишите в классе метод, который возвращает значение FData, и присваивайте результат этого метода переменной temp.

[RuVarez]

Ну так это через функцию, Не красиво получается -

temp = Me->GetData

Что никак нельзя перегрузить оператор присваивания! Даже Delphi умеет)

[rmv240899]

Оператор присваивания вне класса перегрузить не получится. Тем более для базовых типов вообще нельзя перегружать операции.
Лучше через метод. Тогда это будет выглядеть так:

temp = Me.getData()

А сам метод должен выглядеть так:

int getData() const { return FData; }

[RuVarez]

Ладно понятно! Спасибо за помощь(

[ElectroMent]

class TAge
{
private:
  int FData;
public:
  TAge( int value = 0 ) : FData( value ) { }
  TAge( const TAge & a ) : FData( a.FData ) { }
  
  TAge & operator=(int Value);
  TAge & operator=(const TAge &a);

  operator int() { return FData; } // Вместо метода GetFData(), оператор приведения типа

  TAge & operator+=(int Value); // Изменил оператор с унарного + на +=
  TAge & operator+=(const TAge &Value);
  
  // добавил друзей, бирнарные операторы + 
  friend TAge operator+(const TAge &a, const TAge &b); 
  friend TAge operator+(const TAge &a, int b);
  friend TAge operator+(int a, const TAge &b);
};

/* TAge */

TAge & TAge::operator=(int Value)
{
  FData = Value;
  return *this;
}

TAge & TAge::operator=(const TAge &a)
{
	if( this != &a)
	{
		FData = a.FData;
	}
	return *this;
}

TAge & TAge::operator+=(int Value)
{
  FData += Value;
  return *this;
}

TAge & TAge::operator+=(const TAge &Value)
{
  FData += Value.FData;
  return (*this);
}

// friends
TAge operator+(const TAge &a, const TAge &b)
{
	TAge res(a);
	res += b;
	return res;
}

TAge operator+(const TAge &a, int b)
{
	TAge res(a);
	res += b;
	return res;
}

TAge operator+(int a, const TAge &b)
{
	TAge res(b);
	res += a;
	return res;
}

теперь твоя конструкция будет работать.

{
		  Me = 19;
		  Mom = 30;
		  temp = Me + Mom;
		  temp = Me;
		  cout << temp << endl;
		  cin >> temp;
	}

[ElectroMent]

Сообщение от rmv240899

Оператор присваивания вне класса перегрузить не получится. Тем более для базовых типов вообще нельзя перегружать операции.
Лучше через метод. Тогда это будет выглядеть так:

temp = Me.getData()

А сам метод должен выглядеть так:

int getData() const { return FData; }

Такой фигней страдать не нужно, а то можно подумать С++ создавали глупые люди.

[_Bers]

Сообщение от ElectroMent

Такой фигней страдать не нужно, а то можно подумать С++ создавали глупые люди.

Глянь ещё раз на собственный код. Присмотрись по внимательнее: что именно ты сделал? И если ты ещё не понял, то ты сделал надстройку над int, которая ничего абсолютно нового к типу данных int не добавила.

Я могу переписать весь твой код всего одной строчкой. И смысл не изменится:

typedef int TAge;

То, что ты сделал, называется "овер инжениринг". Создание бесполезной сущности, трата времени, и излишнее переусложнение кода.

В ситуациях, когда создание очередной сущности себя действительно оправдывает, способ rmv240899 естественно предпочтителен. Ибо однозначен и прост.

Способ "присваивать теплое мягкому" - плохой путь.
Способ "присваивать мягкое мягкому" - "овер инжениринг".