接口->抽象->具体类设计中的虚拟解构器

Question

我自己尝试通过在 StackOverflow 上查找几个问题来回答这个问题。尽管我认为我理解正确，但我无法解决这个问题。这给我留下了唯一明显的观察结果：我仍然不明白。

我在这篇文章的底部对问题进行了总结，其中的所有内容都是我收集的信息和该问题的背景。

所以，我知道当你有一个基类和一个派生类时，你的解构函数应该在基类中标记为虚拟的。允许多态性。

但是，我似乎无法编译我的代码，或者当它编译时，它不会由于“未定义的引用”而链接。我一直在来来回回地改变，但我似乎始终没有摆脱这个循环。

基本上我有一个接口，定义如下：

#ifndef GUIELEMENT_H_
#define GUIELEMENT_H_

class GuiElement {
    public:
    virtual ~GuiElement();
    virtual void draw() = 0;
};

#endif /* GUIELEMENT_H_ */

我有几个由此扩展的对象。一个简单的关系是 GuiWindow （直接派生自 GuiElement）：

#ifndef CGUIWINDOW_H_
#define CGUIWINDOW_H_

#include <assert.h>
#include <cstddef>

#include "../GuiElement.h"
#include "../GuiInteractionDelegate.h"

class GuiWindow : public GuiElement {

    public:
        GuiWindow(GuiInteractionDelegate * guiInteractionDelegate) {
            assert(guiInteractionDelegate);
            interactionDelegate = guiInteractionDelegate;
        }

        ~GuiWindow() {
            //delete interactionDelegate;
        }

        // called each frame, delegates its behavior to the given concrete cGuiWindowDelegate class.
        void interact() {
            interactionDelegate->interact(this);
        }

    private:
        GuiInteractionDelegate * interactionDelegate;

};

#endif /* CGUIWINDOW_H_ */

此代码不链接，给我：

对“GuiElement::~GuiElement()”的未定义引用

我认为在 GuiWindow 类中实现就足够了？这是正确的吗？

接下来真正困扰我的是，我还有一个从 GuiElement 派生的抽象类，以及其上的具体实现。基本上给予： GuiElement->GuiShape->GuiButton

这是 GuiShape 的标题：

#ifndef GUISHAPE_H_
#define GUISHAPE_H_

#include "../GuiElement.h"
#include "../../gameobjects/Rectangle.h"

class GuiShape : public GuiElement {

    public:
        GuiShape(Rectangle * rect);
        GuiShape(int x, int y, int width, int height);

        ~GuiShape();

        void draw();

        void setX(int value) { rectangle->setStartX(value);     }
        void setY(int value) { rectangle->setStartY(value);     }

        Rectangle * getRectangle() { return rectangle; }

        bool isMouseOverShape();

        void setColors(int darkBorder, int lightBorder, int inner);

        int getDarkBorderColor() { return darkBorderColor; }
        int getLightBorderColor() { return lightBorderColor; }
        int getInnerColor() { return innerColor; }

    protected:
        Rectangle * rectangle;

    private:
        bool rectangleOwner;
        int darkBorderColor;
        int lightBorderColor;
        int innerColor;
};

最后是 GuiButton：

#ifndef CGUIBUTTON_H_
#define CGUIBUTTON_H_

#include <sstream>
#include <string>

#include "allegro.h"

#include "../../gameobjects/Rectangle.h"
#include "GuiShape.h"

class GuiButton : public GuiShape {

    public:
        GuiButton(Rectangle * rect, std::string theLabel);
        GuiButton(int x, int y, int width, int height, std::string theLabel);
        ~GuiButton();

        void draw();

        std::string * getLabel() {
            return label;
        }

        BITMAP * getBitmap() { return bitmap; }
        void setBitmap(BITMAP * value) { bitmap = value; }
        void setHasBorders(bool value) { hasBorders = value; }
        void setPressed(bool value) { pressed = value; }

        bool shouldDrawPressedWhenMouseHovers() { return drawPressedWhenMouseHovers; }
        bool shouldDrawBorders() { return hasBorders; }
        void setDrawPressedWhenMouseHovers(bool value) { drawPressedWhenMouseHovers = value; }
        bool isPressed() { return pressed; }

    private:
        std::string * label;
        bool drawPressedWhenMouseHovers;
        bool hasBorders;
        bool pressed;
        BITMAP * bitmap;

        void drawBackground();
        void drawLighterBorder();
        void drawDarkerBorder();
        void drawButtonUnpressed();
        void drawButtonPressed();
};

#endif /* CGUIBUTTON_H_ */

这使我想到以下问题：

• 使用从 A->B-> 派生对象的虚拟解构函数的最佳方法是什么？ C？
• C 应该只是具体的虚拟吗？如果是这样，如何释放仅在 B 中定义和处理的资源？ (A=GuiElement, B=GuiShape, C=GuiButton)
• 为什么我会通过 A->B 的直接实现得到“未定义的引用”？ (GuiElement->GuiWindow)

预先感谢您的帮助！

Answer 1

使用从 A->B->C 派生对象的虚拟解构函数的最佳方法是什么？

将基础的（或所有）析构函数标记为虚拟。

C 只能是具体的虚拟吗？如果是这样，如何释放仅在 B 中定义和处理的资源？ （A=GuiElement、B=GuiShape、C=GuiButton）

不确定“具体虚拟”是什么意思，但是包含需要销毁的成员的类应该在自己的析构函数中销毁它们。没有例外。当~C被调用时，它会销毁它自己的东西，然后~B将被自动调用。虚拟只是绝对确保首先调用 ~C 。

为什么直接实现 A->B 会得到“未定义的引用”？ (GuiElement->GuiWindow)

virtual ~GuiElement(); 告诉编译器该类有一个稍后定义的析构函数。您想要：

// There is no definition, cannot make a local "GuiElement" variable
// They can only make local "GuiButton" or other derived.
// You can still have pointers to a GuiElement.
// This is called "pure virtual"
virtual ~GuiElement() = 0; 

或：

// There is a definition, someone can make a local "GuiElement" variable
virtual ~GuiElement()  {};

Answer 2

我认为在 GuiWindow 类中实现就足够了？这是正确的吗？

不可以。如果在类中声明了虚函数（不是纯虚函数，如 GuiElement 的析构函数），则必须对其进行定义。

析构函数更进一步：它们必须始终被实现，即使它是纯虚拟的[1]。如果您没有声明它，编译器将为您创建一个（隐式非虚拟的，但如果它将覆盖虚拟析构函数，则它将是虚拟的）。在 C++11 中，您可以将其标记为“默认”（这意味着“编译器，为我实现它”）和“已删除”，这意味着“程序永远不会隐式或显式地破坏这种类型的对象”。

1. 使用从 A->B- 派生对象的虚拟解构函数的最佳方式是什么
   C？

您通常希望将最顶层的析构函数设为虚拟，这意味着层次结构中的所有析构函数都是虚拟的。

如果是这样，如何释放仅在 B 中定义和处理的资源？ （A=GuiElement、B=GuiShape、C=GuiButton）

自然是在 ~B() 中。

[1]：

12.4/7：析构函数可以声明为 virtual (10.3) 或 pure virtual (10.4)；如果该类的任何对象或任何
程序中创建派生类时，应定义析构函数。如果一个类有一个带有
虚拟析构函数，它的析构函数（无论是用户声明的还是隐式声明的）都是虚拟的。