【C++】类和对象（中）
C++知识点更多，文章更用来查缺补漏更好，希望对你们有帮助
1. 类的6个默认成员函数
如果一个类中什么成员都没有，简称为空类。
但是类里面并不是什么都没有，实际上，在什么都不写的情况下，编译器会产生6个默认成员函数
默认成员函数：默认成员函数可以是自己创建的，也可以是编译器默认生成的成员函数
举例（以 构造函数 为例）
class A { A() //不带参数 { ; } A(int x = 4) //全缺省参数 { ; } };
注意事项：
类在实例化的时候一定会调用默认成员函数
2. 构造函数
a. 概念
构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用(即实例化的时候会调用)，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。
b. 特性
1. 函数名与类名相同。
2. 无返回值。 （void 也不用写）
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。
代码举例
#includeusing namespace std; class Data { public: Data(int year = 2, int month = 2, int day = 2) { _year = year; _month = month; _day = day; cout << _year << "年" << _month << "月" << _day << "日" << endl; } private: int _year; int _month; int _day; }; int main() { Data t; return 0; } 运行结果：
分析：
我们可以看到在实例化的时候确实调用了默认成员函数
疑问：
为什么不可以写成 Data t（） ?
因为这样编译器无法辨别它是构造函数还是一个函数的声明（返回类型：Data ，函数名：t , 参数：无参）
#includeusing namespace std; class Data { public: Data(int year = 2, int month = 2, int day = 2) { _year = year; _month = month; _day = day; cout << _year << "年" << _month << "月" << _day << "日" << endl; } Data() { ; } private: int _year; int _month; int _day; }; int main() { Data t; return 0; }
这两个成员函数不构成重载函数，编译器无法确定初始化的时候调用哪个函数
#includeusing namespace std; class Data { public: Data(int year = 2, int month = 2, int day = 2) { _year = year; _month = month; _day = day; cout << _year << "年" << _month << "月" << _day << "日" << endl; } private: int _year; int _month; int _day; }; int main() { Data t(2024,1,5); return 0; } 运行结果：
c. 默认构造函数
默认构造函数：
- 默认构造函数可以是自己创建的（不带参数，或者是 全缺省参数），也可以是编译器默认生成的成员函数
- 默认构造函数只能有一个
如果类中没有构造函数，则C++编译器会自动生成一个无参的默认构造函数
对编译器生成的默认构造函数处理的猜测
编译器生成的默认构造函数对内置类型(如 int , char ,int * ... ...)不做处理（即得到的还是随机值）, 对自定类型（如 calss, union ,struct ......）会自动调用它的构造函数
代码举例
#includeusing namespace std; class Data { public: void Print() { cout << _year << "年" << _month << "月" << _day << "日" << endl; } private: int _year; int _month; int _day; }; int main() { Data t; t.Print(); return 0; } 运行结果：
这里可以看出对 内置类型 没有做任何处理
#includeusing namespace std; class Data { public: Data(int year = 0, int month = 0, int day = 0) { _year = year; _month = month; _day = day; cout << _year << "年" << _month << "月" << _day << "日" << endl; } private: int _year; int _month; int _day; }; class A { Data t1; Data t2; }; int main() { A t3; return 0; } 运行结果：
很明显：实例化对象 t1 , t2 的时候，同时也调用了 它的默认构造函数
注意事项：
C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值。
代码举例
#includeusing namespace std; class Data { public: Data(int year = 0, int month = 0, int day = 0) { _year = year; _month = month; _day = day; } private: int _year; int _month; int _day; }; class A { public: Data t1; Data t2; int size = 0; }; int main() { A t3; cout << t3.size << endl; return 0; } 运行结果：
3. 析构函数
a. 概念
析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。
b. 特性
1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。 （void 也不用写）
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数
代码举例
using namespace std; class stack { public: stack(int n = 4) { int* pa = (int*)malloc(sizeof(int) * n); if (pa == NULL) { perror("malloc fail"); return; } _a = pa; _top = 0; _capacity = 4; cout << "已开辟4字节空间大小" << endl; } ~stack() { free(_a); _a = NULL; cout << "数组已经销毁了" << endl; } private: int* _a; int _top; int _capacity; }; int main() { stack st; return 0; }运行结果：
c. 默认析构函数
- 默认析构函数只能有一个
对编译器生成的默认析构函数处理的猜测
编译器生成的默认析构函数对内置类型(如 int , char ,int * ... ...)不做处理, 对自定义类型（如 class, union ,struct ......）会自动调用它的析构函数
代码举例
#includeusing namespace std; class stack { public: stack(int n = 4) { int* pa = (int*)malloc(sizeof(int) * n); if (pa == NULL) { perror("malloc fail"); return; } _a = pa; _top = 0; _capacity = 4; cout << "已开辟4字节空间大小" << endl; } ~stack() { free(_a); _a = NULL; cout << "数组已经销毁了" << endl; } private: int* _a; int _top; int _capacity; }; class ST { stack t1; stack t2; }; int main() { ST t3; return 0; } 运行结果：
注意事项：
- 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数；有资源申请时，一定要写，否则会造成资源泄漏（比如 类中有动态开辟的的空间时，要写一个析构函数及时释放空间）
- 析构函数像栈一样，都是先进后出释放空间
举例
#includeusing namespace std; class stack { public: ~stack() { free(a); a = nullptr; } private: int* a = (int*)malloc(sizeof(int) * 4); }; int main() { stack t1; stack t2; return 0; } 销毁时，先调用的是后面的析构函数（先t2 , 再t1）
4. 拷贝构造函数
a. 概念
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰，是为了防止改变形参的值)，在用已存在的类类型对象创建新对象时由编译器自动调用。
举例
#includeusing namespace std; class Data { public: Data(int year = 0,int month = 0,int day = 0) { _year = year; _month = month; _day = day; } Data(Data& d) { _year = d._year; _month = d._month; _day = d._day; } private: int _year; int _month; int _day; }; int main() { Data t1; Data t2(t1); return 0; }
b. 特性
1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，（使用传值方式编译器直接报错，因为会引发无穷递归调用）
注意事项：
传值传参时，如果参数是内置类型，如果直接拷贝给形参，但是如果是自定义类型，需要先调用形参的拷贝构造函数（编译器无法承担直接拷贝自定义类型变量的后果）
原因：
对于栈，如果直接拷贝，就会是这样：
如果调用默认析构函数，同一块空间就会被释放两次，所以直接拷贝自定义函数是行不通的
分析（对于参数不是类对象的引用 错误在哪）
class Data
{
pubilc:
Data(int year = 0 , int month = 0, int day = 0)
{
_year = year;
_month = month;
_day = day;
}
Data(Data d)
{
_year = d.year;
_month= d.month;
_day = d.day;
}
private:
int _year;
int _month;
int _day;
}
int mian()
{
Data d1;
Data d2(d1);
return 0;
}
c. 对编译器生成的默认拷贝构造函数处理的猜测
如果没有自己写的拷贝函数，调用拷贝构造函数调用的是 编译器生成的默认拷贝构造函数 （对传值会浅拷贝）
代码举例
#includeusing namespace std; class Data { public: Data(int year = 0,int month = 0,int day = 0) { _year = year; _month = month; _day = day; } void Print() { cout << _year << "/" << _month << "/" << _day << endl; } private: int _year; int _month; int _day; }; int main() { Data t1(2023,1,8); Data t2(t1); t2.Print(); return 0; } 运行结果：
调用的是编译器自己生成的默认拷贝构造函数（即浅拷贝）
但某些情况下，我们需要自己去写拷贝构造函数，完成深拷贝（如：写栈的时候，不能浅拷贝，因为 定义的 int *a 如果是浅拷贝，则类定义的两个对象的成员变量a都是指向同一块空间）
5. 赋值运算符重载
a. 运算符重载
运算符重载是具有特殊函数名的函数 ，可以帮助实现自定义类型的大小比较
函数名字为：关键字operator后面接需要重载的运算符符号。（如：operator+）
注意事项：
- 不能通过连接其他符号来创建新的操作符：比如operator@
- 重载操作符必须有一个类类型参数
- 用于内置类型的运算符，其含义不能改变(如：内置类型的 + 不能改变它原有的含义)
- 作为类成员函数重载时，其形参看起来比操作数数目少1（因为成员函数的第一个参数为隐藏的this）
- .* :: sizeof ?: . 注意以上5个运算符不能重载（这个经常在笔试选择题中出现 ）
代码举例
#includeusing namespace std; class Data { public: Data(int year = 0,int month = 0,int day = 0) { _year = year; _month = month; _day = day; } void Print() { cout << _year << "/" << _month << "/" << _day << endl; } bool operator ==(Data& d) { return _year == d._year && _month == d._month && _day == d._day; } bool operator >(Data& d) { return _year > d._year || ((_year == d._year) && (_month > d._month)) || ((_year == d._year) && (_month == d._month) && _day > d._day); } bool operator >=(Data& d) { return *this == d || *this > d; } bool operator <(Data& d) { return !(*this >= d); } bool operator <=(Data& d) { return *this == d || *this < d; } private: int _year; int _month; int _day; }; int main() { Data t1(2023,1,8); Data t2(2023,1,8); if (t1 == t2) { printf("相等\n"); } return 0; } 运行结果：
b. 赋值运算符重载
将一个类定义的对象的值赋给另一个对象
代码举例
#includeusing namespace std; class Data { public: Data(int year = 0,int month = 0,int day = 0) { _year = year; _month = month; _day = day; } void Print() { cout << _year << "/" << _month << "/" << _day << endl; } Data& operator=(const Data& d) { _year = d._year; _month = d._month; _day = d._day; return *this; } private: int _year; int _month; int _day; }; int main() { Data t1(2023,1,8); Data t2(2023,1,9); Data t3; t3 = t1 = t2; t1.Print(); t3.Print(); return 0; } 运行结果：
分析：
为了能够连续赋值（参考内置类型的连续赋值：int i = j = k ，从右往左运行，把 k 赋值给了 j ，返回 j 的值，再把 j 赋值给 i ，返回 i 的值）
注意事项：
- 参数类型：const T&（传递引用可以提高传参效率）
- 返回值类型：T& （返回引用可以提高返回的效率，有返回值的是为了支持连续赋值）
- 检测是否自己给自己赋值
- 返回 *this ：要复合连续赋值的含义
- 赋值运算符重载成类的成员函数第一个参数是 this指针 ,重载成全局函数 没有 this 指针
对编译器生成的默认赋值运算符重载处理的猜测
和编译器默认生成的拷贝构造函数一样，都是浅拷贝（逐字节的拷贝）
代码举例
#includeusing namespace std; struct Data { public: Data(int year = 1, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } void Print() { cout << _year << "/" << _month << "/" << _day << endl; } private: int _year; int _month; int _day; }; int main() { Data t1(2024, 1, 12); Data t3; t3 = t1; t3.Print(); return 0; } 运行结果：
c. 前置++ 和 后置++ 重载
前置-- 和 后置--实现类似
代码举例
#include#include using namespace std; struct Data { public: Data(int year = 1, int month = 1, int day = 1) { if (year > 0 && month > 0 && month < 13 && day > 0 && day <= GetMonthDay(year, month)) { _year = year; _month = month; _day = day; } else { cout << "日期错误" << endl; exit(0); } } Data& operator+=(int day) { _day += day; while (_day > GetMonthDay(_year, _month)) { _day -= GetMonthDay(_year, _month); _month++; if (_month == 13) { _year++; _month = 1; } } return *this; } int GetMonthDay(int year, int month) { int MonthDay[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 }; if (((year % 4 == 0) && (year % 100 != 0)) || year % 400 == 0) { MonthDay[2]++; } return MonthDay[month]; } Data& operator++() { *this += 1; return *this; } Data operator++(int) { Data tmp = *this; *this += 1; return tmp; } private: int _year; int _month; int _day; }; Data& Data ::operator++() { *this += 1; return *this; } Data Data :: operator++(int) { Data tmp = *this; *this += 1; return tmp; } int main() { Data t1(2024,2 ,23); t1++; //调用 t1.operator++() ++t1; //调用 t1.operator++(0) 参数也可能是其它 int 类型的数字 return 0; } 分析：
为了区分前置加加和后置加加，且能构成重载函数，参数一定要有一个 int 类型（无实际意义）
6. const 成员函数
将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改
代码举例
struct A { public: void fun() const { _a = 5; } private: int _a = 4; }; int main() { A aa; aa.fun(); return 0; }
分析：
// 相当于 const A * this
所以 this 的成员的值不可以修改
7. 取地址及const取地址操作符重载
这两个默认成员函数一般不用重新定义 ，编译器默认会生成。
代码举例
#includeusing namespace std; struct A { private: int _a = 4; }; int main() { A aa; cout << &aa << endl; return 0; } includeusing namespace std; struct A { A* operator&() { return this; } const A* operator&() const { return this; } private: int _a = 4; }; int main() { A aa; cout << &aa << endl; return 0; }