详解C++中的析构函数

时间:2022-03-23 02:44:42

简介

析构函数(Destructors),是对象的成员函数,没有返回值也没有参数,且一个类只有一个析构函数,当对象被销毁的时候调用,被销毁通常有这么几个情况。

  • 函数执行结束
  • 程序执行结束
  • 程序块包含的局部变量
  • delete操作

什么时候要自己写析构函数?

编译器会自动创建默认的析构函数,通常都没有问题,但是当我们在类中动态分配了内存空间时,我们需要手段的回收这块空间,防止内存溢出。就像这样

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class String
{
private:
    char *s;
    int size;
public:
    String(char *); // constructor
    ~String();   // destructor
};
 
String::String(char *c)
{
    size = strlen(c);
    s = new char[size+1];
    strcpy(s,c);
}
 
String::~String()
{
    delete []s;
}

私有的析构函数

可以将析构函数的访问权限设置为private,设置时没有问题的,但是一个问题就是,通常的手段就没法调用析构函数了。

如下所示,程序结束后要调用析构函数,但是析构函数时私有的没法调用,所以会编译出错。

?
1
2
3
4
5
6
7
8
9
10
#include <iostream>
using namespace std;
class Test {
private:
    ~Test() {}
};
int main()
{
    Test t;
}

以下这样不会有问题,因为没有对象被建立,也不用析构

?
1
2
3
4
int main()
{
 Test* t;          
}

以下这样也不会有问题,因为动态分配的内存需要程序员手段释放,所以程序结束时没有释放内存,也没有调用析构函数。这里插一句,动态分配的内存如果不手动释放,程序结束后也会不会释放,但是现代操作系统可以帮我们释放,因为这个动态分配的内存和这个进程有关,操作系统应该可以捕获到这个泄露的内存从而释放。(查资料看到的)

?
1
2
3
4
int main()
{
 Test* t = new Test;
}

如果使用delete来删除对象,会编译出错

?
1
2
3
4
5
int main()
{
 Test* t = new Test;
 delete t;//编译出错,无法调用私有的析构函数
}

可以利用Friend函数,进行对象的销毁,因为Friend可以访问私有成员,所以可以访问析构函数。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
 
class Test {
private:
    ~Test() {}
    friend void destructTest(Test*);
};
 
void destructTest(Test* ptr)
{
    delete ptr;
}
 
int main()
{
    Test* ptr = new Test;
    destructTest(ptr);
 
    return 0;
}

或者给类写一个销毁的方法,在需要销毁的时候调用。

?
1
2
3
4
5
6
class Test {
public:
 destroy(){delete this};
private:
    ~Test() {}
};

那么什么时候需要使用私有的析构函数呢?当我们只希望动态分配对象空间(在堆上)时候,用私有析构,就防止了在栈上分配,因为在编译阶段就会出错。

虚析构函数

当类用到多态的特性时候,使用虚析构函数。看如下的例子。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <iostream>
using namespace std;
class Base
{
public:
 Base(){
  cout << "Base Constructor Called\n";
 }
 ~Base(){
  cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
  cout << "Derived constructor called\n";
 }
 ~Derived1(){
  cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new Derived1();
 delete b;
}

例子里的析构函数都不是虚函数,当我们想用基类的指针来删除派生类对象的时候,就出现了问题,“undefined behavior”,c++标准里规定,只由编译器实现,通常这时不会报错,会调用基类的析构函数。但这应该不是我们想要的,这会导致内存泄漏。所以要把析构函数置为虚函数。(msvc似乎不用给析构函数加virtual,默认就是虚的,gcc没有默认还是要加的)

另外虚析构函数可以是纯虚析构函数,但是要提供函数体,不然没法析构,因为虚析构函数和一般的虚函数的overide还不一样,虚析构函数要挨个执行,不提供函数体,会编译出错。

析构函数的执行顺序

派生类,成员对象,基类这样

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class B
{public: virtual ~B(){cout<<"基类B执行了"<<endl; }
};
 
class D
{public:virtual ~D(){cout<<"成员D执行了"<<endl; }
} ;
 
class E
{public:virtual ~E(){cout<<"成员E执行了"<<endl; }
} ;
 
class A
{public:virtual ~A(){cout<<"基类A执行了"<<endl;};
};
 
class C:public A,B
{
 public:virtual ~C(){cout<<"派生类执行了"<<endl;};
 private:
  E e;
  D d;
};
 
int main()
{
 C *c;
 c=new C();
 delete c;
}

结果为

派生类执行了
成员D执行了
成员E执行了
基类B执行了
基类A执行了

参考

[1]什么时候使用虚函数https://*.com/questions/461203/when-to-use-virtual-destructors
[2]析构函数https://www.geeksforgeeks.org/destructors-c/
[3]虚析构函数https://www.geeksforgeeks.org/virtual-destructor/
[4]纯析构函数https://www.geeksforgeeks.org/pure-virtual-destructor-c/

以上就是详解C++中的析构函数的详细内容,更多关于C++ 析构函数的资料请关注服务器之家其它相关文章!

原文链接:https://www.cnblogs.com/WAoyu/p/13164160.html