C++基础知识（一）构造函数与析构函数

一 构造函数

类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回void。构造函数可用于为某些成员变量设置初始值。

1. 构造函数的作用

构造函数的作用：初始化对象的数据成员

class Counter
{
private:
	//数据成员
	int m_value;

public:
	//类Counter的构造函数
	//以类型作为函数名，无返回类型
	Counter()
	{
		m_value = 0;
	}
};

当该类被创建时，编译系统对象分配内存空间，并自动调用该构造函数，由构造函数完成数据成员的初始化工作。

举例：Counter c1;

编译系统为对象c1的每个数据成员(m_value)分配内存空间，并调用构造函数Counter()自动的初始化对象c1的m_value值设置为0。

2. 构造函数的种类

class Complex
{
private:
	//数据成员
	double m_real;
	double m_imag;

public:
	//1.无参构造函数
	//如果创建一个类没有写任何构造函数，则系统会自动生成默认的无参构造函数，函数为空，什么都不做。
	//只要你写了一个下面的某一种构造函数，系统就不会再在自动生成这样一个默认的构造函数，如果希望有一个这样的无参构造函数，则需要自己显示地写出来。
	Complex(void)
	{
		m_real = 0.0;
		m_imag = 0.0;
	}

	//2.一般构造函数（重载构造函数）
	//一般构造函数可以有多种参数形式，一个类可以有多个一般构造函数，前提是其参数的个数或者类型不同（基于c++的重载函数原理）
	//例如：还可以写一个Complex(int num)的构造函数出来
	//创建对象时根据传入的参数不同，调用不同的构造函数
	Complex(double real, double imag)
	{
		m_real = real;
		m_imag = imag;
	}

	//3.复制构造函数（拷贝构造函数）
	//复制构造函数的参数为类的对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中
	//若没有显示的写复制构造函数，则系统会默认创建一个复制构造函数，但当类中有指针成员时，由系统默认创建该复制构造函数会存在风险，具体原因请查询有关“浅拷贝”、“深拷贝”的文章论述
	Complex(const Complex &c)
	{
		//将对象c中的数据成员的值复制过来
		m_real = c.m_real;
		m_imag = c.m_imag;
	}
	
	//4.类型转换构造函数
	//根据一个指定类型的对象来创建一个本类的对象
	//例如：下面将根据一个double类型的对象，创建一个Complex对象
	Complex(double r)
	{
		m_real = r;
		m_imag = 0.0;
	}

	//5.等号运算符重载
	//注意，这个类似复制构造函数，将等号(=)右边的本类对象的值复制给等号左边的对象，它不属于构造函数，等号左右两边的对象必须均已经被创建
	//若没有显示的写=运算符重载，则系统也会创建一个默认的=运算符重载，但只做一些基本的拷贝工作
	Complex &operator=(const Complex &rhs)
	{
		//首先检测等号右边的是否为左边的对象本身，若是对象本身则直接返回
		if(this == & rhs)
		{
			return *this;
		}

		//复制等号右边的成员到左边的对象中
		this->m_real = rhs.m_real;
		this->m_imag = rhs.m_imag;

		//把等号左边的对象再次传出，目的是为了支持连等
		//eg: a=b=c 系统首先运行 b=c，然后运行 a=(b=c的返回值，这里应该是复制c值后的b对象)
		return *this;
	}
};

1. 无参构造函数

• 如果创建一个类没有写任何构造函数，则系统会自动生成默认的无参构造函数，函数为空，什么都不做。
• 只要你写了一个下面的某一种构造函数，系统就不会再在自动生成这样一个默认的构造函数，如果希望有一个这样的无参构造函数，则需要自己显示地写出来。

2. 一般构造函数（重载构造函数）

• 一般构造函数可以有多种参数形式，一个类可以有多个一般构造函数，前提是其参数的个数或者类型不同（基于c++的重载函数原理）
• 例如：还可以写一个Complex(int num)的构造函数出来
• 创建对象时根据传入的参数不同，调用不同的构造函数

3. 复制构造函数（拷贝构造函数）

• 复制构造函数的参数为类的对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中
• 若没有显示的写复制构造函数，则系统会默认创建一个复制构造函数，但当类中有指针成员时，由系统默认创建该复制构造函数会存在风险，具体原因请查询有关浅拷贝、深拷贝的文章论述

