C++类和对象（中）
✨个人主页： Yohifo
🎉所属专栏： C++修行之路
🎊每篇一句： 图片来源
- I do not believe in taking the right decision. I take a decision and make it right.
- 我不相信什么正确的决定。我都是先做决定，然后把事情做好。
@[toc]
📘前言
祖师爷在设计 C++ 中的类时，规定每个类中都有六个默认成员函数，即使我们不主动写，编译器也会自动生成，这些成员函数就是神秘的天选之子，不仅神秘，而且还很强大，可以这么说：类和对象的是否学懂，取决于对这几个天选之子的理解程度。本文将会逐一介绍这几个默认成员函数，跟随我的脚步，一起揭开他们的神秘面纱
注意：以上函数都需要加上 “默认” 前缀，因为编译器自动生成并调用的是
默认成员函数
📘正文
📖默认成员函数
祖师爷规定，每个类中都必须有这六个默认成员函数：
- 默认构造函数 ==重要==
- 默认析构函数 ==重要==
- 默认拷贝构造函数 ==较重要==
- 默认赋值重载函数 ==较重要==
- 默认取地址重载函数 ==一般==
- 默认
const取地址重载函数 ==一般==
虽说都是祖师爷钦定的天选之子，但最后两个相对来说比较简单，因此介绍也会比较少
默认成员函数规则比较多，尤其是构造和析构，当初祖师爷在设计的时候，部分地方设计欠佳，导致后人在学习 C++ 时，额外增加了不少学习成本
下面就来看看祖师爷是如何设计的、出了什么问题、以及是怎么解决的
📖构造函数
构造函数是祖师爷首先钦定的天选之子
构造函数诞生的目的是为了减少频繁手动初始化的问题，将初始化这个事情变成自动化处理
将C语言和C++都看作车辆，初始化操作看作换挡，可以这样认为：
C语言依赖于手动操作，就像手动挡车辆，有驾驶乐趣，但比较麻烦C++面向对象自动操作，就像自动挡车辆，上手简单，驾驶难度低
我们是可以自己编写构造函数的，祖师爷给了我们这个权力，他钦定的天选之子是默认构造函数，由编译器自动生成，并供类默认调用的，下面来看看编写构造函数的规则
==本文介绍的函数都属于特殊函数，规则和普通函数不同==
构造函数创建规则：
- 函数名和类名相同
- 不需要返回值，甚至连
void都不需要写 - 对象实例化时，编译器
自动调用默认构造函数 - 构造函数支持重载，即可以存在多个构造函数，
但默认构造函数只能有一个
构造函数还有一种特殊形式：默认构造函数
语法规定，不带参数或参数为全缺省的构造函数称为默认构造函数
==默认构造函数有两种写法，推荐全缺省参数的形式==
class Date
{
public:
//特别注意：默认构造函数只允许存在一个形式
//一般推荐使用形式二：全缺省参数
//因为这样方便后续初始化时指定值
////默认构造函数形式一：不带参数
//Date()
//{
// _year = 1970;
// _month = 1;
// _day = 1;
//}
//默认构造函数形式二：参数为全缺省
Date(int year = 1970, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
cout << "Date(int year = 1970, int month = 1, int day = 1)" << endl;
}
//其他普通构造函数，只要与默认构造函数构成重载，都合法
Date(double b)
{
_year = 2023;
_month = 2;
_day = 9;
cout << "Date(double b)" << endl;
}
//……
private:
int _year;
int _month;
int _day;
};
==严格来说，现阶段的初始化方式不规范，此时为赋值==
==正确的初始化方式是使用初始化列表，当然这个东西在下篇介绍==
出自 《Effective C++》
当构造函数写好后，我们就可以这样使用：
int main()
{
//调用默认构造函数，d1 初始化为1970 1 1
Date d1; //相当于 Date d1(); 但不能这样写
//因为调用的是全缺省参数的默认构造函数，我们也可以传参数
//Date d1(2001, 1, 1); //这种初始化也是合法的
//调用自定义构造函数
Date d2(1.1);
return 0;
}
构造函数允许重载，因此调用不会冲突，运行结果如下：
🖋️默认构造函数
如果我们没写默认构造函数， 就会由编译器自动生成，这是祖师爷制定的规则；假如我们写了，同时也满足默认构造函数的需求，编译器就会以我们写的为准，并转而调用我们写的默认构造函数
==注：默认构造函数就是调用时，不需要传参的构造函数==
////默认构造函数形式一：不带参数
//Date()
//{
// _year = 1970;
// _month = 1;
// _day = 1;
//}
//默认构造函数形式二：参数为全缺省
Date(int year = 1970, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
cout << "Date(int year = 1970, int month = 1, int day = 1)" << endl;
}
这里暂时无法给大家演示编译器自动生成并调用的现象
因为祖师爷在设计默认构造函数时，埋下了一个==坑==：
- 默认构造函数不对内置数据类型做处理，如
int、double、char等 - 至于自定义类型，默认构造函数会去调用属于它们的初始化函数(默认构造函数)
注意：数据类型主要分为两类 <内置类型和自定义类型>
简言之：==默认构造函数有点像不干实事的函数==
假设我们的类中只有内置类型，那么默认构造函数真就什么都没有做；出现自定义类型时，也只会主动去调用它的默认构造函数，至于自定义类型的默认构造函数干了什么，类的默认构造函数是不管的
因祖师爷设计疏忽而留下的坑，为后世学习C++增加了阻力
这么看来，这个天选之子似乎没有什么用，默认构造函数还得我们自己编写
不过在有些场景下，默认构造函数很有用
- 题目：用栈实现队列
- 需要在队列这个类中，调用两个栈类，实现队列类
- 此时我们只需要写好栈的
默认构造函数 - 队列类的
默认构造函数不需要写，因为自动生成的会去调用自定义类型的默认构造函数，即栈的默认构造函数，显然是存在的
为了解决祖师爷留下来的坑，委员会在C++11标准中新增了一个补丁声明时给缺省值
🖋️新增补丁
这个补丁是新标准中的，可能部分老编译器不支持
具体操作很简单：在成员变量声明时，将内置类型给上缺省值，调用编译器生成的默认构造函数时，就会以这些缺省值来初始化成员变量，达到初始化的效果
==注意：此时给的是缺省值，并非在声明阶段赋值，类中成员变量为声明阶段==
class Date
{
private:
int _year = 2023; //在内置类型声明时给上缺省值
int _month = 2; //这样即使调用生成的默认构造函数
int _day = 9; //也能达到初始化的效果
};
有了补丁辅助我们后，就可以看看编译器是否调用了默认构造函数
在打了补丁的情况下，实例化一个对象，可以看到效果如下：
C++11中的补丁可以解决内置类型不初始化这个问题，但相对来说，全缺省参数形式的默认构造函数更加实用，不仅能初始化，还能指定初始化值
==注意：这个补丁是为内置类型准备的，对于自定义类型，默认构造函数会去调用属于它的默认构造函数==
==在涉及开辟空间的初始化行为时，可以先给 nullptr，再到默认构造函数体内开辟空间==
📖析构函数
析构函数就是另一个天选之子了
==构造函数：== 解决频繁初始化操作
==析构函数：== 解决频繁销毁操作
不难看出，这是两兄弟，一个负责做菜，一个负责洗碗
此时仍然是手动挡和自动挡的区别
析构函数和构造函数师出同门，规则也都差不多
析构函数创建规则：
- 函数名在类名的前面加上
~ - 也没有返回值，连
void都不需要写 - 对象声明周期结束时，编译器会
自动调用默认析构函数 - 析构函数不支持重载，毕竟不能对同一个对象销毁多次
析构函数也有一种特殊形式：默认析构函数
不过因为析构函数不支持重载，所以默认与否已经不重要了，如果我们写了，编译器就用我们写的默认析构函数，否则就用编译器自动生成的
==默认析构函数也存在默认构造函数的坑：对内置类型不作处理==
🖋️默认析构函数
如果我们没写，编译器会自动生成默认析构函数，假如我们写了，编译器就会用我们写的
==注：默认析构函数是在对象生命周期结束时自动调用==
class Date
{
public:
//析构函数写法比较特殊，需要多加注意
~Date()
{
//假设动态开辟了空间
//是需要在析构函数中释放的
_year = _month = _day = 0;
}
private:
int _year = 2023;
int _month = 2;
int _day = 9;
};
同默认构造函数一样，默认析构函数对内置类型也不处理，对自定义类型，会去调用属于它的默认构造函数
默认构造函数不难写，普通自定义类型是否释放问题不大，但涉及动态内存开辟时，如果不释放内存，就会发生内存泄漏问题，因此当我们的对象涉及动态内存开辟时，需要自己编写默认析构函数，确保安全问题。
~Test()
{
//假设 pa 为动态开辟的空间
//需要释放
free(pa);
pa = nullptr;
}
📖拷贝构造函数
拷贝构造函数 算是 构造函数 的远房亲戚，因为它们的函数名一样，不过参数不同，构成重载
==对于内置类型，我们可以通过 = 完成拷贝，对于自定义类型，规则较多，拷贝需要我们自己完成，因此拷贝构造函数应运而生==
为何自定义类型不能直接赋值？
因为自定义类型种类繁多，比如栈、队列、树、图，数据结构很复杂，尤其是涉及空间开辟问题时，不能简单通过指针赋值完成拷贝，这样会导致重复析构问题；正确做法是 开辟空间->拷贝数据->更新指向->完成拷贝
int a = 10;
int b = a; //内置类型，简单拷贝(赋值)
拷贝构造函数实现也很简单：
class Date
{
public:
//拷贝构造函数，此时是简单拷贝，只能用于非动态内存开辟的空间
//拷贝构造函数函数名与构造函数相同，不过参数类型为类
Date(const Date& d)
{
//d 拷贝给 *this
_year = d._year;
_month = d._month;
_day = d._day;
}
private:
int _year = 2023;
int _month = 2;
int _day = 9;
};
使用时有以下两种用法：
Date d1; //将 d1 拷贝给 d2 和 d3
Date d2(d1); //法一
Date d3 = d1; //法二
既然是天选之子之一，编译器也会生成默认拷贝构造函数
🖋️默认拷贝构造函数
默认拷贝构造函数 是个懂事的函数，对于内置类型，它不再持有偏见，也就是说默认拷贝构造函数能完成简单内置类型的拷贝操作
正常情况下，即成员变量不涉及空间开辟时，拷贝构造函数 没有必要写，用编译器自动生成的足够了
==对于涉及空间开辟的，一定要写默认拷贝构造函数==
class SeqList
{
public:
//现在编写一个涉及空间开辟的拷贝构造函数
SeqList(const SeqList& tmp)
{
_pa = (int*)malloc(sizeof(int) * _capacity);
if (nullptr == _pa)
{
cout << "malloc fail" << endl;
exit(-1); //失败，直接退出程序
}
//将 tmp 空间中的值，拷贝到 *this 中
memcpy(_pa, tmp._pa, sizeof(int) * _size);
_size = tmp._size;
_capacity = tmp._capacity;
}
private:
int* _pa = nullptr;
int _size = 0;
int _capacity = 4; //动态顺序表
};
默认拷贝构造函数实现比较简单，但有一个值得注意的大问题：==无穷递归==
🖋️无穷递归
所谓无穷递归问题就是指设计拷贝构造函数时，参数没有设为引用
如下所示：
SeqList(SeqList tmp)
{
//此时必然会引发无穷递归问题
//……
}
问题出现原因：==值传递，需要先生成临时变量，再传递，而生成临时变量这个行为本身就是在调用拷贝构造函数==
也就是说：此时我们在实现拷贝构造函数，但参数又需要拷贝构造函数 ==这让编译器很难堪==
大力士无法举起自己，光靠金针菇也无法完成卡Bug行为
解决方法：==因为待拷贝对象本来就已经存在，此时可以使用引用，避免产生临时变量，再加以 const 修饰，保护待拷贝对象==
因此正确的拷贝构造函数应该这样写：
SeqList(const SeqList& tmp)
{
//有效避免无穷递归问题
//……
}
🖋️浅拷贝
浅拷贝 就是简单的逐字节序拷贝
==浅拷贝可能出现空间共用的情况==
浅拷贝可能引发对同一块空间的重复析构问题
==浅拷贝不可取，尤其是在面对复杂数据结构时==
🖋️深拷贝
深拷贝需要我们自己实现
深拷贝 在面对空间问题时，会先给 对象2 开辟一块同样大的空间，再将 对象1 空间中的数据拷贝过来
==深拷贝中，两个对象的空间是独立的、互不干扰的==
深拷贝才是众望所归
==当成员涉及复杂数据结构、空间开辟时，就需要写出默认拷贝构造函数==
🖋️小结
构造函数家族至此就介绍完成了，简单小结一下：
| 类型 | 用途 | 处理情况 |
|---|---|---|
| 默认构造函数 | 初始化对象 | 不对内置类型作处理 |
| 默认析构函数 | 销毁对象 | 也不对内置类型作处理 |
| 默认拷贝构造函数 | 拷贝对象 | 只能对简单内置类型做处理 |
何时需要自己写默认析构函数？
- 当我们写出
默认拷贝函数完成复杂对象的拷贝时，就证明需要默认析构函数来释放对象
小技巧：
- 在函数传参与返回时，如果对象生命周期足够长，就可以考虑使用引用的方式，避免参数走
拷贝构造->生成临时变量->再传递的路线，提高程序运行效率
==特别注意：== 默认拷贝构造函数与默认构造函数名相同，当我们只写拷贝而不写构造时，编译器就会报错，因为此时的拷贝会被误以为是默认构造函数
也就是说，==默认拷贝构造函数存在的前提是默认构造函数已存在==
📖运算符重载
C++支持运算符重载，运算符重载使得自定义类型间的符号运算变成可能
比如：
int a = 1;
int b = 2;
a - b; //合法
Date d1;
Date d2;
d1 - d2; //非法，此时需要通过运算符重载解决这个问题
//解决方法如下
const Date operator-(const Date& d)
{
//简单演示，逻辑存在问题，可以忽略
Date tmp(*this); //调用拷贝构造
tmp._year -= d._year; //内置类型，可以正常相减
tmp._month -= d._month; //同理
tmp._day -= d._day; //同上
return tmp; //tmp 为临时变量，不能传引用返回
}
此时就可以正常使用 d1 - d2 了
==注：运算符重载和函数重载没有关系==
🖋️operator操作符
operator 译为运算符，是C++中新的关键字，operator 的作用很简单，实现自定义类型的运算
使用规则：
operator函数中的操作数取决于参数个数operator一般写在类中，方便通过this指针访问成员变量- 写在类中时，
this指针就算一个隐藏参数 operator也可以写在类外，此时会发生无法访问成员变量问题，可以这样解决：- 将成员变量设为
public（不安全） - 通过函数获取类中的成员变量值 （麻烦）
- 设置为友元函数（也比较麻烦）
- 写在类中，最简单、省事，而且还可以使用
this指针
- 将成员变量设为
运算符重载是这样用的：
int main()
{
//注：此时只是演示，日期类的减法不能这样写
Date d1(2023, 2, 9);
Date d2(2022, 2, 9);
Date d3 = (d1 - d2); //结果为 1 0 0
//此时的调用相当于 d1.operator-(d2)
//d1 作为 this 对象传递
//也可以这样使用
Date d4 = operator-(d1, d2);
return 0;
}
基于运算符重载，我们可以干很多事情，比如直接通过 [] 访问类中的成员，实现两个对象的快速运算等操作
🖋️使用注意
operator 虽然很好，但也有很多使用规则：
operator操作符就是函数名- 不能与非操作符链接
- 参数中必须有一个自定义类型
- 对于内置运算符，不能改变其含义
- 成员函数的第一个参数为
this - 有五个运算符不支持重载：
.*稀有运算符，很少见::域作用限定符sizeof操作符? :三目运算符.访问成员符
为何运算符能实现重载？
- 跟函数重载同理，保证函数修饰名不同，构成重载
下面是我测试出的部分运算符重载修饰规则：
==基于运算符重载，我们可以介绍第四个天选之子：赋值重载函数==
📖赋值重载函数
赋值重载函数的实现原理就是运算符重载
此时重载的运算符是 =
赋值重载的目的：==将 d1 对象赋值给 d2，非拷贝构造，d1、d2均已存在==
class Date
{
public:
//赋值重载函数
Date& operator=(const Date& d)
{
//能用引用的地方，就用引用
//避免去走拷贝构造函数
//如果传入的是两个相同值，没必要再执行赋值
if (this == &d)
{
return *this;
}
_year = d._year;
_month = d._month;
_day = d._day;
//返回赋值完成的值，即 *this
return *this;
}
private:
int _year = 2023;
int _month = 2;
int _day = 9;
};
为何传引用？
- 两个对象都已存在，使用引用，提高效率
为何判断相同？
- 避免资源浪费，当类的成员变量很多时，假如出现
d1 = d1 = d1这种情况时，可以有效避免资源浪费
为何返回 *this ？
- 因为可能出现重复赋值的情况，如
d1 = d2 = d3
==赋值重载函数不难实现，只是需要注意的地方很多==
🖋️默认赋值重载函数
祖师爷在实现默认赋值重载函数时，实现的几乎已经很好了，无论是内置类型还是自定义类型，都会处理
==不过默认赋值重载函数仍然是基于字节序的浅赋值，在面对空间开辟时，仍然需要我们自己编写深度赋值重载函数，否则就会发生重复析构问题==
🖋️深度赋值
深度赋值的实现和深拷贝几乎一模一样，这里就不加以赘述
==一但对象中涉及动态内存开辟，必须自己实现深度拷贝==
🖋️注意事项
拷贝构造 和 赋值重载存在本质区别，一个是对象尚未实例化，另一个是两个对象都已存在
当两个对象都被创建，并发生赋值行为时，才叫做赋值重载
Date d1;
Date d2(d1); //拷贝构造，d2 未存在
Date d3 = (d1 - d2); //赋值重载，d1、d2 已存在
涉及空间资源管理时，必须实现深度拷贝
设计赋值重载函数时，充分利用引用，提高效率
📖const修饰
const 修饰可以提高程序的健壮性
const常被用来修饰引用、指针
当被指向对象为常量或临时变量时，必须使用 const 修饰，避免出现权限放大问题
//int* pa = 10; //错误，10 具有常性
const int* pa = (const int*)10; //成功，此时 pa 为常量指针
//int& pb = 20; //错误，20 具有常性
const int& pb = 20; //成功引用，此时 pb = 20
const 一般用来修饰指针参数或引用参数，确保参数在使用过程中不被修改
🖋️修饰*this
引入：两个日期 d1、d2，d1 - d2 时，d1 需要被修改，但 d2 不能被修改，因此实现 operator- 时，参数 d 为 const Date& 类型
我们在实现函数时，存在这种情况 ==确保 *this 不被修改，即 this 指针指向内容不被修改==
this 指针太危险了，如果不加以保护的话，可能实现者的不经意行为会导致严重的后果
class Date
{
public:
//实现简单的打印函数
void Print()
{
cout << _year << "年";
cout << _month << "月";
cout << _day << "日";
cout << endl
//有可能不小心出现这样的情况
_year = _month = _day;
//此时该对象就危险了，成员变量全被改了
}
private:
int _year = 2023;
int _month = 2;
int _day = 9;
};
this 指针给了我们足够的自由，我们在使用时也应该尊重它
class Date
{
public:
//实现简单的打印函数
//原指针类型为 Date* const ，只允许指向对象
//修改指针类型为 const Date* const 双重保护
void Print() const
{
cout << _year << "年";
cout << _month << "月";
cout << _day << "日";
cout << endl
//有可能不小心出现这样的情况
_year = _month = _day; //此时会报错，因为 this 指针类型为 const Date* const
//此时该对象就危险了，成员变量全被改了
}
private:
int _year = 2023;
int _month = 2;
int _day = 9;
};
除了上述情况外，还可能存在这种情况：
const Date d1;
//此时 d1 具有常性，普通的 this 指针无法调动，需要使用 const 指针
总之，const可以修饰this指针，起到保护和权限平移交接的效果
📖取地址重载函数
接下来简单介绍一下剩下两个天选之子
取地址重载函数
- 获取当前对象的地址
class Date
{
public:
Date* operator&()
{
return this;
}
private:
int _year = 2023;
int _month = 2;
int _day = 9;
};
📖const修饰的取地址重载函数
const修饰的取地址重载函数
- 获取
const修饰对象的地址
class Date
{
public:
const Date* operator&() const
{
return this;
}
private:
int _year = 2023;
int _month = 2;
int _day = 9;
};
这两个默认成员函数都很简单，使用编译器默认生成的就够了，除非我们不想让别人获取到当前地址，直接手动设置，每次都返回 nullptr ，当然这种情况几乎不存在
开发者何必为难开发者
📘总结
以上就是关于 类和对象（中） 的全部内容了，本文主要侧重点为 六大天选之子，以及编译器自动生成的默认成员函数，何时用编译器的、何时用我们自己写的，都是有讲究的，部分成员函数规则多、实现麻烦，需要多加练习以加深理解。这里推荐日期类的实现练习，能让我们对类和对象有一个更深层次的理解，关于日期类的实现，我将会在下篇文章中介绍，敬请期待！
如果你觉得本文写的还不错的话，期待留下一个小小的赞👍，你的支持是我分享的最大动力！
如果本文有不足或错误的地方，随时欢迎指出，我会在第一时间改正
…
相关文章推荐
类和对象（上）
C++入门基础
- 点赞
- 收藏
- 关注作者
评论（0）