抽象对象不能声明

Question

我遇到了抽象/虚拟类的问题，这里有一个问题的复制：

#include <iostream>

class A
{
protected:
    virtual std::string getDateTime() = 0;
    virtual void Write(std::string data, bool addDate) = 0;
    virtual bool CheckFile() = 0;
    virtual bool OpenFile(std::string path) = 0;
    virtual void CloseFile() = 0;
};

class B
    : public A
{
public:
    virtual std::string ToString() { return ""; };
    virtual void Write(std::string data) { };
};

class C
    : public A
{
protected:
    std::string getDateTime()
    {
        return "TODAY";
    };

    void Write(std::string data, bool addDate)
    {
        std::cout << "BasicClassA Write" << std::endl;
    };

    bool CheckFile()
    {
        std::cout << "BasicClassA CheckFile" << std::endl;
        return true;
    };

    bool OpenFile(std::string path)
    {
        std::cout << "BasicClassA OpenFile" << std::endl;
        return true;
    };

    void CloseFile()
    {
        std::cout << "BasicClassA CloseFile" << std::endl;
    };
};

class D
    : public B,
      public C
{
public:
    BasicClassB();
    virtual ~BasicClassB();

    std::string ToString()
    {
        return "BasicClassB tostring";
    };

    void Write(std::string data)
    {
        std::cout << "BasicClassB Write" << std::endl;
    };
};

int main(int ac, char *av[])
{
    BasicClassB b;
    std::cout << b.ToString() << std::endl;
    b.Write("");
    return 0;
}

这有一个编译错误：

../src/main.cpp: In function 'int main(int, char**)':
../src/main.cpp:82：错误：无法将变量“b”声明为抽象类型“BasicClassB”
../src/main.cpp:64: 注意：因为以下虚函数在 'BasicClassB' 中是纯虚函数：
../src/main.cpp:13：注意：虚拟 std::string BaseClassA::getDateTime()
../src/main.cpp:14: 注意：virtual void BaseClassA::Write(std::string, bool)
../src/main.cpp:15: 注意：virtual bool BaseClassA::CheckFile()
../src/main.cpp:16: 注意：virtual bool BaseClassA::OpenFile(std::string)
../src/main.cpp:17: 注意：virtual void BaseClassA::CloseFile()

也许我在这里忽略了一点，但是 BaseClassA （BasicClassA）的实现应该包含这些函数，并且因为 BasicClassB 是从BasicClassA也是如此，它应该也包含这些函数吧？

我缺少什么？我应该怎么做才能编译这个？

[编辑] 我按照评论的建议更新了类名
澄清一下：我在 A 类中使用纯虚拟来强制任何子级实现这些功能。

看来虚拟继承是我所需要的，但是，在我的例子中，我似乎没有找到正确的方法......

目标是有几个“基”类，有点像接口，强制子级来实现这些功能，但这些子级的任何子级都应该继承重写的函数（就像虚拟继承一样）

但是，使用任意组合 Any 类：公共虚拟 Anyother { } 不起作用并且总是给出相同的编译错误（上面的错误）。也许我需要改变的不仅仅是继承中的虚拟？

Answer 1

默认情况下，在 C++ 中它不会以这种方式工作 - 您需要钻石继承模式，但在 C++ 中您会获得单独的根：因此 BasicClassA 和 BaseClassB 每个都有自己的 BaseClassA （虚函数表和实例变量）。

您可能想使用虚拟继承。

为了更清楚地了解非虚拟继承：

#include <iostream>


class A
{
    public:
        A(int x) {m_a = x;}
        virtual ~A() {}
        int m_a;
        virtual int getA() {return m_a;}
};

class B : public A
{
    public:
        B() : A(1) {}
};

class C : public A
{
    public:
        C() : A(2) {}
};

class D : public B,
          public C
{
};

void useB(B* b)
{
    std::cout << "useB:" << b->getA() << std::endl;
}

