c++-类（中）

一、类的默认成员函数

1.1 什么是默认成员函数？

默认成员函数就是⽤户没有显式实现，编译器会⾃动⽣成的成员函数称为默认成员函数。 ⼀个类，我们不写的情况下编译器会默认⽣成以下6个默认成员函数

1.2 默认成员函数有哪些？

1、构造函数与析构函数
2、拷贝构造函数
3、赋值操作符重载
4、取地址运算符重载
5、const修饰的取地址操作符重载。

二、构造函数

2.1 什么是构造函数？

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使⽤的局部对象是栈帧创建时，空间就开好了)，⽽是对象实例化时初始化对象。 它类似于我们之前在顺序表和链表部分的初始化函数。

这句话是什么意思呢？

class person
{
public:person()//无参数的构造函数{_age = 0;_num = 0;_height = 0.0;}
private:int _age;//年龄int _num;//电话号码float _height;//身高
};int main()
{person a;//在有了类的对象后，才会调用构造函数//就是初始化a的成员变量return 0;
}

如果我们不写，编译器默认的构造函数初始化是不确定的

2.2 构造函数的特点

1. 函数名与类名相同。
2. ⽆返回值。 (返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)
3. 对象实例化时系统会⾃动调⽤对应的构造函数。
4. 构造函数可以重载。
5. 如果类中没有显式定义构造函数，则C++编译器会⾃动⽣成⼀个⽆参的默认构造函数，⼀旦⽤⼾显式定义编译器将不再⽣成。
6. ⽆参构造函数、全缺省构造函数、我们不写构造时编译器默认⽣成的构造函数，都叫做默认构造函数。 但是这三个函数有且只有⼀个存在，不能同时存在。⽆参构造函数和全缺省构造函数虽然构成函数重载，但是调⽤时会存在歧义。要注意很多同学会认为默认构造函数是编译器默认⽣成那个叫默认构造，实际上⽆参构造函数、全缺省构造函数也是默认构造，总结⼀下就是不传实参就可以调⽤的构造就叫默认构造。
7. 我们不写，编译器默认⽣成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始化是不确定的，看编译器。 对于⾃定义类型成员变量，要求调⽤这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要⽤初始化列表才能解决。

什么意思呢？就如下面的代码；

class stack
{
private:int* arr;int size;int capacity;
public:stack(int n = 4){int* arr = (int*)malloc(sizeof(int) * n);size = 0;capacity = n;}
};class Myqueue
{
private:stack st1;//这里自动调用ST的默认构造，如果ST没有默认构造，那么就会报错stack st2;int size;//size在这里可能会被初始化，也有可能不被初始化，看编译器
};int main()
{Myqueue mq;return 0;
}

说明：C++把类型分成内置类型(基本类型)和⾃定义类型。内置类型就是语⾔提供的原⽣数据类型，如：int/char/double/指针等，⾃定义类型就是我们使⽤class/struct等关键字⾃⼰定义的类型。

虽然说我们不写构造函数，编译器也会自动生成构造函数，但是生成的构造函数，大多数情况下都不能满足我们的需求，所以一般情况我们都会自己写。

构造函数怎么写呢？下面是它的三种写法：

class person
{
public://person()//无参数的构造函数//{//	_age = 0;//	_num = 0;//	_height = 0.0;//}//person(int age, int num, float height)//带参的构造函数//{//	_age = age;//	_num = num;//	_height = height;//}person(int age = 0, int num = 0, float height = 0)//全缺省的构造函数{_age = age;_num = num;_height = height;}void print(){cout << _age << endl;cout << _num << endl;printf("%.1f", _height);}
private:int _age;//年龄int _num;//电话号码float _height;//身高
};int main()
{//调用无参的person a();这种方式是错误的//person a;//调用无参的构造//a.print();//person b(1, 2, 3);//带参的//b.print();//调用全缺省的,这两种方式都正确person c(1, 2, 3);person d;d.print();c.print();//所以我们更建议大家写全缺省的构造函数return 0;
}

总结：构造函数应写尽写。

三、析构函数

3.1 什么是析构函数？

析构函数与构造函数功能相反，析构函数不是完成对对象本⾝的销毁，⽐如局部对象是存在栈帧的，函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会⾃动调⽤析构函数，完成对象中资源的清理释放⼯作。 析构函数的功能类⽐我们之前Stack实现的Destroy功能。

