Перегрузка бинарного оператора

[XuMuK]

Есть класс - реализует некую дин. структуру, похожую на дерево.
Необходимо перегрузить бинарный оператор сложения и присваивания
Т.е. если А, В, С объекты данного класса. Необходимо реализовать С=А+В (в перспективе С=(А+В)-D+E&V ... ну и в таком роде).

Проблема в том, что в ходе исполнения А+В, создается некий объект Х (того же класса, что и А,В,С) в который идет суммирование и ссылка на который потом возвращается.
Далее уже этот объект Х передается в операторную ф-цию присваивания, где фактически создается его копия в объект С.
В итоге, после выполнения С=А+В, получаем "левый" объект Х и утечку памяти.
Для этого временного объекта нужно, явно вызвать деструктор, но вопрос когда и как ?

Может кто сталкивался или знает красивое решение сей проблемы

[_-Re@l-_]

Явно вызвать деструктор? Не перевелись ещё извращенцы на Руси...

В итоге, после выполнения С=А+В, получаем "левый" объект Х и утечку памяти.

Это с чего бы? Вот вам пример своего оператора сложения...

inline MyClass& operator+(const MyClass& b)
{
    MyClass temp = b; // Неявный копирующий конструктор, кстати
    // тут складываете поля текущего объекта и temp
    return temp;
}

И после выхода из этой функции объект temp автоматически уничтожается(как правило)!

[An1ka]

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

Проблема в том, что в ходе исполнения А+В, создается некий объект Х (того же класса, что и А,В,С) в который идет суммирование и ссылка на который потом возвращается.

Надо возвращать не ссылку, а сам объект в таком случаи.

class MyClass
{
	int i;
public:
	MyClass (): i(1) { cout << "Конструктор \n";}
	inline MyClass operator + ( const MyClass b)
	{
		MyClass temp = b; // Неявный копирующий конструктор, кстати
		temp.i += this->i;// тут складываете поля текущего объекта и temp
		return temp;
	}
};
int main ( )
{
	MyClass A, B, C;
	C = A + B;
return 0;
}

Вот данный код оптимизируется компилятором так, что за время выполнения программы будет вызвано всего 3 конструктора( а больше нам и не надо). Но в итоге всё правильно посчитается и C.i будет равно 2.

[XuMuK]

Сообщение от _-Re@l-_

Явно вызвать деструктор? Не перевелись ещё извращенцы на Руси...

Это с чего бы? Вот вам пример своего оператора сложения...

inline MyClass& operator+(const MyClass& b)
{
    MyClass temp = b; // Неявный копирующий конструктор, кстати
    // тут складываете поля текущего объекта и temp
    return temp;
}

И после выхода из этой функции объект temp автоматически уничтожается(как правило)!

В таком случае - два прохода по дереву будет. Т.к. оно большое - хотелось бы за один.

Да и при таком подходе и выражении С=А+В , как мне кажется, объект temp не попадет в operator=, т.к. выйдет из зоны видимости и самовыпилится.

Надо возвращать не ссылку, а сам объект в таком случаи

Очень накладно. Класс со структурой может весить и 100 и больше Мб

[Сыроежка]

Сообщение от _-Re@l-_

Явно вызвать деструктор? Не перевелись ещё извращенцы на Руси...

Это с чего бы? Вот вам пример своего оператора сложения...

inline MyClass& operator+(const MyClass& b)
{
    MyClass temp = b; // Неявный копирующий конструктор, кстати
    // тут складываете поля текущего объекта и temp
    return temp;
}

И после выхода из этой функции объект temp автоматически уничтожается(как правило)!

У вас совершенно некорректный код, так как вы возвращается ссылку на временный объект, который, как вы правильно заметили, удаляется по выходу из функции.

Ваш пример - это пример того, как не надо перегружать операторы!

[Сыроежка]

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

Надо возвращать не ссылку, а сам объект в таком случаи.

class MyClass
{
	int i;
public:
	MyClass (): i(1) { cout << "Конструктор \n";}
	inline MyClass operator + ( const MyClass b)
	{
		MyClass temp = b; // Неявный копирующий конструктор, кстати
		temp.i += this->i;// тут складываете поля текущего объекта и temp
		return temp;
	}
};
int main ( )
{
	MyClass A, B, C;
	C = A + B;
return 0;
}

