C++的诗行：类与对象（中）

类的默认成员函数

默认成员函数就是用户没有显式实现，编译器会自动生成的成员函数称为默认成员函数。⼀个类，我们不写的情况下编译器会默认生成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个，最后的取地址重载不重要我们稍微了解一下即可。

默认成员函数很重要，也比较复杂，我们要从两个方面去学习：

1. 我们不写时，编译器默认生成的函数行为是什么，可否满足我们的需求？
2. 当编译器默认生成的函数不满足我们的需求，我们需要实现时应该怎么实现呢？

1、构造函数

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象（我们常使用的局部对象是栈帧创建时，空间就开好了）而是对象实例化时初始化对象。

构造函数的本质是要替代我们以前Stack和Date类中写的Init函数的功能，构造函数自动调用的特点就完美地替代了Init。

构造函数的特点： 

1、函数名与类名相同且无返回值。（返回值啥也不需要，也不写void）比如以上图中的类类型为例：

全缺省构造函数：

Stack(int key= 3,int value=5)
{
    _key = key;
    _value = value;
}

无参构造函数：

Stack()
{
     _key = 5;
     _value = 6;
}

2、对象实例化时系统会自动调用相应的构造函数。

3、构造函数可以重载

4、一旦用户显式定义编译器便不在生成，如果没有显式定义的构造函数则C++编译器会自动生成一个无参的默认构造函数。编译器默认生成的构造对内置类型成员变量的初始化没有要求，也就是说是否初始化是不确定的，看编译器。

对于自定义类型（类类型）会调用它的默认构造函数进行初始化。如果这个自定义类型（类类型）成员变量没有默认构造函数，就会报错，我们要初始化这个成员变量，需要用初始化列表才可以解决。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

struct text
{
	string s1;
	int a;
	double b;

	text(int _a, int _b, const string& _s1)
		:s1(_s1)        //初始化列表初始化自定义类型（类类型）
		, a(_a)
		, b(_b)
	{}
};

int  main()
{
	text d1(4,5,"yuejianhua");
	cout << d1.a << " " << d1.b << " " << d1.s1 << endl;
	return 0;
}

5、无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数，都叫做默认构造函数。但是这三个函数有且只有⼀个存在，不能同时存在。无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义。

#define _CRT_SECURE_NO_WARNINGS	
#include<iostream>
using namespace std;

class Stack
{
public:
    //全缺省的构造函数
    Stack(int key= 3,int value=5)
    {
        _key = key;
        _value = value;
    }
   //无参构造函数
    Stack()
    {
        _key = 6;
        _value = 9;
    }
    void Print()
    {
        cout << _key << " " << _value << endl;
    }
private:
    //成员变量：
    int _key;
    int _value;
};

int main()
{
    //这里实例化对象的时候编译器无法确定去调用哪一个构造函数，所以会报错
    Stack d1;
    d1.Print();
    return 0;
}

报错提醒如下：

所以我们在显式实现构造函数时要么写成全缺省，要么写成无参二者不可同时存在。但是大概率我们选择全缺省构造函数，此时我们可以传参构造也可以不传参使用缺省值去构造

要注意很多初学者会认为默认构造函数是编译器默认生成那个叫默认构造，实际上无参构造函数、全缺省构造函数也是默认构造，总结⼀下就是不传实参就可以调用的构造就叫默认构造。

 说明：C++将类型分成内置类型（基本类型）和自定义类型。内置类型就是语言提供的原生数据类型，如：int/char/double/指针等，自定义类型就是我们使用class/struct等关键字自己定义的类型。

2、析构函数

析构函数与构造函数的功能相反，析构 函数不是完成对对象本身的销毁，比如局部对象是存在栈帧的。函数结束栈帧销毁，它就释放了，不需要我们管，C++规定对象在销毁时会自动调用析构函数，完成对资源的清理释放工作。

析构函数的功能类比我们之前学过的Destroy函数的功能，而像Date没有Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的。

析构函数的特点：

1.析构函数名是在类名前加上字符~。

2.无参数也无返回值。（也不需要加上void）

3.一个类只能有⼀个析构函数。若未显式定义，系统会自动生成默认的析构函数。

4.对象生命周期结束时，系统会自动调用析构函数。

5.跟构造函数类似，我们不写编译器自动生成的析构函数对内置类型成员不做处理，自定类型成员会调用它的析构函数。

6.还需要注意的是我们显式写析构函数，对于自定义类型成员也会调用他的析构，也就是说自定义类型成员无论什么情况都会自动调用自己的析构函数。

