标签: pure-virtual

可能重复:
C++ Virtual/Pure Virtual Explained
c ++中虚函数实例化的区别
为什么纯虚函数初始化为0？

这是有人给我的一些类声明中的方法.我不知道'.. = 0'是什么意思.它是什么？

virtual void Print() const = 0;

灵感来自:C++ - 我们为什么要在类定义之外定义纯虚析构函数？

以下代码实际上做了什么？

class Object
{
    public:
    virtual ~Object() = 0;
};

Object::~Object() { /*...*/ }

我认为纯虚函数的要点是强制子类实现该特定函数.如果是这种情况,那么为什么还要在虚拟基类中实现相同的功能呢？

我试过的两个编译器接受这种语法,但我在某处读到纯虚析构函数定义应始终在类之外.我编写的代码:

class AbstractBase
{
public:
    virtual ~AbstractBase() = 0
    {}

    virtual void foo()
    {
        ...
    }
};

我理解为什么我得到了我得到的错误(称为纯虚函数).我试图从我的基类的析构函数中调用纯虚函数,如下所示.但是,我不知道如何重写我的代码以防止这种情况发生.以下是基类和派生类(无论如何相关部分):

基类:

TailFileManager::TailFileManager(const std::string &filename, const int fileOpenPeriod_ms)
: m_Stop(false)
{
    m_WorkerThread.reset(new boost::thread(boost::bind(&TailFileManager::TailFile, this, filename, fileOpenPeriod_ms)));
}

TailFileManager::~TailFileManager()
{
    m_Stop = true;
    m_WorkerThread->join();
}

void TailFileManager::TailFile(const std::string &filename, const int fileOpenPeriod_ms)
{
    std::ifstream ifs(filename.c_str());

    while (! ifs.is_open())
    {
        boost::this_thread::sleep(boost::posix_time::milliseconds(fileOpenPeriod_ms));
    ifs.open(filename.c_str());
    }

    ifs.seekg(0, std::ios::end);

    while (! m_Stop)
    {
        ifs.clear();

        std::string line;

        while (std::getline(ifs, line))
        {
            OnLineAdded(line);
        }

        OnEndOfFile();
    }

    ifs.close();
}

派生类:

ETSLogTailFileManager::ETSLogTailFileManager(const std::string &filename, const int heartbeatPeriod_ms)
: TailFileManager(filename, heartbeatPeriod_ms),
  m_HeartbeatPeriod_ms(heartbeatPeriod_ms),
  m_FoundInboundMessage(false),
  m_TimeOfLastActivity(0)
{
}

ETSLogTailFileManager::~ETSLogTailFileManager()
{
}

void ETSLogTailFileManager::OnLineAdded(const …

由于明显的原因，下面的程序无法编译：

#include <iostream>
using namespace std;

class A {
 public:
  A() { pVirt(); }
  virtual void pVirt() const = 0 { count<<"A::pVirt()"; }
};

int main() {
 A aObj;
 aObj.pVirt();
 reutrn 0;
}

问题： 1. 签名中的 0 "virtual void pVirt() const = 0" 是什么意思？，这表示 vtable 中的 NULL 内存偏移量还是只是语法约束？

1. 如果 0 是 NULL 内存偏移量（如果是这样的话）那么为什么 VC++ 不允许指定另一个内存地址，这就是我们不能从外部构造函数调用纯虚函数的原因（可能是因为 vtable 是在对象完全构造之后创建。）？

我正在开发 C++ 程序，但在使用克隆时遇到多重继承问题。问题（以简化形式）如下。

我希望能够克隆从类 Base 派生的所有对象。

class Base{
public:

    virtual Base* clone()const=0;
};

我想定义另外两个从 Base 派生的类，它们都是抽象的，即我不能定义克隆函数，但我必须以某种方式声明它们（我想确保，如果我克隆 Derived*，我会得到back Derived* 而不是 Base*，即我想避免在应用点进行转换）

class Derived1: public virtual Base{
public:
    virtual Derived1* clone()const=0;
};

class Derived2: public virtual Base{
public:
    virtual Derived2* clone()const=0;
};

问题来了，当我声明一个继承自 Derived1 和 Derived2 的第四个类时：

class Derived3: public Derived1,public Derived2{
protected:
    int b;
public:
    Derived3():b(3){};
    Derived3(Derived3 const& l_B) {b=l_B.b;};
    virtual Derived3* clone()const{return new Derived3(*this);}
    ;
};

在这种情况下，我将从 Visual C++ 2010 编译器 C2250: 'Derived3' : 'Derived1 *Base::clone(void) const' 的模糊继承中得到。如果我在 Derived1 和 …

学习期末考试并决定构建一个使用纯虚函数和多态性的程序。我陷入了一个非常奇怪的错误，也许我错过了一些东西。

这是 Shape 抽象类

#ifndef Shape_hpp
#define Shape_hpp

#include <stdio.h>
#include <string.h>

class Shape{
    const char* name;
public:
    Shape(const char* abc);
    virtual double getPerimeter()=0;
    virtual double getArea()=0;
};

#endif /* Shape_hpp */

Shape .cpp 实现文件

#include "Shape.hpp"

Shape::Shape(const char *shape){
    name = shape;
}

圆头文件

#ifndef Circle_hpp
#define Circle_hpp

#include "Shape.hpp"
#include <stdio.h>

class Circle:public Shape{
    double m_radius;
public:
    Circle(double rad);
    double getRadius();            
};

#endif /* Circle_hpp */

圆.cpp实现文件

#include "Circle.hpp"
#include "Shape.hpp"

Circle::Circle(double rad):Shape("Circle"){
    m_radius = rad;
}

double …

我有两节课,PlayerCharacter而且Ability.所述Ability类具有我声明作为一个纯虚函数friend来PlayerCharacter.但是,我似乎无法访问friend声明的函数中的私有成员.这是我忽视的事情吗？

我已经尝试声明子函数而不是虚函数作为友元函数,但是没有效果.

player_chracter.h:

#include "ability.h"

class PlayerCharacter : public Character {
private:
    // Friend function
    friend bool Ability::ExecuteAbility(PlayerCharacter& in_player);

    // This doesn't work either
    //friend bool Dash::ExecuteAbility(PlayerCharacter& in_player);

    // Private variable
    float top_speed_;
}

ability.h:

//Forward declaration
class PlayerCharacter;

class Ability {
public:
    Ability();
    ~Ability();
    virtual bool ExecuteAbility(PlayerCharacter& in_player) = 0;
};
//---------------------------------------------------------
class Dash : public Ability {
public:
    Dash();
    ~Dash();
    bool ExecuteAbility(PlayerCharacter& in_player);
};

ability.cpp:

#include …

根据此答案，在C ++中从概念上类似于接口的方式声明类的方法如下：

class IDemo
{
public:
    virtual ~IDemo() {}
    virtual void OverrideMe() = 0;
};

但是，当我这样做时，会收到警告：'IDemo' has no out-of-line virtual method definitions; its vtable will be emitted in every translation unit。是否有适当的方法在项目中使用此类接口而不用这些vtable污染每个翻译单元？

我正在尝试声明纯虚拟析构函数，在VS2019中我这样写：

    virtual ~A() = 0 {};

很好，但是在Clion中，我接受了以下消息：

函数定义虚拟的纯说明符〜A（）= 0 {};

并且迫使我为该函数编写不同的实现（不是给它带来很多麻烦，而是我想知道为什么会这样）