【C++】 22_对象的销毁

偏执的太偏执、 2022-03-02 14:28 156阅读 0赞

# 对象的销毁 #

>  *  生活中的对象都是被初始化后才上市的
>  *  生活中的对象被销毁前会做一些清理工作

问题： C++ 中如何清理需要销毁的对象呢？

>  *  一般而言，需要销毁的对象都应该做清理
>  *  解决方案
>     
>      *  为每个类提供一个 public 的 free 函数
>      *  对象不再需要时调用 free 函数进行清理

class Test
    {
    private:
        int* p;
    public:
        Test() 
        { 
            p = new int 
        };
        void free() 
        { 
            delete p 
        };
    };

>  *  存在的问题
>     
>      *  free 只是一个普通的函数，必须显示的调用
>      *  对象销毁前没有做清理，很可能造成资源浪费

C++ 编译器是否能够自动调用某个特殊的函数进行对象的清理呢？

# 析构函数 #

>  *  C++ 类中可以定义一个特殊的清理函数
>     
>      *  这个特殊的清理函数叫做析构函数
>      *  析构函数的功能与构造函数相反
>  *  定义： `ClassName()`
>     
>      *  析构函数没有参数也没有返回值类型
>      *  析构函数**在对象销毁时被自动调用**

## 编程实验： 析构函数使用初探 ##

#include <stdio.h>
    
    class Test
    {
    private:
        int mi;
    public:
        Test(int i)
        {
            mi = i;
            printf("Test(int i), i = %d\n", mi);
        }
        ~Test()
        {
            printf("~Test(), i = %d\n", mi);
        }
    };
    
    Test t3(3);
    
    int main()
    {
        Test t(1);
        
        Test* pt = new Test(2);
        
        delete pt;
    
        return 0;
    }

输出：
    Test(int i), i = 3
    Test(int i), i = 1
    Test(int i), i = 2
    ~Test(), i = 2
    ~Test(), i = 1
    ~Test(), i = 3

## 编程实验： IntArray 类的进化 ##

IntArray.h

#ifndef _INTARRAY_H_
    #define _INTARRAY_H_
    
    class IntArray
    {
    private:
        int m_length;
        int* m_pointer;
    
    public:
        IntArray(int len);
        IntArray(const IntArray& obj);
        int length();
        bool get(int index, int& value);
        bool set(int index, int value);
        ~IntArray();
    };
    
    #endif

IntArray.cpp

#include "IntArray.h"
    
    IntArray::IntArray(int len)
    {
        m_pointer = new int[len];
        
        for(int i=0; i<len; i++)
        {
            m_pointer[i] = 0;
        }
        
        m_length = len;
    }
    
    IntArray::IntArray(const IntArray& obj)
    {
        m_length = obj.m_length;
        
        m_pointer = new int[obj.m_length];
        
        for(int i=0; i<obj.m_length; i++)
        {
            m_pointer[i] = obj.m_pointer[i];
        }
    }
    
    int IntArray::length()
    {
        return m_length;
    }
    
    bool IntArray::get(int index, int& value)
    {
        bool ret = (index >= 0) && (index < length());
        
        if( ret )
        {
            value = m_pointer[index];
        }
        
        return ret;
    }
    
    bool IntArray::set(int index, int value)
    {
        bool ret = (index >= 0) && (index < length());
        
        if( ret )
        {
            m_pointer[index] = value;
        }
        
        return ret;
    }
    
    IntArray::~IntArray()
    {
        delete[] m_pointer;
    }

main.cpp

#include <stdio.h>
    #include "IntArray.h"
        
    int main()
    {
        IntArray a(5);
        
        for(int i=0; i<a.length(); i++)
        {
            a.set(i, i+1);
        }
        
        for(int i=0; i<a.length(); i++)
        {
            int value = 0;
            
            if( a.get(i, value) )
            {
                printf("a.[%d] = %d\n", i, value);
            }
        }
        
        IntArray b = a;
        
        for(int i=0; i<b.length(); i++)
        {
            int value = 0;
            
            if( b.get(i, value) )
            {
                printf("b.[%d] = %d\n", i, value);
            }
        }
    
        return 0;
    }

输出：
    a.[0] = 1
    a.[1] = 2
    a.[2] = 3
    a.[3] = 4
    a.[4] = 5
    b.[0] = 1
    b.[1] = 2
    b.[2] = 3
    b.[3] = 4
    b.[4] = 5

>  *  析构函数的定义准则

当类中定义了构造函数，并且构造函数中使用了系统资源（如：内存申请，文件打开，等），则需要自定义析构函数。

# 小结 #

>  *  析构函数是对象销毁时进行清理的特殊函数
>  *  析构函数**在对象销毁时自动被调用**
>  *  析构函数是对象释放系统资源的保帐

以上内容参考狄泰软件学院系列课程，请大家保护原创！