4. 类型转换构造函数

• 根据一个指定类型的对象来创建一个本类的对象

5. 等号运算符重载

• 注意，这个类似复制构造函数，将等号(=)右边的本类对象的值复制给等号左边的对象，它不属于构造函数，等号左右两边的对象必须均已经被创建
• 若没有显示的写=运算符重载，则系统也会创建一个默认的=运算符重载，但只做一些基本的拷贝工作

下面使用上述定义的类对象来说明各个构造函数的用法：

void main()
{
	// 1.调用无参构造函数，数据成员初值被赋为指定值
	Complex c1;
	Complex c2 = Complex();

	// 2.调用一般构造函数，数据成员初值被赋为指定值
	Complex c3(1.0,2.5);
	Complex c4 = Complex(1.0,2.5);

	// 3.调用拷贝构造函数（有以下两种调用方式）
	Complex c5(c4);
	Complex c6 = c4; //注意和 = 运算符重载区分，这里等号左边的对象不是事先已经创建，故需要调用拷贝构造函数，参数为c4
	
	// 4.调用类型转换构造函数
	c2 = 5.2; //系统首先调用类型转换构造函数，将5.2创建为该类的临时对象，然后调用等号运算符重载，将该临时对象赋值为给c2
	
	// 5.调用 = 号运算符重载函数，把c3的数据成员的值赋值给c1
	c1 = c3; //由于c1已经被创建，故不会调用任何构造函数，只会调用 = 号运算符重载函数
}

运行上述代码后，对象的值如下：

//1.调用无参构造函数，数据成员初值被赋为指定值
c1.m_real = 0.0, c1.m_imag = 0.0
c2.m_real = 0.0, c2.m_imag = 0.0
//2.调用一般构造函数，数据成员初值被赋为指定值
c3.m_real = 1 , c3.m_imag = 2.5
c4.m_real = 1 , c4.m_imag = 2.5
//3.调用拷贝构造函数，参数为c4
c5.m_real = 1 , c5.m_imag = 2.5
c6.m_real = 1 , c6.m_imag = 2.5
//4.调用类型转换构造函数
c2.m_real = 5.2 , c2.m_imag = 0
//5.调用 = 号运算符重载函数，把c3的数据成员的值赋值给c1
c1.m_real = 1 , c1.m_imag = 2.5

3. 为什么复制构造函数中可以直接访问对象c的私有成员？

Complex(const Complex & c)
{
    //将对象c中的数据成员值复制过来
    m_real = c.m_real;
    m_imag = c.m_imag;
}

私有成员变量的概念：以private关键字声明，是类的实现部分，不对外公开，不能在对象外部访问对象的私有成员变量。然而，在实现拷贝构造函数和赋值符函数时，在函数里利用对象直接访问了私有成员变量。封装是编译期的概念，是针对类型而非对象的，在类的成员函数中可以访问同类型实例对象的私有成员变量。

针对上面的问题，举例进行说明：

为什么第26行和第32行代码可以编译通过，而第39行和第40行代码会产生编译错误？

class CTest {
public:
    CTest(int i);
    CTest(const CTest& rhs);
    CTest& operator=(const CTest& rhs);
    void printCTest(const CTest& rhs);
private:
	int value;
};

CTest::CTest(int i):value(i)
{
    cout<<"Contructor of CTest"<<endl;
}

CTest::CTest(const CTest& rhs):value(rhs.value)
{
    cout<<"Copy contructor of CTest"<<endl;
}

CTest& CTest::operator=(const CTest& rhs)
{
    cout<<"Assign function of CTest"<<endl;
    if(this == &rhs)
        return *this;
    value = rhs.value; //通过对象访问私有成员变量
    return *this;
}

void CTest::printCTest(const CTest& rhs)
{
    cout<<rhs.value<<endl; //通过对象访问私有成员变量
}

int main()
{
    CTest t = 1;
    CTest tt = 2;
    //cout<<t.value<<endl; //通过对象访问私有成员变量，编译错误
    //cout<<tt.value<<endl; //通过对象访问私有成员变量，编译错误
    t.printCTest(tt);
}

