c++构造函数/析构函数/拷贝构造函数/赋值运算符/const成员函数详述

1.类的6个默认成员函数

当一个类中什么都没有写的时候，称之为空类，空类包含6个默认的成员函数。这6个默认的成员函数不是用户生成的，而是编译器自己生成。6个默认的成员函数：构造函数（初始化对象）、析构函数（对象销毁时清理对象中的资源）、拷贝构造函数、赋值运算符重载、取地址重载。

2. 构造函数

2.1 概念
对于以下日期类：

class Data
{
    
    
public:
	void SetData(int year, int month, int day)
	{
    
    
		_year = year;
		_month = month;
		_day = day;
	}

	void PrintData()
	{
    
    
		cout << _year << "-" << _month << "-" << _day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
    
    
	Data d1;
	d1.SetData(2020, 8, 2);//实际调用Data::SetData(&d, 2020, 8, 2);
	d1.PrintData();
	return 0;
}

  对于Date类，可以通过SetDate公有的方法给对象设置内容，但是如果每次创建对象都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？
  构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。

2.2 特性
  构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

构造函数有以下几点特征：
1. 函数名和类名相同
2. 无返回值，即使加void也不行
3. 对象实例化时编译器自动调用对应的构造函数，并且在对象的生命周期内只调用一次
4. 构造函数可以重载

作用：主要是创建对象时完成对当前对象的初始化，不负责给对象开辟空间。

class Date
{
    
    
public:
	// 1.无参构造函数
	Date()
	{
    
    }
	// 2.带参构造函数
	Date(int year, int month, int day)
	{
    
    
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
void TestDate()
{
    
    
	Date d1; // 调用无参构造函数
	Date d2(2015, 1, 1); // 调用带参的构造函数
						 // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
						 // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
	Date d3();
}

5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
6. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数。
7. 关于编译器生成的默认成员函数，很多童鞋会有疑惑：在我们不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象year/month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么卵用？？

  解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语法已经定义好的类型：如int/char…，自定义类型就是我们使用class/struct/union自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数。

8. 初始化列表是构造函数的特性，用户没有显示出时，初始化列表仍旧存在，只不过比编译器会对成员变量进行默认的初始化（用户没有显示时，相当于编译器自动将初始化列表添加出来）。内置类型成员变量，编译器会将其初始化为随机值。类类型对象，编译器会调用对应类的无参构造函数或者是全缺省的构造函数初始化该成员，如果该类型没有无参或者全缺省的构造函数，则编译器会报错，类中没有默认的构造函数的错误。
   举例：如果类A中包含有类B的对象，并且类B对象是带有参数的构造函数，没有无参的或者是全缺省的构造函数，则必须在类A中完成对类B对象的初始化工作。

class Time
{
    
    
public:
	Time()
	{
    
    
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
    
    
private:
	//如果用户没有显示定义构造函数，编译器才会生成一个默认的构造函数
	// 基本类型(内置类型)
	int _year;
	int _month;
	int _day;
	// 自定义类型
	Time _t;
};
int main()
{
    
    
	Date d;
	return 0;
}

3.析构函数

3.1 概念
前面通过构造函数的学习，我们知道一个对象时怎么来的，那一个对象又是怎么没呢的？
析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。

3.2 特性

• 析构函数名是在类名前加上字符 ~。
• 无参数无返回值，因此不能构成重载。
• 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
• 对象生命周期结束时，C++编译系统系统自动调用析构函数。

class String 
{
    
    
public:
	String(const char* str = "")
	{
    
    
		if (nullptr == str)
			str = "";

		_str = (char*)malloc(strlen(str)+1);
		strcpy(_str, str);
	}
	
	//构造函数中申请了空间，需要在析构函数中释放空间
	~String()
	{
    
    
		if (_str)
		{
    
    
			free(_str);
			_str = nullptr;
		}
	}

private:
	char* _str;
};

void TestString()
{
    
    
	String s1;
	String s2("hello");
}

class Person
{
    
    
private:
	String _name;
	int _age;
};

void TestPerson() 
	//在构造Person对象p时，从汇编代码中能看到，编译器给Person类生成了一个默认的构造函数
	//而生成的默认构造函数中，主要调用了String类的构造函数，目的就是对p对象中所包含的String类型的name来初始化
	//并且调是不能直接调用call Sting(),因为还需继续调用Person的构造函数，来完成Person对象中所包含的
	//string类型的name的初始化，因此编译器给Person生成了一个默认的构造函数

	//在p对象销毁时，因为p对象中包含有String类型的name，name中管理资源，因此必须要调用String类的析构函数
	//完成p对象中所包含的String类型的name的资源清理工作
	//但是在函数退出时，不能直接调用String类的析构函数，因为现在析构的是Person类的对象，直接调用String类的讲不通
	//因此编译器给Person类生成了一个默认的析构函数，在默认的析构函数中调用String类的析构函数，完成对P对象中name所包含的String类型的资源清理工作

	//编译器给Person类生成的析构函数 
	/*~person()
	{
		call ~String();//清理person类对象中包含的string类型成员name中的资源
	}*/
	Person p;
}

  如果用户没有显示提供Person类的析构函数则编译器给Person类生成一个默认的析构函数，在析构函数中完成对Person对象中资源的清理工作。

4 拷贝构造函数

  拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

特征
拷贝构造函数也是特殊的成员函数，其特征如下：

1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。

class Data
{
    
    
public:
	Data(int year = 1900, int month = 1, int day = 1)
	{
    
    
		_year = year;
		_month = month;
		_day = day;
	}

	//拷贝构造函数
	//特殊的构造函数，一定是单参的，参数必须是类类型对象的引用（一般情况下加const）
	//在使用已存在的对象创建新对象时，由编译器自动调用
	//一般拷贝不需要通过外部的形参改变外部的实参，最好用const进行修饰
	Data(const Data& d)
	{
    
    
		_year = d._year;
		_month = d._month;
		_day = d._day;
		cout << this << ":" << &d << endl;
	}

	~Data()
	{
    
    
		//对于Data类析构函数写不写都无所谓，一般情况下我们都不写
		//因为析构函数一般清理当前对象中的资源，而Data类中没有涉及到资源管理
		//该析构函数看用户是否需要，用默认的或者自己给出
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
    
    
	Data d1(2020, 8, 7);
	
	//d1初识化d2
	//d2是新创建的对象，既然新创建了对象就需要调用构造函数 
	//因为是用已经存在的d1创建新对象d2，所以要调用拷贝构造函数
	Data d2(d1);
	return 0;
}

3. 若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝。

class Data
{
    
    
public:
	Data(int year = 1900, int month = 1, int day = 1)
	{
    
    
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
    
    
	Data d1(2020, 8, 7);
	//Data类没有显示提供拷贝构造函数，但是d2对象创建成功后，d2对象中的内容和d1对象中的内容相同
	//用已经存在对象d1拷贝构造新对象d2---调用的就是编译器生成的默认的拷贝构造函数
	//编译器给data类生成的默认的拷贝构造函数已经能够完成拷贝的构造
	//编译器生成拷贝构造函数：值得拷贝（内存）：将一个对象中的内容原封不动的拷贝到新对象中
	
	//对于Data类：使用编译器生成的默认构造函数没有问题
	//Data的拷贝构造函数写不写都可以
	Data d2(d1);
	return 0;
}

4. 发现：Data类拷贝构造是否存在不会影响最后的拷贝；
   问题：是否任何类的拷贝构造函数都可以不用提供拷贝构造函数，编译器都会生成一个默认的拷贝构造函数。

class String
{
    
    
public:
	String(const char* str = "")
	{
    
    
		if (nullptr == str)
			str = "";

		_str = (char*)malloc(strlen(str)+1);
		strcpy(_str, str);
	}

	~String()
	{
    
    
		if (_str)
			free(_str);
	}

private:
	char* _str; 
};

int main()
{
    
    
	//用s1拷贝构造s2，肯定要调用拷贝构造函数
	//因为String类没有显示提供拷贝构造函数，则使用的是编译器生成的默认的拷贝构造函数
	//而默认的拷贝构造函数是按照值得方式进行拷贝，即：将s1对象中的内容原封不动的拷贝新对象中
	String s1("hello");
	String s2(s1);
	return 0;
}

理由如下：

  编译器生成的拷贝构造函数默认情况下就是按照浅拷贝的方式生成的。将一个对象中的资源原封不动的拷贝到另一个对象中，导致另一个对象共享同一份资源，在对象被销毁时将该资源释放多次而引起程序崩溃。
因此：如果类中涉及到资源管理时，必须要显示给出拷贝构造函数
比如：
Data类：拷贝构造函数是否提供都可以。
String类：拷贝构造函数必须要显式给出，因为编译器生成的拷贝构造函数是按照浅拷贝的方式生成的。

5.赋值运算符重载

运算符重载

1. C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
2. 函数名字：关键字operator后面接需要重载的运算符符号。
3. 函数原型：返回值类型 operator操作符(参数列表)。

总结

• 作用：为了提高代码的可读性
• 注意：与函数重载不同–运算符重载和函数重载是两个不同的概念。
• 什么情况下需要对一个运算符进行重载？
  一般都是针对的是自定义类型的对象，因为内置类型所有的运算符操作编译都支持，而自定义类型的对象中可能包含有多个成员，在进行相应的运算符操作时，编译器不知道该如何操作，为了告诉编译器如何进行操作，因此引入了运算符重载。

class Data
{
    
    
public:
	Data(int year = 1900, int month = 1, int day = 1)
	{
    
    
		_year = year;
		_month = month;
		_day = day;
	}

	//isLess是一个成员函数，需要Data类型的对象进行调用
	//注意：isLess函数参数也可以是值的方式，只不过按照值的方式传参，在传参时按照值的方式进行，在传参时会创建一个临时对象，会影响运行效率
	//一般情况下：类类型作为函数的参数时，一般都是按照引用的方式进行传参，如果不需要通过形参改变外部实参，需要加上const
	bool isLess(const Data& d)
	{
    
    
		if ((_year < d._year) || (_year == d._year && _month < d._month)
			|| (_year == d._year && _month == d._month && _day < d._day))
		{
    
    
			return true;
		}
		return false;
	}

	//< 运算符的重载
	bool operator<(const Data& d)
	{
    
    
		if ((_year < d._year) || (_year == d._year && _month < d._month)
			|| (_year == d._year && _month == d._month && _day < d._day))
		{
    
    
			return true;
		}
		return false;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
    
    
	Data d1(2020, 8, 7);
	Data d2(2020, 8, 8);

	//Data是用户自定义的类型，自定义类型包含多个成员变量，编译器不知道按照什么规则进行比较
	//法1.告诉编译器如何对日期类型的对象进行比较，对<进行运算符重载
	if (d1 < d2)
		cout << "d1 < d2" << endl;

	//法2. 提供了一个公有的函数来进行比较
	if (d1.isLess(d2))
	{
    
    
		cout << "d1 < d2" << endl;
	}
	return 0;
}

输出结果：
注意：

• 不能通过连接其他符号来创建新的操作符：比如operator@；
• 重载操作符必须有一个类类型或者枚举类型的操作数；
• 用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不 能改变其含义；
• 作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的操作符有一个默认的形参this，限定为第一个形参；
• .* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。以下是常见的操作符重载表：

补充++操作：

class Data
{
    
    
public:
	Data(int year = 1900, int month = 1, int day = 1)
	{
    
    
		_year = year;
		_month = month;
		_day = day;
	}
	Data(const Data& d)
	{
    
    
		_year = d._year;
		_month = d._month;
		_day = d._day;

		cout << "Data(const Data& d):" << this << endl;
	}

	//执行的是前置++操作
	Data& operator++()
	{
    
    
		_day += 1;
		return *this;
	}

	//后置++
	//注意：temp是函数栈上的对象，当函数退出时，temp就要被销毁掉
	//因此后置++的函数返回值不能使用引用的方式进行返回，只能按照值的方式进行返回
	//语法为了区分后置++和前置++运算符重载的区别
	//最终在后置++的参数列表中增加了一个int类型的参数,在实际函数调用中int类型参数不会使用
	Data operator++(int)
	{
    
    
		Data temp(*this);
		_day += 1;
		return temp;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
    
    
	Data d1(2020, 8, 8);
	Data d2;

	d2 = ++d1;//d2 = d1.operator++();

	d2 = d1++;//相当于d2 = d1.operator++(0);
	return 0;
}

赋值运算符重载
如果用户没有显示定义，则编译器会生成一份默认的赋值运算符重载函数；
注意：编译器是按照浅拷贝的方式生成的赋值运算符重载，如果类中没有涉及到资源管理，赋值运算符重载是否提供或者使用编译器生成的默认的赋值运算符重载时没有任何问题的，比如Data类；如果类中涉及到资源管理时，则用户必须显示提供赋值运算符重载，否则就会导致1.、资源泄漏，2、同一份资源被多个对象共享，在对象销毁时会进行多次释放，导致程序崩溃。

实例：“=”运算符的重载

//必须要有返回值：目的是为了支持连续赋值
Date& operator=(const Date& d)
{
    
    
	//避免自己给自己赋值--区分this和d是否是同一个对象
	if (this != &d)
	{
    
    
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	return &*this;
}

总结赋值运算符主要有四点：

1. 参数类型
2. 返回值
3. 检测是否自己给自己赋值
4. 返回*this
5. 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。

6 const成员

const修饰类的成员函数
  将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

在C语言中，被const修饰的是一个不能被修改的变量。测试：const int a = 10; int array[a];//编译报错
在C++中，被const修饰的已经是一个常量，而且具有宏替换的属性。

void TestConst()
{
    
    
	const int a = 10;
	int* pa = (int*)&a;

	*pa = 100;
	cout << a << endl;//10 但是a的值已经是100，原因是在编译阶段，编译器已经将a用10替换了
	cout << *pa << endl;//100
}

const修饰常量的替换发生在编译阶段，会参与参数类型的检测，代码的安全性更高。在C++中建议使用const修饰的常量代替宏常量。
在C++中，const也可以修饰类的成员：

1. const修饰类的成员变量，表明该成员变量不能被修改。
2. const修饰类的成员函数，称为const类型的成员函数。

class Date
{
    
    
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
    
    
		_year = year;
		_month = month;
		_day = day;
	}

	//被const修饰的成员函数称为const类型的成员函数
	//const成员函数中不能修改类的“成员函数”
	//const本质上修饰的是成员函数隐藏的this指针
	//表示：this指针指向的空间中的内容不能被修改，即：this指向当前对象不能修改
	void PrintDate()const
	{
    
    
		
		cout << _year << "-" << _month << "-" << _day << endl;
		//_day++;//被const修饰，不能被修改
		cout << typeid(this).name() << endl;
	}

	//const在返回值类型之前，修饰的是该函数的返回值
	//普通成员函数中，可以修改this指向的当前对象的属性信息
	const Date& GetDate()
	{
    
    
		_day++;
		cout << typeid(this).name() << endl;
		return *this;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
    
    
	Date d(2020,8,8);
	d.PrintDate();
	d.GetDate();
	return 0;
}

结果：
C++的人性化：
理论上，被const修饰的成员函数中不能修改任何的"成员变量"，但有些情况下，可能需要在const成员函数中修改个别成员变量。可以再成员变量之前加mutable，例如mutable int _day;表明该成员变量可以在const成员函数中被修改

几点说明：

1. const类型对象可以调用普通类型的成员函数吗?
   const类型的对象，即对象的成员不能被修改，假若调用了普通类型的成员函数，有可能被修改。因此const类型的对象只能调用const类型的成员函数，不能调用普通类型的成员函数。
2. 非const对象可以调用const成员函数吗？
   普通类型的对象可以修改也可以不修改，非const类型的对象对于普通成员函数和const类型的成员函数都可以进行调用。
3. const成员函数内可以调用其他非const成员函数吗？
   const成员函数中不能调用普通类型的成员函数，普通类型的成员函数可以是被修改的，与const成员函数相违背。
4. 非const成员函数内可以调用其他的const成员函数吗？
   可以。 普通类型的成员函数的成员变量可以修改，也可以不修改，因此可以调用const类型的成员函数。