构造函数初始化列表

推荐在构造函数初始化列表中进行初始化

构造函数的执行分为两个阶段

初始化段
普通计算段函数体中的赋值，实际上内存已经分配好了

对象成员及其初始化

成员的构造顺序与初始化列表中的顺序无关，而与成员定义的顺序有关。如果成员类型是类类型，且该类型没有默认构造函数，则一定要放在初始化列表中

const成员、引用成员初始化

const成员，引用成员的初始化也只能放在构造函数的初始化列表中进行，上面中提到了，对象成员（对象所对应的类没有默认构造函数）的初始化，也只能在构造函数初始化列表中进行。

const对应的常量只是对类的某一对象是常量，

枚举对类的任何对象可以是常量

#include <iostream>
using namespace std;

// const成员的初始化只能在构造函数初始化列表中进行
// 引用成员的初始化也只能在构造函数初始化列表中进行
// 对象成员（对象所对应的类没有默认构造函数）的初始化，也只能在构造函数初始化列表中进行
class Object
{
public:
	enum E_TYPE
	{
		TYPE_A = 100,
		TYPE_B = 200
	};
public:
	Object(int num=0) : num_(num), kNum_(num), refNum_(num_)
	{
		//kNum_ = 100;
		//refNum_ = num_;
		cout<<"Object "<<num_<<" ..."<<endl;
	}
	~Object()
	{
		cout<<"~Object "<<num_<<" ..."<<endl;
	}

	void DisplayKNum()
	{
		cout<<"kNum="<<kNum_<<endl;
	}
private:
	int num_;
	const int kNum_;
	int& refNum_;
};

int main(void)
{
	Object obj1(10);
	Object obj2(20);
	obj1.DisplayKNum();
	obj2.DisplayKNum();

	cout<<obj1.TYPE_A<<endl;
	cout<<obj2.TYPE_A<<endl;
	cout<<Object::TYPE_A<<endl;


	return 0;
}

拷贝构造函数

功能：使用一个已经存在的对象来初始化一个新的同一类型的对象

声明：只有一个参数并且参数为该类对象的引用

如果类中没有说明拷贝构造函数，则系统自动生成一个缺省复制构造函数，作为该类的公有成员

Test t(10);
//Test t2(t);		// 调用拷贝构造函数
Test t2 = t;		// 等价于Test t2(t);

注意一定要是引用，因为如果不是引用就涉及实参初始化形参，要调用拷贝构造函数，出现递归调用

拷贝构造函数调用的几种情况

当函数的形参是类的对象，调用函数时，进行形参与实参结合时使用。这时要在内存新建立一个局部对象，并把实参拷贝到新的对象中。理所当然也调用拷贝构造函数。
当函数的返回值是类对象，函数执行完成返回调用者时使用。理由也是要建立一个临时对象中，再返回调用者。为什么不直接用要返回的局部对象呢？因为局部对象在离开建立它的函数时就消亡了，不可能在返回调用函数后继续生存，所以在处理这种情况时，编译系统会在调用函数的表达式中创建一个无名临时对象，该临时对象的生存周期只在函数调用处的表达式中。所谓return 对象，实际上是调用拷贝构造函数把该对象的值拷入临时对象。如果返回的是变量，处理过程类似，只是不调用构造函数。

#include "Test.h"
#include <iostream>
using namespace std;

void TestFun(const Test t)
{

}

void TestFun2(const Test& t)
{

}

Test TestFun3(const Test& t)
{
	return t;            //返回调用拷贝构造函数
}

const Test& TestFun4(const Test& t)
{
	//return const_cast<Test&>(t);
	return t;           //不会调用拷贝构造函数
}

int main(void)
{
	Test t(10);


	//t = TestFun3(t);     临时对象进行拷贝赋值运算
	//Test t2 = TestFun3(t);   不会进行拷贝赋值运算，临时对象被接管

	//Test& t2 = TestFun3(t);  引用临时对象，临时对象不会马上销毁

	//Test t2 = TestFun4(t);   会调用拷贝构造函数生成t2
	const Test& t2 = TestFun4(t); 不会调用拷贝构造函数
	cout<<"........"<<endl;

	return 0;
}

深拷贝与浅拷贝

在没有提供拷贝构造函数时，系统会提供默认的拷贝函数，系统提供的默认拷贝构造函数是浅拷贝，各个成员进行赋值，但是当成员含义指针时涉及到动态内存的分配，如果涉及浅拷贝就会共享同一块内存，但是当一个对象释放时，另一个对象也会出现无效的状态，有可能出现同一块内存释放两次的情况。因此就要实施深拷贝，将指针指向的对象的值进行拷贝。

赋值操作

系统默认提供的赋值操作也是浅拷贝，各个成员进行赋值。因此也要实施深拷贝

禁止拷贝

将赋值与拷贝构造函数声明为私有，并不实现

空类默认产生的成员

class Empty {};
Empty(); 			// 默认构造函数
Empty( const Empty& );	// 默认拷贝构造函数
~Empty(); 			// 默认析构函数
Empty& operator=( const Empty& );  // 默认赋值运算符
Empty* operator&();		               // 取址运算符
const Empty* operator&() const;	    // 取址运算符 const

简单实现string 实施深拷贝

#ifndef _STRING_H_
#define _STRING_H_

class String
{
public:
	String(char* str="");
	~String();
	String(const String& other);
	String& operator=(const String& other);

	

	void Display();

private:
	char* AllocAndCpy(char* str);
	
	char* str_;
};

#endif // _STRING_H_

#include "String.h"
//#include <string.h>
#include <cstring>
#include <iostream>
using namespace std;

String::String(char* str/* = */)
{
	str_ = AllocAndCpy(str);
}

String::~String()
{
	delete[] str_;
}

String::String(const String& other)
{
	str_ = AllocAndCpy(other.str_);
}

String& String::operator =(const String &other)
{
	if (this == &other)
		return *this;
	
	delete[] str_;
	str_ = AllocAndCpy(other.str_);
	return *this;
}

char* String::AllocAndCpy(char* str)
{
	int len = strlen(str) + 1;
	char* tmp = new char[len];
	memset(tmp, 0, len);
	strcpy(tmp, str);
	return tmp;
}

void String::Display()
{
	cout<<str_<<endl;
}

8.构造函数与析构函数（二）