条款 07 为多态基类声明vitual析构函数

最新推荐文章于 2025-01-15 11:39:59 发布
最新推荐文章于 2025-01-15 11:39:59 发布
阅读量350 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： effective c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sbfksmq/article/details/48209959
1 在有多态的基类中把析构函数声明为virtual
   因为在delete使用指向子类的基类指针(多态)时，尽管是指向子类，但因为指针的类型为基类类型，导致子类并没有被析构，形成局部销毁
2 没有virtual的基类，尽量避免把析构声明为virtual ，因为虚的在会增加对象的大小的50%~%100，也影响其可移植性
3 非多态用途的string ,STL中的vector,list,set等的析构函数都为non-virtual，因为他们都非禁止派生，如果你试图继承他们，无意间把你派生的子类指针转换成了基类类型，在             delete后又出错，且子类也并未析构
4 如果你想拥有一个不被实例的基类并且用来通过基类接口处理子类对象，可以把基类的析构定义为纯虚
为多态基类声明virtual析构函数
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-14 388
•为基类声明virtual析构函数：当派生类对象经由一个基类指针被删除，而该基类带有一个non-virtual析构函数，结果未定义——实际执行时通常发生的是对象的derived成分没有销毁，即“局部销毁”，造成资源泄露（因为存在这个问题，所以不要继承一个不被用作基类的类） •class不用作基类时，不要将析构函数声明为virtual：virtual会引入虚函数指针，这会增加空间开销，使得类无法被C函数使用，从而不再具有移植性 ...
【复读EffectiveC++07】条款07：为多态基类声明virtual析构函数
weixin_51122602的博客
03-13 584
带多态性质的基类应该声明一个virtual析构函数或如果类带有任何virtual函数，也应该拥有一个virtual析构函数。 类的设计目的如果不是作为基类使用，或不是为了具备多态性，那就不该声明virtual析构函数。
为多态基类声明一个虚析构函数
weixin_33973609的博客
11-19 142
使用一个基类指针删除派生类对象，同时基类的析构函数是非虚的，那么这个指针只会删除派生类对象中的基类的部分，其派生部分不会被删除。造成资源泄漏。而如果一个类并不用作基类，则没必要把析构函数声明为虚的，否则会浪费空间来存储虚函数指针和虚函数表。STL容器并不含虚析构函数，因此最好不要继承STL容器。只要有一个纯虚函数，就会导致抽象基类，即不能声明该基类的对象。抽象基类只能用来继承，纯虚函数如：virt...
第六篇：为多态基类声明虚析构函数
weixin_34008784的博客
01-27 133
前言        在很多类中，可以看到其析构函数都是声明为虚函数的。        那么，为何要将析构函数声明为虚函数？哪些情况要将析构函数声明为虚函数？        本文将为你解惑。        在使用 C++ 实现多态的时候，有一点一定要清楚：当派生类对象经由基类指针被删除，而此基类的析构函数没有被声明为虚函数的话，那么析构函数只会释放基类部分的成员而无视派生类成员。     ...
Effective C++ ——为多态基类声明虚析构函数
michael019的博客
09-17 522
1.多态基类需要声明一个virtual 析构函数 2.不作为基类的类则不需要声明virtual 析构函数，否则是个馊主意，因为虚函数会增加类的体积class Animal { public: Animal() { cout << "基类构造函数" << endl; } virtual ~Animal() { cout << "
为多态基类声明一个虚析构函数（Effective C++_7）
午后斜阳
09-07 599
一、声明虚析构函数的原因（1）先考虑没有声明虚析构函数的代码：#include <iostream> using namespace std;class Base{ public: Base(int x,int y):a(x),b(y){ cout<<"Base Construction"<<endl; } virtual void display()=0;
effective_为多态基类声明虚析构函数
ShenHang_的博客
12-28 259
条款07这里需要补充的知识点（我觉得很重要）： 一.如果一个类不企图被当作基类，那么令其析构函数为虚函数是很愚蠢的。正确的做法应该是：只有当类中有至少一个虚函数时，才把其析构函数声明为虚析构函数。 因为虚函数的作用是为了动态联编（实现多态），而为了实现动态联编，对象需要额外多出vptr指针，会增加体积（sizeof可以明显看出），vptr指向一个由函数指针构成的数组，称为vtbl（虚表），每一个带...
07：为多态基类声明virtual析构函数
cqxm11的博客
04-15 114
1.polymorphic（带多态性质的）base classes应该声明一个virtual析构函数。若class带有任何virtual函数，它就应该拥有一个virtual析构函数。2.Classes的设计目的如果不是作为base classes使用，或不是为了具备多态性（polymorphic），就不该声明virtual析构函数。
《Effective C++》条款七：为多态基类声明virtual析构函数
zpznba的博客
03-15 297
多态基类：顾名思义，是为了实现多态的基类。也就是说当一个类准备作为基类使用，且这个类中有虚函数的话，那么就应该给这个类加上虚析构函数。而非基类或者不用于多态的基类，就不要加。下面来具体分析一下： 严格来说，多态分为编译时多态和运行时多态，编译时多态是函数的重载，而运行时多态则是迟绑定技术，即根据基类指针或引用的实际指向来决定采取何种行动，一般来说，多态特指运行时多态。下面我们来举有关C++多态的...
Effective C++ 之【条款7：为多态基类声明virtual析构函数】
weixin_44387866的博客
01-15 520
虚析构函数的运作方式是，最深层派生的那个类的析构函数最先被调用，然后是其上的基类的析构函数被依次调用。C++明确指出，当derived class对象经由一个base class指针被删除，而base class带有一个non-virtual析构函数，其结果未有定义，实际执行时通常发生的是对象的derived成分没被销毁。这样Point对象也不能塞入到一个64-bit的缓存器了，C++的Point对象就不能再和其他语言（如C）的相同声明具备一样的结构了，因此也无法传递至其他语言写的函数中去了。
条款07：为多态基类声明virtual析构函数
W2155的博客
03-12 441
声明为虚函数，结构中会多存一个虚表指针vptr，在64bit的机器上，如果有两个对象是两个int+vptr可能会占用64~128bit，使其不能直接塞入64-bit的缓存器。我们用一个基类的指针，指向一个派生类的对象，这个时候，对基类的指针执行delete，会出现只有基类的部分删除，造成内存泄漏。加上virtual之后就会变成多态调用，调用delete会调用派生类的析构函数，再调用基类的析构函数。加上虚表指针之后，C++的对象，不在和其他语言具有相同的结构，因为其他语言没有虚表指针。
只在多态基类中声明虚析构函数
胡萝卜手
06-13 2271
  今天碰到一个bug,查了半天发现是某位虚基类没有定义虚析构函数，delete时导致派生类没有正确释放资源，遂从网上搜到一篇文章，留个记号关于virtual desctructor的详细讨论。同样来自于《Effective C++》3rd Edition。  跟踪时间是很平常的任务，所以开发一个名为 TimeKeeper 的基类，并让不同的派生类来实现不同的计时方法是很合
Effective C++条款07:为多态基类声明virtual析构函数
Dylan的博客
03-02 259
显而易见，这个条款和多态的这个特性息息相关。多态的其中一个重要是通过我们在基类中的声明虚函数，子类进行重写（override）。那么在基类中，我们声明了虚函数或者纯虚函数，那么我们应该对应地就要有虚析构函数，但是往往我们会忽略这个问题，这就会导致严重的内存泄漏问题。 下面我们上代码： class base //这里的基类并没有声明虚析构函数 { public: base() { ...
07 为多态基类声明虚析构函数
gb173652770的专栏
04-30 324
一、多态基类为什么要声明虚析构函数 当derived class对象经由一个base class指针被删除，而该bass class 带着一个non-virtual吸狗善书，其结果未有定义——实际执行时通常发生的是对象的的derived成分没有被销毁。 二、为什么多态基类中声明为虚析构函数，派生类就会被析构？ 析构函数的运作方式：最深层派生的那个class其析构函数最先被调用，然后是其每一个base class的析构函数被调用。（运作方式如何实现的？见下段粗体字。 ） 抽象类的析构函数声明为纯虚析构函数：
条款14 在资源管理类中小心coping 行为
sbfksmq的博客
09-05 548
#include #include using namespace std; class Mutex{ }; void lock(Mutex*pm){ cout << "locked " << endl; } void unlock(Mutex*pm){ cout << "unlocked" << endl; } class Lock{ public: explicit Lo
款31：将文件间的编译依存关系降到最低
sbfksmq的博客
09-17 497
/*条款31：将文件间的编译依存关系降到最低*/ #include #include//如果不加上下面三行会编译不过，然而这就是形成编译依存关系的源头 #include"data.h" #include"address.h" using namespace std; class Person { public: /* namespace std{ 但这是不正确，而是一个bas
条款46：需要类型转换时请为模板定义非成员函数
sbfksmq的博客
09-28 478
/*条款46：需要类型转换时请为模板定义非成员函数*/ #include using namespace std; template class Rational{ public: Rational(const T&numerator=0,const T&denominator=1):a(numerator),b(denominator){ } const T numerator()
条款47：请使用traits classes 表现类型信息
sbfksmq的博客
09-28 464
/*条款47：请使用traits classes 表现类型信息*/ //Traits 是一种技术，一个C++程序员共同遵守的协议，它的要求之一是：它对内置类型和用户自定义类型的表现必须一样好 //advance 用来将某个迭代器移动某个给定距离 #include using namespace std; template void advance(IterT &iter,DistT d);//但s
为什么基类需要虚析构函数才能正确删除派生类对象？
最新发布
06-18
<think>###为什么基类需要虚析构函数才能正确删除派生类对象？**回答：**基类需要虚析构函数来确保当通过基类指针删除派生类对象时，能够正确调用派生类的析构函数。如果基类析构函数不是虚函数，则只会调用基类的析构函数，导致派生类资源泄漏。####详细解释**1.非虚析构函数的问题**当基类析构函数不是虚函数时，通过基类指针删除派生类对象会引发**未定义行为**（通常是派生类部分未被销毁）：```cppclassBase{public:~Base(){cout<<"~Base()\n";}//非虚析构};classDerived:publicBase{public:Derived(){data=newint[100];}//分配资源~Derived(){delete[]data;//释放资源cout<<"~Derived()\n";}private:int*data;};intmain(){Base*obj=newDerived();deleteobj;//仅调用Base::~Base()，导致内存泄漏}```***输出**：仅`~Base()`***后果**：`Derived`的`data`数组未被释放（内存泄漏），`~Derived()`未被调用。**2.虚析构函数的解决方案**将基类析构函数声明为虚函数后：```cppclassBase{public:virtual~Base(){cout<<"~Base()\n";}//虚析构};//Derived类定义不变...intmain(){Base*obj=newDerived();deleteobj;//正确调用Derived::~Derived()->Base::~Base()}```***输出**：```~Derived()~Base()```***调用链**：`deleteobj`→调用虚析构函数→根据动态类型`Derived`调用`Derived::~Derived()`→自动调用基类析构函数`Base::~Base()`####技术原理**虚析构函数的动态绑定机制**-**虚函数表（vtable）**：当类有虚函数时，编译器为其生成虚函数表，其中包含所有虚函数地址（包括析构函数）。-**析构函数调用过程**：1.通过基类指针调用`delete`时，查找虚函数表获得实际析构函数地址。2.先调用派生类析构函数（释放派生类资源）。3.派生类析构函数执行完毕后，自动调用基类析构函数（通过静态绑定）。```mermaidgraphTDA[deletebase_ptr]-->B{基类析构是否虚函数？}B-->|是|C[查虚表调用实际析构函数]C-->D[执行派生类析构函数]D-->E[自动调用基类析构函数]B-->|否|F[直接调用基类析构函数]F-->G[派生类析构未执行→资源泄漏]```####最佳实践1.**基类设计规则**-如果类可能被继承（作为基类），**必须声明虚析构函数**。-即使基类不需要析构逻辑，也应提供空实现的虚析构函数：```cppclassAbstractBase{public:virtual~AbstractBase()=default;//C++11风格};```2.**最终类（禁止继承）的优化**若类不应被继承（C++11起可用`final`关键字），可不使用虚析构函数以避免虚表开销：```cppclassFinalClassfinal{//禁止继承public:~FinalClass(){...}//非虚析构};```3.**抽象类的纯虚析构函数**纯虚析构函数仍需提供实现（因为派生类析构会隐式调用它）：```cppclassAbstractBase{public:virtual~AbstractBase()=0;//纯虚声明};//必须提供实现（在类外）AbstractBase::~AbstractBase(){}//空实现```####常见错误场景-**STL容器存储基类指针**：```cppstd::vector<Base*>vec;vec.push_back(newDerived());//若~Base()非虚，delete时发生资源泄漏```-**智能指针使用**：```cppstd::unique_ptr<Base>p=std::make_unique<Derived>();//若~Base()非虚，同样导致派生类析构未被调用```---§§相关问题§§:1.虚析构函数的实现原理是什么？2.纯虚析构函数为什么需要提供实现？3.使用`final`关键字修饰的类是否还需要虚析构函数？4.在多继承场景下，虚析构函数如何工作？</think>### 为什么基类需要虚析构函数才能正确删除派生类对象？ **答案：** 基类需要虚析构函数是为了确保当通过基类指针删除派生类对象时，能够正确调用完整的析构函数链（包括派生类的析构函数）。如果基类析构函数不是虚函数，则只会调用基类的析构函数，导致派生类资源泄漏。 #### 详细解释 ##### 1. 非虚析构函数的问题 当基类析构函数不是虚函数时，通过基类指针删除派生类对象会导致**派生类析构函数不被调用**： ```cpp #include <iostream> using namespace std; class Base { public: ~Base() { cout << "Base destructor\n"; } // 非虚析构函数 }; class Derived : public Base { public: ~Derived() { cout << "Derived destructor\n"; } // 不会被调用 }; int main() { Base* obj = new Derived(); delete obj; // 仅调用 Base::~Base() return 0; } ``` **输出结果：** ``` Base destructor ``` **问题：** - `Derived` 的析构函数未被调用 - 如果 `Derived` 持有资源（如动态内存、文件句柄等），会导致资源泄漏 ##### 2. 虚析构函数的解决方案 将基类析构函数声明为虚函数后： ```cpp class Base { public: virtual ~Base() { cout << "Base destructor\n"; } // 虚析构函数 }; // Derived 类保持不变... int main() { Base* obj = new Derived(); delete obj; // 正确调用派生类析构函数 return 0; } ``` **输出结果：** ``` Derived destructor Base destructor ``` **关键机制：** 1. **动态绑定**：虚析构函数通过虚函数表（vtable）实现动态绑定 2. **调用顺序**： - 先调用派生类析构函数 - 自动调用基类析构函数（通过静态绑定） 3. **内存释放**： ```mermaid graph LR A[delete base_ptr] --> B[查虚表找实际析构函数] B --> C[调用Derived::~Derived] C --> D[执行派生类资源释放] D --> E[自动调用Base::~Base] E --> F[执行基类资源释放] ``` #### 技术原理深度解析 1. **对象内存布局**： ```cpp Derived object memory: [vptr] -> Derived vtable [Base members] [Derived members] ``` - `vptr` 指向包含析构函数地址的虚表 2. **虚表结构**： ``` Derived vtable: [0] Destructor address: Derived::~Derived [1] Other virtual functions... ``` 3. **删除操作的本质**： ```cpp // delete obj 的等价操作 if (obj != nullptr) { // 1. 通过vptr查找析构函数 void (*dtor)(void*) = obj->vptr[0]; // 2. 调用实际析构函数 dtor(obj); // 调用Derived::~Derived // 3. 释放内存 operator delete(obj); } ``` #### 关键应用场景 1. **多态对象处理**： ```cpp class Shape { public: virtual ~Shape() = default; // 必须为虚析构 virtual void draw() const = 0; }; class Circle : public Shape { // 资源管理 vector<double> vertexData; public: void draw() const override { /*...*/ } ~Circle() { /* 释放vertexData资源 */ } }; int main() { Shape* shape = new Circle(); // ... 使用shape ... delete shape; // 必须调用Circle::~Circle } ``` 2. **智能指针的正确使用**： ```cpp std::unique_ptr<Base> ptr = std::make_unique<Derived>(); // 当ptr离开作用域时： // 如果~Base()非虚 → 仅调用Base析构函数 // 如果~Base()为虚 → 正确调用Derived和Base析构函数 ``` #### 特殊注意事项 1. **抽象类的纯虚析构函数**： ```cpp class AbstractBase { public: virtual ~AbstractBase() = 0; // 纯虚声明 }; // 必须提供实现（派生类析构会隐式调用它） AbstractBase::~AbstractBase() {} ``` 2. **继承体系中的层级处理**： - 只要最顶层基类有虚析构函数，所有派生类都会受益 - 中间层的虚析构函数声明是好的实践但不是绝对必要 3. **性能考量**： - 虚析构函数会增加虚表指针（vptr）开销（每个对象8字节） - 在性能敏感场景，对不会被继承的类使用`final`关键字避免虚函数开销 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值