C++Primer Plus第十二章程序清单12.1~12.3一个失败的例子分析

12.1.2 特殊成员函数
StringBad 类的问题是由特殊成员函数引起的。这些成员函数是自动定义的，就 StringBad 而言，这些函数的行为与类设计不符。具体地说，C++自动提供了下面这些成员函数:
1，默认构造函数，如果没有定义构造函数;
2，默认析构函数，如果没有定义;
3，复制构造函数，如果没有定义;
4，赋值运算符，如果没有定义;
5，地址运算符，如果没有定义。
更准确地说,编译器将生成上述最后三个函数的定义–如果程序使用对象的方式要求这样做。例如，
如果您将一个对象赋给另一个对象，编译器将提供赋值运算符的定义。结果表明，StringBad 类中的问题是由隐式复制构造函数和隐式赋值运算符引起的。隐式地址运算符返回调用对象的地址(即this指针的值)。这与我们的初衷是一致的，在此不详细讨论该成员函数。默认析构函数不执行任何操作，因此这里也不讨论，但需要指出的是，这个类已经提供默认构造函数。至于其他成员函数还需要进一步讨论。
C++11提供了另外两个特殊成员函数:移动构造函数(moveconstructor)和移动赋值运算符(moveassignment operator)，这将在第18章讨论。
1.默认构造函数
如果没有提供任何构造函数，C++将创建默认构造函数。例如，假如定义了一个Klunk 类，但没有提供任何构造函数，则编译器将提供下述默认构造函数:

	Klunk::Klunk())//implicit default constructor

也就是说,编译器将提供一个不接受任何参数,也不执行任何操作的构造函数(默认的默认构造函数)，这是因为创建对象时总是会调用构造函数:

	Klunk lunk;//invokes default constructor

默认构造函数使Lunk 类似于一个常规的自动变量，也就是说，它的值在初始化时是未知的。如果定义了构造函数，C++将不会定义默认构造函数。如果希望在创建对象时不显式地对它进行初始化，则必须显式地定义默认构造函数。这种构造函数没有任何参数，但可以使用它来设置特定的值

	Klunk::Klunk()//explicit default constructor
	{
	 klunk ct=0;
	 ...
	 }

带参数的构造函数也可以是默认构造函数，只要所有参数都有默认值。例如，Klunk类可以包含下述内联构造函数:

Klunk(int n=0){fklunk ct=n};

但只能有一个默认构造函数。也就是说，不能这样做:

Klunk(){fklunkct=0}
Klunk(intn=0){klunk ct=n};
// constructor #1
//ambiquous constructor #2

这为何有二义性呢?请看下面两个声明:

	Klunk kar(10);//clearly matches Klunt(int n)
	Klunk bus ;
	//could match either constructor

第二个声明既与构造函数#1(没有参数)匹配，也与构造函数#2(使用默认参数0)匹配。这将导致编译器发出一条错误消息。

2.复制构造函数
复制构造函数用于将一个对象复制到新创建的对象中。也就是说，它用于初始化过程中(包括按值传递参数)，而不是常规的赋值过程中。类的复制构造函数原型通常如下:

Class name(const Class name &);

它接受一个指向类对象的常量引用作为参数。例如，String类的复制构造函数的原型如下:

StrinqBad(const StringBad &);

对于复制构造函数，需要知道两点:何时调用和有何功能。

3.何时调用复制构造函数
新建一个对象并将其初始化为同类现有对象时，复制构造函数都将被调用。这在很多情况下都可能发生，最常见的情况是将新对象显式地初始化为现有的对象。例如，假设moto是一个 StringBad 对象，则下面4种声明都将调用复制构造函数:

StringBad ditto(motto);// calls stringBad(const StringBad &)
StringBad metoo=motto;//calls StringBad(constStringBad &)
StringBad also=StringBad(motto);
					//calls stringBad(const stringBad &)
StringBad *pStringBad =newStringBad(motto);
					//calls stringBad(const stringBad &)

其中中间的2种声明可能会使用复制构造函数直接创建metoo和also，也可能使用复制构造函数生成一个临时对象，然后将临时对象的内容赋给 metoo和 also，这取决于具体的实现。最后一种声明使用 moto初始化一个匿名对象，并将新对象的地址赋给 pstring指针。
每当程序生成了对象副本时，编译器都将使用复制构造函数。具体地说，当函数按值传递对象(如程序清单12.3中的 callme20)或函数返回对象时，都将使用复制构造函数。记住，按值传递意味着创建原始变量的-个副本。编译器生成临时对象时，也将使用复制构造函数。例如，将3个Vector 对象相加时，编译器可能生成临时的 Vector 对象来保存中间结果。何时生成临时对象随编译器而异，但无论是哪种编译器，当按值传递和返回对象时，都将调用复制构造函数。具体地说，程序清单12.3中的函数调用将调用下面的复制构造函数:

callme2(headline2);

