Question

How can I make pure virtual function a operator+(); function. wheh ı do like this in base class int operator+()=0; compiler gives error . in derive class operator+() function compiler say that derive class cannot make . because following class is abstract I know that I cannot create object of abstract classes but now I try to make derive class object.

这里是法典

#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。不管怎样,你再做错事,这显然必须不同于这种情况(而且可能与操作者超负荷这一具体问题没有联系,只是虚拟的)。

<>strong>Edit: (根据评论,在你想要打上W/acode>const base&的情况下,在方法上添加const;——注意到其他答复也遗漏了const;以及,也根据评论:

如果你也想做<条码>15 + b,那么仅为此目的增加一项独立职能,即在<条码>> > > 封顶/条码>之前:

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

Answer 2

如果你正在寻找标准操作员+()执行,那么不幸的是,不可能:

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

该法典无法编纂,因为汇编者不能按价值退还十类摘要。

Answer 3

注:问题已经更新,使得这一答案无效。

如果你重新描述是正确的,你就重新开始使用<代码>virtual。 B. 确定经营者为虚拟......的关键词

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

Answer 4

我看到你应该处理的两个问题,或者至少能更好地了解两个问题。这两条oil倒了这样一个事实,即你没有在你的基类中解决纯虚拟声明问题,ana:

1> 操作员+() 页: 1 具体来说,<代码>ana:operator+()是一个非固定的+操作者(只接收一个歌剧),而baba:operator+(baba& ali)是baba上的双向操作者(接受两个歌剧)。你们需要决定如何使用和使用。如果你想要使用双程+(在<条码>baba<>>>>上给出定义,则你在<条码>中宣布:

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

和baba:

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

由于<条码>x的定义在<条码>ana<>/条码>上,因此为什么需要成为<条码>的纯粹虚拟方法。如果你有其他不同种类的衍生产品,则会引人注意(可能会导致通勤)。但是,我期待你有自己的理由,因此我再次赢得问题。

2) operator=(ana&): You also have a problem with the assignment operator declarations. Again, you re not resolving the pure virtual. In ana you have: virtual void operator=(ana&)=0; while in baba you have: void operator=(baba &ali). The arguments are different since baba& is not the same as ana&; so the pure virtual declaration is again not resolved. In order to fix this, you probably want to change the declaration in ana to:

virtual void operator=(const ana&)=0

和baba:

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

我对你为什么要宣布这纯粹是虚拟表示同样关切,因为我再次认为,不同的衍生类别将不同地加以实施,从而产生有意义的行为。我再次肯定你有其原因。

我确实希望这一帮助。

Answer 5

纯虚拟功能的辛迪加就是:

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

但请注意,你很少想这样做——你通常希望超载<条码>操作器+<>条码>,作为自由功能加以执行,以便允许左轮操作(如有必要)转换。

Answer 6

 #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?

友情链接