Перегруженный метод С++ в производном классе

Нет, он не будет вызывать функцию базового класса. Класс B имеет operator+, он не принимает правильный параметр, конец истории.

Вы можете определить operator+ как свободную функцию, а не в любом классе. Возможно, друг, если ему нужен доступ к личным данным:

A operator+(const A &lhs, const A &rhs) { ... }
B operator+(const B &lhs, const B &rhs) { ... }

Тогда b + a вызовут первого оператора, как и a + b. b + b вызовет второй.

В качестве альтернативы вы можете «скрыть» реализацию базового класса, поместив это в класс B:

using A::operator+;

хотя, наверное, лучше этого не делать. Большинство операторов лучше работают как свободные функции, потому что тогда вы получаете автоматические преобразования для обоих операндов. C++ никогда не выполняет преобразования в левой части вызова функции-члена.

Между прочим, оператор + почти наверняка должен возвращать значение, а не ссылку, поскольку автоматическая (стековая) переменная больше не существует после возврата функции. Таким образом, вызывающему объекту необходимо передать копию результата, а не ссылку на него. По этой причине оператор + и наследование не являются хорошим сочетанием, хотя, вероятно, оно может работать, пока вызывающий объект знает, что он делает.

Проблема называется скрытием — функция-член в производном классе скрывает функции с тем же именем в базовом классе. В этом случае вы не можете получить доступ к A::operator+(A&), потому что он скрыт B::operator+. Способ исправить это — определить B::operator+(A&) и, возможно, заставить его вызывать функцию базового класса.

Изменить: есть раздел в C++ FAQ Lite, в котором более подробно рассматривается эта проблема и предлагается другое возможное решение, а именно ключевое слово using.

Проблема в том, что вы определяете оператор member, поэтому при вызове как b + a он приводит к b.operator+( a ), которого не существует.

Accepted practice is to define free operators that themselves would call [virtual] members on the arguments.

Редактировать:

class base
{
public:

  virtual ~base();
  virtual void print( std::ostream& ) const;
};

std::ostream& operator<<( std::ostream& out, const base& b )
{
  b.print( out ); return out;
}

На самом деле это не работает для математических операций, так как вы хотите возвращать значение [const], а не ссылку, т.е. избегать глупостей, таких как a + b = c;.

Например, определено сложение действительных и комплексных чисел, но в результате получается комплексное число, поэтому вы не можете вывести complex из real. По другому - может быть. Но все же вы хотите определить точный интерфейс операций:

const real operator+( const real&, const real& );
const complex operator+( const complex&, const complex& );

Надеюсь, это даст вам достаточно, чтобы переосмыслить свой дизайн :)

Пара вещей приходит на ум. Во-первых, вы бы вообще хотели сделать оператор + "виртуальным". Тогда производный оператор + со ссылкой на B будет переопределением из-за ковариации, а не сокрытием реализации базового класса, что здесь и происходит.

Тем не менее, я подозреваю (но не могу сказать наверняка, не скомпилировав тестовый проект), что это действительно решит вашу проблему. Это потому, что стандартным ответом для бинарных операторов является использование статических методов, которые принимают два параметра в классе. C++ STL широко использует эту технику, и я не знаю причин пытаться реализовать бинарные операторы как методы экземпляра, виртуальные или нет. Это слишком запутанно, без реальных плюсов.