变量value符号的解析：
1. 确定符号的查找域
如第26行代码，当编译器发现value变量时，它会在value变量所属对象rhs的类域中寻找该符号。
2. 确定当前域中哪些符号可以访问
由第一步可知，当前查找的域是类域，而printCTest函数在CTest类体中，所以printCTest可以访问CTest类中的所有变量(包括私有成员变量)，因而value符号在CTest类域中被找到。如第39行代码，main函数不在CTest类体中，所以main函数不可以访问CTest类域中的私有成员变量。
3. 符号已查找到，编译通过
类成员变量的访问权限是编译器强加的，编译器可以找到value，通过编译，自然就可以访问到value变量的值。
4. 第26行代码中value符号的查找域不是对象rhs对应的作用域，C++编译器的实现是在对象rhs的类域查找value符号

5. 使用初始化列表来初始化字段

使用初始化列表来初始化字段：

CTest::CTest(int i):value(i)
{
    cout<<"Contructor of CTest"<<endl;
}

上面的语法等同于如下语法：

CTest::CTest(int i)
{
	value = i;
    cout<<"Contructor of CTest"<<endl;
}

假设有一个类C，具有多个字段X、Y、Z等需要进行初始化，同理的，您可以使用上面的语法，只需要在不同的字段使用逗号进行分隔，如下所示：

C::C( double a, double b, double c): X(a), Y(b), Z(c)
{
  ....
}
//等同于：
C::C( double a, double b, double c)
{
	X = a;
	Y = b;
	Z = c;
	....
}

4. 浅拷贝与深拷贝

在关于复制构造函数的描述中提到，如果没有自定义复制构造函数，则系统会创建默认的复制构造函数，但系统创建的默认复制构造函数只会执行“浅拷贝”，即将被拷贝对象的数据成员的值赋值给新创建的对象，若该类的数据成员中有指针成员，则会使得新的对象的指针所指向的地址与被拷贝对象的指针所指向的地址相同，在delete该指针时会导致两次重复delete而出错。下面是示例：

#include <iostream.h>
#include <string.h>

class Person
{
private:
	char *m_pName;
	
public:
	//构造函数
	Person(char *pN)
	{
		cout << "调用一般构造函数！\n";
		m_pName = new char[strlen(pN) + 1];
		//在堆中开辟一个内存块存放pN所指的字符串
		if(m_pName != nullptr)
		{
			//如果m_pName不是空指针，则把形参指针pN所指的字符串复制给它
			strcpy(m_pName, pN);
		}
 	}

	//系统创建的默认复制构造函数，只做位模式拷贝
	Person(Person &p)
	{
		//使两个字符串指针指向同一地址位置
		m_pName = p.m_pName;
	}
	
	~Person()
	{
		delete m_pName;
	}
};

void main()
{
	Person man("Jack");
	Person woman(man);
}

结果导致 man 和 woman 的指针都指向了同一个地址，函数结束析构时，同一个地址被delete两次。

下面自己设计复制构造函数，实现“深拷贝”，即不让指针指向同一地址，而是重新申请一块内存给新的对象的指针数据成员。

Person(Person &chs)
{
	//用运算符new为新对象的指针数据成员分配空间
	m_pName = new char[strlen(chs.m_pName) + 1];

	if(m_pName != nullptr)
	{
		//复制内容
		strcpy(m_pName, chs.m_pName);
	}
}

则新创建的对象的m_pName与原对象chs的m_pName不再指向同一地址了

二 析构函数

类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。
析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。
下面的实例有助于更好地理解析构函数的概念：

#include <iostream>
using namespace std;

class Line
{
public:
    void setLength(double len);
    double getLength();
    Line();   // 这是构造函数声明
    ~Line();  // 这是析构函数声明
    
private:
    double length;
};

// 成员函数定义，包括构造函数
//构造函数
Line::Line(void)
{
    cout << "Object is being created" << endl;
}
//析构函数
Line::~Line(void)
{
    cout << "Object is being deleted" << endl;
}

void Line::setLength(double len)
{
    length = len;
}

double Line::getLength()
{
    return length;
}

// 程序的主函数
int main( )
{
    Line line;
 
    // 设置长度
    line.setLength(6.0); 
    cout << "Length of line : " << line.getLength() <<endl;
 
    return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Object is being created
Length of line : 6
Object is being deleted

参考文章：

• c++构造函数详解
• c++ 类构造函数 & 析构函数
• 私有成员变量的理解