类的构造函数、析构函数与赋值函数

摘自林锐高质量C++编程

1. 每个类最基本的函数包括：构造函数、析构函数与赋值函数

    每个类只有一个析构函数和一个赋值函数，但可有多个构造函数（包含一个拷贝构造函数和若干普通构造函数）

例如String的结构如下：

class String
{
public:
String(const char *str = NULL); // 普通构造函数
String(const String &other); // 拷贝构造函数
~ String(void); // 析构函数
String & operate =(const String &other); // 赋值函数
private:
char *m_data; // 用于保存字符串
};

 

2. 构造函数有个特殊的初始化方式叫初始化表，它位于函数参数表之后，却在函数体{} 之前。这说明该表里的初始化工作发生在函数体内的任何代码被执行之前。
  初始化表的使用规则：
（1）如果类存在继承关系，派生类必须在其初始化表里调用基类的构造函数。例如：

class A
{…
A(int x); // A 的构造函数
};
class B : public A
{…
B(int x, int y);// B 的构造函数
};
B::B(int x, int y)
: A(x) // 在初始化表里调用A 的构造函数
{
…
}

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

（3）类的数据成员的初始化可以采用初始化表或函数体内赋值两种方式，这两种方式的效率不完全相同。
         非内部数据类型的成员对象应当采用第一种方式初始化，以获取更高的效率；对于内部数据类型的数据成员而言，两种初始化方式的效率几乎没有区别

 

3. 构造和析构的次序
构造从类层次的最根处开始，在每一层中，首先调用基类的构造函数，然后调用成员对象的构造函数。析构则严格按照与构造相反的次序执行，该次序是唯一的，否则编译器将无法自动执行析构过程。

 

4. 类String 的构造函数与析构函数

// 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;
}

5. 不要轻视拷贝构造函数与赋值函数

（1）如果不主动编写拷贝构造函数和赋值函数，编译器将以“位拷贝”的方式自动生成缺省的函数。倘若类中含有指针变量，那么这两个缺省的函数就隐含了错误。例如：

String a;
String b;
a.m_data =“hello”;
b.m_data =“world”.

 现将a 赋给b，缺省赋值函数的“位拷贝”意味着执行b.m_data = a.m_data。这将造成三个错误：一是b.m_data 原有的内存没被释放，造成内存泄露；二是b.m_data 和a.m_data指向同一块内存，a 或b 任何一方变动都会影响另一方；三是在对象被析构时，m_data 被释放了两次。

（2）拷贝构造函数是在对象被创建时调用的，而赋值函数只能被已经存在的对象调用

6. 类String 的拷贝构造函数与赋值函数

// 拷贝构造函数
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);
}

// 赋值函数
String & String::operate =(const String &other)
{
// (1) 检查自赋值
if(this == &other)
return *this;
// (2) 释放原有的内存资源
delete [] m_data;
// （3）分配新的内存资源，并复制内容
int length = strlen(other.m_data);
m_data = new char[length+1];
strcpy(m_data, other.m_data);
// （4）返回本对象的引用
return *this;
}

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

（2）用delete 释放原有的内存资源。

（3）分配新的内存资源，并复制字符串。

（4）返回本对象的引用，目的是为了实现链式表达。

7. 偷懒的办法处理拷贝构造函数与赋值函数

如果我们实在不想编写拷贝构造函数和赋值函数，又不允许别人使用编译器生成的缺省函数，偷懒的办法是：只需将拷贝构造函数和赋值函数声明为私有函数，不用编写代码。例如：

class A
{ …
private:
A(const A &a); // 私有的拷贝构造函数
A & operate =(const A &a); // 私有的赋值函数
};

如果有人试图编写如下程序：
A b(a); // 调用了私有的拷贝构造函数
b = a; // 调用了私有的赋值函数
编译器将指出错误，因为外界不可以操作A 的私有函数。

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

基类的构造函数、析构函数、赋值函数都不能被派生类继承。如果类之间存在继承关系，在编写上述基本函数时应注意以下事项：
(1)派生类的构造函数应在其初始化表里调用基类的构造函数。

(2)基类与派生类的析构函数应该为虚（即加virtual 关键字）

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

例如：

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