前言：此部分知识点零碎，需要耐心去学习，推荐读者分三部分进行学习
第一部分：一到八
第二部分：九
第三部分：十到十四
目录
一、面向过程和面向对象初步认识
- C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
- C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
以设计一个外卖系统为例进行理解
面向过程：关注下单，接单，送餐这些过程。体现到代码层面就是--方法/函数
面向对象：关注实现类对象及类对象间的关系，用户，商家，骑手以及他们之间的关系。体现到代码层面--类的设计及类之间的关系
C++ 基于面向对象：面向对象和面向过程混编 原因：C++兼容C
java:纯面向对象的
二、类的引入
一个简单的学生类：
struct Student { char name[10]; int age; int id; }; int main() { struct Student s1; //兼容C的用法 Student s2; //升级到类，Student类名，也是类型 strcpy(s1.name, "张三"); s1.id = 1; s1.age = 10; strcpy(s2.name, "张三"); s2.id = 1; s2.age = 10; return 0; }可能有人会说，这不是结构体吗？原因就是：C++兼容C里面结构体的用法，同时struct在C++里面升级成了类
C语言中定义一个变量只能这样用
C++中则可以省略掉struct，同时在C++中，更喜欢将s1,s2称之为对象
C++类与结构体不同的是除了可以定义变量，还可以定义函数/方法
struct Student { //成员变量 char _name[10]; int _age; int _id; //成员函数/成员方法 void Init(const char* name,int age,int id ) { strcpy(_name, name); _age = age; _id = id; } void Print() { cout << _name << endl; cout << _age << endl; cout << _id << endl; } }; int main() { Student s1; //兼容C的用法 Student s2; //升级到类，Student类名，也是类型 s1.Init("张三", 18, 00); s1.Print(); return 0; }然而上面结构体的定义，在C++中更喜欢用class来代替
三.类的定义
class className { // 类体：由成员函数和成员变量组成 }; // 一定要注意后面的分号class 为 定义类的 关键字， ClassName 为类的名字， {} 中为类的主体，注意 类定义结束时后面 分号 。类中的元素称为 类的成员： 类中的 数据 称为 类的属性 或者 成员变量 ; 类中的 函数 称为 类的方法 或者 成员函数 。.ps:声明和定义全部放在类体中，需要注意：成员函数如果 在类中定义 ，编译器可能会将其当成 内联函数 处理。
四.类的访问限定符及封装
还是针对上一个例子，我们将struct改为class，其余不变，发现编译器报了一堆错误
这就关乎到了类的访问限定符
- 1. public修饰的成员在类外可以直接被访问
- 2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
- 3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
- 4. class的默认访问权限为private，struct为public(因为struct要兼容C)
class Student
{
private:
char _name[10];
int _age;
int _id;
public:
void Init(const char* name, int age, int id)
{
strcpy(_name, name);
_age = age;
_id = id;
}
void Print()
{
cout << _name << endl;
cout << _age << endl;
cout << _id << endl;
}
};
int main()
{
Student s1; //兼容C的用法
Student s2; //升级到类，Student类名，也是类型
s1.Init("张三", 18, 00);
s1.Print();
return 0;
}同时需要注意：一般在定义类的时候，建议明确定义访问限定符，不要用class/struct默认限定
C++中struct和class的区别是什么？
解答： C++ 需要兼容 C 语言，所以 C++ 中 struct 可以当成结构体去使用。另外 C++ 中 struct 还可以用来定义类。和 class 是定义类是一样的，区别是 struct 的成员默认访问方式是 public ， class 是的成员默认访问方式是 private。
封装
什么是封装呢？封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行 交互。（数据和方法一起放在了类里面 2.访问限定符 可以给你访问的定义成公有，不想给你访问的定义成私有 ）
(1) 类比当下疫情管理，我国对疫情采取的就是封装，对疫情严重的地方进行隔离开来，而其他有些国家采取的就是不封装，自由管理，不进行隔离，任由其自生自灭。哪种方法更好，想必就不用多说了。(2) 再者如何管理兵马俑呢？比如如果什么都不管，兵马俑就被随意破坏了。那么我们 首先建了一座房子把兵马俑给封装 起来。但是我们目的全封装起来，不让别人看。所以我们 开放了售票通 道 ，可以买票突破封装在合理的监管机制下进去参观。类也是一样，我们使用类数据和方法都封装到一下。 不想给别人看到的，我们使用protected/private 把成员 封装 起来。 开放 一些共有的成员函数对成员合理的访问。所以封装本质是一种管理。
五.类的作用域
类定义了一个新的作用域，类的所有成员都在类的作用域中。在类外定义成员，需要使用 :: 作用域解析符指明成员属于那个类域
错误写法：
正确写法：
六.类的实例化
- 1. 类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它
- 2. 一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量
- 3. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。
七.类对象模型
如何计算类对象的大小
类中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？如何计算一个类的大小？针对这一个类，试着计算下它的大小class Stack { public: void Init(); void Push(int x); private: int* _a; int _top; int _capacity; }; int main() { Stack s1; cout << sizeof(Stack) << endl; cout << sizeof(s1) << endl; }分析：如果计算时，不包括成员函数，只有成员变量，它的大小应该就是12，如果包括成员函数，它的大小应该是20。
由结果可知，在计算类大小时，不包括成员函数，仅有成员变量，并且遵从结构体内存对齐规则。
结构体内存对齐规则
- 1. 第一个成员在与结构体偏移量为0的地址处。
- 2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
- 注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
- VS中默认的对齐数为8
- 3. 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
- 4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是
- 所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
类里面的成员函数又存在哪里呢？
成员函数实际上是存放在公共代码区的，因为每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。所以为了解决此问题，将成员函数存放在了公共代码区。
接着再来计算下以下类的大小
class A1 { public: void f1() {} private: int _a; }; // 类中仅有成员函数 class A2 { public: void f2() {} }; // 类中什么都没有---空类 class A3 {}; int main() { cout << sizeof(A1) << endl; cout << sizeof(A2) << endl; cout << sizeof(A2) << endl; }
需要注意的是空类的大小是1，原因是编译器会给空类一个字节来唯一标识这个类，这个字节不存储有效数据，只表示对象存在
结论：一个类的大小，实际就是该类中”成员变量”之和，当然也要进行内存对齐，
八.this指针
首先我们定义一个日期类
class Date { public: void Init(int year, int month, int day) { _year = year; _month = month; _day = day; } void Print() { cout << _year << endl; cout << _month << endl; cout << _day << endl; } private: int _year; int _month; int _day; }; int main() { Date d1; return 0; }
假设我们将类里面定义的_year名字换成year，会发生什么呢？
class Date { public: void Init(int year, int month, int day) { year = year; _month = month; _day = day; } void Print() { cout << year << endl; cout << _month << endl; cout << _day << endl; } private: int year; int _month; int _day; }; int main() { Date d1; d1.Init(2022, 3,3); return 0; }通过监视我们发现，如果写成year会和初始化中的year重复，导致不进行初始化
原因：当成员变量year与形参year重名的时候，编译器会将左边的year当成形参【用year这个变量的时候，出现与形参同名情况，且他俩在不同作用域，编译器会优先访问近的（也就是形参）相当于当全局变量与局部变量同名的时候会优先访问局部变量】
为了避免这种情况：
1. 建议命名风格区分，这几种风格都是可行的（建议使用这种解决方法）
int _year; int year_; int m_year; int mYear;2. 用 :: 作用域解析符
void Init(int year, int month, int day) { Date::year = year; _month = month; _day = day; }
对于下面这个类，有这样一个问题。
Date 类中有Init 与Print 两个成员函数，函数体中没有关于不同对象的区分，那当d 1 调用Print 函数时，该函数是如何知道应该设置d1 对象，而不是设置d 2 对象呢？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; d1.Init(2022,3,3); d1.Print(); Date d2; d2.Init(2022, 3, 4); d2.Print(); return 0; }
通过汇编我们发现他俩确实是调的同一个函数
解决方式：
C++ 中通过引入 this 指针解决该问题，即： C++ 编译器给每个 “ 非静态的成员函数 “ 增加了一个隐藏的指针参 数，让该指针指向当前对象 ( 函数运行时调用该函数的对象 ) ，在函数体中所有成员变量的操作，都是通过该 指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成 。
实际上Print函数有个隐藏的形参，d1,d2调用时也会有隐藏的实参
同样Init也会被处理
- 1.this指针是隐含的，是编译器编辑时加的，我们不能在显示的在调用函数和函数定义中增加
- 2.可以在成员函数中使用this指针，因为类里面有些地方会有需要
- 3.this是个关键字，一般存在栈中（形参），但不同编译器不同，vs存在ecx寄存器中
- 4.这个this是有const修饰的，这个指针是不能被改变的
下面程序的运行结果是 A.编译报错 B.运行崩溃 C.正常运行
class A { public: void Show() { cout << "Show()" << endl; } private: int _a; }; int main() { A* p = nullptr; p->Show(); }答案是：C
编译是检查不出来空指针的问题的，空指针不是语法错误，空指针是运行时的错误
分析：1. p虽然是空指针，但是p调用成员函数不会编译错误，因为空指针不是语法错误，编译器检查不出来
2.p虽然是空指针，但是p调用成员函数不会出现空指针访问。因为成员函数没有存在对象里面
3.这里会把p作为实参传给隐藏的this指针。传空指针不报错，空指针只要不去解引用是不会报错的。
这道题，并没有解引用this
下面程序的运行结果是 A.编译报错 B.运行崩溃 C.正常运行
class A { public: void PrintA() { cout << _a << endl; } private: int _a; }; int main() { A* p = nullptr; p->PrintA(); }答案是：B
这道题解引用了this，也就是解引用了空指针
九.类的6个默认成员函数
构造函数
构造函数 是一个 特殊的成员函数，名字与类名相同 , 创建类类型对象时由编译器自动调用 ，保证每个数据成员都有一个合适的初始值，并且在对象的生命周期内只调用一次 。其特征如下：
- 1. 函数名与类名相同。
- 2. 无返回值。
- 3. 对象实例化时编译器自动调用对应的构造函数。
- 4. 构造函数可以重载。
这就是两个构造函数
class Date { public: Date() { _year = 0; _month = 0; _day = 0; } Date(int year, int month, int day) { _year = year; _month = month; _day = day; } private: int _year; int _month; int _day; };int main() { Date d1; //调用无参构造函数 Date d2(2022, 3, 3); //调用带参的构造函数 }
一般我们更推荐全缺省或半缺省构造函数，但是缺省构造函数不能和无参的构造函数同时存在，语法上他俩可以共存，但在无参调用的时候就会产生二义性。编译器不知道该调用哪个
如下图：
注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明以下代码的函数：声明了 d3 函数，该函数无参，返回一个日期类型的对象Date d3 ();
5. 如果类中没有显式定义构造函数，则 C++ 编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。关于编译器生成的默认成员函数，会有很多疑惑：在我们不实现构造函数的情况下，编译器会生成 默认的构造函数。但是看起来默认构造函数又没什么用？对象调用了编译器生成的默认构造函数，但是对象year/month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么卵用？？
类型的分类（重要）
原因： C++里面把类型分为两类：内置类型（基本类型，语言原生定义的类型）和自定义类型
内置类型 如：int，char，double，指针，内置型数组等等，自定义类型：我们是用class，struct等定义的类型，我们不写编译器默认生成的构造函数，对于内置类型不做初始化处理，对于自定义类型成员变量会去调用它的默认构造函数（不用参数就可以调的）初始化，如果没有默认构造函数就会报错
默认构造函数
无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数。
eg：
class A
{
public:
A()
{
cout << "A()" << endl;
_a = 0;
}
private:
int _a;
};
class Date
{
public:
private:
//内置类型
int _year;
int _month;
int _day;
//自定义类型
A _aa;
};
int main()
{
Date d1;
}
通过监视与运行结果，我们发现，Date这个类中的默认构造函数，自动去调用了A这个类里面的默认构造函数。
如果A中没有默认的构造函数，代码如下
class A { public: A(int a) { cout << "A()" << endl; _a = 0; } private: int _a; }; class Date { public: private: int _year; int _month; int _day; A _aa; }; int main() { Date d1; }
编译器就会报错。
这块可以说是C++设计不好的一部分，仅对自定义类型成员变量进行初始化，不对内置类型成员变量进行初始化。
析构函数
- 1. 析构函数名是在类名前加上字符 ~。
- 2. 无参数无返回值。
- 3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
- 4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。
class Date
{
public:
Date(int year=0,int month=0,int day=0)
{
_year = year;
_month = month;
_day = day;
}
~Date()
{
//Date类没有资源要清理，不用实现析构也可以
cout << "~Date()" << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
Date d2(2022, 3, 3);
}
在日起类中的析构函数似乎没什么用处，但在栈类中的析构函数却骑着十分重要的作用
class stack { public: stack(int capcity = 4) //将上面的合而为一 { if (capcity == 0) { _a = nullptr; _size = _capcity = 0; } else { _a = (int*)malloc(sizeof(int) * capcity); _size = 0; _capcity = capcity; } } void push(int x) {} //stack的析构函数具有重大意义 ~stack() { cout << "~Stack()析构函数" << endl; free(_a); _a = nullptr; _size = _capcity = 0; } private: int* _a; int _size; int _capcity; }; int main() { stack st1; stack st2; return 0; }构造与析构顺序：st1先构造，st2后构造，st2先析构，st1后析构
s1,s2是存在栈中的，但s1,s2指向的空间是堆上面的，堆上的资源不手动释放是不会释放的
如果我们不写析构函数，默认生成的析构函数和构造函数类似，对内置类型的成员变量不进行处理，对自定义类型的成员变量会去调用它的析构函数
class stack { public: stack(int capcity = 4) //将上面的合而为一 { if (capcity == 0) { _a = nullptr; _size = _capcity = 0; } else { _a = (int*)malloc(sizeof(int) * capcity); _size = 0; _capcity = capcity; } } void push(int x) {} //stack的析构函数具有重大意义 ~stack() { cout << "~Stack()析构函数" << endl; free(_a); _a = nullptr; _size = _capcity = 0; } private: int* _a; int _size; int _capcity; }; class Date { public: Date(int year = 0, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } private: int _year; int _month; int _day; stack _st; }; int main() { Date d1; return 0; }
总结：析构函数完成对象中资源的清理，如果类对象需要资源清理，才需要自己实现析构函数。析构函数生命周期到了以后，自动调用
拷贝构造函数
class Date { public: Date(int year = 0, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } Date(const Date& d) //拷贝构造函数 { _year = d._year; _month = d._month; _day = d._day; } private: int _year; int _month; int _day; }; int main() { Date d1(2022,3,3); Date d2(d1); return 0; }拷贝构造函数也是特殊的成员函数，其特征如下：
1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须使用引用传参（一般用const修饰），使用传值方式会引发无穷递归调用。（调用拷贝构造函，需要先传参数，传值传参又是一个拷贝构造。）
若未显示定义，系统生成默认的拷贝构造函数。
默认生成的构造函数：
1.0 对内置类型成员，会完成按字节序的拷贝。（浅拷贝）
字节序拷贝就是指对于两个同类型的对象d1，d2，会将d1这块空间里的东西一个字节一个字节的拷贝给d2，就像memcpy一样
class Date { public: Date(int year = 0, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } private: int _year; int _month; int _day; }; int main() { Date d1(2022,3,3); Date d2(d1); return 0; }
我们没有写拷贝构造，默认生成的将d1拷贝给了d2
那么编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？class stack { public: stack(int capcity = 4) //将上面的合而为一 { if (capcity == 0) { _a = nullptr; _size = _capcity = 0; } else { _a = (int*)malloc(sizeof(int) * capcity); _size = 0; _capcity = capcity; } } void push(int x) {} //stack的析构函数具有重大意义 ~stack() { cout << "~Stack()析构函数" << endl; free(_a); _a = nullptr; _size = _capcity = 0; } private: int* _a; int _size; int _capcity; }; int main() { stack st1(10); stack st2(st1); return 0; }
发生报错，原因如下
拷贝的时候是没问题的，完成了浅拷贝，但是当析构的时候就出现问题了
出了作用域以后st2需要析构，它的析构函数会对它指向的空间进行释放，st1在进行析构，又对这块空间进行了释放，显而易见，一块空间是不能释放两次的，导致程序崩溃。
2.0对自定义类型成员，会调用自定义类型成员的拷贝构造
class A { public: A() { } A(const A& a) { cout << "const A& a" << endl; } }; class Date { public: Date(int year = 0, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } private: int _year; int _month; int _day; A _a; }; int main() { Date d1; Date d2(d1); return 0; }
赋值运算符重载
运算符重载
C++ 为了增强代码的可读性引入了运算符重载 ， 运算符重载是具有特殊函数名的函数 ，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。函数名字为：关键字 operator 后面接需要重载的运算符符号 。函数原型： 返回值类型 operator 操作符 ( 参数列表 )注意：
- 不能通过连接其他符号来创建新的操作符：比如operator@
- 重载操作符必须有一个类类型或者枚举类型的操作数
- 用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不 能改变其含义
- 作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的
- 操作符有一个默认的形参this，限定为第一个形参
- .* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。
我们以日期类为例：实现一个比较日期大小的 >重载
class Date { public: Date(int year = 0, int month = 0, int day = 0) { _year = year; _month = month; _day = day; } int _year; int _month; int _day; }; bool operator>(const Date& d1, const Date& 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; } else { return false; } } int main() { Date d1(2022, 1, 16); Date d2(2022, 1, 31); Date d3(2022, 3, 3); //默认情况下C++是不支持自定义类型对象使用运算符的 cout << (d1 > d2) << endl; cout << operator>(d1, d2) << endl; }我们可以直接通过 d1>d2 直接调用 > 运算符重载；也可以通过operator>(d1, d2)调用；实际上当直接调用 d1>d2，编译器在底层就会将它转化成operator>(d1, d2)。
这是我们定义在全局的运算符重载函数，这里会发现运算符重载成全局的就需要成员变量是公有的，那么问题来了，封装性如何保证？
解决方法：我们直接将这个运算符重载函数写到类里面
但当我们直接将它写进类里面后，发现报错，此运算符函数的参数太多，原因就是隐藏的this指针首先我们调用的时候会这样调用
所以我们要将运算符重载函数中的参数去掉一个，将它改为
class Date { public: Date(int year = 0, int month = 0, int day = 0) { _year = year; _month = month; _day = day; } bool 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; } } private: int _year; int _month; int _day; };
这个地方写不写this都可以，类里面是允许写出this的，一般我们是会省略掉this的
赋值运算符重载
赋值运算符主要有四点：
- 1. 参数类型
- 2. 返回值
- 3. 检测是否自己给自己赋值
- 4. 返回*this
- 5. 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。
一个已经存在的对象拷贝初始化一个马上创建实例化的对象-->拷贝构造 Date d4(d1);
两个已将存在的对象，之间进行赋值拷贝 d1 = d3;
我们自身实现一个赋值的运算符重载
class Date { public: Date(int year = 0, int month = 0, int day = 0) { _year = year; _month = month; _day = day; } void operator=(const Date& d) { _year = d._year; _month = d._month; _day = d._day; } private: int _year; int _month; int _day; }; int main() { Date d1(2022, 1, 16); Date d2(2022, 1, 31); Date d3(2022, 3, 3); d1 = d3; }但是我们发现，它并不支持连续赋值功能
所以我们对赋值运算符重载的返回值进行修改。
我们首先分析一下赋值表达式
int i, j, k; i = j = k = 10;连续赋值的执行，从右向左，先将10赋值给K，这个赋值表达式有一个返回值，这个返回值就是左操作数K，然后K在做右操作数，赋值给j,这也有一个返回值j,然后j在做右操作数，赋值给i,同样有一个返回值i，但是现在并没有变量接受 。
由此可得，日起类实例化出的对象需要实现连续赋值，就需要有返回值，返回值就是这些对象的类型Date。return返回的就应该是左操作数，也就是this，this是一个指针，所以返回的应该是*this
Date operator=(const Date& d) { _year = d._year; _month = d._month; _day = d._day; return *this; }但是现在又有一个新的问题，我们使用的是传值返回，传值就要有拷贝，我们自己写一个拷贝构造进行验证
class Date { public: Date(int year = 0, int month = 0, int day = 0) { _year = year; _month = month; _day = day; } Date(const Date& d) { cout << "拷贝构造" << endl; } Date operator=(const Date& d) { _year = d._year; _month = d._month; _day = d._day; return *this; } private: int _year; int _month; int _day; }; int main() { Date d1(2022, 1, 16); Date d2(2022, 1, 31); Date d3(2022, 3, 3); d2 = d1 = d3; }
发现一共调用了两次拷贝构造，那么这个拷贝构造能否消除掉呢？我们一般是通过引用返回来实现的，而恰好，这个*this除了作用域后依然存在，因为*this就是调用这个成员函数的对象，所以我们可以用传引用返回。
Date& operator=(const Date& d) { _year = d._year; _month = d._month; _day = d._day; return *this; }
经验证，也确实没有调用拷贝构造。
赋值运算符重载目前看来已经没什么大的问题了，但是不排除有人会这样调用 d1=d1;，将自身赋值给自身，这样写是没有问题的，但是我们可以对他进行优化
Date& operator=(const Date& d) { //极端情况下自己给自己赋值就可以不用处理了，直接判断一下跳过 if (this != &d) { _year = d._year; _month = d._month; _day = d._day; } return *this; }
编译器默认生成赋值重载
编译器默认生成赋值重载，跟拷贝构造做的事情完全类似
- 内置类型成员变量，会完成字节序值拷贝---浅拷贝
- 自定义类型成员变量，会调用它的operator=
内置类型函数
class Date { public: Date(int year = 0, int month = 0, int day = 0) { _year = year; _month = month; _day = day; } private: int _year; int _month; int _day; }; int main() { Date d1(2022, 1, 16); Date d2(2022, 1, 31); Date d3(2022, 3, 3); d2 = d1 = d3; }
同理对于日期类，默认生成的赋值运算重载就可以满足需求。对于栈类，默认生成的赋值运算重载不能实现需求。我们需要自己去实现深拷贝的拷贝构造
小问题
int main() { Date d1(2022, 1, 16); Date d2(2022, 1, 31); Date d3(2022, 3, 3); d2 = d1 = d3; Date d5 = d1; }Date d5 = d1;这是拷贝构造还是赋值重载呢？
答案：这是拷贝构造，因为这是一个已经存在的对象拷贝初始化一个马上创建实例化的对象
总结一下：默认生成的这四个默认成员函数，构造和析构处理机制是类似的，拷贝构造和赋值重载处理机制是类似的
const成员
以日期类为例
class Date { public: void Print() { cout << _year << "-" << _month << "-" << _day << endl; } private: int _year; int _month; int _day; };当主函数这样调用是出现了报错
原因就是权限的放大
为了解决这个问题，C++增加了一个const成员函数，即在函数声明的后面加一个const，因为this是隐藏的，不能显示的加这个const
总结：成员函数加const都是好的，建议能加const的都用上，这样普通对象和const对象都可以调用。但是如果要修改成员变量的函数，是不能加const的
取地址及const取地址操作符重载（了解）
这两个默认成员函数一般不用重新定义 ，编译器默认会生成。class Date { public: private: }; int main() { Date d1; const Date d2; cout << &d1 << endl; cout << &d2 << endl; }
我们不写，也是可以的，编译器默认生成的足够使用
当然，你自己非要写也是可以的
class Date { public: Date* operator&() { return this; } const Date* operator&()const { return this; } }; int main() { Date d1; const Date d2; cout << &d1 << endl; cout << &d2 << endl; }这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比 如想让别人获取到指定的内容！
十.再谈构造函数
声明、定义、初始化三个概念
首先要明白声明、定义、初始化三个概念的不同。
声明：指定变量的名字和类型，可以多次声明。
定义：为该成员变量分配存储空间，有且仅有一个定义。
初始化：为该成员变量赋初值。
在类的声明中，静态成员变量仅完成了声明过程，并没有进行定义和赋初值。
静态成员变量在编译时存储在静态存储区，即定义过程应该在编译时完成，因此一定要在类外进行定义，但可以不初始化。
构造函数体赋值
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};初始化列表
class Date
{
public:
Date(int year, int month, int day)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};
和之前的调用方式也都是一样的。
初始化列表的意义
假设我们定义了一个const int _N;
class Date
{
public:
private:
int _year; //声明
int _day;
int _month;
const int _N;
};
有人说在声明的时候初始化
C++规定是不能在这里初始化的，因为这里是声明，声明不能初始化，初始化是给他的空间给值（已经有空间了），但声明的时候并没有开空间，所以就不能给他的空间给值
如果在构造函数中初始化，就会报这种错误，说明到构造函数体内的时候 ，成员变量已经定义出来了
基于这样的原因，初始化列表就派上用场了
Date(int year, int month, int day) :_year(year) ,_month(month) , _day(day) ,_N(10) {}这样也是可行的
Date(int year , int month , int day ) :_N(10) { _year = year; _month = month; _day = day; }
C++在这块的规定并不是必须用初始化列表初始化，也不是必须在函数体内初始化。而是灵活调用
初始化列表是成员变量定义的地方。它的初始化相当于是 int j =10;
而在函数体体内初始化。相当于是 int j ; j=10; 先定义，过了一会在初始化。
两者更推荐初始化列表初始化。必须在定义的时候初始化的变量必须用初始化列表初始化，其他的无所谓。除了const 还有以下两种：
- 引用成员变量
- 自定义类型成员(该类没有默认构造函数)
eg：
class A
{
public:
A(int a)
{
_a = a;
}
private:
int _a;
};
class Date
{
public:
Date(int year, int month, int day,int i)
:_year(year)
,_month(month)
, _day(day)
,_N(10)
,_ref(i)
,_aa(-1)
{}
void Print()
{
cout << _year << "-" << _month << "_" << _day << endl;
}
private:
int _year; //声明
int _day;
int _month;
const int _N;
int& _ref;
A _aa; //A 没可用的默认构造函数
};
int main()
{
int i = 0;
Date d1(2022, 1, 31, i);
}
如果非要使用在函数体内去初始化自定义类型成员时
class A { public: A(int a=0) { cout << "A(int a=0)" << endl; _a = a; } A(const A& aa) { cout << "A(const A& a)" << endl; _a = aa._a; } A& operator=(const A& aa) { cout << "A& operator=(const A&a)" << endl; _a = aa._a; return *this; } private: int _a; }; class Date { public: Date(int year, int month, int day, const A& aa) { _year = year; _month = month; _day = day; _aa = aa; } void Print() { cout << _year << "-" << _month << "_" << _day << endl; } private: int _year; //声明 int _day; int _month; A _aa; }; int main() { A aa(10); Date(2022, 3, 3, aa); }
发现调用了两次构造，一次=重载，分析：
虽然我们没有写初始化列表，但是初始化列表是成员变量定义的地方，_aa会在初始化列表调用定义的默认构造函数初始化
如果我们用了初始化构造
class A { public: A(int a=0) { cout << "A(int a=0)" << endl; _a = a; } A(const A& aa) { cout << "A(const A& a)" << endl; _a = aa._a; } A& operator=(const A& aa) { cout << "A& operator=(const A&a)" << endl; _a = aa._a; return *this; } private: int _a; }; class Date { public: Date(int year, int month, int day, const A& aa) :_aa(aa) { _year = year; _month = month; _day = day; } void Print() { cout << _year << "-" << _month << "_" << _day << endl; } private: int _year; //声明 int _day; int _month; A _aa; }; int main() { A aa(10); Date(2022, 3, 3, aa); }
分析：
所以自定义类型用初始化列表初始化更高效
PS：自定义类型在初始化列表初始化，不管这个自定义类型有没有默认的构造函数，都会去调用它的默认构造函数
class A
{
public:
A(int a)
{
cout << "A(int a=0)" << endl;
_a = a;
}
A(const A& aa)
{
cout << "A(const A& a)" << endl;
_a = aa._a;
}
A& operator=(const A& aa)
{
cout << "A& operator=(const A&a)" << endl;
_a = aa._a;
return *this;
}
private:
int _a;
};
class Date
{
public:
Date(int year, int month, int day)
:_aa(88)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "_" << _day << endl;
}
private:
int _year; //声明
int _day;
int _month;
A _aa;
};
int main()
{
Date(2022, 3, 3);
}
总结下：
- 初始化列表是成员变量定义的地方
- const,引用，没有默认构造函数的自定义类型成员变量必须在初始化列表初始化，因为他们都必须在定义的时候初始化
- 对于其他类型成员变量，如int _year,int _month .在哪初始化都可以
- 初始化列表就是给成员变量找了一个依次定义处理的地方
-
有两种初始化的方式，一种是在构造函数体内对成员变量进行初始化，一种是使用初始化列表来初始化成员变量，都可以达到初始化成员变量的效果，但是尽量使用初始化列表初始化，这是因为所有构造函数都要走初始化列表，初始化列表会给每个成员都进行一次初始化，如果你的初始化列表显示初始化了某个成员，它就会去初始化，如果你没有显式初始化某个成员，它也会初始化，对于内置类型的成员变量，它会按照默认值进行初始化，如果没有设置默认值，就会用随机值进行初始化，对于自定义类型成员会调用它的默认构造函数进行初始化。
也就是说尽管你在函数体内进行初始化操作，实际上人家已经在初始化列表中就已经初始化过了，所以还不如在初始化列表中直接进行初始化操作，这样就可以减少默认构造函数调用的次数，这样就会更高效一些。
小问题：
对下面这段代码，正确的是
class A { public: A(int a) :_a1(a) ,_a2(_a1) {} void Print() { cout<<_a1<<" "<<_a2<<endl; } private: int _a2; int _a1; } int main() { A aa(1); aa.Print(); }A . 输出 1 1B . 程序崩溃C . 编译不通过D . 输出 1 随机值
答案是：D
原因：成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关
_a2先声明，先初始化_a2,这是_a2和_a1都是随机值，所以_a2就被初始化成随机值，随后_a1被初始化成立1
explicit关键字
class Date { public: Date(int year) :_year(year) { cout<<"Date(int year)" << endl; } Date(const Date& date) { cout << "Date(const Date& date)" << endl; } private: int _year; //声明 }; int main() { Date d(2022); Date d2 = 2022; //隐式类型转换 }观察这段代码，Date d5 = 2022; 这个赋值是可以实现的，编译器也不会报错，它就相当于是发生了隐式类型转换。
什么是隐式类型转换呢？这里简单回顾一下。
double i = 1.1; int j = i;这段代码就是隐式类型转换，因为 i 和 j 相近类型，意义相似，他们都是表示数据大小,所以可以将 i 赋值给 j ，PS：隐式类型转换还会产生一个临时变量，博主在C++基础入门中引用那部分有介绍过。而下面这段代码发生的就是强制类型转换int* p = &j; int d = (int)p;因为他俩一个表示地址，一个表示大小，不发生隐式类型转换，但是可通过强制类型转换。
发生隐式类型转换的原因：
而此刻这个日期类也发生了隐式类型转换，本来整形和日期类没有任何关系，但是我们写的类支持一个单参数的构造函数后，整形就可以构造一个日期类的对象。
本来是用2022构造一个临时对象Date（2022），再用这个对象拷贝构造d2，但是C++编译器在连续的一个过程中，多个构造会被优化，合二为一，所以这里被优化为直接构造。注意：虽然他俩都是直接构造但是他俩的意义是不一样的。
解决方法：
如果我们不想发生隐式类型转换，我们就可以用用explicit修饰构造函数，将会禁止单参构造函数的隐式转换。
class Date { public: //不想让这个过程发生就加这个关键字 explicit Date(int year) :_year(year) { cout << "Date(int year)" << endl; } Date(const Date& date) { cout << "Date(const Date& date)" << endl; } private: int _year; //声明 };
十一.static成员
概念 ： 声明为static 的类成员 称为 类的静态成员 ，用 static 修饰的 成员变量 ，称之为 静态成员变量 ；用 static 修饰 的 成员函数 ，称之为 静态成员函数 。 静态的成员变量一定要在类外进行初始化特性
- 1. 静态成员为所有类对象所共享，不属于某个具体的实例
- 2. 静态成员变量必须在类外定义，定义时不添加static关键字，同时要指定它是属于这个类
- 3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问
- 4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
- 5. 静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值
实现一个类，计算中程序中创建出了多少个类对象。
int _count = 0;
class A
{
public:
A(int a = 0)
{
_count++;
}
A(const A& a)
{
_count++;
}
private:
int _a;
};
void f(A a)
{
}
int main()
{
A a1;
A a2 = 1;
f(a1);
cout << _count << endl;
}这是已经实现好的，但是会有很多缺点，_count是全局变量，会被随意修改，
如果我们将他定义为成员变量呢？ 也是不行的，因为这样的话，_count就成了每个对象都有的成员起不到计数的作用。
这时候static就派上用场了
class A { public: A(int a = 0) { _Scount++; } A(const A& a) { _Scount++; } private: int _a; //静态成员变量属于整个类，所有对象，生命周期在整个程序运行期间 static int _Scount; //声明 }; int A::_Scount = 0; //定义初始化在成员变量前加static就可以把他定义成静态成员变量了。静态成员变量属于整个类，所有对象，生命周期在整个程序运行期间。在类型外面定义的时候，要指定它是属于这个类
关于_Scount的访问
关于_Scount的访问，假设它是公有的，类静态成员即可用类名::静态成员或者对象.静态成员来访问
当它是私有的时候又该怎么办呢？
1.0 我们可以写一个公有的函数去用对象去访问他，但这种方式不能用类名::成员函数去访问，只能用对象去访问
class A
{
public:
A(int a = 0)
{
_Scount++;
}
A(const A& a)
{
_Scount++;
}
int Getcount()
{
return _Scount;
}
private:
int _a;
static int _Scount; //声明
};
int A::_Scount = 0; //定义初始化
void f(A a)
{
}
int main()
{
A a1;
A a2 = 1;
f(a1);
cout << a1.Getcount() << endl;
}2.0 将这个成员函数也定义成静态的，它的特点就是没有this指针只能访问静态成员变量和函数，既可以用类名::成员函数去访问，还可以用对象去访问
class A
{
public:
A(int a = 0)
{
_Scount++;
}
A(const A& a)
{
_Scount++;
}
static int Getcount()
{
return _Scount;
}
private:
int _a;
//静态成员变量属于整个类，所有对象，生命周期在整个程序运行期间
static int _Scount; //声明
};
int A::_Scount = 0; //定义初始化
void f(A a)
{
}
int main()
{
A a1;
A a2 = 1;
f(a1);
cout << A::Getcount() << endl;
cout << a1.Getcount() << endl;
}十二.C++11 的成员初始化新玩法
class B
{
public:
B(int b=0)
:_b(b)
{}
private:
int _b;
};
class A
{
public:
private:
int _a=0;
B _bb;
};
int main()
{
A _aa;
return 0;
}
缺省值就是如果你没有显示的去初始化这个_a，就用这个缺省值去初始化了，如果你显示的去初始化了_a,就不会用缺省值了。如果你在初始化列表阶段没对成员变量初始化，这里就会使用缺省值初始化。
除此外还能这样进行以下操作（ vs2019 以上的版本都是支持的）
class B { public: B(int b=0) :_b(b) {} private: int _b; }; class A { public: A() {} private: int _a=0; B _bb1 = 10; B _bb2 = B(20); int* p = (int*)malloc(4 * 10); int a[10] = { 1,2,3,4,5 }; }; int main() { A _aa; return 0; }
但要注意，这里给的都是缺省值
静态的成员变量是不行的，因为缺省值是给构造函数用的，构造函数不处理静态的成员变量，因此静态的成员变量必须在类外全局位置才能初始化。
十三.友元
友元分为： 友元函数 和 友元类友元提供了一种突破封装的方式，有时提供了便利。 但是友元会增加耦合度，破坏了封装，所以友元不宜多用 。（就像黄牛一样，破坏管理规则）
友元函数
- 友元函数可访问类的私有和保护成员，但不是类的成员函数
- 友元函数不能用const修饰
- 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
- 一个函数可以是多个类的友元函数
- 友元函数的调用与普通函数的调用和原理相同
<<重载的实现
还是这个日期类
class Date
{
public:
Date(int year = 0, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "_" << _day << endl;
}
private:
int _year;
int _day;
int _month;
};
int main()
{
Date d1(2022,3,7);
}
假如直接进行输出，显然是不行的，原因就是流插入（<<）操作符不支持自定义类型，只支持内置类型。若果我们要想实现就要对它进行重载。
cout 是一个ostream的类型，对他进行重载也很简单
void operator<<(ostream& out) { out << _year << "/" << _month << "/" << _day << endl; }但是写好之后主函数还是报错，原因就是：调用方式错了，在运算符重载里面，如果是双操作数的操作符重载第一个参数（隐含的this）是左操作数，第二个参数是右操作数
如果这样去调用那就是没有问题的，但是这就违背了cout的用法，不符合正常使用的习惯，所以就得另寻方法
如果想要让cout去左边，我们就可以搞一个全局的参数
void operator<<(ostream& out, const Date& d) { out << d._year << "/" << d._month << "/" << d._day << endl; }
但是这就又出现了之前说的封装性的问题，访问不了私有，C++因此提供了友元：一个全局函数想用对象去访问私有或者保护提供了一种方式叫友元
class Date { public: friend void operator<<(ostream& out, const Date& d) { out << d._year << "/" << d._month << "/" << d._day << endl; } private: int _year; int _day; int _month; };只要在函数名前加一个friend 就可以把这个函数作为全局的函数又能访问私有或者保护，这个函数就称为友元函数
class Date { public: friend void operator<<(ostream& out, const Date& d); Date(int year = 0, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } void Print() { cout << _year << "-" << _month << "_" << _day << endl; } private: int _year; int _day; int _month; }; void operator<<(ostream& out, const Date& d) { out << d._year << "/" << d._month << "/" << d._day << endl; } int main() { Date d1(2022,3,7); cout << d1; }
当我们想要去连续输出，又会发现报错，原因和之前=的重载类似，缺少个返回值，所以增加一个返回值就可。
ostream& operator<<(ostream& out, const Date& d) { out << d._year << "/" << d._month << "/" << d._day << endl; return out; }
我先用这个函数输出d1，输出完后又返回out，out就是cout的别名，也就是返回cout，所以又能输出d2
>>重载的实现
class Date
{
public:
Date(int year = 0, int month = 1, int day = 1);
void Print()const;
friend istream& operator>>(istream& in, Date& d);
private:
int _year;
int _month;
int _day;
};
istream& operator>>(istream& in, Date& d)
{
cout << "请依次输入年月日，用空格隔开：" << endl;
in >> d._year >> d._month >> d._day;
return in;
}友元类
- 友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
- 友元关系是单向的，不具有交换性。 比如下面Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
- 友元关系不能传递
- 如果B是A的友元，C是B的友元，则不能说明C时A的友元
class Time
{
friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
Time(int hour=0, int minute=0, int second=0)
: _hour(hour)
, _minute(minute)
, _second(second)
{}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
void SetTimeOfDate(int hour, int minute, int second)
{
// 直接访问时间类私有的成员变量
_t._hour = hour;
_t._minute = minute;
_t._second = second;
}
private:
int _year;
int _month;
int _day;
Time _t;
};
int main()
{
Date d1;
d1.SetTimeOfDate(1,30,10);
}
十四.内部类
概念及特性
概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。注意此时这个内部类是一个独立的 类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。
注意：内部类就是外部类的友元类。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
- 特性：
- 1. 内部类可以定义在外部类的public、protected、private都是可以的。
- 2. 注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。
- 3. sizeof(外部类)=外部类，和内部类没有任何关系。
类大小的计算
class A { private: static int k; int h; public: //内部类 //1.内部类B和定义在全局基本是一样的，只是他受外部类A类域的限制 //2.内部类B天生就是外部类A的友元，也就是B中可以访问A，但是A不能访问B class B { public: void foo(const A& a) { cout << k << endl;//OK cout << a.h << endl;//OK } private: int _b; }; /*void dd(B bb) { bb._b; }*/ }; int A::k = 1; int main() { cout << sizeof(A) << endl; return 0; }
因为计算的时候只于外部类有关，只计算h的字节大小，不计算K是因为它是静态的，放在静态区的。
用内部类实例化对象
如果想用B实例化出对象，得这样去调用，前提是这个内部类是公有的，如果是私有的就不能这样去调用
int main() { A::B bb; return 0; }
小结：1.内部类B和定义在全局基本是一样的，只是他受外部类A类域的限制
2.内部类B天生就是外部类A的友元，也就是B中可以访问A，但是A不能访问B
201
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
