类的构造，拷贝构造，析构，赋值（string类）

1. 构造函数初始化表的使用规则：

   1. 如果类存在继承关系，派生类必须在起初始化表里调用基类的构造函数

   2. 类的const常量只能在初始列表里被初始化，因为他不能在函数体内用赋值的方式初始化

   3. 类的数据成员的初始化可以采用初始化表或函数体内赋值两种方式，，这两种方式的 效率不完全相同

非内部数据类型的成员对象应当采用第一种方式初始化，以获取更高的效率。例如

 class A

 {… A(void);    // 无参数构造函数 

A(const A &other);  // 拷贝构造函数 

A & operate =( const A&other); // 赋值函数

}； 

      class B 

{    public:  

B(const A &a); // B 的构造函数  

 private:   A  m_a;   // 成员对象

};

示例 9-2(a)中，类 B 的构造函数在其初始化表里调用了类 A 的拷贝构造函数，从而 将成员对象 m_a 初始化。

示例 9-2 (b)中，类 B 的构造函数在函数体内用赋值的方式将成员对象 m_a 初始化。 我们看到的只是一条赋值语句，但实际上 B 的构造函数干了两件事：先暗地里创建 m_a 对象（调用了 A 的无参数构造函数），再调用类 A 的赋值函数，将参数 a 赋给m_a。

 对于内部数据类型的数据成员而言，两种初始化方式的效率几乎没有区别，但后者 的程序版式似乎更清晰些。若类 F 的声明如下：

class F

{  

public:

 F(int x, int y);  // 构造函数  

private:  i

nt m_x, m_y; 

int m_i, m_j;  

};

示例 9-2(c)中 F 的构造函数采用了第一种初始化方式，示例 9-2(d)中 F 的构造函 数采用了第二种初始化方式。

2.  代码展示：

class String 
{
public:   String(const char *str = NULL); // 普通构造函数   
		  String(const String &other); // 拷贝构造函数   
		  ~ String(void);     // 析构函数   
		  String & operator = (const String &other); // 赋值函数   
private:   
	char   *m_data;    // 用于保存字符串 
}; 
// String 的普通构造函数		  
String::String(const char *str)
{
	if (str == NULL)
	{
		m_data = new char[1];
		*m_data = '\0';
	}
	else
	{
		int length = strlen(str);
		m_data = new char[length + 1];
		strcpy(m_data, str);
	}

}
// String 的析构函数
String::~String(void)
{
	delete[]m_data;//由于由于 m_data 是内部数据类型，也可以写成 delete m_data; 
}

// 拷贝构造函数
String::String(const String&other)
{
	//允许操作other的私有成员m_data;
	int length = strlen(other.m_data);
	m_data = new char[length + 1];
	strcpy(m_data, other.m_data);
	cout << "kaobeigouzao" << endl;
}
//赋值函数
String&String::operator = (const String &other)
{

	//检查自赋值
	if (this == &other)
		return*this;
	//释放原有的内存资源
	delete[]m_data;
	//分配新的内存资源，并复制内容
	int length = strlen(other.m_data);
	m_data = new char[length + 1];
	strcpy(m_data, other.m_data);
	//返回本对象的引用
	cout << "fuzhi" << endl;
	return *this;
	

}
void main()
{
	String a;//构造
	char *str = "fdsgfd";
	String b(a);//拷贝构造
	String c;//构造
	c = a;//赋值
	
}

类 String 拷贝构造函数与普通构造函数（参见 9.4 节）的区别是：在函数入口处无需与 NULL 进行比较，这是因为“引用”不可能是 NULL，而“指针”可以为 NULL。  类 String 的赋值函数比构造函数复杂得多，分四步实现：

（1）第一步，检查自赋值。你可能会认为多此一举，难道有人会愚蠢到写出 a = a 这样的自赋值语句！的确不会。但是间接的自赋值仍有可能出现，例如

也许有人会说：“即使出现自赋值，我也可以不理睬，大不了化点时间让对象复制自己而已，反正不会出错！

他真的说错了。看看第二步的 delete，自杀后还能复制自己吗？所以，如果发现自 赋值，应该马上终止函数。注意不要将检查自赋值的 if 语句 if(this == &other) 错写成为  if( *this == other)

（2）第二步，用 delete 释放原有的内存资源。如果现在不释放，以后就没机会了，将造成内存泄露。

（3）第三步，分配新的内存资源，并复制字符串。注意函数 strlen 返回的是有效字符串长度，不包含结束符‘\0’。函数 strcpy 则连‘\0’一起复制。

（4）第四步，返回本对象的引用，目的是为了实现象 a = b = c 这样的链式表达。注意不要将 return *this 错写成 return this 。那么能否写成 return other 呢？效果 不是一样吗？ 不可以！因为我们不知道参数other 的生命期。有可能 other 是个临时对象，在赋 值结束后它马上消失，那么 return other 返回的将是垃圾。

3. 如何在派生类中实现类的基本函数

基类的构造函数、析构函数、赋值函数都不能被派生类继承。如果类之间存在继承关系，在编写上述基本函数时应注意以下事项：

1.派生类的构造函数应在其初始化表里调用基类的构造函数。

   2.基类与派生类的析构函数应该为虚（即加 virtual 关键字）。例如

class Base
{
public:
	virtual ~Base()
	{
		cout << "~base" << endl;
	}
};
class Derived :public Base
{
public:
	 virtual~Derived()
	{
		cout << "~Derived" << endl;
	}

};
void main()
{
	Base*Pb = new Derived;
	delete Pb;
}

3.在编写派生类的赋值函数时，注意不要忘记对基类的数据成员重新赋值。例如：

class Base
{
public:
	Base&operator = (const Base&other);// 类 Base 的赋值函数 
private:
	int m_i, m_j, m_k;

};
class Derived :public Base
{
public:
	Derived &operator=(const Derived&other);
private:
	int m_x, m_y, m_z;
};
Derived&Derived::operator=(const Derived&other)
{
	//（1）检查自赋值  
	if(this == &other)   return *this;  
	//（2）对基类的数据成员重新赋值  
	Base::operator =(other); // 因为不能直接操作私有数据成员  
	//（3）对派生类的数据成员赋值  
	m_x = other.m_x;  m_y = other.m_y;  m_z = other.m_z;  
	//（4）返回本对象的引用  
	return *this;

}

参考资料：《高质量c++编程指南》