7.如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数；但是有资源申请时，一定要自己写析构函数，否则会造成资源泄露。

8.一个局部域的多个对象，C++规定后定义的先析构。

#define _CRT_SECURE_NO_WARNINGS	
#include<iostream>
using namespace std;
//这里先声明两个类
class teacher
{
public:
	teacher(size_t _a)
	{
		a = _a;
		_str = new char[a];
	}
	~teacher()
	{
		cout << "~teacher" << endl;
		delete[] _str;
		_str = nullptr;
	}
private:
	size_t a;
	char* _str;
};

class student
{
public:
	student(size_t _a)
	{
		a = _a;
		_str = new char[a];
	}
	~student()
	{
		cout << "~student" << endl;
		delete[] _str;
		_str = nullptr;
	}
private:
	size_t a;
	char* _str;
};

//在main函数结束后先析构student后析构teacher（后定义的先析构）
int main()
{
	teacher d1(4);
	student d2(3);
	return 0;
}

运行结果：

3、拷贝构造函数

如果一个构造函数的第一个参数是自生类类型的引用，且任何额外的参数都有默认值，则此构造函数也叫做拷贝构造函数，也就是说拷贝构造是一个特殊的构造函数。

拷贝构造的特点：

1.拷贝构造函数是构造函数的一个重载

2.拷贝构造函数的参数只有一个且必须是自身类类型对象的引用，使用传值方式编译器直接报错，因为传值传参会调用拷贝构造而拷贝构造中的传值传参又会调用拷贝构造....导致无穷递归调用。

3.C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以自定义类型传值传参和传值返回都会调用拷贝构造来完成。

4.若未显式定义拷贝构造，编译器会自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝（一个字节一个字节地拷贝），对自定义类型的成员变量会调用它的拷贝构造。

5.像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的拷贝构造就可以完成需要的拷贝，所以不需要我们显式实现拷贝构造。

像string这样的类，虽然也都是内置类型，但是_a指向了资源，编译器自动生成的拷贝构造完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝(对指向的资源也进行拷贝)。

 实现string类的深拷贝（对拷贝对象重新分配地址空间）

string(const string& ret)
		{

			_str = new char[ret._capacity + 1];
			strcpy(_str,ret._str);
			_size = ret._size;
			_capacity = ret._capacity;
		}

这里还有⼀个小技巧，如果⼀个类显式实现了析构并释放资源，那么他就需要显式写拷贝构造，否则就不需要。

6.传值返回会产生⼀个临时对象调用拷贝构造，传值引用返回，返回的是返回对象的别名(引用)，没有产生拷贝。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回是有问题的，这时的引用相当于⼀个野引用，类似⼀个野指针⼀样。

传引用返回可以减少拷贝，但是⼀定要确保返回对象，在当前函数结束后还在，才能用引用返回。

4、运算符重载

当运算符被用于类类型的对象时，C++语言允许我们通过运算符重载的方式指定新的含义。C++规定类类型的对象使用运算符时，必须转换成调用对应运算符重载，若没有对应的运算符重载，则会编译报错。

class text
{
public:
	text(size_t _d1)
	{
		d1 = _d1;
	}
private:
	size_t d1;
};

int main()
{
	text v1(5);
	text v2(6);
//这里没有+的运算符重载，就会编译报错
	size_t re = v1 + v2;
	cout << re << endl;
	return 0;
}

运算符重载是具有特定名字的函数，它的名字是由operator和后面要定义的运算符共同构成，和其他函数一样，他也具有其返回类型和参数列表以及函数体。

重载运算符函数的参数个数和该运算符作用的运算对象一样多。一元运算符有一个参数，二元运算符有两个参数，二元运算符的左侧运算对象传给第一个参数，右侧运算对象传给第二个参数。

如果一个重载运算符函数是一个成员函数，则他的第一个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少一个。

运算符重载后，其优先级和结合性与对应的内置类型运算符保持一致。

不能通过连接语法中没有的符号来创建新的操作符：比如operator@

重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，无法很好的区分。
C++规定，后置++重载时，增加⼀个int形参，跟前置++构成函数重载，方便区分：

Data& Data::operator ++()//前置++
{
	return (*this += 1);
}
Data Data::operator ++(int)//后置++
{
	Data temp(*this);
	*this += 1;
	return temp ;
}
Data& Data::operator --()//前置--
{
	return (*this -= 1);
}

