个人主页： 星纭-CSDN博客
系列文章专栏：C++****
踏上取经路，比抵达灵山更重要。
目录
[五. 构造函数初始化列表](#五. 构造函数初始化列表)
一.类的定义
1.类定义的格式
cpp
#include<iostream>
using namespace std;
class student
{
int score = 99;
int id = 2024;
}; // 分号不能省略class为定义类的关键字，student是类的名字，{}中为类的主体，其中包含的内容称为类的成员，类中的变量称为类的属性或者成员变量，类中的函数称为类的方法或者类的成员函数。
注意类的最后的分号不能省略。
cpp
class Date
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
// 为了区分成员变量，⼀般习惯上成员变量
// 会加⼀个特殊标识，如_ 或者 m开头
int _year; // year_ m_year
int _month;
int _day;
};为了区分成员变量，一般习惯上成员变量会加上一个特殊标识，如成员变量前面加上_或者变量后面加上m等等。注意：这个只是习惯上，并不是必须的。
cpp
typedef struct ListNodeC
{
struct ListNodeC* next;
int val;
}LTNode;
// 不再需要typedef，ListNodeCPP就可以代表类型
struct ListNodeCPP
{
void Init(int x)
{
next = nullptr;
val = x;
}
ListNodeCPP* next;
int val;
};C++中struct也可以定义类，C++兼容C中struct的用法，同时struct升级成了类，明显的变化是struct中可以定义函数，一般情况下我们还是推荐使用class定义类。struct的名称就可以代表类型，不再需要typedef了。
2.访问限定符
C++一种实现封装的方式就是用类将对象的属性和方法结合在一起，让对象更新完善，通过访问权限选择性的将其接口提供给外部客户使用。
访问限定符有三个：public,private,protected.
public修饰的成员在类外可以直接被访问；protected和private修饰的成员在类外面不能直接被访问，protected和private是一样的，后面再讲解二者区别。
cpp
#include<iostream>
using namespace std;
class Date
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
d1.Init(2024,9,3);
//d1._year = 2025;
//在外面是不能改变的
//只能使用init（）函数
return 0;
}访问权限作用域从该访问限定符开始直到下一个访问限定符出现的位置，如果后面没有了，作用域就到}即类的结束。
访问限定符是可以重复的，并不是每一个只能使用一次。
class定义成员没有被访问限定符修饰时默认为private，struct默认为public。
一般成员变量都会被限制为private或者protected防止他人随意改变，需要给别人使用的成员函数才会放为public。
1.3类域
类定义了一个新的作用域，类的所有成员都在类中，在类外定义成员时，需要使用::作用域操作符指明该成员属于哪个类域。
cpp
#include<iostream>
using namespace std;
class Stack
{
public:
// 成员函数
void Init(int n = 4);
private:
// 成员变量
int* array;
size_t capacity;
size_t top;
};
// 声明和定义分离，需要指定类域
void Stack::Init(int n)
{
array = (int*)malloc(sizeof(int) * n);
if (nullptr == array)
{
perror("malloc申请空间失败");
return;
}
capacity = n;
top = 0;
}类域影响的是编译的查找规则，上面程序中init如果不指定类域Stack，那么编译器就把init当成全局函数，那么编译的时候，就会找不到array等成员的定义在哪里，然后就会报错。指定类域Stack,就是知道init是成员函数，当前域找不到的array等成员，就会到类域中去查找。
二.实例化
2.1实例化的概念
用类类型在物理内存中创建对象的过程，称为类实例化出对象。
类是对象进行一种抽象的描述，是一个模型一样的东西，限定了类有哪些成员变量，这些成员变量只是声明，没有分配空间，用类实例化出对象时，才会分配空间。
一个类可以实例化出多个对象，实例化出的对象占用的实际物理空间，储存成员变量。打个比方，用类实例化出对象就像现实中，使用建筑设计图建造出房子，类就是设计图，房子就是对象，设计图规划了有多少个房间，房间的大小功能等，但是并没有实体的建筑存在，也不能住人，用设计图修建出房子，多少人才能住人。同样类就像设计图一样，不能存储数据，实例化出的对象才能分配物理内存存储数据。
cpp
class Date
{
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()
{
// Date类实例化出对象d1和d2
Date d1;
Date d2;
d1.Init(2024, 3, 31);
d1.Print();
d2.Init(2024, 7, 5);
d2.Print();
return 0;
}2.2对象的大小
分析⼀下类对象中哪些成员呢？类实例化出的每个对象，都有独⽴的数据空间，所以对象中肯定包含 成员变量，那么成员函数是否包含呢？⾸先函数被编译后是⼀段指令，对象中没办法存储，这些指令 存储在⼀个单独的区域(代码段)，那么对象中⾮要存储的话，只能是成员函数的指针。再分析⼀下，对 象中是否有存储指针的必要呢，Date实例化d1和d2两个对象，d1和d2都有各⾃独⽴的成员变量 _year/_month/_day存储各⾃的数据，但是d1和d2的成员函数Init/Print指针却是⼀样的，存储在对象 中就浪费了。如果⽤Date实例化100个对象，那么成员函数指针就重复存储100次，太浪费了。这⾥需 要再额外哆嗦⼀下，其实函数指针是不需要存储的，函数指针是⼀个地址，调⽤函数被编译成汇编指 令[call地址]，其实编译器在编译链接时，就要找到函数的地址，不是在运⾏时找，只有动态多态是在 运⾏时找，就需要存储函数地址，这个我们以后会讲解。
C++规定类实例化的对象也要符合内存对⻬的规则。
这个规则和C语言的结构体内存对齐一样
1.第一个成员要放在与结构体偏移量为0的位置上
2.其他成员要对齐到某个数字的整数倍地址处.
这个数叫作对齐数,对齐数 = 编译器默认对齐数与该成员大小的较小值.
vs中默认对齐数为8
3.结构体的总大小为最大对齐数的整数倍。
4.如果嵌套了结构体，嵌套的结构体要对齐到自己最大对齐数的整数倍处，结构体的总大小为所有对齐数（包含嵌套的结构体的对齐数）的最大值的整数倍。
cpp
#include<iostream>
using namespace std;
// 计算⼀下A/B/C实例化的对象是多⼤？
class A
{
public:
void Print()
{
cout << _ch << endl;
}
private:
char _ch;
int _i;
};
class B
{
public:
void Print()
{
//...
}
};
class C
{
};
int main()
{
A a;
B b;
C c;
cout << sizeof(a) << endl;
cout << sizeof(b) << endl;
cout << sizeof(c) << endl;
return 0;
}上面的程序运行以后，我们看到没有成员变量的B和C类对象的大小是1，为什么没有成员变量还要给一个字节呢？因为如果什么都不给，无法表示该对象存在，所以这里给一个字节就是单纯为了站位表示对象存在。
三.this指针
Date类中有init与print两个成员函数，函数体中并没有关于不同对象的区分，那么当d1调用init和print函数时，该函数是如何知道应该访问的是d1对象还是d2对象的呢？
C++给了一个隐含的this指针解决这里的问题。
cpp
class Date
{
public:
// void Init(Date* const this, int year, int month, int day)
void Init(int year, int month, int day)
{
_year = year;
this->_month = month;
this->_day = day;
}
void Print()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};编译器编译后，类成员函数都会默认在形参的第一个位置上加上一个参数增加一个当前类类型的指针，叫做this指针。比如Date类的init真实原型是：
void Init(Date* const this, int year, int month, int day)
但是这个是不能自己显示的写在形参中的，C++规定不能在实参和形参的位置显示的写this 指针，编译时编译器自己会处理，但是我们可以在函数体类显示的使用this指针。
类的成员函数中访问成员变量，本质都是通过this指针访问实现的，如init函数中给_year赋值，this->_year = year;
1.下面程序编译运行的结果是（）
A.编译报错 B.运行崩溃 C.正常运行
cpp
#include<iostream>
using namespace std;
class A
{
public:
void Print()
{
cout << "A::Print()" << endl;
}
private:
int _a;
};
int main()
{
A* p = nullptr;
p->Print();
return 0;
}
这个程序是正常运行的，因为虽然p是一个空指针，但是并没有访问，p->print()编译后会变成上面的指令，仅仅是调用这个函数而已。所以不会报错和崩溃。
cpp
void Print()
{
cout << "A::Print()" << endl;
cout << _a << endl;
}如果把print函数改成这样就会运行崩溃。
四.类的默认成员函数
默认成员函数就是我们自己没有显示写，编译器会自动帮忙生成的成员函数称之为默认成员函数。一个类我们不写的情况下，会默认生成以下六个默认成员函数，C++11以后还会增加两个默认成员函数，移动构造和移动赋值。
1.构造函数
构造函数是特殊的成员函数，需要注意的是它的名字虽然叫做构造，但是构造函数的主要任务并不是开空间创造对象（我们常使用的局部对象是栈帧创建时，空间就开好了），构造函数的功能就是对象实例化时初始化对象。构造函数的本质就是替代我们自己所写的init()函数的功能，构造函数自动调用的特点完美的替代了init();
构造函数的特点：
1.函数名与类名相同
2.没有返回值（这里的没有返回值是什么都没有，连void都不用写）
3.对象实例化的时候，系统会自动调用对应的构造函数
cpp
#include<iostream>
using namespace std;
class Date
{
public:
Date()
{
_year = 1;
_month = 1;
_day = 1;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
return 0;
}
通过调试，我们发现类的成员变量都被初始化为了1.如果不写构造函数，我们就需要写Init()函数来完成我们想要的初始化结果，并且还要自己调用，而析构是在创建完对象后就会自动调用了。
4.构造函数是可以重载的
我们可以写多种构造函数来满足我们的要求
cpp
//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 = 2024, int month = 9,int day = 5)
{
_year = year;
_month = month;
_day = day;
}
//4.半缺省构造
Date(int year, int month = 9, int day = 5)
{
_year = year;
_month = month;
_day = day;
}但是注意：第一种和第三种不能同时存在，因为这样调用的时候就不明确掉用那一个，同理第三种和第四种也不能同时存在，第二种和第三种也不能同时存在。
cpp
Date d2();如果我们通过无参数构造函数来创建对象的时候，对象的后面不要加上括号，否则编译器无法辨认这是函数还是实例化对象。编译器就会发出一下警告
warning C4930: "Date d2(void)": 未调用原型函数(是否是有意用变量定义的?)
5.如果类中没有显示的定义构造函数那么C++编译器就会自动生成一个无参数的默认构造函数，一旦我们自己显示定义了就不会再生成了。
6.无参数构造函数，全缺省构造函数，我们不写时编译器自动生成的构造函数，都叫做默认构造函数。但是这三个函数有且只有一个存在，不能同时存在。无参数构造函数和全缺省构造函数虽然构成函数重载，但是调用的时候会造成歧义。编译器自动生成的构造函数，无参数构造函数，全缺省构造函数都是默认构造，总结一下就是不用传参就可以调用的构造就叫做默认构造。
cpp
class A
{
private:
Date d1;
Date d2;
};如果我们再创建一个类，其中成员变量采用另一个类类型的变量，并且我们不写默认构造函数，编译器对于自定义类型的变量，也会自动调用该变量的构造函数，当然如果这个成员变量没有默认构造函数就会报错。
cpp
public:
A()
{
;
}假设我们写了默认构造函数但是对其什么都不干，这个自定义类型的成员函数还会初始化吗，编译器还是会自动调用其构造函数，当然如果我们要在A类中初始化该自定义类型的成员变量就要用到后面学的初始化列表了
7.我们不写，编译器默认⽣成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始 化是不确定的，看编译器。对于⾃定义类型成员变量，要求调⽤这个成员变量的默认构造函数初始化。
2.析构函数
析构函数的作用与构造函数的作用刚好相反，析构函数的作用不是完成对象本身的销毁，局部对象是存在栈帧的，函数栈帧结束，变量就自动释放了，不需要我们手动销毁，C++规定对象销毁的时候会自动调用析构函数，完成对象中资源的清理释放工作，就和我们之前实现的Stack中的Destory功能，而像Date没有Destory,其实就是没有动态开辟的内存需要释放，所以不需要析构函数的。
析构函数的特点：
1.析构函数的名字就是类的名字前面加上~字符
2.无返回值并且没有参数
3.一个类只能有一个析构函数，如果没有显示的定义，编译器会自动生成一个。
4.对象生命周期结束的时候会自动的调用析构函数
cpp
#include<iostream>
using namespace std;
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()
{
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
STDataType* _a;
size_t _capacity;
size_t _top;
};
int main()
{
Stack st;
return 0;
}通过调试我们发现编译器是会自动调用构造和析构函数的。
cpp
// 两个Stack实现队列
class MyQueue
{
public:
//编译器默认⽣成MyQueue的析构函数调⽤了Stack的析构，释放的Stack内部的资源
// 显⽰写析构，也会⾃动调⽤Stack的析构
/*~MyQueue()
{}*/
private:
Stack pushst;
Stack popst;
};
int main()
{
Stack st;
MyQueue mq;
return 0;
}5.跟构造函数类似，我们不写编译器自动生成的析构函数对内置类型成员不做处理，自定义类型会自动调用他的析构函数。
6.还需要注意的是，我们显示的写析构函数，对于自定义类型的成员变量也会调用它的析构函数，也就是自定义类型无论什么情况下都会自动调用自己的析构函数。
7.如果类里面没有申请任何资源，析构函数是可以不用写的，直接使用编译器生成默认析构函数就行了，但是如果有申请资源，如果不显示的写析构函数就是造成内存泄漏。
3.拷贝构造函数
拷贝构造是一种特殊的构造函数，它的第一个参数是自身类类型的应用，切任何额外参数都有默认值，这就是拷贝构造函数。
拷贝构造的特点：
1.拷贝构造函数是构造函数的一个重载。
2.C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥⾃定义类型传值传参和传值返回都会调⽤拷⻉构造完成。
cpp
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
// 编译报错：error C2652: "Date": ⾮法的复制构造函数: 第⼀个参数不应是"Date"
//Date(Date d)
Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._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;
};//Date(Date d)
3.如果采用这样的拷贝构造就会引发下一次的拷贝构造，语法逻辑上会造成无线递归调用，拷贝构造函数也可以多个参数，但是第一个参数必须是类类型对象的引用，且额外参数必须有缺省值。
cpp
void Func1(Date d)
{
cout << &d << endl;
d.Print();
}
// Date Func2()
Date& Func2()
{
Date tmp(2024, 7, 5);
tmp.Print();
return tmp;
}4.如果没有显示的定义拷贝构造，编译器会自动生成拷贝构造函数，自动生成的拷贝构造对内置类型成员仅仅会完成值拷贝（浅拷贝）一个字节一个字节的拷贝，也就是说如果存在指针变量，那么进行拷贝构造两个指针的值是一样的，也就是两个指针指向的是同一个空间，而对于自定义类型来说，会自动调用其对应的拷贝构造函数。
cpp
Date d1(2024, 7, 5);
Func1(d1);
cout << &d1 << endl;C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥传值传参要调⽤拷⻉构造
所以这⾥的d1传值传参给d要调⽤拷⻉构造完成拷⻉，传引⽤传参可以较少这⾥的拷⻉
输出结果两个地址并不相同
cpp
Date d2(&d1);
d1.Print();
d2.Print();这样也可以完成构造，但是不是拷贝构造，这是通过指针来完成的 ，只是一个普通的构造
cpp
Date d3(d1);
d2.Print();这样写才是拷贝构造，而不是通过指针完成
cpp
// 也可以这样写，这⾥也是拷⻉构造
Date d4 = d1;
d2.Print();这样也是常用的拷贝构造，
cpp
Date ret = Func2();
ret.Print();Func2返回了⼀个局部对象tmp的引⽤作为返回值
Func2函数结束，tmp对象就销毁了，相当于了⼀个野引⽤
输出结果就是随机值 。
cpp
#include<iostream>
using namespace std;
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指向资源创建同样⼤的资源再拷⻉值
_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;
}
void Push(STDataType x)
{
if (_top == _capacity)
{
int newcapacity = _capacity * 2;
STDataType* tmp = (STDataType*)realloc(_a, newcapacity * sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
return;
}
_a = tmp;
_capacity = newcapacity;
}
_a[_top++] = x;
}
~Stack()
{
cout << "~Stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
STDataType* _a;
size_t _capacity;
size_t _top;
};首先我们写一个栈，再用这个栈来写一个队列（简单写一个）
cpp
// 两个Stack实现队列
class MyQueue
{
public:
private:
Stack pushst;
Stack popst;
};
cpp
Stack st1;
st1.Push(1);
st1.Push(2);
Stack st2 = st1;Stack不显⽰实现拷⻉构造，⽤⾃动⽣成的拷⻉构造完成浅拷⻉ ，此时我们调试发现两个stack的_a的值是一样的，也就是两个指向同一个空间，那么程序结束析构的时候，就会对这个空间析构两次，这样程序就崩溃了
确实是析构了两次。
cpp
MyQueue mq1;、
MyQueue mq2 = mq1;MyQueue⾃动⽣成的拷⻉构造，会⾃动调⽤Stack拷⻉构造完成pushst/popst的拷⻉，只要Stack拷⻉构造⾃⼰实现了深拷⻉，他就没问题 、
像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷⻉构造就可以完 成需要的拷⻉，所以不需要我们显⽰实现拷⻉构造。像Stack这样的类，虽然也都是内置类型，但 是_a指向了资源，编译器⾃动⽣成的拷⻉构造完成的值拷⻉/浅拷⻉不符合我们的需求，所以需要 我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)。像MyQueue这样的类型内部主要是⾃定义类型 Stack成员，编译器⾃动⽣成的拷⻉构造会调⽤Stack的拷⻉构造，也不需要我们显⽰实现 MyQueue的拷⻉构造。这⾥还有⼀个⼩技巧，如果⼀个类显⽰实现了析构并释放资源，那么他就 需要显⽰写拷⻉构造，否则就不需要。
传值返回会产⽣⼀个临时对象调⽤拷⻉构造，传值引⽤返回，返回的是返回对象的别名(引⽤)，没 有产⽣拷⻉。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使⽤ 引⽤返回是有问题的，这时的引⽤相当于⼀个野引⽤，类似⼀个野指针⼀样。传引⽤返回可以减少 拷⻉，但是⼀定要确保返回对象，在当前函数结束后还在，才能⽤引⽤返回。
4.赋值运算符重载
1.运算符重载
当运算符被⽤于类类型的对象时，C++语⾔允许我们通过运算符重载的形式指定新的含义。C++规 定类类型对象使⽤运算符时，必须转换成调⽤对应运算符重载，若没有对应的运算符重载，则会编 译报错。
运算符重载是具有特殊名字的函数，他的名字是由operator和后⾯要定义的运算符共同构成。和其 他函数⼀样，它也具有其返回类型和参数列表以及函数体。
cpp
int operator+(int x, int y)
{
return x - y;
}编译会报错，必须要有一个类类型的对象，而且这与原本运算符+的作用不一样，也无法区分。
重载运算符函数的参数个数和该运算符作⽤的运算对象数量⼀样多。⼀元运算符有⼀个参数，⼆元 运算符有两个参数，⼆元运算符的左侧运算对象传给第⼀个参数，右侧运算对象传给第⼆个参数。
但是不能通过连接语法中没有的符号来创建新的操作符：⽐如operator@。
重载运算符分两种情况，一种是直接重载为全局的。
但是重载为全局的⾯临对象访问私有成员变量的问题
cpp
#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()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
//private:
int _year;
int _month;
int _day;
};
bool operator==(const Date& d1, const Date& d2)
{
return d1._year == d2._year
&& d1._month == d2._month
&& d1._day == d2._day;
}如果其中的成员变量不是公有的，那么我们这个运算符重载就是错误的，因为我们不能在类外面访问私有成员变量 。
对应的解决方式：
// 有⼏种⽅法可以解决： // 1、成员放公有 // 2、Date提供getxxx函数 // 3、友元函数 // 4、重载为成员函数
cpp
Date d1(2024, 7, 5);
Date d2(2024, 7, 6);
// 运算符重载函数可以显⽰调⽤
operator==(d1, d2);
// 编译器会转换成 operator==(d1, d2);
d1 == d2;第二种更加常用，
重载成成员函数
cpp
Date& operator++()
{
cout << "前置++" << endl;
//...
return *this;
}
Date operator++(int)
{
Date tmp;
cout << "后置++" << endl;
//...
return tmp;
}这个++运算符就是重载成成员函数的（为写完），因为前置++和后置++的作用不一样，所以为了区分后置++多一个参数int，但是不给变量，只用写一个int就行了
载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，⽆法很好的区分。 C++规定，后置++重载时，增加⼀个int形参，跟前置++构成函数重载，⽅便区分。
重载运算符函数的参数个数和该运算符作⽤的运算对象数量⼀样多。⼀元运算符有⼀个参数，⼆元 运算符有两个参数，⼆元运算符的左侧运算对象传给第⼀个参数，右侧运算对象传给第⼆个参数。
如果⼀个重载运算符函数是成员函数，则它的第⼀个运算对象默认传给隐式的this指针，因此运算 符重载作为成员函数时，参数⽐运算对象少⼀个。
运算符重载之后，其优先级和结合性与对应的内置类型运算符保持一致。
一个类需要重载哪些运算符是看哪些运算符重载之后有意义，比如Date类重载operator-就有意义，日期-日期就可算出日期之间的天数，但是日期加上日期本身是没有什么实际意义的，所以operator+就没有意义，但是日期加天数又有意义，所以operator+是可以重载的。
重载操作符⾄少有⼀个类类型参数，不能通过运算符重载改变内置类型对象的含义
.* :: sizeof ?: . 注意以上5个运算符不能重载。
cpp
Date d1(2024, 7, 5);
Date d2(2024, 7, 6);
// 运算符重载函数可以显⽰调⽤
d1.operator==(d2);
// 编译器会转换成 d1.operator==(d2);
d1 == d2;
// 编译器会转换成 d1.operator++();
++d1;
// 编译器会转换成 d1.operator++(0);
d1++;2.赋值运算符重载
赋值运算符重载是一个默认的成员函数，用于完成两个已经存在的对象直接拷贝赋值，这里要注意跟拷贝构造，赋值运算符重载是用于一个对象赋值给另一个已经存在的对象，而拷贝构造是用一个对象来初始化一个即将创建的对象。两者是不同的。尤其是在使用的时候要区分。
赋值运算符重载的特点：
1.赋值运算符重载是一个运算符重载，规定必须重载为成员函数。赋值运算符的重载的参数建议写成const当前类类型的引用，减少传值传参的拷贝。也防止数据被改变
2.有返回值。
cpp
Date& operator=(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
return *this;
}可以思考一下，为什么这里需要有返回值。
因为，原本的=是可以连续赋值的，a = b = c;
这里之所以可以连续赋值就是因为有返回值。
这里也要有返回值。并且引用返回可以提高效率 。
3.如果我们没有显示的写，编译器会自动生成一个默认赋值运算符重载，默认的赋值运算符重载行为跟默认拷贝构造类似，只会进行浅拷贝，也就是对自定义类型调用其对应的赋值重载函数。
同理会出现指向同一块空间的情况。
cpp
Date d1(2024, 7, 5);
Date d2(d1);
Date d3(2024, 7, 6);
d1 = d3;
// 需要注意这⾥是拷⻉构造，不是赋值重载
// 请牢牢记住赋值重载完成两个已经存在的对象直接的拷⻉赋值
// ⽽拷⻉构造⽤于⼀个对象拷⻉初始化给另⼀个要创建的对象
Date d4 = d1;4.像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的赋值运算符重载就 可以完成需要的拷⻉，所以不需要我们显⽰实现赋值运算符重载。像Stack这样的类，虽然也都是 内置类型，但是_a指向了资源，编译器⾃动⽣成的赋值运算符重载完成的值拷⻉/浅拷⻉不符合我 们的需求，所以需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)。像MyQueue这样的类型内部 主要是⾃定义类型Stack成员，编译器⾃动⽣成的赋值运算符重载会调⽤Stack的赋值运算符重载， 也不需要我们显⽰实现MyQueue的赋值运算符重载。这⾥还有⼀个⼩技巧，如果⼀个类显⽰实现 了析构并释放资源，那么他就需要显⽰写赋值运算符重载，否则就不需要。
5.取地址运算符重载
1.const成员函数
将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后 ⾯。
const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进⾏修改。 const修饰Date类的Print成员函数，Print隐含的this指针由 Date* const this 变为 const Date* const this
cpp
//void Print(const Date* const this) const
void Print() const
{
cout << _year << "-" << _month << "-" << _day << endl;
}
Date d1(2024, 7, 5);
d1.Print();
const Date d2(2024, 8, 5);
d2.Print();如果不加const 那么对于d2这样的对象来说，它本身是不能修改的，但是print函数的this指针是 Date* const this这个是可以更改d2的，又因为this指针不能显示的写出来，所以为了方便，就直接在末尾加上const。表示在该类中不能修改类的任何成员。这是为了防止权限变大
2.取地址运算符重载
取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，⼀般这两个函数编译器⾃动 ⽣成的就可以够我们⽤了，不需要去显⽰实现。除⾮⼀些很特殊的场景，⽐如我们不想让别⼈取到当前类对象的地址，就可以⾃⼰实现⼀份，胡乱返回⼀个地址。
cpp
class Date
{
public :
Date* operator&()
{
return this;
// return nullptr;
}
const Date* operator&()const
{
return this;
// return nullptr;
}
private :
int _year ; // 年
int _month ; // ⽉
int _day ; // ⽇
};五. 构造函数初始化列表
1.之前我们实现构造函数的时候，初始化成员变量都是在函数体内进行赋值，而构造函数初始化还有一种方式，就是初始化列表，初始化列表的使用方式是一个冒号开始，接着就是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
2.每个成员变量在初始化列表中只能出现一次，语法上可以认为初始化列表是每个成员变量定义初始化的地方。
cpp
class Time
{
public:
Time(int hour)
:_hour(hour)
{
cout << "Time()" << endl;
}
private:
int _hour;
};那么这个初始化列表到底有什么用呢？作用好像和直接在函数体内部初始化差不多。
类中的成员变量类型可以有很多种，那么有几个特殊的类型。
cpp
int &a;
const int b;
Time time;对于引用类型来说，声明的时候就必须初始化，因为他是不能改变的。可是如何在函数体内初始化 ？
cpp
c = 100;
a = c;如果这样初始化，并不是让a成为c的别名，而是将a所指向的变量值改成100；
达不到我们想要的初始化结果。
同理const类型也是这样，我们不能更改b的值，也就不能在函数体内进行初始化。
对于这样的情况，就需要在初始化列表中进行初始化 。
3.引⽤成员变量，const成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进⾏初始 化，否则会编译报错。
在C++中，那些你不在初始化列表初始化的成员也会⾛初始化列表。而对于没有默认构造的类类型的变量来说，其因为没有缺省值，所以在初始化列表中就会初始化失败。
- 尽量使⽤初始化列表初始化，因为那些你不在初始化列表初始化的成员也会⾛初始化列表，如果这 个成员在声明位置给了缺省值，初始化列表会⽤这个缺省值初始化。如果你没有给缺省值，对于没 有显⽰在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++并没有规定。对于没有 显⽰在初始化列表初始化的⾃定义类型成员会调⽤这个成员类型的默认构造函数，如果没有默认构 造会编译错误。
5.C++11⽀持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显⽰在初始化列表初始化的 成员使⽤的。
初始化列表总结： ⽆论是否显⽰写初始化列表，每个构造函数都有初始化列表； ⽆论是否在初始化列表显⽰初始化，每个成员变量都要⾛初始化列表初始化；
cpp
class Date
{
public:
Date(int& x, int year = 1, int month = 1, int day = 1)
:_year(year)
, _month(month)
, _day(day)
, _t(12)
, _ref(x)
, _n(1)
{
// error C2512: "Time": 没有合适的默认构造函数可⽤
// error C2530 : "Date::_ref" : 必须初始化引⽤
// error C2789 : "Date::_n" : 必须初始化常量限定类型的对象
}
void Print() const
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
Time _t; // 没有默认构造
int& _ref; // 引⽤
const int _n; // const
};下⾯程序的运⾏结果是什么（）
A.输出1 1
B.输出2 2
C.编译报错
D.输出1 随机值
E.输出1 2
F.输出2 1
cpp
#include<iostream>
using namespace std;
class A
{
public:
A(int a)
:_a1(a)
, _a2(_a1)
{}
void Print() {
cout << _a1 << " " << _a2 << endl;
}
private:
int _a2 = 2;
int _a1 = 2;
};
int main()
{
A aa(1);
aa.Print();
}初始化列表中按照成员变量在类中声明顺序进⾏初始化，跟成员在初始化列表出现的的先后顺序⽆ 关。建议声明顺序和初始化列表顺序保持⼀致。
所以先初始化_a2,_a2是用_a1初始化的，但是此时_a1还没有初始化，所以是随机值，那么_a2也就是随机值，然后再初始化_a1,也就是1.所以是1和随机值。
六.类型转换
1.C++⽀持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数。
cpp
#include<iostream>
using namespace std;
class A
{
public:
// 构造函数explicit就不再⽀持隐式类型转换
// explicit A(int a1)
A(int a1)
:_a1(a1)
{}
//explicit A(int a1, int a2)
A(int a1, int a2)
:_a1(a1)
, _a2(a2)
{}
void Print()
{
cout << _a1 << " " << _a2 << endl;
}
int Get() const
{
return _a1 + _a2;
}
private:
int _a1 = 1;
int _a2 = 2;
};
class B
{
public:
B(const A& a)
:_b(a.Get())
{}
private:
int _b = 0;
};
int main()
{
// 1构造⼀个A的临时对象，再⽤这个临时对象拷⻉构造aa3
// 编译器遇到连续构造+拷⻉构造->优化为直接构造
A aa1 = 1;
aa1.Print();
const A& aa2 = 1;
// C++11之后才⽀持多参数转化
A aa3 = { 2,2 };
// aa3隐式类型转换为b对象
// 原理跟上⾯类似
B b = aa3;
const B& rb = aa3;
return 0;
}构造函数之前加上explicit就不再支持隐式类型转换。类类型的对象之间也可以隐式类型转换。也需要对应的构造函数。
七.static成员
用static修饰的成员变量，称之为静态成员变量，静态成员变量一定要在类外进行初始化。
静态的成员变量为所有类共享的，不属于某个具体的对象，也不存在于对象中，而是存放在静态区。
用static修饰的函数，称之为静态成员函数，静态成员函数没有this指针。
静态成员函数可以访问其他静态的成员，但是不能访问非静态的，因为没有this指针。
突破类域就可以访问静态的成员，可以通过类名：：静态成员或者函数来进行访问。
当然静态成员也受访问限定符的限制。
静态成员变量不能在声明位置给缺省值初始化，因为缺省值是个构造函数初始化列表的，静态成员 变量不属于某个对象，不⾛构造函数初始化列表。
cpp
#include<iostream>
using namespace std;
class A
{
public:
A()
{
++_scount;
}
A(const A& t)
{
++_scount;
}
~A()
{
--_scount;
}
static int GetACount()
{
return _scount;
}
private:
// 类⾥⾯声明
static int _scount;
};
// 类外⾯初始化
int A::_scount = 0;
int main()
{
cout << A::GetACount() << endl;
A a1, a2;
A a3(a1);
cout << A::GetACount() << endl;
cout << a1.GetACount() << endl;
// 编译报错：error C2248: "A::_scount": ⽆法访问 private 成员(在"A"类中声明)
//cout << A::_scount << endl;
return 0;
}八.友元
友元提供了一种突破类访问限定符封装的方式，友元分为：友元函数和友元类，在函数声明或者类声明的签名加friend，并且把友元声明放到一个类的里面
cpp
#include<iostream>
using namespace std;
// 前置声明，都则A的友元函数声明编译器不认识B
class B;
class A
{
// 友元声明
friend void func(const A& aa, const B& bb);
private:
int _a1 = 1;
int _a2 = 2;
};
class B
{
// 友元声明
friend void func(const A& aa, const B& bb);
private:
int _b1 = 3;
int _b2 = 4;
};
void func(const A& aa, const B& bb)
{
cout << aa._a1 << endl;
cout << bb._b1 << endl;
}
int main()
{
A aa;
B bb;
func(aa, bb);
return 0;
}类也是同理，在A中加上 friend class B;那么在B类中就可以访问A的成员。
外部友元函数可访问类的私有和保护成员，友元函数仅仅是⼀种声明，他不是类的成员函数。
友元函数可以在类定义的任何地⽅声明，不受类访问限定符限制。
⼀个函数可以是多个类的友元函数。
友元类中的成员函数都可以是另⼀个类的友元函数，都可以访问另⼀个类中的私有和保护成员。
友元类的关系是单向的，不具有交换性，⽐如A类是B类的友元，但是B类不是A类的友元。
友元类关系不能传递，如果A是B的友元，B是C的友元，但是A不是C的友元。
九.内部类
如果⼀个类定义在另⼀个类的内部，这个内部类就叫做内部类。内部类是⼀个独⽴的类，跟定义在 全局相⽐，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类。
内部类默认是外部类的友元类。
cpp
#include<iostream>
using namespace std;
class A
{
private:
static int _k;
int _h = 1;
public:
class B // B默认就是A的友元
{
public:
void foo(const A& a)
{
cout << _k << endl; //OK
cout << a._h << endl; //OK
}
};
};
int A::_k = 1;
int main()
{
cout << sizeof(A) << endl;
A::B b;
A aa;
b.foo(aa);
return 0;
}内部类本质也是⼀种封装，当A类跟B类紧密关联，A类实现出来主要就是给B类使⽤，那么可以考 虑把A类设计为B的内部类，如果放到private/protected位置，那么A类就是B类的专属内部类，其 他地⽅都⽤不了。
十.匿名对象
⽤类型(实参)定义出来的对象叫做匿名对象，相⽐之前我们定义的类型对象名(实参)定义出来的 叫有名对象 匿名对象⽣命周期只在当前⼀⾏，⼀般临时定义⼀个对象当前⽤⼀下即可，就可以定义匿名对象。
cpp
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
A aa1;
// 不能这么定义对象，因为编译器⽆法识别下⾯是⼀个函数声明，还是对象定义
//A aa1();
// 但是我们可以这么定义匿名对象，匿名对象的特点不⽤取名字，
// 但是他的⽣命周期只有这⼀⾏，我们可以看到下⼀⾏他就会⾃动调⽤析构函数
A();
A(1);十一.对象拷⻉时的编译器优化
现代编译器会为了尽可能提⾼程序的效率，在不影响正确性的情况下会尽可能减少⼀些传参和传返 回值的过程中可以省略的拷⻉。 如何优化C++标准并没有严格规定，各个编译器会根据情况⾃⾏处理。当前主流的相对新⼀点的编 译器对于连续⼀个表达式步骤中的连续拷⻉会进⾏合并优化，有些更新更"激进"的编译器还会进⾏ 跨⾏跨表达式的合并优化。
cpp
#include<iostream>
using namespace std;
class A
{
public:
A(int a = 0)
:_a1(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a1(aa._a1)
{
cout << "A(const A& aa)" << endl;
}
A & operator=(const A & aa)
{
cout << "A& operator=(const A& aa)" << endl;
if (this != &aa)
{
_a1 = aa._a1;
}
return *this;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a1 = 1;
};
void f1(A aa)
{}
A f2()
{
A aa;
return aa;
}
int main()
{
// 传值传参
A aa1;
f1(aa1);
cout << endl;
// 隐式类型，连续构造+拷⻉构造->优化为直接构造
f1(1);
// ⼀个表达式中，连续构造+拷⻉构造->优化为⼀个构造
f1(A(2));
cout << endl;
cout << "***********************************************" << endl;
// 传值返回
// 返回时⼀个表达式中，连续拷⻉构造+拷⻉构造->优化⼀个拷⻉构造 （vs2019 debug）
// ⼀些编译器会优化得更厉害，进⾏跨⾏合并优化，直接变为构造。（vs2022 debug）
f2();
cout << endl;
// 返回时⼀个表达式中，连续拷⻉构造+拷⻉构造->优化⼀个拷⻉构造 （vs2019 debug）
// ⼀些编译器会优化得更厉害，进⾏跨⾏合并优化，直接变为构造。（vs2022 debug）
A aa2 = f2();
cout << endl;
// ⼀个表达式中，连续拷⻉构造+赋值重载->⽆法优化
aa1 = f2();
cout << endl;
return 0;
}