当前位置： 首页 > news >正文

C++入门3——类与对象2（类的6个默认成员函数）

news 文章来源：https://blog.csdn.net/weixin_73629886/article/details/139155483 2025/5/10 12:39:57

目录

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

2. 构造函数

2.1 构造函数的概念

2.2 构造函数的特性

3. 析构函数

3.1 析构函数的概念

3.2 析构函数的特性

4.拷贝构造函数

4.1 拷贝构造函数的概念

4.2 拷贝构造函数的特性

5.赋值运算符重载函数

5.1运算符重载函数

5.2 赋值运算符重载函数

 5.3 前置++和后置++重载

前置++：

后置++：

6.（&）取地址操作符重载函数和const取地址操作符重载函数

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

如果一个类中什么成员都没有，简称为空类。可是空类中真的什么都没有吗？

其实并不是的，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。 默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

10cc6ae830cc460293c48d89a2fc6c29.png

类的6个默认成员函数编译器都会自己生成，如果编译器生成的默认成员函数能够满足我们的需求，我们就无需再自己实现；

相反，如果编译器生成的默认成员函数不能满足我们的需求，我们就必须要自己实现了。

本篇博客正是介绍类的这6个默认成员函数都有哪些特性，讲述什么情况下只需使用默认成员函数，什么情况下需要自己实现以及要怎样实现的问题！

2. 构造函数

2.1 构造函数的概念

如下代码，我们定义一个日期类并且调用成员函数：

