C++中的类与对象（中）

在上一节中，我们初步了解了一下，C++中的类，这一概念，这一节让我们进一步深入了解一下。

文章目录

前言

一、类中的默认成员函数

1.1 构造函数

构造函数的特点：

1.2 析构函数

析构函数的特点：

1.3 拷贝构造函数

拷贝构造的特点：

1.4 赋值运算符重载函数

赋值运算符重载函数的特点：

二、运算符重载

2.1 运算符重载的性质

2.2 取地址运算符重载

const取地址运算符重载

总结

前言

在C++类中，有几个自带的函数，这些函数不需要我们自己去写，编译器会帮我们默认生成，别看它们是编译器默认生成的，其实作用还不小呢，接下来就让我们学习一下这几个默认函数吧。

一、类中的默认成员函数

何为默认成员函数，就是用户没有显示实现的，而编译器会自动默认生成的成员函数就叫做默认成员函数。一般情况下，我们不写成员函数的话，编译器会自动帮我们生成6个默认成员函数。需要注意的是6个默认成员函数中重要的是前四个，还有两个是取地址重载不是很重要，我们只要了解一下即可。接下来我们学习默认成员函数从以下两点学习：

一：我们不写成员函数时，编译器默认生成的函数行为是什么，是否满足我们的需求。

二：编译器默认生成的函数不满足我们的需求时，我们需要自己来实现，那么如何自己实现。

1.1 构造函数

构造函数是特殊的成员函数，我们要注意的是，虽然构造函数的名称叫做构造，但是构造函数并不是开空间创建对象（我们经常使用的局部对象就是函数栈帧创建时空间就已经开辟好了），而是对类对象实例化时进行初始化。因此我们可以将构造函数认为是一个给已经存在的空间进行初始化的成员函数。

构造函数的特点：

1.构造函数的函数名与类名相同（这是一个强制要求，不可以自己任意发挥）

2.无返回值（在C++中规定好了，对于构造函数是没有返回值的，我们什么都不用写，也不用写void)

3.对象实例化时系统会自动调用对应的构造函数（注意是自动调用，我们无法手动调用）

4.构造函数可以重载（有时候我们可以根据类的特点写多个构造函数以次来应对不同初始化的情况，一般情况我们可以写一个无参函数，一个全缺省函数）

5.如果类中没有显示定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显示实现，编译器将不再生成

6.无参构造函数，全缺省构造函数，我们不写构造函数时编译器默认生成的构造函数都叫做默认构造函数。但是这三个函数有且只有一个存在，不能够同时存在。无参构造函数与全缺省构造函数虽然会构成函数重载，但是在调用时会产生歧义。（很多人如果只看字面意思：默认构造函数可能就会认为是编译器默认生成的默认构造函数，其实无参构造函数与全缺省构造函数都是默认构造，总结一下就是不传实参就可以调用的构造就叫做默认构造）

7.我们在不写时，编译器默认生成的构造函数，对于内置类型成员变量的初始化是没有要求的，也就是初始化不确定，要看编译器。对于自定义类型成员变量，要求调用这个成员变量的默认构造函数进行初始化，如果这个成员变量没有默认构造函数，那么就会发生报错，我们要初始化这个成员变量，需要初始化列表才能够解决。

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

如下是几个简单的构造函数：

class Date
{
public:// 1.⽆参构造函数 Date(){_year = 1;_month = 1;_day = 1;}// 2.带参构造函数 Date(int year, int month, int day){_year = year;_month = month;_day = day;}//3.全缺省构造函数 Date(int year = 1, int month = 1, int day = 1){_year = year;_month = month;_day =day;}
private:int _year;int _month;int _day;
};

1.2 析构函数

在C++中，析构函数（Destructor）是一个特殊的成员函数，它在对象生命周期结束时自动调用，主要用于释放对象在创建时动态分配的资源，如内存、文件句柄、数据库连接等。析构函数通常用于进行清理操作。

析构函数的特点：

1.函数名与类名相同，但前面有一个波浪号（~）作为前缀。

2.没有返回值，即使是 void 也没有。

3.没有参数，因为析构函数是由系统自动调用的，无法传递参数。