Data Data::operator --(int)//后置--
{
	Data temp(*this);
	*this -= 1;
	return temp;
}

重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位
置，第⼀个形参位置是左侧运算对象，调用时就变成了 对象<<cout，不符合使用习惯和可读性。
重载为全局函数把ostream/istream放到第⼀个形参位置就可以了，第二个形参位置当类类型对象

下面是string的流插入/流提取运算符重载：

ostream& operator <<(ostream& out, const string& s)//要写不可以加const
	{
		for (auto ch : s)
		{
			out << ch;
		}
		return out;
	}
	istream& operator >>(istream& in, string& s1)//只读不写可以加const
	{
		s1.clear();
		const int N = 256;
		char buff[N];//创建buff的目的是防止连续的+=导致不断开空间导致代码效率低下
		int i = 0;
		char ch;
		ch=in.get();//用in>>ch时遇到空格时会忽略导致程序停不下来(默认提取不到空格和换行)
		while (ch != ' ' && ch != '\n')
		{
			buff[i++] = ch;
			if (i = N - 1)//说明buff中装满了
			{
				s1 += buff;
				buff[0] = '\0';
				i = 0;
			}
			ch = in.get();
		}
		if (i > 0)
		{
			s1 += buff;
			buff[0] = '\0';
			i = 0;
		}
		return in;
	}

备注：

重载操作符至少有一个类类型参数，不能通过运算符重载改变内置类型对象的含义，如：int operator +(int x,int y);。

⼀个类需要重载哪些运算符，是看哪些运算符重载后有意义，比如Date类重载operator -就有意
义，但是重载operator+就没有意义。

 .*   : :    sizeof   ?:    . 注意以上5个运算符不能重载。

4.1 赋值运算符重载

赋值运算符重载是一个运算符重载，规定必须重载为成员函数。赋值运算符重载的参数建议写成const 当前类类型引用，否则传值传参会有拷贝。

有返回值，且建议写成当前类类型引用，引用返回会提高效率，有返回值目的是为了支持连续赋值场景。

没有显式实现时，编译器会自动生成一个默认赋值运算符重载，默认赋值运算符重载行为与默认构造函数类似，对内置类型成员变量会完成值拷贝/浅拷贝（一个字节一个字节地拷贝），对自定义类型成员变量会调用它的拷贝构造。

class Date
{
public:
	Date(size_t year=1999,size_t month=1,size_t day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	bool operator ==(const Date& d)
	{
		return (_year == d._year) && (_month == d._month) && (_day==d._day);
	}
	bool operator !=(const Date& d)
	{
		return !(*this == d);
	}
	Date& operator =(const Date& d1)
	{
		//不能是自己给自己赋值！
		if (*this != d1)
		{
			_year = d1._year;
			_month = d1._month;
			_day = d1._day;
		}
		return *this;//有返回值是为了支持连续赋值
	}
private:
	size_t _year;
	size_t _month;
	size_t _day;
};

4.2、取地址运算符重载

取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，⼀般这两个函数编译器自动生成的就可以够我们用了，不需要去显式实现。除非一些很特殊的场景，比如我们不想让别人取到当前类对象的地址，就可以自己实现一份，胡乱返回一个地址。

class Date
{
public:
	//成员函数：
	Date* operator &()
	{
		return this;
	}

	const Date* operator&()const
	{
		return this;
	}
private:

	size_t year=1999;
	size_t month=1;
	size_t day=1;

};

5、const成员函数

将const修饰的成员函数称为const成员函数，const修饰成员函数将const放到参数列表的后面

const 实际修饰的是该成员函数隐含的this指针，表明在该成员函数中不可以对类中的任何成员进行修改。

const修饰Date类的Print成员函数，Print隐含的this指针由Date* const this 变为const Date* const this。

class Date
{
public:
	Date(size_t year=1999,size_t month=1,size_t day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	bool operator ==(const Date& d)
	{
		return (_year == d._year) && (_month == d._month) && (_day==d._day);
	}
	bool operator !=(const Date& d)
	{
		return !(*this == d);
	}
	//
	void Print()const
	{
		cout << _year << " " << _month << " " << _day<< endl;
	}
	Date& operator =(const Date& d1)
	{
		//不能是自己给自己赋值！
		if (*this != d1)
		{
			_year = d1._year;
			_month = d1._month;
			_day = d1._day;
		}
		return *this;
	}
private:
	size_t _year;
	size_t _month;
	size_t _day;
};