C++防灾——为指针成员分配专门的存储空间

  在C++中,当类中有指针类型的数据成员时,必须注意在构造函数中,分配专门的存储单元,并将地址赋值给指针型数据成员。

  这样做的目的在于,要保证指针指向的存储单元能够由类本身控制。

  如果这种情形处理不好,将可能会造成灾难性的后果,尽管多数情况程序看上去执行还算正常(这种错误是真正可怕的错误)。

  为了帮助读者理解,本文将从实例出发,展示不用这种处理的灾难性后果,同时给出正确处理的方法演示。


  一、一个编译正确,运行也正确的坏程序

//例程1
#include <iostream>
using namespace std;
class IntArray
{
public:
	IntArray(){arr_point=NULL; arr_len=0;}
	IntArray(int a[], int n);
	void showArray();
private:
	int *arr_point;  //数组的首地址
	int arr_len;
};

IntArray::IntArray(int a[], int n)
{
	arr_point=a;  //这是灾难的源头
	arr_len=n;
}

void IntArray::showArray()
{
	for (int i=0; i<arr_len; ++i)
		cout<<*(arr_point+i)<<' '; //或cout<<arr_point[i]<<' '
	cout<<endl;
	return;
}

int main()
{   
	int x[]={1,2,3,4,5};
	IntArray arr(x,5);
	arr.showArray();  // 输出1 2 3 4 5
	system("pause");
        return 0;
}

  这个程序在执行main()函数时,第31行利用定义好的 x 数组,新建了arr 对象。第33行arr.showArray();输出的结果表明,对象的创建是正确的。

  然而,这的确是个正确的坏程序。大多数情况不会出问题。但是,有时,无法预料到是何时,运行结果可能会不正确;甚至,有其他意外。

  这不是无中生有,危言耸听。

  让我们逐渐接近内幕。


  二、让面向对象的机制失效的程序

//例程2
#include <iostream>
using namespace std;
class IntArray
{
public:
	IntArray(){arr_point=NULL; arr_len=0;}
	IntArray(int a[], int n);
	void showArray() const;
private:
	int *arr_point;  //数组的首地址
	int arr_len;
};


IntArray::IntArray(int a[], int n)
{
	arr_point=a; 
	arr_len=n;
}


void IntArray::showArray() const
{
	for (int i=0; i<arr_len; ++i)
		cout<<*(arr_point+i)<<' '; //或cout<<arr_point[i]<<' '
	cout<<endl;
	return;
}


int main()
{   
	int x[]={1,2,3,4,5};
	const IntArray arr(x,5);
	arr.showArray();  //输出1 2 3 4 5
	x[3]=999;
	arr.showArray();  //输出的是1 2 3 999 5 !!!!!!
	system("pause");
        return 0;
}

【运行结果】

1 2 3 4 5
1 2 3 999 5
请按任意键继续. . .

【一点说明】
  其实还是上面的程序,只在main()中多加了两个语句。结果,在没有对 arr 对象做任何操作的前提下,arr 的值却变了!对象的封装性何在?!对象值的改变没有通过类的内部操作完成,也不是通过调用公共接口完成。而是,在arr 没有参与的情况下,变化已经发生。明明你买了一只烤鸭放在自家的冰箱里,取出来的却是一坨NF!

  更为严重的是,例程2中甚至将showArray成员声明为const成员函数(第9和24行),将arr对象声明为const对象(第35行)。常对象不允许修改的底线也被挑战了,且得逞了!

  这还不是最严重的!


  三、这个类会酿成灾难

//例程3

……//类的定义与例程2完全相同

int main()
{   
	int *x=new int[5];
	for (int i=0; i<5; ++i)
		x[i]=i+1;  //x是通过动态分配空间获得的,后面的释放从机制上是合法的
	const IntArray arr(x,5);
	arr.showArray();  //输出1 2 3 4 5
	delete [] x;      //释放x,x可以由操作系统分配作其他用途(很正常,main中不再用局部变量x,及早释放,可以挪作他用。如果x数组很大,效益可观)
	arr.showArray();  //这是灾难发生的部位:输出结果不可预料,可能导致生产线停车、火车驶上了不该行驶的车道、火箭失控……
	system("pause");
        return 0;
}

【运行结果】

1 2 3 4 5
1 2 3 999 5
-17891602 -17891602 -17891602 -17891602 -17891602
请按任意键继续. . .

【解释】
  在注释中已经指出了灾难所在,会得出错误的结果,灾难甚至可能是程序停止执行,意外退出。也有可能输出还会“正确”,而“正确”的惟一解释是这段程序太短了,arr中的arr_point指向的空间恰好还没有被操作系统分配作其他用途。当例程3的第12行和第13行中间插入了其他代码,完成了一些操作,甚至转移过流程,谁也说不清到执行第13行时,原先x曾经占用的内存的作用。的确,arr中的arr_point指向的是一个谁都说不清楚正在作何用的空间!!这个例子所示的只是显式地、有意地让灾难发生。在实际的项目中,类似 delete [ ] x; 的操作可能不在这里发生,可能根本不是由于delete造成。乐观些想这个问题, 如果在灾难发生前我们觉察出了问题,要在几万行代码中找到问题的根源,也是一件相当不易的事情,需要会出巨大的成本。

  而这一切,如果能遵循本文开头的嘱咐,原来是不会发生的。


  四、深刻理解:错误是这样发生的

  用例程1来说明问题。执行例程1时,发生的主要事情如图所示:

C++防灾——为指针成员分配专门的存储空间

  所以,在例程2中,main()函数可以修改 x[3] 的值;例程3中,x 数组已经被释放了,arr 对象仍然“一往无前”地将之用作数组。后一种情况是灾难性的,前 种情况也千万不要将之用作为技巧:看,我能够绕开C++的限制修改对象成员指向的值(有些hacker的感觉?)。在工程中,切忌将不同实体间的联系复杂化,这是一种复杂化的表现,多种机制瞎搅乎的结果,必定是质量低下、破绽百出、bug多多的程序。


  五、正确的做法

//例程4
#include <iostream>
using namespace std;
class IntArray
{
public:
	IntArray(){arr_point=NULL; arr_len=0;}
	IntArray(int a[], int n);
	~IntArray();
	void showArray() const;

private:
	int *arr_point;  //数组的首地址
	int arr_len;
};

IntArray::IntArray(int a[], int n)
{
	arr_point=new int[n];  //arr_point指向了属于自己的新空间
	for (int i=0; i<n; ++i) 
		*(arr_point+i)=*(a+i);   //将数组a中元素逐个赋值
	arr_len=n;
}

IntArray::~IntArray() //由于在类中涉及动态分配存储空间,在析构函数中将对应空间释放
{
	if (!arr_point) // 等同于if (arr_point!=NULL) 
		delete [] arr_point; //释放在类的生命周期中分配的,arr_point指向的空间
}

void IntArray::showArray() const
{
	for (int i=0; i<arr_len; ++i)
		cout<<*(arr_point+i)<<' '; //或cout<<arr_point[i]<<' '
	cout<<endl;
	return;
}

int main()
{   
	int *x=new int[5];
	for (int i=0; i<5; ++i)
		x[i]=i+1;
	const IntArray arr(x,5);
	arr.showArray();   // 输出1 2 3 4 5
	x[3]=999;
	arr.showArray();   // 输出1 2 3 4 5, arr使用专属的存储空间!
	delete [] x;
	arr.showArray();   // 输出1 2 3 4 5, arr使用专属的存储空间!!
	system("pause");
    return 0;
}

【运行结果】

1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
请按任意键继续. . .

【解释】
  程序的关键是IntArray类的构造函数和析构函数。在构造函数中,为arr_point指向的空间专门分配存储单元并赋值,从而这块存储区域成为相应对象的专属操作对象,不通过面向对象的机制,不能访问这儿的空间。尽管在main()函数中涉及的 x 数组的值修改,甚至释放 x 所占的空间,但此时,x 和arr 对象已经完全没有任何关系,对arr_point 所指向的空间没有任何的影响。程序中的各实体之间的“耦合”达到最小,各自按照各自的机制运行。

  下面的图示进一步说明了例程中内存空间的变化。

C++防灾——为指针成员分配专门的存储空间

  六、补充一个例子:当指针指向字符时

#include <iostream>
#include <string.h>
#include <iomanip> 
using namespace std;

class CPerson 
{
protected:
	char *m_szName;
	char *m_szId;
	int m_nSex;//0:women,1:man
	int m_nAge;
public:
	CPerson(char *name,char *id,int sex,int age);
	void Show();
	~CPerson();
};

CPerson::CPerson(char *name,char *id,int sex,int age)
{
	m_szName=new char[strlen(name)+1];  //分配正好大小的空间,根据形参name指向的字符串
	strcpy(m_szName,name);     //字符串的复制
	m_szId=new char[strlen(id)+1];    //指针成员都这样处理  
	strcpy(m_szId,id);
	m_nSex=sex;
	m_nAge=age;
}

void CPerson::Show()
{
	cout<<setw(10)<<m_szName<<setw(25)<<m_szId;	//setw:设置输出数据的宽度,使用时应#include <iomanip.h> 
	if(m_nSex==0)
		cout<<setw(7)<<"women";
	else
		cout<<setw(7)<<"man";
	cout<<setw(5)<<m_nAge<<endl;
}

CPerson::~CPerson()
{
	delete [ ]m_szName;   //析构函数中要释放动态分配的空间
	delete [ ]m_szId;
}

int main()
{
	char name[10],id[19];
	int sex,age;
	cout<<"input name,id,sex(0:women,1:man),age:\n";
	cin>>name>>id>>sex>>age;
	CPerson person(name,id,sex,age);
	person.Show();
	system("pause");
	return 0;
}
【说明】

  此例是博文《 第10周-任务2-CEmployee类继承CPerson类》程序中的一部分,该文以CPerson为基类作了派生。

  在以前的博文中,《第9周-任务4-二维数组类》也涉及到了本文所讲的内容,请参考。

  

  七、总结

  重申本文中心:在C++中,当类中有指针类型的数据成员时,必须注意在构造函数中,分配专门的存储单元,并将地址赋值给指针型数据成员。




上一篇:mysql基础知识点


下一篇:iOS开发拓展篇—音频处理(音乐播放器4)