4.每个类只能有一个析构函数，不能重载。

5.自动调用：当对象的生命周期结束（对象离开作用域或者显式调用 delete 时），析构函数自动执行。

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

7.还需要注意的是，与构造函数不同，我们如果显示写析构函数，对于自定义类型成员也会调用它的析构函数，也就是说无论什么情况都会自动调用析构函数（并不会像构造函数那样，我们显示写了构造函数后，就不会调用自定义成员的构造函数）

8.对于类中没有申请资源是，析构函数可以不写，直接使用编译器生成的默认析构函数即可，就比如我们之前写的Date类。如果我们默认生成的析构可以用，也就不需要显示写析构，如MyQueue类(使用两个栈来实现一个队列）；但是如果有资源申请的话，就一定要自己写析构函数，否则会造成资源泄露（资源申请比如malloc,fopen等等）。

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

如下代码是几个常见的析构函数：

class Date
{~Date(){_year=1;_month=1;_day=1;}
}class Stack
{~Stack(){if(arr==nullptr){return ;}free(arr);arr=mullptr;capacity=top=0;}
}class MyQueue()
{~MyQueue(){//...可以默认调用我们上面写好Stack的析构函数，因为它的成员变量的类型都是Stack类型的}
private:
Stack pushst;
Stacl popst;

为了能让大家更加清楚地了解析构函数的几个特点，接下来我用具体实例具体结果来展示

#define  _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;class Date
{
public:Date(int year=2000,int month=1,int day=1){_year = year;_month = month;_day = day;}~Date(){cout << "日期销毁啦" << endl;}
private:int _year;int _month;int _day;
};class Stack
{
public:~Stack(){cout << "栈销毁啦" << endl;}private:int* arr;int capacity;int top;
};class MyQueue
{
public:~MyQueue(){cout << "队列销毁啦" << endl;}
private:Stack pushst;Stack popst;
};int main()
{Date d1(2025,1,26);Date d2(2025,1,25);Date d3(2025,1,24);Stack st;MyQueue mq;return 0;
}

上面我们写了三个不同的类，我们再把它们的析构函数显示实现出来，那么运行时我们就能够看到了。结果如下图所示，编译器是在类对象实例化之后自动调用析构函数的，而且调用的顺序是后定义的先调用。对于MyQueue类，由于它的两个成员变量的类型是我们上面创建的Stack类类型，那么编译器在调用它的析构函数时，也会链式调用Stack的析构函数（用来清理它的两个成员变量）

1.3 拷贝构造函数

拷贝构造函数也是一种构造函数，不过它的功能是用来拷贝的。因此拷贝构造函数的第一个参数是自身类类型的引用，且任何额外的参数都有默认值。

拷贝构造的特点：

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

2.拷贝构造函数的第一个参数必须是类类型对象的引用，使用传值方式编译器会直接报错，而且在逻辑上会引发无穷递归调用。拷贝构造函数也可以多个参数，但是第一个参数必须是类类型对象的引用，后面的参数必须有缺省值。

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

4.若未显示定义拷贝构造，编译器会自动生成拷贝构造函数。自动生成的拷贝构造函数对内置类型的成员变量会进行值拷贝/浅拷贝（一个字节一个字节的拷贝，只能拷贝值，不能拷贝一个新的内存空间），对于自定义类型成员变量会调用它自己的拷贝构造函数。

5.对于那种类成员变量全是内置类型且没有指向什么资源，编译器自动生成的拷贝构造就可以了，所以就不需要我们显示实现拷贝构造。但是对于那些有成员变量指向资源时，编译器自动生成的拷贝构造完成的值拷贝/浅拷贝不符合我们的需求，我们需要自己来实现深拷贝（对指向的资源也进行拷贝）。对于是否要显示写拷贝构造函数，这里有一个小技巧，如果一个类显示实现了析构并释放了资源就需要我们自己来显示写拷贝构造函数（因为有资源的释放就说明有空间，而编译器的拷贝构造不能够拷贝空间，只能够拷贝值，所以我们需要自己实现拷贝构造），否则就不需要。

6.传值返回会产生一个临时对象调用拷贝构造；而传值引用返回，返回的是返回对象的别名（引用）没有产生拷贝。但是如果返回对象是一个当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回是有问题的，这时的引用就相当于一个野引用，类似我们之前学习的野指针。传引用返回可以减少拷贝，但是一定要确保返回对象，在当前函数结束后还存在，才能引用返回。

无穷递归调用

如下是日期类和栈类的拷贝构造函数，对于没有资源指向的类就可以按照日期类那样来写，我们可以看到对于日期类的拷贝构造函数中的参数只有一个类类型的引用参数，其实还有一个隐藏的参数const Date*this 这个指针参数，这个参数我们在刚学习类时就已经介绍了，它是在类中的成员函数参数默认存在的，不需要我们自己写，我们也不能够写（每次编译器都会自己加上的，如果我们再自己写一个，参数就会多一个），至于另一个参数就是我们要拷贝的对象了。对于有资源指向的类我们可以按照栈类那样来写，同样的参数和上面是一样的，一个隐藏的指针参数，一个引用参数。但是在写拷贝构造函数时，我们需要自己动态申请一个和要拷贝对象一样大的空间，除此之外，我们还要将拷贝对象空间的内容拷贝过去，我们可以之前C语言中内存拷贝函数memcpy来实现。

class Date
{
public:Date(int year = 2000, int month = 1, int day = 1){_year = year;_month = month;_day = day;}
//参数中有个隐藏的const Date&thisDate(const Date& d){this->_year = d._year;_month = d._month;_day = d._day;}private:int _year;int _month;int _day;
};typedef int STDataType;
class Stack
{
public://构造函数Stack(int n = 4){_a = (STDataType*)malloc(sizeof(STDataType) * n);if (nullptr == _a){perror("malloc申请空间失败");return;}_capacity = n;_top = 0;}//拷贝构造函数Stack(const Stack& st){_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);if (nullptr == _a){perror("malloc申请空间失败!!!");return;}
//我们进行深拷贝，不仅要拷贝一个空间，还要将空间里面的内容一起拷贝进去memcpy(_a, st._a, sizeof(STDataType) * st._top);_top = st._top;_capacity = st._capacity;}private:int* _a;int _capacity;int _top;
};

1.4 赋值运算符重载函数

赋值运算符重载函数也是一种默认生成的成员函数，它是用于两个已经存在的类对象进行拷贝赋值的，这个函数要与我们刚刚学习的拷贝构造函数做区别，拷贝构造函数是拷贝初始化一个类对象，而赋值重载函数是对于两个已经类实例化过的对象进行赋值拷贝的，这也是两个函数的主要区别。

赋值运算符重载函数的特点：

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

2.这个默认成员函数有返回值，且建议写成当前类类型引用，引用返回可以提高效率，有返回值的目的是为了支持连续赋值的情况（如果没有返回值，那个进行一次赋值后就跳出运算了，那么下一个赋值运算无法计算）

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

4.这一点与拷贝构造的一个特点一样，如果一个类中的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的赋值运算符重载就可以完成需要的拷贝，所以就不用我们显示实现赋值运算符重载了。但是对于一个类中有指向资源的成员变量时，编译器自动生成的赋值运算符的重载（值拷贝/浅拷贝）就不行，所以就需要我们自己实现深拷贝，那么就需要我们自己写赋值运算符重载函数了。同样的，这里也有一个小技巧，如果一个类中显示实现了析构函数并释放资源，就需要我们自己来实现赋值运算符重载了，否则就不需要。

如下代码是我们实现的一个日期类中的一个赋值运算符重载函数，由于我们的赋值运算符重载函数是一个成员函数，所以我们就将this指针参数隐藏，这个参数指的就是要被拷贝赋值的那个值，另一个参数就是要拷贝赋值的值。

class Date
{//d1=d2  --->    const Date*this=const Date&dDate& operator=(const Date& d){if (this != &d){this->_year = d._year;_month = d._month;_day = d._day;}return *this;}
}

二、运算符重载

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

2.1 运算符重载的性质

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

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

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

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

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

• .* （成员指针访问运算符）， ::（作用域解析运算符）， sizeof（字节计算符）， ? :（条件操作符）， .（成员访问运算符）注意以上5个运算符不能重载。

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

• ⼀个类需要重载哪些运算符，是看哪些运算符重载后有意义，比如Date类重载operator-就有意义（可以表示两个日期差多少天），但是重载operator*就没有意义。

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

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

接下来我写一个关于日期类，其中有关于各种运算符的重载

//date.h#pragma once
#include<iostream>
#include<assert.h>
using namespace std;
class Date
{friend ostream& operator<<(ostream& out, const Date& d);friend istream& operator>>(istream& in, Date& d);
public:int GetMonthDay(int year,int month){assert(month > 0 && month <13);static int GetMonthDayArry[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };if ((month == 2) && (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)){return 29;}return GetMonthDayArry[month];}Date(int year = 2000, int month = 1, int day = 1);void print();bool DateCheck();Date(const Date& d){_year = d._year;_month = d._month;_day = d._day;}bool operator<(const Date& d);bool operator>(const Date& d);bool operator<=(const Date& d);bool operator>=(const Date& d);bool operator==(const Date& d);bool operator!=(const Date& d);Date& operator+=(int day);Date operator+(int day);Date& operator-=(int day);Date operator-(int day);//++d1Date& operator++();//d1++Date operator++(int);//--d1Date& operator--();//d1--Date operator--(int);int operator-(const Date& d);private:int _year;int _month;int _day;};

//date.cpp
#define  _CRT_SECURE_NO_WARNINGS
#include"date.h"Date::Date(int year , int month , int day )
{_year = year;_month = month;_day = day;if (!DateCheck()){cout << "日期非法" << endl;}
}void Date::print()
{cout << _year << "-" << _month << "-" << _day << endl;
}bool Date::DateCheck()
{if (_month < 1 || _month>13 || _day<1 || _day>GetMonthDay(_year, _month)){return false;}else{return true;}
}bool Date::operator<(const Date& d)
{if (_year < d._year){return true;}else if (_year == d._year && _month < d._month){return true;}else if (_year == d._year && _month == d._month && _day < d._day){return true;}else{return false;}
}bool Date::operator>(const Date& d)
{return !(*this <= d);
}
bool Date::operator<=(const Date& d)
{return *this < d || *this == d;
}
bool Date::operator>=(const Date& d)
{return !(*this < d);
}
bool Date::operator==(const Date& d)
{return _year == d._year && _month == d._month && _day == d._day;
}
bool Date::operator!=(const Date& d)
{return !(*this == d);
}Date& Date::operator+=(int day)
{if (day < 0){return *this -= -day;}_day += day;while(_day > GetMonthDay(_year, _month)){_day -= GetMonthDay(_year, _month);_month++;if (_month == 13){_year++;_month = 1;}}return *this;
}Date Date::operator+(int day)
{Date tmp(*this);tmp += day;return tmp;
}Date& Date::operator-=(int day)
{if (day < 0){return *this += -day;}_day -= day;while (_day<0){_day += GetMonthDay(_year, _month);_month--;if (_month == 0){_year--;_month = 12;}}return *this;
}Date Date::operator-(int day)
{Date tmp(*this);tmp -= day;return tmp;
}//++d1
Date& Date::operator++()
{return *this += 1;
}
//d1++
Date Date::operator++(int)
{Date tmp(*this);tmp += 1;return tmp;
}//--d1
Date& Date::operator--()
{return *this -= 1;
}
//d1--
Date Date::operator--(int)
{Date tmp(*this);tmp -= 1;return tmp;
}//d1-d2
int Date::operator-(const Date& d)
{Date max = *this;Date min = d;int flag = 1;if (*this < d){max = d;min = *this;flag = -1;}int n = 0;while (min!=max){
//这里的两个加加都要是前置++,否则无法出运算结果++min;++n;}return n * flag;
}//ostream,istream分别是out，in的返回值类型，这是自带的库中的
ostream& operator<<(ostream& out, const Date& d)
{out << d._year << "年" << d._month << "月" << d._day << "日" << endl;return out;
}
istream& operator>>(istream& in, Date& d)
{cout << "请依次输入年月日：";in >> d._year >> d._month >> d._day;if (!d.DateCheck()){cout << "输入有误，请重新输入：";}return in;}

//test.cpp
#define  _CRT_SECURE_NO_WARNINGS
#include"date.h"
int main()
{Date d1(2025, 1, 25);d1.print();Date ret1 = d1 += 100;ret1.print();Date ret2 = d1 + 100;ret2.print();ret2 += -100;ret2.print();d1.print();ret2 -= 100;ret2.print();Date d3(2025, 1, 25);Date d4(2004, 7, 5);int n = d4 - d3;cout << n << endl;cout << d1<<d3<<d4;//     operator<<(cout,d)cin >> d1;return 0;
}

2.2 取地址运算符重载

取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，一般这两个函数编译器自动生成的就可以够我们用了，不需要去显示实现。（这两个函数也就是我们最开始所说六个默认生成的函数中的两个）除非一些很特殊的场景，比如我们不想让别人取到当前类对象的地址，就可以自己实现一份，胡乱返回一个地址。这里我们就是来讲解一下这两个函数是什么，我们知道这两个函数是自己默认生成的，是什么就够了。

class Date
{
public:Date(int year=1,int month=1,int day=1){_year = year;_month = month;_day = day;}//这个取地址运算符重载函数，取的是普通对象变量的地址Date* operator&(){///return this;//返回对象的地址return ( Date*)0x11111FF;//返回自己任意写的地址}
//这个const修饰的取地址运算符重载函数，取的是被const修饰的对象变量的地址const Date* operator&() const{//return this;return nullptr;//返回一个空地址（全0）}
private:int _year;int _month;int _day;
};

如果我们想要自己显示写那两个函数的话，可以根据上面的日期类中取地址运算符重载来模仿，其实取地址运算符重载就是我们上面所说的运算符重载中的一种特殊形式，由于取地址运算符只能够作为成员函数，因此它们的参数也不用我们自己显示去写了，系统会默认加上去的（写了就会报错，不能写）至于函数体中就是返回一个地址，可以是对象的地址，也可以是空地址，还可以是一个胡乱写的地址，这个根据需求去写。普通取地址运算符重载函数很常规，现在我来着重介绍一下const修饰的取地址运算符函数重载。

const取地址运算符重载

在 C++ 中，除了可以重载普通的取地址运算符 &，你还可以重载**const**版本的取地址运算符。这允许你在获取对象地址时，确保返回的地址是只读的（即返回一个 const 指针），从而避免对该对象进行修改。

重载 const 版本的取地址运算符，是为了防止对常量对象的修改。当你对一个常量对象使用取地址符时，返回的指针应该是一个指向常量的指针，确保对象的内容不能被修改。当我们用const修饰成员函数时，我们传递的参数可以是用const修饰的，也可以是没有const修饰的。因为const修饰过的成员函数后，对于这个成员函数中的变量就变得只能读不能够修改，我们传递参数时，只能够是权限平移或者权限缩小地传递过去，不能够出现权限放大的情况（一个被const的对象被传递给非const修饰的成员函数，就造成了权限放大的情况，因为本来那个对象只能读，但是放到了一个又能读又能修改的成员函数中，这就是权限放大）

为什么需要重载 const 版本的取地址运算符？

保护常量对象：当你想确保某些对象是不可修改的（如常量对象），重载 const 版本的 & 运算符能够帮助你避免意外修改。
灵活性：通过重载 const 版本的运算符，你可以根据对象是否是常量来决定是否返回一个 const 或非 const 指针，增强了代码的灵活性和可读性。

#include<iostream>
using namespace std;
class Date
{
public:Date(int year = 1, int month = 1, int day = 1){_year = year;_month = month;_day = day;}// void Print(const Date* const this) constvoid Print() const{cout << _year << "-" << _month << "-" << _day << endl;}
private:int _year;int _month;int _day;
};
int main()
{// 这⾥⾮const对象也可以调⽤const成员函数是⼀种权限的缩⼩ Date d1(2024, 7, 5);d1.Print();const Date d2(2024, 8, 5);d2.Print();return 0;
}