Вот данный код оптимизируется компилятором так, что за время выполнения программы будет вызвано всего 3 конструктора( а больше нам и не надо). Но в итоге всё правильно посчитается и C.i будет равно 2.

И ваш пример также является примером того, как не следует перегружать операторы. Конечно никакой серьезной ошибки нет, тем не менее в качестве аргумента лучше передавать не временный объект, а констатную ссылку на исходный объект. Иначе накладные расходы по вызовам конструкторов и деструкторов временных объектов сильно возрастают.

Кроме того желательно возвращать констатнтный объект, так как это более соответствует результатм операций со встроенными типами. То есть правильный код оператора суммирования будет выглядеть так:

inline const MyClass operator + ( const MyClass &b) const
{
	return ( MyClass( i + b.i ) );
}

Правда вам следует в ваш кдасс добавить конструктор с одним параметром!

[Carbon]

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

В таком случае - два прохода по дереву будет. Т.к. оно большое - хотелось бы за один.

Оператор сложения пишется так:

C operator + (const B & arg) const
{
    C temp = ...; // Временный объект
    ....
    return temp;
}

Оператор присваивания так:

A & operator = (const A & arg)
{
    if (this != &arg) // или по-другому определять, что объекты равны
    {
        // присваивание
    }
    return *this;
}

Если нужен один проход по дереву и чтоб без создания промежуточных объектов, то нужен итератор и там уже операции +, -, ++, -- и т.д.
Там накладные расходы на создание временных объектов будут минимальны, настолько, что и передавать их в функции можно будет не по ссылке, а копиями.

[Carbon]

Прекращаем холивар! Ещё одно сообщение из цикла "возврат ссылки/значения" и начну раздавать нарушения!

По теме: Тема была в правильной реализации операторов для дерева. Пусть автор отпишется, иначе тему закрываю.

[An1ka]

Сообщение от Сыроежка

И ваш пример также является примером того, как не следует перегружать операторы. Конечно никакой серьезной ошибки нет, тем не менее в качестве аргумента лучше передавать не временный объект, а констатную ссылку на исходный объект. Иначе накладные расходы по вызовам конструкторов и деструкторов временных объектов сильно возрастают.

Только где эти накладные расходы ? Вы хоть код то запускали и проверяли ? В реальности нет никаких накладых раходов... Компиляторы умеют всё оптимизировать То, что написано в старых книжках очень сильно отличается от реальных "военно-полевых" условий !

Сообщение от Сыроежка

Кроме того желательно возвращать констатнтный объект

Константный не обязательно возвращать ! При возврате константного объекта некоторые операции будут не доступны, например :
(A+B).func () - которая изменяет объект.

[Сыроежка]

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

Только где эти накладные расходы ? Вы хоть код то запускали и проверяли ? В реальности нет никаких накладых раходов... Компиляторы умеют всё оптимизировать То, что написано в старых книжках очень сильно отличается от реальных "военно-полевых" условий !


Константный не обязательно возвращать ! При возврате константного объекта некоторые операции будут не доступны, например :
(A+B).func () - которая изменяет объект.

Объясняю по порядку. Ког8да вы передаете в качестве параметра объект по значению, то 1) вызывается конструктор для этого объекта; 2) при завершении оператора-функции вызывается деструктор этого объекта. У вас очевидно малый опыт программирования, но порой объекты бывают достаточно сложные. Например, конструкторы могут выделять память для своих членов, открытвать файлы и т.д. К тому же сами члены объекта также могут требовать вызова конструкторов и деструкторов. Кроме того в самом стеке функции должна быть выделена память под весь объект. Какой смысл передавать объект по значению, если вы с ним ничего не делаете?! Не проще ли передать вместо всего объекта через стек лишь константную ссылку на него? Сравните размер ссылки и размер объекта!

Что касается второго вашего вопроса. Возврашение не константного объекта нарушает общепринятое представление для операций со встроенными типами. То есть общая семантика операторов нарушается. Вы же не можете выполнять такой, например, код

int x = 3, y = 4;

x + y = 5;

Такое повдение ожидают пользователи вашего кода и от вами определнных типов, то есть семантика операций должна быть идентична для встроенных типов и ваших типов. Этот принцип называется принципом наибольшей предсказуемости поведения.