Приветствую!

Последний раз с С++ сидел очень давно. Вот настряпал код, на который компилятор начал ругаться:


Я так понимаю, оператор + возвращает объект класса А, а у В нет бинарного оператора = который берет справа объект класса А. Но ведь у предка В (А) есть оператор = который берет справа А, а по скольку объект В является всегда и объектом А, то все должно сработать. Что я не догоняю?

Необходимо, чтобы это все скомпилилось. Пока реализации нет, но это и неважно.

neutrino

происходит это, потому что объекту производного класса нельзя присваивать объекты базового. Можно наоборот, но тогда произойдёт "срезка" объекта.


Это сообщение отредактировал(а) zim22 - 20.10.2009, 15:17

На самом деле, если рассматривать перегрузку оператора, как перегрузку функции, то эти аргументы не катят. Ведь я могу использовать скажем перегруженный оператор = с А для переписывания полей А, а для переписывания полей Б уже использовать оператор = перегруженный в Б. Что-то типа:



Но по аналогии с функциями это дело не компилится. Значит мне нужно перегружать в В оператор = который берет как аргумент объект класса А. Но ведь тогда получается совсем лишний и дурацкий оператор в В:


Как правильно разрулить ситуацию???

То есть в потомках ВСЕГДА надо перегружать все операторы =, которые были перегружены в предке??? Что-то какашка какая-то или я опять не понял...

Добавлено через 1 минуту и 24 секунды

Да, как-то об этом не подумал.

Ну в принципе да. Но это нормально. Представим ситуацию.

оператор хоть и написан в классе A, он скрыт в классе B, это логично, потому-что этот оператор НЕ ЯВЛЯЕТСЯ оператором присваивания для класса B, он не присваивает члены класса B, он работает для класса A, вот и прекрасно, пусть продолжает работать  

Это сообщение отредактировал(а) azesmcar - 20.10.2009, 15:51

Спасибо за объяснения!

[офтоп]
Вот еще почему Java рулит, так это потому, что там нет перегрузки операторов и подобной хрени. Ожидал от C# того же, но оказалось, что и там такая же какашка. По моему перегрузка операторов только путает больше. Исключением может быть уж очень интенсивное программирование каких-нибудь матриц или комплексных чисел где операторы сократят код. Хотя на моей практике в 6 лет таких примеров не было. ИМХО это лишнее. 
[/офтоп]

ещё можно написать внутри B такое:

тогда дублирования кода не будет

Это сообщение отредактировал(а) maxim1000 - 20.10.2009, 16:14

maxim1000, Спасибо, то что надо!

Не представляю языка программирования без перегрузки операторов. Это огромное удобство, навязать объекту нужное тебе поведение.


Было. Просто вы не знали что это можно сделать намного проще, и сократить код.

niXman, 

Нет. Не было. В основном я разрабатывал инфраструктуру.

I кстати, как можно сократить код с помощью перегрузки операторов? Ведь все, что можно это:

вместо:
someObject.add(anotherObject);

написать:
someObject += anotherObject;

Может быть, если кто-то интенсивно использует какую-нибудь область математики v программировании, тo ему стоит перегрузить операторы. Например в линейной алгебре может оказаться полезно писать умножение через всеm понятный оператор *, а не функцию multiply. Но поскольку я в основном разрабатывал каждый раз что-то для другой области, то мне не стоилo перегружать операторы.

И вообще интересный факт, действительно почему в Java операторы нельзя перегружать? Почему разработчики этого языка не добавили такую возможность?

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

http://stackoverflow.com/questions/77718/j...erator-overload
и ещё миллион ссылок в гугле

В комментарии к твоей репутации UnrealMan ответил.

  

  

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

Если вам приходится наследовать класс с перегруженными операторами и появляется желание не перегружать их в классе-потомке, то следует задуматься а правильно ли вы спроектировали класс-предок и класс потомок =) Что делает такого потомок что для него у вас нет желания перегрузить операторы вновь? Может должно быть наоборот Предок должен быть потомком а потомок предком, или потомок вообще должен быть инкапсулирован в предок и т д

Механику перегрузки операторов придумывали не идиоты, все очень логично если вы понимаете что это не просто функции члены =)

  

Знаете, если вы работаете на себя и перегрузка операторов для классов у вас нигде не оговорена в контракте или в соглашении группы разработчиков - то вас С++ НЕ ЗАСТАВЛЯЕТ пользоваться перегрузкой операторов, также как и не заставляет обязательно делать многое другое! (например не заставляет обязательно перехватывать все исключения)
Вы можете также как и в Java создавать функции члены (Add, Summ, Equa или как вы там еще их называете =) ) и пользоваться ими себе на здоровье =)

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

А по поводу Java - очень глупо сказано, не в том месте сравниваете языки =)
Да и сравниванием не рекомендую заниматься для разных задач они =)
и каждый в своей сфере хороши.