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

Question

Как я могу сделать чисто виртуальную функцию оператором + (); функция. где я делаю это в базовом классе? оператор int + () = 0; Компилятор выдает ошибку. в производном классе оператор + () функция Компилятор говорит, что производный класс не может сделать. потому что следующий класс является абстрактным Я знаю, что не могу создать объект абстрактных классов, но теперь я пытаюсь создать объект производного класса.

Вот код

#include <iostream>
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;
    }

Answer 1

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

#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, как и ожидалось. Что бы вы ни делали неправильно, очевидно, что оно должно отличаться от этого (и, вероятно, не связано с конкретной проблемой наличия перегрузки оператора чисто виртуальной).

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

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

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

Answer 2

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

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

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

Answer 3

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

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

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

Answer 4

Я вижу две проблемы, которые вы должны решить или, по крайней мере, лучше понять. Они оба сводятся к тому, что вы не разрешили чисто виртуальное объявление в вашем базовом классе, 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; }

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

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

Answer 5

 #include 
using namespace std;
class ana {
    protected :
    int x;
    public :</p>

<p>virtual int operator+()=0;
virtual void operator=(ana&)=0;
    };</p>

<p>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;
       }</p>

<pre><code>};
</code>

int main () { баба к (4);

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

Answer 6

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

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

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