我搜索过这个，但我并没有真正理解答案。

我是 C++ 的新手，我想要实现的是拥有一个抽象类作为我的对象类型的基类，这样我就可以将我的对象存储在抽象类型的指针数组中类而不是使用 void *。此外，我的对象共享一些公共(public)成员函数，这些函数可以通过抽象类实现轻松减少我的代码库。

但是，我对抽象类的构造函数和析构函数感到困惑。

抽象类实际上并不需要构造函数，因为可以传入的参数对于两者都是通用的，需要对派生类中的所述参数做不同的事情才能正确设置 protected 属性(矩阵的大小).那么，没有构造函数可以吗？另外，由于我没有构造函数，析构函数 应该是什么？

我说的是实现虚拟析构函数的答案。但是，我不确定这意味着什么，并且有一个关于潜在内存泄漏的讨论说只要派生类重新实现析构函数就不会存在任何内存泄漏。所以，这确实意味着我可以实现一个虚拟析构函数，然后在派生对象中说 Foo 和 Bar 我只是实现 ~Foo 和 ~Bar 来防止内存泄漏(当然假设它们是正确的)？我不确定我是否理解派生类中的重新实现的确切含义。

最佳答案

析构函数

一般来说，在实现抽象基类时，有两个推荐的析构函数选项(source):

1。实现一个公共(public)的、虚拟的析构函数

当您打算拥有基类的指针时使用它，它可能指向派生类的实例。例如:

class MyBase {
public:
    virtual ~MyBase() {};
};

class MyDerived : public MyBase {
public:
    virtual ~MyDerived() {};
}

std::unique_ptr<MyBase> pInstance = std::make_unique<MyDerived>();

通过在基类(以及派生类)中使析构函数成为虚拟的，您可以确保 MyDerived 的析构函数在运行时被调用。 如果析构函数是非虚拟的，在指向 MyBase 的指针上调用 delete 将不会调用 MyDerived 的析构函数 .

2。实现 protected 非虚拟析构函数

在您不想让用户创建指向派生对象的基类指针的情况下使用它。

class MyBase {
protected:
    ~MyBase() {};
};

class MyDerived : public MyBase {
public:
    ~MyDerived() {};
}

// NOT ALLOWED: std::unique_ptr tries to call protected destructor.
std::unique_ptr<MyBase> pBadInstance = std::make_unique<MyDerived>();

// Allowed: std::unique_ptr calls public MyDerived::~MyDerived()
std::unique_ptr<MyDerived> pGoodInstance = std::make_unique<MyDerived>();

然而，这有一个重要的警告。如果你有一个很深的继承层次结构，拥有一个非虚拟析构函数意味着你必须在你的层次结构中一直执行这个规则。例如:

class MyBase {
protected:
    ~MyBase() {};
};

class MyDerived : public MyBase {
public:
    ~MyDerived() {};
}

class MyDerivedAgain : public MyDerived {
public:
    ~MyDerivedAgain() {};
}

// Uh oh! MyDerivedAgain destructor would not be called!
std::unique_ptr<MyDerived> pGoodInstance = std::make_unique<MyDerivedAgain>();

如果你选择走这条路，你应该确保你不允许任何你的基类被实例化。 除叶派生类之外的所有析构函数都应受到保护。

这似乎有点令人费解，但它具有一些优势，例如避免 vtable 空间，以及通过在运行时避免 vtable 查找(最好的微优化)来适度提高紧密循环中的性能。

构造器

在任何类中省略构造函数是完全可以的，只要所有变量都可以默认构造(或没有构造函数(例如 int))。 C++ 编译器将简单地创建默认构造函数 MyAbstractClass::MyAbstractClass() { }。也就是说，通常最好创建一个构造函数来初始化任何抽象类变量:

好的:

class MyBase {
protected:
    int _x;
    int _y;
};

class MyDerived : public MyBase {
public:
    MyDerived(int x, int y) {
       _x = x;
       _y = y;
    }
};

更好:

class MyBase {
public:
    MyBase(int x, int y) : _x(x), _y(y) {
    }

protected:
    int _x;
    int _y;
};

class MyDerived : public MyBase {
public:
    MyDerived(int x, int y) : MyBase(x, y) {
    }
};

带有 MyBase::MyBase(int, int) 构造函数的“更好”版本更好，因为它强制 _x 和 _y立即初始化，编译器将检查是否调用了基类构造函数。通过在派生构造函数中初始化基类变量，您可能会招致灾难，因为您可能忘记初始化变量并导致各种运行时问题。

附录:关于“接口(interface)”的注释

如果你正在实现一个定义了“契约”的接口(interface)类，你可以跳过构造函数(接口(interface)没有变量或实现，不需要构造函数)，而使用公共(public)虚析构函数。这确保了任何实现该接口(interface)的类在被删除时都会被清除。

class MyInterface {
public:
    virtual ~MyInterface() = 0;

    virtual void MyMethod() = 0;

    virtual void MyOtherMethod() = 0;
};

// Base class virtual destructors should always have an implementation,
// even when they are pure-virtual.
MyInterface::~MyInterface() { }

// -----------------------------------------------------------------------------

class MyImplementation : public MyInterface {
    virtual ~MyImplementation () { }

    virtual void MyMethod() { std::cout << "MyMethod()" << std::endl; }

    virtual void MyOtherMethod()  { std::cout << "MyOtherMethod()" << std::endl; }
};

关于c++ - 抽象基类c++的析构函数和无构造函数，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/40666985/