程序使用复制构造函数初始化sb–callme20)函数的 StringBad 型形参。由于按值传递对象将调用复制构造函数，因此应该按引用传递对象。这样可以节省调用构造函数的时间以及存储新对象的空间。
默认的复制构造函数的功能默认的复制构造函数逐个复制非静态成员(成员复制也称为浅复制)，复制的是成员的值。在程序清单
12.3中，下述语句:

StringBad sailor =sports;

与下面的代码等效(只是由于私有成员是无法访问的，因此这些代码不能通过编译):

StringBad sailor;
sailor.str=sports.str;
sailor.len =sports.len;

如果成员本身就是类对象，则将使用这个类的复制构造函数来复制成员对象。静态函数(如num_strings)不受影响，因为它们属于整个类，而不是各个对象。图12.2说明了隐式复制构造函数执行的操作。
12.1.3 回到 Stringbad:复制构造函数的哪里出了问题现在介绍程序清单 12.3 的两个异常之处(假设输出为该程序清单后面列出的)。首先，程序的输出表明，析构函数的调用次数比构造函数的调用次数多2，原因可能是程序确实使用默认的复制构造函数另外创建了两个对象。当 callme20被调用时，复制构造函数被用来初始化 callme20的形参，还被用来将对象 sailor 初始化为对象 sports。默认的复制构造函数不说明其行为，因此它不指出创建过程，也不增加计数器 mum_strings 的值。但析构函数更新了计数，并且在任何对象过期时都将被调用，而不管对象是如何被创建的。这是一个问题，因为这意味着程序无法准确地记录对象计数。解决办法是提供一个对计数进行更新的显式复制构造函数:StringBad::stringBad(constString&s)
num strings++;
…//important stuff to go here
提示:如果类中包含这样的静态数据成员，即其值将在新对象被创建时发生变化，则应该提供一个显式复制构造函数来处理计数问题。
第二个异常之处更微妙，也更危险，其症状之一是字符串内容出现乱码
:headline2:DÃo
原因在于隐式复制构造函数是按值进行复制的。例如,对于程序清单 12.3,隐式复制构造函数的功能相当于
:sailor.str =sport.str;
这里复制的并不是字符串，而是一个指向字符串的指针。也就是说，将sailor 初始化为 sports 后，得到的
是两个指向同一个字符串的指针。当 operator<<0)函数使用指针来显示字符串时，这并不会出现问题。但当析构函数被调用时，这将引发问题。析构函数 StingBad 释放 str 指针指向的内存，因此释放 sailor 的效果如下
😕/delete the string that ditto.str points todelete []sailor.str;
sailor.str 指针指向“Spinach Leaves Bowl for Dollars”，因为它被赋值为sports.str，而 sports.str 指向的正是上述字符串。所以 delete语句将释放字符串“Spinach Leaves Bowlfor Dollars”占用的内存。然后，释放 sports的效果如下:
delete []sports.str;//effect is undefined
sports.str 指向的内存已经被 saior 的析构函数释放，这将导致不确定的、可能有害的后果。程序清单12.3 中的程序生成受损的字符串，这通常是内存管理不善的表现。另一个症状是，试图释放内存两次可能导致程序异常终止。例如，Microsoft VisualC++2010(调试模式)显示一个错误消息窗口，指出“Debug Asserion Failed!”;而在 Linux 中，g++ 4.4.1显示消息“double fee orcorruption”并终止程序运行。其他系统可能提供不同的消息，甚至不提供任何消息，但程序中的错误是相同的。

1.定义一个显式复制构造函数以解决问题
解决类设计中这种问题的方法是进行深度复制(deepcopy)。也就是说，复制构造函数应当复制字符串并将副本的地址赋给 str 成员，而不仅仅是复制字符串地址。这样每个对象都有自己的字符串，而不是引用另一个对象的字符串。调用析构函数时都将释放不同的字符串，而不会试图去释放已经被释放的字符串。可以这样编写 String 的复制构造函数:

StringBad::stringBad(conststringBad &st)
{
	num_strings++;//handle static member update
	len =st.len;//same length
	std = new char[len+1];// allot spacestd::strcpy(str,st.str);//copy string to new location
	cout <<num_strings":"<<str
	<< "\" object created\n";//For Your Information
}

必须定义复制构造函数的原因在于，一些类成员是使用 new 初始化的、指向数据的指针，而不是数据本身。图 12.3说明了深度复制。
警告:如果类中包含了使用 new初始化的指针成员,应当定义一个复制构造函数,以复制指向的数据,而不是指针，这被称为深度复制。复制的另一种形式(成员复制或浅复制)只是复制指针值。浅复制仅浅浅地复制指针信息，而不会深入“挖掘”以复制指针引用的结构。

12.1.4 Stringbad 的其他问题:赋值运算符

并不是程序清单12.3的所有问题都可以归咎于默认的复制构造函数,还需要看一看默认的赋值运算符。ANSIC允许结构赋值，而C++允许类对象赋值，这是通过自动为类重载赋值运算符实现的。这种运算符的原型如下:

