如果基类析构函数是虚拟的,是否需要派生类析构函数定义？
问题：如果基类析构函数是虚拟的,是否需要派生类析构函数定义？
回答：
在 C++ 中，当基类析构函数是虚拟的（即声明为 virtual）时，子类析构函数（如果存在的话）通常也需要声明为 virtual。这是因为子类在继承时，会继承基类的虚拟析构函数。为了确保在运行时能够正确调用相应的析构函数，子类析构函数需要被声明为虚拟的。
以下是一个简单的示例：
class Base {
public:
virtual ~Base() {}
};
class Derived : public Base {
public:
~Derived() override {} // 虚拟析构函数
};在这个示例中，Base 类有一个虚拟析构函数，Derived 类继承自 Base，因此 Derived 类也包含一个虚拟析构函数。
需要注意的是，并非所有情况都需要在派生类析构函数中声明为虚拟。如果基类析构函数不是虚拟的，子类析构函数不需要声明为虚拟。
名词解释：
- 析构函数：一种特殊类型的成员函数，用于在对象销毁时执行清理操作。
- 虚拟析构函数：一种特殊类型的析构函数，允许在派生类中重写（如果基类析构函数是虚拟的，则子类析构函数必须也是虚拟的；否则，将引发运行时错误。）。
推荐腾讯云产品：
- 腾讯云云服务器（CVM）：提供高性能、稳定、安全、弹性的云计算服务。
- 腾讯云数据库 Redis：提供高性能、高可用、高扩展性的 Redis 数据库服务。
- 腾讯云容器服务（TKE）：提供易于使用、高效、安全的容器运行环境。
产品介绍链接：
相关·内容
2回答
当派生类不是立即派生，而是从已经派生的类派生时，我对重写函数感到困惑。
#include <iostream>
struct Base
{
virtual ~Base() { std::cout << "Base destructor called\n"; }
};
struct Derived : Base
{
Derived() {}
// Implicitly supplied destructor, I'm guessing. Which is also virtual?
};
struct MostDer
浏览 0提问于2018-01-26得票数 3
回答已采纳
我在理解虚函数时遇到了问题。当我重载一个虚函数时，新的派生函数是否只被调用？或者同时使用派生函数和基函数？因为我注意到当调用虚拟析构函数时，基析构函数和派生类析构函数也会被调用。
浏览 0提问于2013-02-18得票数 1
回答已采纳
我有一个抽象基类，它的目的是允许创建指向基类的指针数组。(适用于“许多事物”)
我的抽象基类不包含任何成员函数。因此，没有纯粹的虚拟方法，因此我认为它在技术上并不抽象。
但是，我不希望能够创建这个类的实例。
是否可以创建一个无成员的抽象基类？如果没有，是否有另一个解决方案来阻止创建我的“抽象基础”的实例？使构造函数protected满足吗？
有人向我指出，实际上，如果该类的目的是允许创建指向基类的向量或指针数组，则不需要抽象基类--您可以简单地不使用基类并将继承层次结构顶部的类用作基类。或者，您可以复制和粘贴该顶级类，并将实现的方法转换为没有实现的纯虚拟函数，但是这在逻辑上似乎与抽象基指针的思
浏览 1提问于2015-08-03得票数 1
回答已采纳
1回答
我正在构建一个循环链表，我想知道do_remove方法是否定义得很好。当我运行这个程序时，它向我展示了它是，然而，我仍然有点困惑，为什么我不需要一个虚拟的destrutor在这种情况下。
是否只有当我想通过派生类的基本指针销毁派生类时才需要虚拟析构函数？
这是否意味着，通过将基类降为派生类，然后调用派生类析构函数，它将始终调用基类析构函数？
do_remove方法中是否存在可能的漏洞？
PS:我需要两个步骤来创建和销毁对象--分配/调用构造函数/调用析构函数/去分配；这就是我目前使用::operator new的原因。
下面是我正在编写的代码的一个独立的示例：
#include <ios
浏览 1提问于2017-12-17得票数 0
回答已采纳
我有一个问题，我看到在一些代码中，派生类中的虚拟析构函数是空的，那么为什么我们需要它，因为它什么也不做？它是否用于调用基类中的析构函数，如果没有它，则不能调用析构函数？或者仅仅是一个符号，告诉代码阅读器这个析构函数是虚拟的，这使得代码更容易阅读？谢谢!
浏览 4提问于2014-10-25得票数 4
回答已采纳
6回答
基于我发现的和堆栈溢出上的其他链接，如果我们计划以多形性方式使用它，那么我们应该始终在基类中定义一个虚拟析构函数。我想知道这条规则是否有例外。
我已经看到了不为纯抽象基类定义虚拟析构函数的生产代码，在cppcon 2014视频中，大约10:06定义的BoolExp结构是一个纯抽象类，没有虚拟析构函数。
所以对于这样定义的纯抽象类
class Base {
public:
virtual foo() = 0;
virtual bar() = 0;
}
我的问题是，我们必须为“基类”定义一个虚拟析构函数，即使它有任何数据成员？虚拟析构规
浏览 1提问于2019-07-30得票数 5
回答已采纳
考虑一个简单的接口/实现设计：
class Base
{
public:
virtual ~Base()
{
// Virtual empty destructor
}
};
class Derived : public Base
{
public:
virtual ~Derived()
{
// Lots of clean up code here
// ...
}
};
使用此设计，我理解以下代码是安全和有效的：
Base* base = new Derived();
delete bas
浏览 0提问于2013-01-11得票数 3
回答已采纳
6回答
接口需要虚拟析构函数，还是自动生成的？例如，下面两个代码段中哪一个是最好的，为什么呢？请注意，这是全班学生。在Java语言中，没有其他方法、变量等，这是一个“接口”.
class Base
{
public:
virtual void foo() = 0;
virtual ~Base() {}
};
或者..。
class Base
{
public:
virtual void foo() = 0;
~Base() {} // This line can be omitted, but included for clarity.
};
编辑由于“不是我想要的”答
浏览 0提问于2010-06-03得票数 10
回答已采纳
在我的代码中，我使用了三个类。见下文的执行情况：
class Medicine
{
int a;
}
class Pain:public Medicine
{
int b;
}
class Comb:public Pain
{
string salt,com;
}
所有类都只有参数化构造函数。call()就像
call()
{
cout<<"You are in class the_name_of_the_class"<<endl;
}
我在所有函数中都定义了一个同名为call()的函数。(到目前为止，它们还
浏览 0提问于2013-08-21得票数 0
回答已采纳
1回答
隐式声明析构函数
、、、
如果我是正确的，默认析构函数总是隐式声明的，除非用户声明它。根据
通过指向基的指针删除对象会调用未定义的行为，除非基类中的析构函数是虚拟的。
现在，考虑下面的示例：
struct B {};
struct D : B {};
隐式声明的析构函数B::~B()是虚拟的吗？如果没有，那么在使用继承时，应该始终声明一个虚拟析构函数吗？
浏览 2提问于2021-09-28得票数 1
回答已采纳
我编写了一个没有虚拟函数的基类和派生类。虚拟的使用通常是我看到的关于何时使用虚拟析构函数的指南。
然而，虽然我的类没有虚拟函数，但我在传递类时以多态方式使用它们。因此，类库应该实现一个虚拟析构函数吗？
class Base;
class Derived;
main()
{
base& baseVar = derived();
foo(baseVar);
}
浏览 0提问于2014-03-08得票数 1
回答已采纳
C++编译器是否生成默认函数，如构造器/析构函数/复制-构造器.为了这个“课”？
class IMyInterface
{
virtual void MyInterfaceFunction() = 0;
}
我的意思是不可能实例化这个“类”，所以我认为不会生成默认函数。否则，人们会说你必须使用虚拟析构函数。这意味着，如果我没有定义析构函数虚拟，它将是默认创建，而不是虚拟。
此外，我还想知道为一个纯虚拟接口定义一个虚拟析构函数是否合理，就像上面的那个吗？(因此这里没有使用指针或数据，因此不需要销毁任何东西)
谢谢。
浏览 5提问于2014-01-23得票数 9
回答已采纳
我正在处理文件描述符的类层次结构，其中基类持有int，并在销毁过程中调用close，而子类不添加任何虚拟方法或数据成员，只是它们的构造不同(例如，named_file_filedes采用路径并使用ctor中的open初始化基)或非虚拟成员函数(例如，只能在kqueue_filedes上调用kevent )。在此情况下，基类是否需要虚拟析构函数？子类的大小都是相同的，并且它们都没有自定义的销毁逻辑。标记c++11，因为这是我要针对的标准版本。
浏览 0提问于2014-02-21得票数 1
回答已采纳
1回答
我有一个代表抽象数据类型‘包’的接口。为了实现该抽象数据类型，我使用了基于数组和基于链接的实现。
在这里，类的定义
正如您所指出的，我已将虚拟析构函数添加到我的基类中
template<class ItemType>
class BagInterface{
public:
virtual int getCurrentSize() const = 0;
virtual bool isEmpty() const = 0;
virtual bool add(const ItemType& newEntry) = 0;
浏览 5提问于2020-10-15得票数 1
回答已采纳
3回答
请考虑以下几点
class base{
base();
~base();
}:
class derived : public base{
};
当派生对象被析构并且派生类没有定义析构函数时，是否会自动调用基类析构函数？
否则，如果我在派生类中也有析构函数，我是否也需要显式调用基类析构函数？
class base{
base();
~base();
}:
class derived : public base{
derived();
~derived
base::~base(); //do I need this?
浏览 2提问于2011-04-05得票数 8
回答已采纳
2回答
假设我有这段代码--这段代码什么也不做，我知道它们是内存泄漏，因为car的析构函数不是虚拟的。但是，我不明白为什么我会得到这段代码的调试断言。我正在使用2010。
struct car {
~car()
{std::cout << "Destructor of car"; }
};
struct honda: public car {
virtual ~honda()
{ std::cout << "Destructor of honda"; }
};
int main()
{
car *c
浏览 7提问于2015-02-08得票数 1
回答已采纳
可能重复：
如果一个类的所有数据成员(具有虚拟函数)及其继承的类都是非指针类型的(意味着它不能保存任何动态内存)，那么是否需要将析构函数声明为虚拟的呢？
示例
class base {
int x;
public:
virtual void fn(){}
};
class der: public base {
int y;
public:
void fn(){}
};
我们需要一个虚拟破坏者吗？
浏览 6提问于2012-02-01得票数 4
回答已采纳
3回答
我实现了一个接口：
class ISolution
{
public:
virtual ~ISolution() = 0;
virtual void resultat() = 0;
};
还有一些派生的类：
class SolX : ISolution
{
private:
int member;
MyClass myOb;
public:
SolX(const MyClass& inOb) : myOb(inOb) {}
~SolX() {}
void resultat()
{
// the body
}
};
当我编译它时，我会得到以
浏览 4提问于2014-05-06得票数 0
回答已采纳
默认析构函数可以自动生成为虚拟析构函数吗？
如果我定义了一个基类，但没有默认的析构函数，是否会自动生成一个默认的虚拟析构函数？
浏览 11提问于2009-07-13得票数 60
回答已采纳
#include <iostream>
using namesapce std;
class A
{
public:
virtual ~A(){cout<<"delete A"<<endl};
};
class B: public A
{
public:
B(int n):n(n){}
void show(){cout<<n<<endl;}
~B(){cout<<"delete B"<<endl;}
浏览 6提问于2016-09-20得票数 0
假设我有下面的代码
class Base{
public:
int getVal();
private:
int a, b;
};
class Derived::public Base{
public:
void printVal();
};
int main(){
Base *b = new Derived();
delete b;
}
我知道虚拟析构函数可以正确地删除东西，但是即使派生类中没有虚拟函数和数据成员，使用基指针删除(当没有虚拟析构函数时)也是不好的吗？如果这样做了，会发生什么？
浏览 0提问于2010-10-16得票数 12
回答已采纳
1回答
我的代码中有一个内存泄漏，所以我剥离了它来调试它。罪魁祸首是Solitaire::State结构中的std::stack数据成员。特别是嵌套的State结构中的那些；如果我向Solitaire类添加一个堆栈数据成员，它就不会泄漏。 我如何确保这些堆栈被释放？ #include <iostream>
#include <fstream>
#include <stack>
class SearchState {
public:
protected:
};
class SearchDomain {
public:
~SearchDomain();
p
浏览 22提问于2020-10-01得票数 0
3回答
我有Y型的类层次结构: C类继承A和B，D类继承C，A和B有虚拟析构函数，C的析构函数不是虚拟的。我知道，如果没有双重继承(比方说没有B)，那么C()将是虚拟的。我的问题是双重继承会影响它吗？
class A { virtual ~A(); ...};
class B { virtual ~B(); ...};
class C : public A, public B { ~C(); ...};
class D : public C { virtual ~D(); ... };
我必须通过指向C的指针删除D类的实例。
C* c = new D;
delete c;
我怀疑有一些角落的情况下，~
浏览 0提问于2019-01-18得票数 0
回答已采纳
为什么在下面的例子中都调用了析构函数，~D()，~C()，~B()，~A()？
只有一个虚拟析构函数：A的那个。
代码如下：
#include<iostream>
using namespace std;
class A
{
public:
virtual ~A()
{
cout<<"destruct A\n";
}
};
class B:public A
{
public:
~B()
{
cout<<"destruct B\n";
}
};
class C:public B
{
pu
浏览 0提问于2012-10-17得票数 6
回答已采纳
2回答
我有一个继承链，其中A类公开地从B类继承，后者又公开地从C类继承。C类的析构函数被标记为“虚拟”。是否有人反对将B类和A类的析构函数标记为虚拟的？或者在这种情况下是否需要支付性能/内存损失？
浏览 0提问于2018-07-26得票数 4
回答已采纳
这已在我的正式说明中提供，但我发现了一个错误。在我把它交给我的教练之前，我只是想和我所有的血亲们确认一下。
#include <iostream.h>
class Base {
public:
virtual void display() { cout << "Base class" << endl; }
};
class Derived: public Base {
// Nothing here
};
void main()
{
Base * ptr;
// Calls Base::display
浏览 7提问于2015-04-05得票数 1
我用的是gcc。我知道当我们销毁基类指针指向的派生类对象时，虚析构函数是如何解决这个问题的。我想知道它们是如何工作的？
class A
{
public:
A(){cout<<"A constructor"<<endl;}
~A(){cout<<"A destructor"<<endl;}
};
class B:public A
{
public:
B(){cout<<"B constructor"<<endl;}
浏览 2提问于2010-04-22得票数 5
回答已采纳
例如：
class base
{
public:
base()
{
// allocate memory for basearray
}
virtual ~base()
{
// delete basearray
}
protected:
float* basearray;
};
class derived1 : public base
{
public:
derived1()
{
// allocate memory for derivedarray
}
~derived1()
{
// delete der
浏览 1提问于2012-01-31得票数 1
回答已采纳
我有一个struct O，用第三方代码定义。因为它是C代码，所以它不定义virtual destructor。(在我的例子中，它是来自OVERLAPPED struct的win32 appi)。
我正在修改的客户代码有一个class S，它来自class A，来自struct O。
struct O{};
class A : public O{};
class S : public A{};
他们中没有人将其析构函数声明为virtual。
如果在指向delete的指针上调用O，则会出现泄漏。好的。
但是，如果我曾经在指向S的指针上调用delete，那么delete标准会指出什么呢？它是否会自动
浏览 8提问于2015-02-02得票数 1
回答已采纳
我得到了这个奇怪的链接器错误：
Error 1 error LNK2019: unresolved external symbol "public: virtual __thiscall Data::~Data(void)" (??1Data@@UAE@XZ) referenced in function "public: virtual __thiscall Job::~Job(void)" (??1Job@@UAE@XZ) C:\...\Job.obj
Error 2 error LNK2019: unresolved external s
浏览 0提问于2012-05-31得票数 1
回答已采纳
3回答
是否可以删除抽象类而不是子类？是否所有分配都会因此而被释放？
请考虑以下情况作为示例，但请不要将您的答案限制在这种情况下：
struct A {
virtual void fun() = 0;
};
struct B : public A {
void fun() { /* actually doing something here. */ }
};
struct C {
A *a;
void OneTask() {
// (...)
a = new B();
}
void AnotherTask() { /* u
浏览 0提问于2013-04-11得票数 1
7回答
我有两个类Foo和Bar，其中Bar继承自Foo。这两个类都有一个getLength()方法。我的main中有一个函数，它接受超类Foo对象作为参数，但通常会向它传递一个Bar对象。
当传递Bar对象时，为什么它仍然调用Foo getLength()方法？
浏览 0提问于2011-02-01得票数 1
5回答
当至少有一个类方法是虚的时，每个人都说析构函数应该是虚的。
我的问题是，在使用向上转换时，析构函数应该是虚拟的，这不是正确的吗？
class A {
public:
~A(){
cout << "Destructor in A" << endl;
}
};
class B: public A
{
public:
~B(){
cout << "Destructor in B" << endl;
}
};
int main()
{
A* a
浏览 2提问于2011-05-13得票数 3
回答已采纳
只是一个简单的问题。
编译器给了我一个选项:虚拟析构函数，但是我创建了一个没有虚拟析构函数的普通类。
在virtual之前添加单词~是否与使用编译器生成的虚拟析构函数创建类相同？
示例
在此之前：
~String();
之后：
virtual ~String();
我之所以问这个问题，是因为我在“父”类中使用了其他类指针。
浏览 0提问于2017-03-14得票数 0
2回答
我知道virtual会传播到派生类方法，在派生类的方法声明中添加as关键字是可选的，我知道必须将基类的析构函数标记为virtual，以便进行多态破坏，但我想知道的是，派生类的默认析构函数是否继承了基类的虚拟析构函数，因此我必须将其显式写入派生类。
示例：
class A{
public:
virtual ~A() override = default;
}
class B: public A{
public:
// have i to write this or it's already what the compiler get as default?
vir
浏览 1提问于2020-01-19得票数 0
回答已采纳
1回答
我有一个抽象的类，它定义了具体类的常见行为。因此，将没有需要清理的内存，因为无法实例化类。但是，我知道，如果派生析构函数的静态类型是基类，则需要一个虚拟析构函数。
这是否意味着我应该始终为抽象类声明一个虚拟析构函数，而只是将实现保留为空？
浏览 0提问于2013-09-29得票数 0
回答已采纳
我正在尝试弄清楚C++中类继承的诀窍，并且我已经构建了一个示例项目：
#include "stdafx.h"
#include <iostream>
using namespace std;
class A
{
public:
A()
{
cout << "Class A initialized" << endl;
}
~A()
{
cout << "Class A destructed" << endl;
浏览 0提问于2014-04-09得票数 3
11回答
在某些情况下，派生类具有非virtual析构函数是合法的吗？非virtual析构函数表示类不应用作基类。让派生类的非virtual析构函数充当Java final修饰符的弱形式吗？
我特别感兴趣的是派生类的基类具有virtual析构函数的情况。
浏览 2提问于2011-09-13得票数 69
回答已采纳
假设我们有下一个代码：
class ISampleInterface
{
public:
virtual ~ISampleInterface() {} ;
virtual void Method1() = 0;
virtual void Method2() = 0;
};
class SampleClass : public ISampleInterface
{
public:
SampleClass() { };
~SampleClass() override { };
void Method1() { };
void Method2
浏览 3提问于2015-11-20得票数 2
我知道派生类的类型与指向其基类的指针是兼容的。在给定的示例代码中，new bar对象构造先调用foo::foo()，然后调用bar::bar()。在各自的构造函数中，我将资源分配给类成员foo::int *a和bar::int *b。
现在我正在将这样构造的对象初始化为基类类型。使用obj，我可以调用基类析构函数，但不能调用派生类析构函数。那么，在这种情况下，我如何释放派生类资源呢？这不是内存泄漏吗？
#include <iostream>
class foo
{
int *a;
public:
foo()
{
a = new int[5];
浏览 0提问于2011-01-06得票数 1
回答已采纳
6回答
我最近刚刚读到，将C++析构函数实现为虚拟functions1是一个很好的实践。为何会这样呢？这是一个普遍的良好做法吗？如果不是，在什么条件下/在何种情况下，析构函数才能成为虚拟函数？
参考
浏览 4提问于2011-06-22得票数 3
回答已采纳
我为它创建一个派生类对象和一个基类点，然后使用dynamic_cast转换基类点到派生类点。我删除派生类点，但程序调用派生析构函数和基析构函数。为什么程序调用基本析构函数？毕竟，基本析构函数不是虚拟函数.
#include<iostream>
#include<stdlib.h>
using namespace std;
class con {
private:
double num;
public:
con() {
num = 0;
cout << "default..." <<
浏览 6提问于2017-08-04得票数 0
回答已采纳
我有两个类：
class A {
public:
virtual void somefunction() = 0;
};
class B : public A {
public:
B();
~B();
void somefunction();
};
B::B() {}
void B::somefunction() {
// some code
}
但是在使用g++时，我得到了错误：
class A has virtual functions and accessible non-virtual destructor
class B has vir
浏览 2提问于2011-04-29得票数 17
回答已采纳
4回答
可能的重复：
编译器不强制Child class在其Base具有纯virtual析构函数时实现析构函数。
struct Base
{
virtual void foo () = 0;
virtual ~Base() = 0;
};
Base::~Base() {} // necessary
struct Child : Base
{
void foo() {}
//ok! no destructor needed to create objects of 'Child'
};
有趣的是，编译器宁愿强迫Base定义析构函数体。。(供参考)
那么，在类
浏览 4提问于2011-07-28得票数 20
回答已采纳
我们不能使抽象类的对象，那么为什么需要一个析构的抽象类？对于抽象类来说，是否有必要使析构成为纯虚拟的？
class Base()
{
public:
virtual ~Base() = 0;
};
Base :: ~Base()
{
}
class Derived :: public Base
{
public:
~Derived();
};
浏览 0提问于2018-01-24得票数 1
回答已采纳
class AbstractQuery {
virtual bool isCanBeExecuted()=0;
public:
AbstractQuery() {}
virtual bool Execute()=0;
};
class DropTableQuery: public AbstractQuery {
vector< std::pair< string, string> > QueryContent;
QueryValidate qv;
public:
explicit DropTableQuery(const
浏览 0提问于2008-11-06得票数 4
回答已采纳
我有一个使用基类的派生类型存储的unique_ptrs向量
std::unique_ptr<std::vector<std::unique_ptr<Variable>>> decisionVariables;
其中变量是超类，派生类型是路由类。我的问题是，当删除包含decisionVariables的类时，路由实例似乎不会被删除。
路由是从变量派生的：
#ifndef __VARIABLE__
#define __VARIABLE__
/**
* Interface for decision variables.
*/
#include <c
浏览 0提问于2013-08-09得票数 5
回答已采纳
我的情况类似于，其中有两个类共享一个公共接口函数，因此我将该函数(示例中的manage_data_in_memory())提取到两个类继承的基类中。然而，这两个类在其他方面是不相关的，其中一个是多态的，而另一个不是。也不期望有人声明这个基类的一个对象，因为它的存在只是为了防止代码重复(有什么方法可以强制执行吗？)我知道纯虚拟函数可以阻止对象被实例化，但是声明一个在派生类中不做任何操作的虚拟纯虚拟函数似乎是错误的设计)。
在这种情况下，基类析构函数需要是虚拟的吗？这将迫使另一个派生类也具有一个不需要的虚拟析构函数。谢谢。
所以现在我有了表格中的代码
class base { // don&#
浏览 4提问于2022-02-17得票数 0
回答已采纳
4回答
/*Child is inherited from Parent*/
class Parent {
public:
Parent () //Constructor
{
cout << "\n Parent constructor called\n" << endl;
}
protected:
~Parent() //Dtor
{
cout << "\n Parent destructor called\n" << endl;
浏览 0提问于2012-01-23得票数 11
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
