полиморфизм C++ перегрузки оператора

Примечание. Вопрос был обновлен, поэтому он стал менее достоверным.

Если ваше описание верное, вы просто забываете использовать ключевое слово virtual , чтобы указать оператор как виртуальный ...

class Addable{
public:
    virtual int operator+ const ( const Addable& other ) = 0; // pure virtual
    virtual int operator+ const ( int number ) = 0; // pure virtual
};

Синтаксис чистой виртуальной функции будет примерно таким:

class X { 
public:
     virtual int operator+(X const &rhs) = 0;
};

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

Ваши расплывчатые упоминания о коде практически невозможно понять. Отвечая на ваш вопрос "Как я могу сделать чистую виртуальную функцию функцией operator+();", нет абсолютно никакого секрета в этом, например, рассмотрим следующую тривиальную программу:

#include <iostream>

class base {
public:
  virtual int operator+(int) const = 0;
};

class deriv: public base {
public:
  int operator+(int) const {return 23;}
};

int main() {
  deriv d;
  base& b = d;
  std::cout << b + 15 << std::endl;
  return 0;
}

Это компилируется и работает просто отлично и выдает 23, как и ожидалось. Что бы вы ни делали неправильно, очевидно, что это должно отличаться от этого (и, вероятно, не связано с конкретной проблемой того, что перегрузка оператора должна быть чисто виртуальной).

Edit: (согласно комментариям, добавил const к методу на случай, если вы захотите вызвать его с const base& - обратите внимание, что в других ответах этот const также опущен; и, также согласно комментариям):

Если вы хотите иметь возможность также делать 15 + b, просто добавьте отдельную функцию для этой цели, скажем, непосредственно перед main:

inline int operator+(int i, const base&b) {
    return b + i;
}

 #include 
using namespace std;
class ana {
    protected :
    int x;
    public :

virtual int operator+()=0;
virtual void operator=(ana&)=0;
    };

class baba:public ana{
    public:
    baba(int k){x=k;}
    int   operator+(baba &ali){
        int k;
        k=x+ali.x;
        return k;
    }
   void operator=(baba &ali){
       x=ali.x;
       }

};


int main(){
baba k(4);

return 0;
}<code>what is wrong here?

Если вы ищете стандартную реализацию operator+(), то, к сожалению, это невозможно:

class X { 
public:
     virtual X operator+(X const &rhs) = 0;
};

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

Я вижу две проблемы, которые вам следует решить или, по крайней мере, лучше понять. Обе они сводятся к тому, что вы не разрешили чисто виртуальное объявление в вашем базовом классе, ana:

1) operator+(): Ваш класс baba определяет оператор +, отличный от базового класса. В частности, ana::operator+() является унарным оператором + (принимает только один операнд), а baba::operator+(baba& ali) является бинарным оператором (принимает два операнда) на baba. Вам нужно решить, какой из них использовать, и использовать его. Если вы хотите использовать двоичный + (что, учитывая ваше определение в baba, я думаю, вы хотите), то вы объявляете в ana:

virtual int operator+(const ana&) const =0;

и в baba:

virtual int operator+(const ana& ali) const {return x+ali.x; }  

Почему это должен быть чисто виртуальный метод в ana, поскольку x определен в ana - любопытно. Это приведет к интересным последствиям, если у вас есть другие производные классы, которые делают вещи по-другому (потеря коммутативности, вероятно, приведет к этому). Но я ожидаю, что у вас есть свои причины, так что я не буду задавать вопросы дальше.

2) operator=(ana&): У вас также есть проблема с объявлением оператора присваивания. Опять же, вы не разрешаете чистую виртуальность. В ana у вас есть: virtual void operator=(ana&)=0; в то время как в baba у вас есть: void operator=(baba &ali). Аргументы разные, поскольку baba& не то же самое, что ana&; поэтому чисто виртуальное объявление снова не разрешено. Чтобы исправить это, вы, вероятно, захотите изменить объявление в ana на:

virtual void operator=(const ana&)=0

и в baba:

virtual void operator=(const ana& ali) { x=ali.x; }

У меня аналогичные сомнения относительно того, почему вы хотите объявить это как чисто виртуальное, поскольку, опять же, это предполагает, что различные производные классы будут реализовывать это по-разному, что приведет к интересному поведению. Опять же, я уверен, что у вас есть свои причины.

Надеюсь, это поможет.