#include <iostream>
using namespace std;class Data
{
public:void Init(int year, int month, int day){_year = year;_month = month;_day = day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;
};int main()
{Data d1;d1.Init(2023, 5, 23);d1.Print();Data d2;d2.Init(2022, 5, 23);d2.Print();return 0;
}

 44e1ffcedc9c467aadcdcaf42e7d37aa.png

按照我们之前学过的，按部就班地先调用初始化成员函数，再调用打印成员函数，运行结果也中规中矩地跑出来了。

可是有一天，我需要很多个Data变量，写代码又太急躁，在创建某个Data变量时忘记调用Init成员函数了，如下所示：

#include <iostream>
using namespace std;class Data
{
public:void Init(int year, int month, int day){_year = year;_month = month;_day = day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;
};int main()
{Data d1;d1.Init(2023, 5, 23);d1.Print();Data d2;d2.Print();return 0;
}

结果d2出现了随机值：

1e18b406df5f416aaf074c75e432021d.png

通过以上赘述：对于Data类，可以通过Init公有方法给对象设置日期，如果忘记一次初始化就会导致bug的产生，那就不得不每次创建对象时都调用该方法设置信息，可是这样是不是有些太麻烦了呢？有没有方法在对象创建时，就将对象设置进去呢？

答案当然是有的，这就引出了C++的1个默认成员函数——构造函数：

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次。

2.2 构造函数的特性

构造函数是特殊的成员函数，需要注意的是，构造函数没有用我们经常熟悉的Init来命名，虽然名称叫构造，但是构造函数的主要任 务并不是开空间创建对象，而是初始化对象。

其特征如下：

1. 函数名与类名相同；

2. 无返回值；

3. 对象实例化时编译器自动调用对应的构造函数；

4. 构造函数可以重载；

验证如下：

#include <iostream>
using namespace std;class Data
{
public://退出历史舞台：/*void Init(int year, int month, int day){_year = year;_month = month;_day = day;}*///1. 函数名与类名相同；2. 无返回值；Data(int year, int month, int day){_year = year;_month = month;_day = day;}//4. 构造函数可以重载；Data(){_year = 8;_month = 8;_day = 8;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;
};int main()
{//调用含参构造函数：Data d1(2023, 5, 23); //3. 对象实例化时编译器自动调用对应的构造函数；d1.Print();//调用无参构造函数：Data d2;   //注意这里不能用诸如：Data d2（）；不能加（），因为会与函数声明产生歧义；d2.Print();return 0;
}

0ec1ea8c46d54512a7b8f4b376ae0b7b.png

当然这里也完全可以用到缺省参数：

#include <iostream>
using namespace std;class Data
{
public:Data(int year = 8, int month = 8, int day = 8){_year = year;_month = month;_day = day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;
};int main()
{Data d1(2023, 5, 23); d1.Print();Data d2(2023, 5);d2.Print();Data d3;d3.Print();return 0;
}

27c42a08303444c2a7c7c03cd85b2fb5.png

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

代码验证如下：

#include <iostream>
using namespace std;class Data
{
public:如果显示定义，编译器将不再生成//Data(int year, int month, int day)//{//	_year = year;//	_month = month;//	_day = day;//}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year ;int _month ;int _day ;
};int main()
{Data d1;d1.Print();return 0;
}

将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数：

a623d63f50a747b791ab574543849818.png

将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用：

830c8ed1f42a4d059858ba4bc84f8d85.png

这时你可能要问了：

在不显示定义构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数似乎并没有什么用处呀！？

上面d1对象调用了编译器生成的默认构造函数，但是d1的对象_year/_month/_day，结果显示依旧是随机值，上面的运行结果就是铁铮铮的事实呀！这不是恰恰证明了这里编译器生成的默认构造函数并没有什么卵用吗？

这就涉及到了构造函数的第6个特性：

6.C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，编译器生成默认的构造函数会对自定义类型成员调用的它的默认成员函数，而内置类型则不做处理。

代码验证如下：

#include <iostream>
using namespace std;class Time
{
public:Time(){cout << "Time()" << endl;_hour = 0;_minute = 0;_second = 0;}
private:int _hour;int _minute;int _second;
};
class Date
{public:
void Print()
{cout << _year << "-" << _month << "-" << _day << endl;
}
private:// 基本类型(内置类型)int _year;int _month;int _day;// 自定义类型Time _t;
};
int main()
{Date d;d.Print();return 0;
}

2c14a15d9be9457d8eddcce7c59bddbb.png

说到这里，我又有些不解，同样都是变量，为什么还要分自定义类型调用它的默认成员函数，内置类型却不做处理呢？这难道不是一件画蛇添足的事情吗？

这次不否定了，说的确实有道理，所以在C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值。

代码验证如下：

#include <iostream>
using namespace std;
class Time
{
public:Time(){cout << "Time()" << endl;_hour = 0;_minute = 0;_second = 0;}
private:int _hour;int _minute;int _second;
};
class Date
{
public:void Print(){cout << _year << "-" << _month << "-" << _day << endl;}
private:// 基本类型(内置类型)// C++11支持，声明时给缺省值int _year = 2023;int _month = 5;int _day = 23;// 自定义类型Time _t;
};
int main()
{Date d;d.Print();return 0;
}

3120721a56154ceaa8705d2cb793f407.png

思考如下代码能否正常运行：

#include <iostream>
using namespace std;
class Date
{
public:Date(){_year = 2023;_month = 5;_day = 23;}Date(int year = 2023, int month = 5, int day = 23){_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;
};
// 以下测试函数能正常运行吗？
void Test()
{Date d1;
}

答案是否定的：

d656dc64cf62454db57c305c43dbf8e2.png

针对以上现象，可以引出构造函数的第7个特性：

7.无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。 注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。 

3. 析构函数

3.1 析构函数的概念

通过上面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没的呢？这就需要我们学习析构函数了：

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

3.2 析构函数的特性

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

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

2. 无参数无返回值类型；

3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：与构造函数不同的是，析构函数不能重载；

4. 对象生命周期结束时，C++编译系统自动调用析构函数；

#include <iostream>
using namespace std;class Data
{
public:Data(int year = 2023, int month = 5, int day = 23){_year = year;_month = month;_day = day;}void Ptint(){cout << _year << "-" << _month << "-" << _day << endl;}//1. 析构函数名是在类名前加上字符 ~；2. 无参数无返回值类型；~Data(){cout << "~Data" << endl;}private:int _year;int _month;int _day;
};
int main()
{Data d;d.Ptint();//这里为调用~Data，4. 对象生命周期结束时，C++编译系统自动调用析构函数；return 0;
}

8a52bdecb899413c8864f56c085965be.png

当然，Data类并不需要析构函数，这里只是为了证明C++自动调用了析构函数。

我们将析构函数用到顺序表中，可能会对析构函数有更深刻的理解：

#include <iostream>
using namespace std;typedef int DataType;class SeqList
{
public:SeqList(){cout << "已经调用了SeqList()构造函数；" << endl;_a = (DataType*)malloc(sizeof(DataType) * 4);if (_a == nullptr){perror("malloc failed");//如果扩容失败，说明原因exit(-1);}_size = 0;//当size≥capacity时就动态开辟空间_capacity = 4;//初始化数组容量为4}~SeqList(){cout << "已经调用了~SeqList()析构函数；" << endl;free(_a);_a = nullptr;_size = _capacity = 0;}private:int* _a;int _size;int _capacity;
};int main()
{SeqList sl;return 0;
}

5bc4ac37324a40f48897bdce2e1c6215.png

对于第3条特性，系统自动生成默认的析构函数，会不会完成一些事情呢？

5. 答案与构造函数相似，编译器生成的默认析构函数，对自定义类型成员调用它的析构函数，而内置类型则不做处理。

代码验证如下：

#include <iostream>
using namespace std;class Time
{
public:~Time(){cout << "已经调用了~Time()析构函数" << endl;}
private:int _hour;int _minute;int _second;
};
class Date
{
private:// 基本类型(内置类型)int _year = 2023;int _month = 5;int _day = 23;// 自定义类型Time _t;
};
int main()
{Date d;return 0;
}

运行结果为：

c3aa8ce8ea1245e68bad3d05be46c610.png

对以上结果和第3、第5条特性的详细解释：

程序运行结束后输出：“已经调用了~Time()析构函数”，在main中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？

因为：main中创建了Date对象d，而d中包含4个成员变量，其中_year, _month, _day三个是内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；

而_t是Time类对象，所以在d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数；

但是：main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time类的析构函数；

即：当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁，main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数；

注意：创建哪个类的对象则调用该类的构造函数，销毁哪个类的对象则调用该类的析构函数

6. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如 Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如SeqList类。 

4.拷贝构造函数

4.1 拷贝构造函数的概念

电视剧中以及现实中，双胞胎的例子不在少数，我们甚至可以说简直他们就是一个模子里刻出来的！那么，在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？答案的肯定的。

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

4.2 拷贝构造函数的特性

1. 拷贝构造函数是构造函数的一个重载形式。即：拷贝构造函数是一个特殊的构造函数；

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

代码验证如下：

不考虑特性2，我们偏偏就要直接传值调用：

#include <iostream>
using namespace std;
class Date
{
public:Date(int year = 2023, int month = 7, int day = 7){_year = year;_month = month;_day = day;}Date( Date d)   {_year = d._year;_month = d._month;_day = d._day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;
};
int main()
{Date d1;d1.Print();Date d2(d1);d2.Print();return 0;
}

会发现程序报错：

b31d40394d984383bd2ed4c7383d1dc6.png

这是为什么呢？答案就像特征2中所说的，在此过程中引发了无穷递归调用：

当我们直接传值调用时，会发生先传值再调用拷贝构造函数的情况，即：

1a006970791e4df69d80e6f568086dfa.png

所以正确应该如特性2所说的那样：

#include <iostream>
using namespace std;
class Date
{
public:Date(int year = 2023, int month = 7, int day = 7){_year = year;_month = month;_day = day;}// Date( Date d)   // 错误写法：编译报错，会引发无穷递归Date( Date& d)   // 正确写法{_year = d._year;_month = d._month;_day = d._day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;
};
int main()
{Date d1;d1.Print();Date d2(d1);d2.Print();return 0;
}

c645327e9ba447eabf769d8e8016f1ca.png

那么在概念中又提到:(一般常用const修饰),这是为什么呢？

这是为了防止我们在定义拷贝构造函数时写反了：

Date( Date& d)   {d._year = _year;d._month = _month;d._day = _day;}

那么运行结果不但不会正确，反而会偷鸡不成蚀把米：

e2ca2a2a701447fca1d4aece104a34ee.png

所以加上const，即使出现了这样的低级错误，编译器就会报错，我们也能及时发现：

 Date( const Date& d)   {d._year = _year;d._month = _month;d._day = _day;}

869fcebb101943eab5ebba1c98d195c5.png

正确代码：

#include <iostream>
using namespace std;
class Date
{
public:Date(int year = 2023, int month = 7, int day = 7){_year = year;_month = month;_day = day;}// Date( Date d)   // 错误写法：编译报错，会引发无穷递归Date( const Date& d)   // 正确写法{_year = d._year;_month = d._month;_day = d._day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;
};
int main()
{Date d1;d1.Print();Date d2(d1);d2.Print();return 0;
}

3.与构造函数和析构函数相似，若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。

代码验证如下：

#include <iostream>
using namespace std;
class Time
{
public:Time(){_hour = 8;_minute = 8;_second = 8;}Time(const Time& t){_hour = t._hour;_minute = t._minute;_second = t._second;cout << "已经调用了！Time::Time(const Time&)" << endl;}
private:int _hour;int _minute;int _second;
};
class Date
{
public:void Print(){cout << _year << "-" << _month << "-" << _day << endl;}
private:// 基本类型(内置类型)int _year = 2023;int _month = 7;int _day = 7;// 自定义类型Time _t;
};
int main()
{Date d1;// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数Date d2(d1);d2.Print();return 0;
}

66d29c0c52404b548d981f17b4d16f1d.png

与前面的构造函数和析构函数相似的问题：编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？

当然像上面的Data类这样的类是没必要的。那么像顺序表之类的类呢？验证如下：

#include <iostream>
using namespace std;typedef int DataType;class SeqList
{
public:SeqList(){cout << "已经调用了SeqList()构造函数；" << endl;_a = (DataType*)malloc(sizeof(DataType) * 4);if (_a == nullptr){perror("malloc failed");//如果扩容失败，说明原因exit(-1);}_size = 0;//当size≥capacity时就动态开辟空间_capacity = 4;//初始化数组容量为4}//打印void Print(){for (int i = 0; i < _size; i++){cout << _a[i] << endl;}}//尾插void PushBack(const DataType& x){_a[_size] = x;_size++;}~SeqList(){cout << "已经调用了~SeqList()析构函数；" << endl;free(_a);_a = nullptr;_size = _capacity = 0;}private:int* _a;int _size;int _capacity;
};int main()
{SeqList sl1;sl1.PushBack(1);sl1.PushBack(2);sl1.PushBack(3);sl1.PushBack(4);sl1.Print();SeqList sl2(sl1);sl2.Print();return 0;
}

运行结果如图：

7e3a76d24fa24a6eb89a9fd691544b0c.png

我们可以看到，程序崩溃了！这是为什么呢？

打开监视窗口看一下sl1和sl2的内存地址：

a665e2e2d22f42d2910c10bb75c0a469.png

发现二者的地址相同，所以我们就知道了： 

1.sl1对象调用构造函数创建，在构造函数中，申请了（_capacity）4个元素的空间，然后里面存储了4个元素：1 2 3 4；

2. sl2对象使用sl1对象拷贝构造，而SeqList类没有显示定义拷贝构造函数，则编译器会给SeqList类生成一份默认的拷贝构造函数，默认拷贝构造函数是按照值拷贝的，即将sl1中的内容原封不动地拷贝到sl2中。因此sl1与sl2指向了同一块内存空间；

3. 当程序退出时，sl2和sl1要销毁。sl2先销毁，sl2销毁时调用析构函数，已经将0x00b59580的空间释放了，但是sl1并不知道，到sl1销毁时，会将0x00b59580的空间再释放一次（正如3.2的第5条特性说的那样），一块内存空间多次释放，必然会导致bug的产生。

现在我已经知道原因了，那么正确的代码应该怎么写呢？这就需要用到深拷贝去解决（关于深拷贝后面会有详解）：

//自定义拷贝构造函数，不用编译器默认生成的（深拷贝）SeqList( const SeqList& sl){_a = (DataType*)malloc(sizeof(DataType) * 4);//我也开辟一个空间if (_a == nullptr){perror("malloc failed");//如果扩容失败，说明原因exit(-1);}memcpy(_a, sl._a, sizeof(int) * sl._capacity);_size = sl._size;_capacity = sl._capacity;}

32d8e2931faa4aba9c7fd30cce45486b.png

所以，我们应该要明白：

4.类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请 时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

5.赋值运算符重载函数

5.1运算符重载函数

在学习赋值运算符重载之前，我们先来了解一下运算符重载：

通过上面的学习，我们已经知道了内置类型和自定义类型的区别，思考这样一个问题：

显而易见，内置类型对象可以直接用各种运算符，内置类型是语言自己定义的，编译直接转换成指令

举个简单的例子，内置类型的int类型2和1，编译器可以轻松知道2>1；内置类型的double类型2.2和1.1,编译器轻松知道2.2>1.1,诸如此类......

那么问题来了，我们通篇写的Data类对象，我这时候需要判断2012年7月7日与2013年7月7日哪个日期更大，编译器能直接判断出2012年7月7日<2013年7月7日吗？显然是不能的！因为自定义类型编译器不支持直接转换成指令。

那么这时候就需要我们自己写一个函数来实现：

写一个大于比较函数：

bool Greater(Data d1, Data d2)
{if (d1._year > d2._year){return true;}else if (d1._year == d2._year && d1._month > d2._month){return true;}else if (d1._year == d2._year && d1._month ==d2._month && d1._day > d2._day){return true;}return false;
}

再比如我写一个等于比较的函数：

bool Equal(Data d1, Data d2)
{return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}

运行一下：

#include <iostream>
using namespace std;
class Data
{
public:Data(int year = 2012, int month = 7, int day = 7){_year = year;_month = month;_day = day;}Data(const Data& d){_year = d._year;_month = d._month;_day = d._day;}void Ptint(){cout << _year << "-" << _month << "-" << _day << endl;}//private:int _year;int _month;int _day;
};//布尔类型（bool）用于表示真（true）和假（false）的值。
//它只有两个取值：true 和 false，分别对应 1 和 0 。
bool Greater(Data d1, Data d2)
{if (d1._year > d2._year){return true;}else if (d1._year == d2._year && d1._month > d2._month){return true;}else if (d1._year == d2._year && d1._month ==d2._month && d1._day > d2._day){return true;}return false;
}bool Equal(Data d1, Data d2)
{return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}int main()
{Data d1(2013, 7, 7);Data d2(2012, 7, 7);cout << Greater(d1, d2) << endl;cout << Equal(d1, d2) << endl; return 0;
}

40c3044b923f4d26a6af88b477fb7d38.png

说到这里，我们来说一个题外话，关于函数的命名，其实在C语言中我们就遇到过很多了，一个函数命名就如同给自己的孩子取名字一样，比如上面的判断大于和判断相等函数，我能用Greater、Equal，为什么就不能用DaYu、DengYu，或者Compare1、Compare2，又或者func1、func2呢？

这些确实都是可以的呀！我创建的函数，我乐意怎样取名我就怎样取名！

可是话说回来，你的孩子在你口中叫狗蛋儿、在老师口中叫张三，有一天你去开家长会，老师问你是谁的家长，你说你是狗蛋儿的家长，你这样说老师会知道张三就是狗蛋儿，狗蛋儿就是张三吗？

话再说回来，你写的函数叫DaYu、DengYu，而你的同事要用这个函数，你写的DaYu、DengYu，同事能知道这是个什么函数吗？

所以，为了规避这种情况，增强代码的可读性，C++引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator操作符(参数列表)

因此上述两个函数就可以写为（更加规范，我们加上const和&）：

//bool Greater(Data d1, Data d2)
bool operator>(const Data& d1, const Data& d2)
{if (d1._year > d2._year){return true;}else if (d1._year == d2._year && d1._month > d2._month){return true;}else if (d1._year == d2._year && d1._month ==d2._month && d1._day > d2._day){return true;}return false;
}//bool Equal(Data d1, Data d2)
bool operator == (const Data& d1, const Data& d2)
{return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}
int main()
{Data d1(2013, 7, 7);Data d2(2012, 7, 7);/*cout << Greater(d1, d2) << endl;cout << Equal(d1, d2) << endl; */cout << operator > (d1, d2) << endl;cout << operator == (d1, d2) << endl;return 0;
}

09a4e81684514c94a4c1a3efa58519c0.png

以及为了令自定义类型更贴合与内置类型一样让编译器自己计算，直接转为指令：

int main()
{Data d1(2013, 7, 7);Data d2(2012, 7, 7);/*cout << Greater(d1, d2) << endl;cout << Equal(d1, d2) << endl; *//*cout << operator > (d1, d2) << endl;cout << operator == (d1, d2) << endl;*/bool ret1 = d1 > d2;   //d1>d2吗？是为1，否为0；bool ret2 = d1 == d2;  //d1=d2吗？是为1，否为0；int a = 3 > 2;         //3>2吗？是为1，否为0；int b = 3 == 2;        //3=2吗？是为1，否为0；cout << ret1 << endl << ret2 << endl;cout << a << endl << b << endl;return 0;
}

6c14fcf3156e47f4be3a01e2d23d84ae.png

仔细观察我们上面写的Data类，可以发现我把private注释掉了，那现在我把注释关掉：

c95e1a2b39d84902b7952dc26cc6ed78.png

成员变量变私有了该怎么办呢？其实C++常用的解决方法是直接将函数放到类里面，因为类里面可以随便访问private：

class Data
{
public:Data(int year = 2012, int month = 7, int day = 7){_year = year;_month = month;_day = day;}Data(const Data& d){_year = d._year;_month = d._month;_day = d._day;}bool operator == (const Data& d1, const Data& d2){return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;}void Ptint(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;
};

可是这样写发现还是编译不通过：

02d4b6013b5f4a4dad00c0501e5e4edb.png

它说函数参数太多？！我放到类外面参数就不多，怎么放到类里面就多参数了呢？

对！因为存在一个隐含的this指针（详细请看C++入门2——类与对象（1）中的3），所以这时就可以这样修改：

class Data
{
public:Data(int year = 2012, int month = 7, int day = 7){_year = year;_month = month;_day = day;}Data(const Data& d){_year = d._year;_month = d._month;_day = d._day;}bool operator>(const Data& d2){if (_year > d2._year){return true;}else if (_year == d2._year && _month > d2._month){return true;}else if (_year == d2._year && _month == d2._month && _day > d2._day){return true;}return false;}bool operator == ( const Data& d2){return _year == d2._year && _month == d2._month && _day == d2._day;}void Ptint(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;
};

那么在函数调用时，编译器就会帮我们负重前行：

int main()
{Data d1(2013, 7, 7);Data d2(2012, 7, 7);bool ret1 = d1 > d2;    //d1.operator>(d2)--->d1.operator>(&d1,d2)bool ret2 = d1 == d2;   //d1.operator==(d2)--->d1.operator==(&d1,d2)cout << ret1 << endl << ret2 << endl;return 0;
}

所以运算符重载归纳有以下特点：

1. 不能通过连接其他符号来创建新的操作符：比如operator@；

2. 重载操作符必须有一个类类型参数；

3. 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义；

4. 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this；

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

5.2 赋值运算符重载函数

铺了那么多前戏，终于来到我们要学习的赋值运算符重载函数了：

我们知道，拷贝构造就是将一个已经初始化的变量A拷贝到未初始化的变量B中，

那么如果存在两个都已经初始化的变量A、B，我想把A的值拷贝到B，显然就不能再用拷贝构造了，要用到我们就要开始讲的赋值运算符重载：

1. 赋值运算符重载格式：

参数类型：const T&，传递引用可以提高传参效率

返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值检测是否自己给自己赋值

返回*this ：要复合连续赋值的含义

（详解精华都在代码里）：

#include <iostream>
using namespace std;
class Data
{
public:Data(int year = 2012, int month = 7, int day = 7){_year = year;_month = month;_day = day;}Data(const Data& d){_year = d._year;_month = d._month;_day = d._day;}//d1=d2;d1传给this，d2传给d//返回值应该是什么类型呢？当然是Data类型；应该返回d1的地址，所以用&引用返回Data& operator=(const Data& d){//判断是否为自己给自己赋值，&放到这里不是引用，是取地址：//判断d2的地址是否与d1地址相等if (this != &d){_year = d._year;_month = d._month;_day = d._day;}return *this;//返回d1的地址}void Ptint(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;
};int main()
{Data d1(2023, 7, 7);Data d2(2022, 8, 8);//拷贝构造：一个已经存在的对象去拷贝初始化另一个对象Data d3(d2);d1.Ptint();d2.Ptint();d3.Ptint();cout << endl;//赋值运算符重载：两个已经存在的对象拷贝d1 = d2;//运算自定义类型，就要用到运算符重载operator=d1.Ptint();d2.Ptint();d3.Ptint();
}

bfc851358b7a4f188d2536f11d56f2a8.png

2. 赋值运算符只能重载成类的成员函数不能重载成全局函数

 原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现 一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值 运算符重载只能是类的成员函数。

3. 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。 

4.如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必 须要实现。

这些特性与拷贝构造函数有极大的相似性，这里不再过多赘述。

 5.3 前置++和后置++重载

在C语言中，我们已经知道了：前置++，先加后用；后置++，先用后加 这样的基本常识

那么我们学了运算符重载，现在我要自定义类型Data前置++和后置++，要怎么定义和实现呢？

前置++：

前置++为先+1后使用；所以前置++的返回值应该是返回+1之后的结果；

故前置++重载函数的实现为：

// 前置++：返回+1之后的结果Date& operator++()//返回d1，所以返回值类型当然为Date类型{_day += 1;return *this;//this指向的对象函数结束后不会销毁，故以&引用方式返回提高效率}

后置++：

后置++为先使用后+1；所以后置++的返回值应该为+1之前的旧值，故需在实现时需要先将this保存一份，然后给this+1；

那么问题来了，前置++和后置++都是一元运算符，实现起来两个函数名字相同，都是operator++，怎么才能区分这两个函数呢？

为了让前置++与后置++形成能正确重载，C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递

故后置++重载函数的实现为：

	Date operator++(int){Date temp(*this);// 先将this保存一份，然后给this + 1_day += 1;return temp;    // temp是临时对象，出了作用域就会被销毁，//因此只能以值的方式返回，不能返回引用}

验证：

#include <iostream>
using namespace std;
class Date
{
public:Date(int year = 2023, int month = 7, int day = 7){_year = year;_month = month;_day = day;}// 前置++：返回+1之后的结果Date& operator++()//返回d1，所以返回值类型当然为Date类型{_day += 1;return *this;//this指向的对象函数结束后不会销毁，故以&引用方式返回提高效率}Date operator++(int){Date temp(*this);// 先将this保存一份，然后给this + 1_day += 1;return temp;    // temp是临时对象，出了作用域就会被销毁，//因此只能以值的方式返回，不能返回引用}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}
private:int _year;int _month;int _day;
};
int main()
{Date d1;Date d2(2022, 7, 7);d1 = ++d2;//前置++，编译器默认调用不带（int）参数的operator++d1.Print();d1 = d2++;//后置++，编译器默认调用带（int）参数的operator++d1.Print();return 0;
}

042923162f184534aa7a272a212b0bb8.png

小知识：在C语言中前置++和后置++二者的效率高低可能并不明显，但是在C++中，一般来说前置++的效率要高于后置++

6.（&）取地址操作符重载函数和const取地址操作符重载函数

终于来到类的最后两个默认成员成员函数了，二者的形式为：

class Date
{
public://（&）取地址操作符重载Date* operator&(){return this;}//const（&）取地址操作符重载const Date* operator&()const{return this;}
private:int _year; // 年int _month; // 月int _day; // 日
};

这两个默认成员函数一般不用重新定义 ，编译器默认会生成。

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需 要重载，比如想让别人获取到指定的内容！所以这里就不再过多介绍这两个默认成员函数。

（本篇完） 

相关文章：

C++入门3——类与对象2（类的6个默认成员函数）

目录 1.类的6个默认成员函数 2. 构造函数 2.1 构造函数的概念 2.2 构造函数的特性 3. 析构函数 3.1 析构函数的概念 3.2 析构函数的特性 4.拷贝构造函数 4.1 拷贝构造函数的概念 4.2 拷贝构造函数的特性 5.赋值运算符重载函数 5.1运算符重载函数 5.2 赋值运算符重…...

编程日记 2024/5/31 15:23:18

CobaltStrike基本渗透

目录 CobaltStrike简介 主要功能&#xff1a; 使用注意&#xff1a; 在使用CobaltStrike进行渗透测试时&#xff0c;务必遵守法律法规&#xff0c;并获得合法授权。 CobaltStrike安装 前提 安装 服务端安装 windows安装 CS基本使用 监听器配置 一些基本的攻击…...

编程日记 2024/5/31 15:21:15

【linux深入剖析】进程间通信

&#x1f341;你好&#xff0c;我是 RO-BERRY &#x1f4d7; 致力于C、C、数据结构、TCP/IP、数据库等等一系列知识 &#x1f384;感谢你的陪伴与支持 &#xff0c;故事既有了开头&#xff0c;就要画上一个完美的句号&#xff0c;让我们一起加油 目录 1.进程间通信目的2. 什么…...

编程日记 2024/5/31 15:20:14

关系数据库：关系模式

文章目录 基本概述关系的相关名词术语笛卡儿积与关系关系的类型 关系模式总结 基本概述 关系的相关名词术语 关系&#xff1a;简单来说&#xff0c;就是一张二维表格。属性(Attribute)&#xff1a;也称字段或列&#xff0c;在现实世界中&#xff0c;要描述一个事务常常取若干…...

编程日记 2024/5/31 15:17:11

医学图像处理质量的评价方法

评判处理后医学图像的质量是确保图像处理技术有效性和可靠性的关键。以下是一些常用的图像质量评估方法和指标&#xff1a; 1. 主观评估 主观评估是由专业人员&#xff08;如放射科医生&#xff09;通过视觉检查对图像质量进行评分。常用的主观评估方法包括&#xff1a; 视觉…...

编程日记 2024/5/31 15:16:09

Ehcache Java 缓存框架

详解 下图是 Ehcache 在应用程序中的位置&#xff1a; Ecache 是一个广泛使用的 Java 缓存框架&#xff0c;能够有效提升应用性能&#xff0c;并减少与后端数据库的交互次数。它采用了一系列高级缓存策略&#xff0c;包括内存缓存、磁盘缓存、分布式缓存等&#xff0c;并提供了…...

编程日记 2024/5/31 15:15:08

详解Spring IoCDI（二）

目录 承接上文&#xff1a;详解Spring IoC&DI &#xff08;一&#xff09; 1.IoC详解 1.1方法注解Bean 1.2方法注解要配合类注解使用 1.3定义多个对象 1.4重命名Bean 1.5扫描路径 2.DI详解 2.1DI与IoC的关系 2.2属性注入 2.3构造方法注入 2.4Setter注入 2.5 三…...

编程日记 2024/5/31 15:13:06

说明白计算机网络之TCP的流量控制与拥塞控制之慢开始算法与拥塞避免算法

TCP的流量控制 利用滑动窗口实现流量控制 设A向B发送数据&#xff0c;连接建立时候&#xff0c;B告诉A自身的接收窗口大小&#xff0c;A的发送窗口大小不能超过接收方B的窗口大小 流量控制&#xff1a;发送方发送速率不要太快&#xff0c;要让接收方来得及接收。窗口大小的单…...

编程日记 2024/5/31 15:11:04

这款信创FTP软件，可实现安全稳定的文件传输

信创&#xff0c;即信息技术应用创新&#xff0c;2018年以来&#xff0c;受“华为、中兴事件”影响&#xff0c;国家将信创产业纳入国家战略&#xff0c;并提出了“28n”发展体系。“8”具体指金融、石油、电力、电信、交通、航空航天、医院、教育等主要行业。目前企业使用比较…...

编程日记 2024/5/31 15:10:03

代码随想录算法训练营第十天|232.用栈实现队列、225. 用队列实现栈

232.用栈实现队列 题目链接&#xff1a;232. 用栈实现队列 文档讲解&#xff1a;代码随想录 状态&#xff1a;写出来 &#xff0c;但差强人意 思路&#xff1a; 定义两个容器&#xff0c;可以是Stack&#xff0c;也可以是Deque&#xff0c;stackIn相当于临时容器,用来存放元素&…...

编程日记 2024/5/31 15:08:01

STM32 IIC协议

本文代码使用 HAL 库。 文章目录 前言一、什么是IIC协议二、IIC信号三、IIC协议的通讯时序1. 写操作2. 读操作 四、上拉电阻作用总结 前言 从这篇文章开始为大家介绍一些通信协议&#xff0c;包括 UART&#xff0c;SPI&#xff0c;IIC等。 UART串口通讯协议 SPI通信协议 一、…...

编程日记 2024/5/31 15:05:59

Java生成随机数的几种方式

随机数&#xff0c;在一些特殊场景下&#xff0c;是非常常用的。比如一些测试和验证场景、安全加密、随机抽样等都有随机数的‘身影’。 一、 使用java.util.Random类 java.util.Random类提供了更全面的随机数生成功能&#xff0c;包括随机整数、随机浮点数、随机布尔值等。 p…...

编程日记 2024/5/31 15:04:58

【面试】什么是Java虚拟机

目录 1. 说明2. 关键点 1. 说明 1.Java虚拟机&#xff08;Java Virtual Machine&#xff0c;简称JVM&#xff09;是运行所有Java程序的抽象计算机&#xff0c;是Java语言的运行环境。2.JVM是Java平台无关性的关键&#xff0c;它允许Java程序在任何支持JVM的硬件和操作系统上运…...

编程日记 2024/5/31 15:03:57

Go 语言的基本构成、要素与编写规范

Go 语言&#xff0c;作为由 Google 开发的现代编程语言&#xff0c;以其简洁、高效和并发编程能力而著称。在构建高性能分布式系统和现代软件开发中&#xff0c;Go 语言正日益受到欢迎。本篇文章将详细探讨 Go 语言程序结构的各个要素&#xff0c;包括函数定义、注释规范、数据…...

编程日记 2024/5/31 15:02:55

从了解到掌握 Spark 计算框架（二）RDD

文章目录 RDD 概述RDD 组成RDD 的作用RDD 算子分类RDD 的创建1.从外部数据源读取2.从已有的集合或数组创建3.从已有的 RDD 进行转换 RDD 常用算子大全转换算子行动算子 RDD 算子综合练习RDD 依赖关系窄依赖宽依赖宽窄依赖算子区分 RDD 血统信息血统信息的作用血统信息的组成代码…...

编程日记 2024/5/31 15:00:53

香橙派OrangePi AIpro上手笔记——之USB摄像头目标检测方案测试（三）

整期笔记索引 香橙派OrangePi AIpro上手笔记——之USB摄像头目标检测方案测试&#xff08;一&#xff09; 香橙派OrangePi AIpro上手笔记——之USB摄像头目标检测方案测试&#xff08;二&#xff09; 香橙派OrangePi AIpro上手笔记——之USB摄像头目标检测方案测试&#xff08;…...

编程日记 2024/5/31 14:57:50

【git】常用命令

删除 删除本地分支&#xff1a; // 删除本地分支 git branch -d localBranchName 删除远程仓库分支 git push origin --delete <branch_name> 验证远程分支是否删除 git fetch -p //会清理已经删除的远端分支的引用 git branch -r //列出所有远端分支&#xff0…...

编程日记 2024/5/31 14:56:48

JavaWeb_MySQL数据库

数据库&#xff1a; MySQL数据模型&#xff1a; MySQL是关系型数据库。 SQL&#xff1a; 简介 分类&#xff1a; 数据库设计-DDL 对数据库操作&#xff1a; 表操作&#xff1a; 小练习&#xff1a; 创建下表 SQL代码&#xff1a; create table tb_user (id int primar…...

编程日记 2024/5/31 14:55:46

中国BI步入增长大周期，腾讯云ChatBI加速AI+BI融合

过去十年&#xff0c;大数据技术的快速发展&#xff0c;让数据消费前进一大步&#xff0c;数据价值得到一定程度的挖掘与释放&#xff0c;真正开启了“用数”的大时代。但数据分析繁杂的技术栈、复杂的处理过程以及程式化的交互方式&#xff0c;让“数据消费”的门槛始终降不下…...

编程日记 2024/5/31 14:53:44

揭秘Python：下划线的特殊用法，你绝对想不到！

在Python编程中&#xff0c;下划线&#xff08;underscore&#xff09;是一个常见而又强大的工具。它不仅仅是一个普通的字符&#xff0c;而是具有特殊含义和用法的符号。今天&#xff0c;我们就来揭开Python下划线的神秘面纱&#xff0c;探索它的各种妙用。 下划线的基本用法…...

编程日记 2024/5/31 14:50:41

深入探索Java世界中的Jackson魔法：玩转JsonNode

哈喽&#xff0c;大家好&#xff0c;我是木头左&#xff01; 揭秘Jackson库&#xff1a;JSON处理的瑞士军刀 在Java的世界里&#xff0c;处理JSON数据就像是一场探险。幸运的是&#xff0c;Jackson库就像一把多功能的瑞士军刀&#xff0c;为提供了强大而灵活的工具来解析和操作…...

编程日记 2024/5/31 14:49:40

为什么要使用动态代理IP？

一、什么是动态代理IP&#xff1f; 动态代理IP是指利用代理服务器来转发网络请求&#xff0c;并通过不断更新IP地址来保护访问者的原始IP&#xff0c;从而达到匿名访问、保护隐私和提高访问安全性的目的。动态代理IP在多个领域中都有广泛的应用&#xff0c;能够帮助用户…...

编程日记 2024/5/31 14:48:38

【PB案例学习笔记】-09滚动条使用

写在前面 这是PB案例学习笔记系列文章的第8篇&#xff0c;该系列文章适合具有一定PB基础的读者。 通过一个个由浅入深的编程实战案例学习&#xff0c;提高编程技巧&#xff0c;以保证小伙伴们能应付公司的各种开发需求。 文章中设计到的源码&#xff0c;小凡都上传到了gitee…...

编程日记 2024/5/31 14:46:35

C++中常见的构造函数类别

目录 摘要 默认构造函数&#xff08;Default Constructor&#xff09;&#xff1a; 带参数的构造函数&#xff08;Parameterized Constructor&#xff09;&#xff1a; 拷贝构造函数&#xff08;Copy Constructor&#xff09;&#xff1a; 移动构造函数&#xff08;Move C…...

编程日记 2024/5/31 14:45:33

万界星空科技MES系统功能介绍

制造执行系统或MES 是一个全面的动态软件系统&#xff0c;用于监视、跟踪、记录和控制从原材料到成品的制造过程。MES在企业资源规划(ERP) 和过程控制系统之间提供了一个功能层&#xff0c;为决策者提供了提高车间效率和优化生产所需的数据。 万界星空科技MES 系统基础功能&am…...

编程日记 2024/5/31 14:44:32

炸裂的开源AI语音生成模型ChatTTS

今天看到GitHub上开源了一个非常厉害的AI语音生成模型ChatTTS&#xff0c;可以生成和人类声音非常接近的语音&#xff0c;而且有语气、语调、可以停顿和发出笑声&#xff0c;再也没有了以前的AI味道 体验地址&#xff1a;https://colab.research.google.com/drive/1MYep5f0-BJ…...

编程日记 2024/5/31 14:42:30

Mac逆向Electron应用

工具库 解压asar文件 第一步 找到应用文件夹位置 打开活动监视器&#xff1a; 搜索相关应用 用命令行打开刚才复制的路径即可 open Applications/XXX.app/Contents/Resources/app第二步 解压打包文件 解压asar文件...

编程日记 2024/5/31 14:41:29

（三）MobaXterm、VSCode、Pycharm ssh连接服务器并使用

背景&#xff1a;根据前两篇文章操作完成后&#xff0c; 手把手教学&#xff0c;一站式安装ubuntu及配置服务器-CSDN博客 手把手教学&#xff0c;一站式教你实现服务器&#xff08;Ubuntu&#xff09;Anaconda多用户共享-CSDN博客 课题组成员每人都有自己的帐号了&#xff0…...

编程日记 2024/5/31 14:40:28

【Linux】初识信号及信号的产生

初始信号 初始信号什么是信号站在应用角度的信号查看Linux系统定义的信号列表 信号的常见处理方式信号的产生通过终端按键产生信号什么是core dump?如何开启core dump?core dump有什么用&#xff1f;为什么默认关闭core dump&#xff1f;设置了core文件大小但是没有产生core文…...

编程日记 2024/5/31 14:39:27

故障诊断 | 基于 KAN、KAN卷积的轴承故障诊断模型

研究背景： 轴承是机械设备中常见的关键部件之一，其工作状态直接影响设备的性能和可靠性。因此，轴承故障的早期诊断对于设备的正常运行和维护具有重要意义。近年来，基于振动信号的轴承故障诊断成为了研究的热点之一。KAN: Kolmogorov-Arnold Network 是一种有效的处理方法。…...

编程日记 2024/5/31 14:38:26