class stack
{
private:int* arr;int size;int capacity;
public:stack(int n = 4){int* arr = (int*)malloc(sizeof(int) * n);//需要我们手动销毁size = 0;capacity = n;}
};

如果我们没有申请空间的话，编译器给的析构函数完全够用，但是在这里我们申请了空间，所以我们需要自己写析构函数，否则会造成内存泄漏。

3.2 析构函数的特点

1. 析构函数名是在类名前加上字符 ~。
2. ⽆参数⽆返回值。 (这⾥跟构造类似，也不需要加void)
3. ⼀个类只能有⼀个析构函数。若未显式定义，系统会⾃动⽣成默认的析构函数。
4. 对象⽣命周期结束时，系统会⾃动调⽤析构函数。
5. 跟构造函数类似，我们不写编译器⾃动⽣成的析构函数对内置类型成员不做处理，⾃定类型成员会调⽤它的析构函数。

什么意思呢，比如我们上面我们的queue是由两个栈来构成的，如果我们不写queue的析构，它也会调用stack的析构函数。

6. 还需要注意的是我们显⽰写析构函数，对于⾃定义类型成员也会调⽤他的析构，也就是说⾃定义类型成员⽆论什么情况都会⾃动调⽤析构函数。（所以这里我们写不写都可以,但是如果有额外空间开辟的一定要自己写，防止内存泄漏）
7. ⼀个局部域的多个对象，C++规定后定义的先析构。

class stack
{
private:int* arr;int size;int capacity;
public:stack(int n = 4){arr = (int*)malloc(sizeof(int) * n);size = 0;capacity = n;}~stack(){free(arr);arr = nullptr;size = 0;//这一步可以不写，因为生命周期到了，size、capacity也被销毁了capacity = 0;}
};int main()
{stack st1;stack st2;//先销毁return 0;
}

四、拷贝构造函数

4.1 什么是拷贝构造函数？

如果⼀个构造函数的第⼀个参数是⾃⾝类类型的引⽤，且任何额外的参数都有默认值，则此构造函数也叫做拷⻉构造函数，也就是说拷⻉构造是⼀个特殊的构造函数。
它的作用就是用类的其他对象来初始化当前创建的对象
例如：

class date
{
private:int _year;int _mouth;int _day;
public:date(int year = 1, int mouth = 1, int day = 1){_year = year;_mouth = mouth;_day = day;}date(const date& d){_year = d._year;//前面的是当前创建的对象的成员_mouth = d._mouth;//后面的是被用作初始化的对象的成员_day = d._day;}void print(){cout << _year << ':' << _mouth << ':' << _day << endl;}
};int main()
{date d1(2024, 8, 22);//这里使用构造函数里的初始化值初始化d1.print();date d2(d1);//这里是使用类的对象来初始化当前对象d2.print();return 0;
}

4.2 拷贝构造函数的特点

1. 拷⻉构造函数是构造函数的⼀个重载。

date(int year = 1, int mouth = 1, int day = 1){_year = year;_mouth = mouth;_day = day;}date(const date& d){_year = d._year;//前面的是当前创建的对象的成员_mouth = d._mouth;//后面的是被用作初始化的对象的成员_day = d._day;}

大家可以看到拷贝构造函数名跟构造函数一样，并且两者都做的初始化操作，所以
拷贝构造函数是构造函数的重载。

2. 拷⻉构造函数的第⼀个参数是⾃⾝类类型的引⽤，使⽤传值⽅式编译器直接报错，因为语法逻辑上会引发⽆穷递归调⽤。

date(const date& d)//date(const date d);//错误的

为什么呢？

class date
{
private:int _year;int _mouth;int _day;
public:date(int year = 1, int mouth = 1, int day = 1){_year = year;_mouth = mouth;_day = day;}date(const date& d)//最好加上const，防止我们的疏忽造成修改，{_year = d._year;//前面的是当前创建的对象的成员_mouth = d._mouth;//后面的是被用作初始化的对象的成员_day = d._day;}void print(){cout << _year << ':' << _mouth << ':' << _day << endl;}
};void fuck(date d)
{d.print();
}
int main()
{date a(2024, 8, 22);//C++规定传值传参，先调用拷贝构造fuck(a);//这里并不是直接调用我们的fuck函数，而是先调用拷贝构造return 0;
}

假如我们传值调用的话，那就会引起我们的无穷递归。

所以这里必须加上引用“&”。

3. C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥⾃定义类型传值传参和传值返回都会调⽤拷⻉构造完成。

4. 若未显式定义拷⻉构造，编译器会⽣成⾃动⽣成拷⻉构造函数。⾃动⽣成的拷⻉构造对内置类型成员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的拷⻉构造。
   

5. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷⻉构造就可以完成需要的拷⻉，所以不需要我们显⽰实现拷⻉构造。像Stack这样的类，虽然也都是内置类型，但是 _arr指向了资源，编译器⾃动⽣成的拷⻉构造完成的值拷⻉/浅拷⻉不符合我们的需求，所以需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉) 。像MyQueue这样的类型内部主要是⾃定义类型Stack成员，编译器⾃动⽣成的拷⻉构造会调⽤Stack的拷⻉构造，也不需要我们显⽰实现MyQueue的拷⻉构造。这⾥还有⼀个⼩技巧，如果⼀个类显⽰实现了析构并释放资源，那么他就需要显⽰写拷⻉构造，否则就不需要。

这里由于篇幅原因我就不放代码了，我给大家看一下如果我们使用编译器自己的拷贝构造函数去拷贝我们的栈的结果：

大家可以看到两个数组的地址是一样的，这块同样的空间就会重复析构两次，所以会出现程序崩溃。

那我们如何写深拷贝呢？

这样就可以了。

6. 传值返回会产⽣⼀个临时对象调⽤拷⻉构造，传值引⽤返回，返回的是返回对象的别名(引⽤)，没有产⽣拷⻉。 但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使⽤引⽤返回是有问题的，这时的引⽤相当于⼀个野引⽤，类似⼀个野指针⼀样。传引⽤返回可以减少拷⻉，但是⼀定要确保返回对象，在当前函数结束后还在，才能⽤引⽤返回。

这一段话的意思我们用图片来理解

最后我再介绍拷贝构造的另一种写法

int main()
{stack st1(4);st1.push(1);st1.push(2);stack st2(st1);stack st2 = st1;//这个也是拷贝构造return 0;
}

这样写也是ok的，自己想咋写就咋写。那这一块我们就算是完成了。

五、赋值运算符重载

5.1 运算符重载

1、当运算符被⽤于类类型的对象时，C++语⾔允许我们通过运算符重载的形式指定新的含义。C++规定类类型对象使⽤运算符时，必须转换成调⽤对应运算符重载，若没有对应的运算符重载，则会编译报错。
2、运算符重载是具有特名字的函数，他的名字是由operator和后⾯要定义的运算符共同构成。和其他函数⼀样，它也具有其返回类型和参数列表以及函数体。
例如

bool operator==(date d1, date d2)
{return d1.getyear() == d2.getyear() &&d1.getmouth() == d2.getmouth() &&d1.getday() == d2.getday();
}

3、重载运算符函数的参数个数和该运算符作⽤的运算对象数量⼀样多。⼀元运算符有⼀个参数，⼆元运算符有两个参数，⼆元运算符的左侧运算对象传给第⼀个参数，右侧运算对象传给第⼆个参数。
4、如果⼀个重载运算符函数是成员函数，则它的第⼀个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数⽐运算对象少⼀个。
例如：
类外：

bool operator==(date d1, date d2)
{return d1.getyear() == d2.getyear() &&d1.getmouth() == d2.getmouth() &&d1.getday() == d2.getday();
}

类内：

bool operator==(date d2){return _year == d2._year &&_mouth == d2._mouth &&_day == d2._day;}

5、运算符重载以后，其优先级和结合性与对应的内置类型运算符保持⼀致。
6、1、“ . * ” 2、“ ：：” 3、“ sizeof ” 4、“ ？： ” 5、“ . ”注意以上5个运算符不能重载。
7、重载操作符⾄少有⼀个类类型参数，不能通过运算符重载改变内置类型对象的含义，如： int operator+(int x, int y)
8、重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，⽆法很好的区分。C++规定，后置++重载时，增加⼀个int形参，跟前置++构成函数重载，⽅便区分。
9、重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位置，第⼀个形参位置是左侧运算对象，调⽤时就变成了 对象<<cout，不符合使⽤习惯和可读性。重载为全局函数把ostream/istream放到第⼀个形参位置就可以了，第⼆个形参位置当类类型对象。

总结：
运算符重载有两种调用方式，一种在类外：

class date
{
private:int _year;int _mouth;int _day;
public:date(int year = 1, int mouth = 1, int day = 1){_year = year;_mouth = mouth;_day = day;}int getyear(){return _year;}int getmouth(){return _mouth;}int getday(){return _day;}
};bool operator==(date d1, date d2)
{return d1.getyear() == d2.getyear() &&//因为我们比较的是对象的私有成员d1.getmouth() == d2.getmouth() &&//而在类外不能直接获取类的私有成员d1.getday() == d2.getday();//所以需要一个get函数来获取我们的私有成员。
}int main()
{date x1(2024, 8, 21);date x2(2024, 8, 22);//operator==(x1, x2);//显示调用x1 == x2;//这样写也会转换为上面的显示调用return 0;
}

在类内：

class date
{
private:int _year;int _mouth;int _day;
public:date(int year = 1, int mouth = 1, int day = 1){_year = year;_mouth = mouth;_day = day;}bool operator==(date d2)//因为在类内第一个参数一定是我们的this指针，所以只能有一个参数{return _year == d2._year &&//在类内能够直接获取我们的私有成员_mouth == d2._mouth &&_day == d2._day;}
};int main()
{date x1(2024, 8, 21);date x2(2024, 8, 22);//operator==(x1, x2);//显示调用x1 == x2;//这样写也会转换为上面的显示调用return 0;
}

5.2 赋值运算符重载

5.2.1 什么是赋值运算符重载

赋值运算符重载是⼀个默认成员函数，⽤于完成两个已经存在的对象直接的拷⻉赋值，这⾥要注意跟拷⻉构造区分，拷⻉构造⽤于⼀个对象拷⻉初始化给另⼀个要创建的对象。

代码上来看：

int main()
{stack st1(4);stack st2(1);st2 = st1;//赋值重载stack st3(4);stack st4 = st3;//拷贝构造return 0;
}

这块一定要分清。

5.2.2 赋值运算符的特点

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

2. 有返回值，且建议写成当前类类型引⽤，引⽤返回可以提⾼效率，有返回值⽬的是为了⽀持连续赋值场景。

class date
{
public:date(int year = 1, int mouth = 1, int day = 1){_year = year;_mouth = mouth;_day = day;}//date operator=(const date& d)//{//	_year = d._year;//	_mouth = d._mouth;//	_day = d._day;//	return *this;//这种写法是正确的，this指针在函数体内是可以显示的写出来的，//	//但是这种写法不好//}date& operator=(const date& d)//如果不传引用的话，我们返回了这个对象的时候，会调用拷贝{//影响我们的效率，但如果我们就是不想写，问题也不大_year = d._year;_mouth = d._mouth;_day = d._day;return *this;}void print(){cout << _year << " " << _mouth << " " << _day << " " << endl;}
private:int _year;int _mouth;int _day;
};int main()
{int i, j, k;i = j = k = 1;//在c语言中支持连续赋值，所以我们的代码也要实现赋值重载也需要实现连续复制。date d1(2024, 8, 8);date d2, d3;d3 = d2 = d1;
}

3. 没有显式实现时，编译器会⾃动⽣成⼀个默认赋值运算符重载，默认赋值运算符重载⾏为跟默认拷贝构造函数类似，对内置类型成员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的赋值重载。

4. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的赋值运算符重载就可以完成需要的拷⻉，所以不需要我们显⽰实现赋值运算符重载。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器⾃动⽣成的赋值运算符重载完成的值拷⻉/浅拷⻉不符合我们的需求，所以需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)。像MyQueue这样的类型内部主要是⾃定义类型Stack成员，编译器⾃动⽣成的赋值运算符重载会调⽤Stack的赋值运算符重载，也不需要我们显⽰实现MyQueue的赋值运算符重载。这⾥还有⼀个⼩技巧，如果⼀个类显⽰实现了析构并释放资源，那么他就需要显⽰写赋值运算符重载，否则就不需要。

最后我们写一个赋值重载：

class date
{
public:date(int year = 1, int mouth = 1, int day = 1){_year = year;_mouth = mouth;_day = day;}void operator=(const date& d)//建议写引用{_year = d._year;_mouth = d._mouth;_day = d._day;}void print(){cout << _year << " " << _mouth << " " << _day << " " << endl;}
private:int _year;int _mouth;int _day;
};int main()
{date d1(2024, 8, 22);date d2;d2 = d1;//赋值重载d1.print();d2.print();
}

六、取地址运算符重载

由于篇幅原因，这一部分我们下一节继续<^^>

七、总结

这一块我们学完一定要明白两个东西：

（1）、我们不写时，编译器默认⽣成的函数⾏为是什么，是否满⾜我们的需求。
（2）、编译器默认⽣成的函数不满⾜我们的需求，我们需要⾃⼰实现，那么如何⾃⼰实现？

以上就是这一章的全部内容，内容虽然有点长，但希望大家认真看完，并且能够将我给出的代码能够练习一下。