Class name & Class name::operator=(const Class name &);

它接受并返回一个指向类对象的引用。例如，StringBad类的赋值运算符的原型如下:

StringBad & StringBad::operator=(const StringBad &);

1.赋值运算符的功能以及何时使用它将已有的对象赋给另一个对象时，将使用重载的赋值运算符:StringBad headlinel("Celery

StringBad headline1("Celery Stalks at Midnight")
....
StringBad knot;

初始化对象时，并不一定会使用赋值运算符:

knot = headline1;//assignment operator invoked

这里，metoo 是一个新创建的对象，被初始化为kmot 的值，因此使用复制构造函数。然而，正如前面指出的，实现时也可能分两步来处理这条语句:使用复制构造函数创建一个临时对象，然后通过赋值将临时对象的值复制到新对象中。这就是说，初始化总是会调用复制构造函数，而使用=运算符时也可能调用赋值运算符。与复制构造函数相似，赋值运算符的隐式实现也对成员进行逐个复制。如果成员本身就是类对象，则程序将使用为这个类定义的赋值运算符来复制该成员，但静态数据成员不受影响。

2.赋值的问题出在哪里
程序清单12.3将headline1赋给 knot:

knot = headlinel;

为 knot 调用析构函数时，将显示下面的消息:

"Celery stalks at Midnight" object deleted, 2 left

为 Headline1调用析构函数时，显示如下消息(有些实现方式在此之前就异常终止了):

"-"obiect deleted，-2 left

出现的问题与隐式复制构造函数相同:数据受损。这也是成员复制的问题，即导致headline1.str和knot.str 指向相同的地址。因此，当对knot 调用析构函数时，将删除字符串“Celery Stalksat Midnight”;当对 headlinel 调用析构函数时，将试图删除前面已经删除的字符串。正如前面指出的，试图删除已经删除的数据导致的结果是不确定的，因此可能改变内存中的内容，导致程序异常终止。要指出的是，如果操作结果是不确定的，则执行的操作将随编译器而异，包括显示独立声明(Declaration ofIndependence)或释放隐藏文件占用的硬盘空间。当然，编译器开发人员通常不会花时间添加这样的行为。

3.解决赋值的问题
对于由于默认赋值运算符不合适而导致的问题，解决办法是提供赋值运算符(进行深度复制)定义。
其实现与复制构造函数相似，但也有一些差别。
由于目标对象可能引用了以前分配的数据，所以函数应使用delete[]来释放这些数据。函数应当避免将对象赋给自身:否则，给对象重新赋值前，释放内存操作可能删除对象的内容

函数返回一个指向调用对象的引用。
通过返回一个对象,函数可以像常规赋值操作那样,连续进行赋值,即如果 S0、S1和S2都是 StringBad对象，则可以编写这样的代码:
S0=S1=S2;
使用函数表示法时，上述代码为:
S0.operator=(S1.operator=(S2));
因此，S1.operator=(S2)的返回值是函数S0.operator=()的参数。因为返回值是一个指向 StringBad 对象的引用，因此参数类型是正确的。下面的代码说明了如何为 StringBad 类编写赋值运算符:

StringBad & StringBad::operator=(const StringBad &st)
{
	if (this == &st)	//object assigned to itself
		return *this;		// all done
	delete []str;
	len =st.len;
	str=newchar[len+1];//get space for new string
	std::strcpy(str，st.str);// copy the string
	return *this;// free old string
//return reference to invoking obiect
}

代码首先检查自我复制，这是通过查看赋值运算符右边的地址(&s)是否与接收对象(tis)的地址相同来完成的。如果相同，程序将返回*this，然后结束。第10章介绍过，赋值运算符是只能由类成员函数重载的运算符之一。
如果地址不同，函数将释放 st 指向的内存，这是因为稍后将把一个新字符串的地址赋给 str。如果不首先使用 delete运算符，则上述字符串将保留在内存中。由于程序中不再包含指向该字符串的指针，因此这些内存被浪费掉。
接下来的操作与复制构造函数相似，即为新字符串分配足够的内存空间，然后将赋值运算符右边的对象中的字符串复制到新的内存单元中。

上述操作完成后，程序返回*this 并结束。
赋值操作并不创建新的对象，因此不需要调整静态数据成员num_strings 的值。
将前面介绍的复制构造函数和赋值运算符添加到 StringBad 类中后，所有的问题都解决了。例如，下面是在完成上述修改后，程序输出的最后几行:
End of main()
“Celery stalks at Midnight” object deleted, 4 left
“Spinach Leaves Bowl for Dollars” object deleted, 3 left
“Spinach Leaves Bowl for Dollars” obiect deleted, 2 left
“Lettuce Prey” object deleted,l left
“Celery Stalks at Midnight” object deleted,0 left
现在，对象计数是正确的，字符串也没有被损坏。

今天到这里，下篇文章写解决办法