void useC(C* c)
{
    std::cout << "useC:" << c->getA() << std::endl;
}

int main()
{
    D* d = new D();
    useB(d);
    useC(d);

    return 0;
}

这会产生输出：

useB:1
useC:2

此示例显示虚拟继承以及您想要的混合行为类型。

#include <iostream>


class A
{
    public:
        A(int x) {m_a = x;}
        virtual ~A() {}
        int m_a;
        virtual int getA() {return m_a;}
        virtual int virt() = 0;
};

class B : virtual public A
{
    public:
        B() : A(1) {}
};

class C : virtual public A
{
    public:
        C() : A(2) {}
        virtual int virt() {return 42;}
};

class D : public B,
          public C
{
    public:
        D() : A(3) {}
};



void useB(B* b)
{
    std::cout << "useB:" << b->getA() << std::endl;
}

void useC(C* c)
{
    std::cout << "useC:" << c->getA() << std::endl;
    std::cout << "useC-virt:" << c->virt() << std::endl;
}

int main()
{
    D* d = new D();
    useB(d);
    useC(d);

    return 0;
}

输出：

useB:3
useC:3
useC-virt:42

注意：C 和 B 的构造函数在设置 m_a 方面没有发言权，m_a 是 D() 构造函数初始化列表的控制器。

编辑：
将虚拟应用到您的代码中：

#include <iostream>

class A
{
protected:
    virtual std::string getDateTime() = 0;
    virtual void Write(std::string data, bool addDate) = 0;
    virtual bool CheckFile() = 0;
    virtual bool OpenFile(std::string path) = 0;
    virtual void CloseFile() = 0;
};

class B
    : virtual public A
{
public:
    virtual std::string ToString() { return ""; };
    virtual void Write(std::string data) { };
};

class C
    : virtual public A
{
protected:
    std::string getDateTime()
    {
        return "TODAY";
    };

    void Write(std::string data, bool addDate)
    {
        std::cout << "C Write" << std::endl;
    };

    bool CheckFile()
    {
        std::cout << "C CheckFile" << std::endl;
        return true;
    };

    bool OpenFile(std::string path)
    {
        std::cout << "C OpenFile" << std::endl;
        return true;
    };

    void CloseFile()
    {
        std::cout << "C CloseFile" << std::endl;
    };
};

class D
    : public B,
      public C
{
public:
    std::string ToString()
    {
        return "D tostring";
    };

    void Write(std::string data)
    {
        std::cout << "D Write" << std::endl;
    };
};

int main(int ac, char *av[])
{
    D b;
    std::cout << b.ToString() << std::endl;
    b.Write("");
    return 0;
}

Answer 2

BaseClassA有5个纯虚函数。即使只有一个纯虚函数的类也是“抽象类”。纯虚函数（简而言之）的目的是禁止创建抽象类的对象。

为了实例化 BaseClassB，它需要定义在 BaseClassA 中声明为纯虚函数的所有 5 个函数。 （如果没有这些定义，BaseClassB 也会变成 Abstract，因此您无法从中创建对象）。

Answer 3

BasicClassB 仅派生自 BaseClassA，它是一个抽象类，因为这些方法：

virtual std::string getDateTime() = 0;
virtual void Write(std::string data, bool addDate) = 0;
virtual bool CheckFile() = 0;
virtual bool OpenFile(std::string path) = 0;
virtual void CloseFile() = 0;

是纯虚拟。

错误消息非常清楚：为了能够实例化 BasicClassB，您必须提供上述方法的实现。

另请注意，BasicClassB中对Write的定义：

virtual void Write(std::string data) { };

与BaseClassA中的定义不同：

virtual void Write(std::string data, bool addDate) = 0;

因此仍需要为实现此方法>BasicClassB 变得可实例化。

Answer 4

事实上，您将“=0”添加到函数中意味着它们是纯虚拟的，并且必须在子类中实现。这显然不是你想要的。如果从基类中具有实现的函数中删除“=0”，它应该按预期工作。