一、对象不再需要的时候如何销毁?
解决方案一:
为每个类提供一个public的free函数
对象不再需要时立即调用free函数进行清理(如之前的数组类)
但是很有可能忘了调用,最终导致内存泄漏
解决方案二:
析构函数:
析构函数没有参数也没有返回值类型声明(故析构函数不能被重载)
析构函数在对象销毁时被自动调用
#include <iostream>
using namespace std;
class Test
{
int mi;
public:
Test(int i)
{
mi = i;
cout<<"Test():"<<mi<<endl;
}
~Test()
{
cout<<"~Test():"<<mi<<endl;
}
};
int main()
{
Test t(1);//局部变量
Test* pt = new Test(2);
delete pt;
cin.get();
return 0;
}
数组类的进化:将free函数换成析构函数
array.h
#ifndef _ARRAY_H_
#define _ARRAY_H_
#include<iostream>
class Array
{
private:
int m_length;
int *m_poiter;
public:
Array(int length);
Array(const Array& obj);
int get_length();
bool set_data(int index, int data);
bool get_data(int index, int& data);
~Array();
};
#endif
array.cpp:
#include"array.h"
Array::Array(int length)
{
m_length = length;
m_poiter = new int[m_length];
for(int i = 0; i < m_length; i++)
{
m_poiter[i] = 0;
}
}
Array::Array(const Array& obj)
{
m_length = obj.m_length;
m_poiter = new int[obj.m_length];
for(int i = 0; i < obj.m_length; i++)
{
m_poiter[i] = obj.m_poiter[i];
}
}
int Array::get_length()
{
return m_length;
}
bool Array::set_data(int index, int data)
{
bool ret = ((0 <= index)&&(index<get_length()));
if(ret)
{
m_poiter[index] = data;
}
return ret;
}
bool Array::get_data(int index, int& data)
{
bool ret = ((0<=index) && (index<get_length()));
if(ret)
{
data = m_poiter[index];
}
return ret;
}
Array::~Array()
{
delete[] m_poiter;
}
main.cpp
#include"array.h"
using namespace std;
int main()
{
Array array(5);
cout << array.get_length()<<endl;
cout << endl;
for(int i = 0; i < array.get_length(); i++)
{
array.set_data(i, i+1);
}
for(int i = 0; i < array.get_length(); i++)
{
int data = 0;
if(array.get_data(i, data))
{
cout << data << endl;
}
}
cout << endl;
Array array2 = array;
for(int i = 0; i < array2.get_length(); i++)
{
int data = 0;
if(array2.get_data(i, data))
{
cout << data <<endl;
}
}
return 0;
}
当类中自定义了构造函数,并且构造函数中使用了系统资源(如:内存申请,文件打开等)则
需要自定义构造函数
小结:
1.析构函数是对象销毁时进行清理的特殊函数
2.析构函数在对象销毁时自动被调用
3.析构函数是对象释放系统资源的保障