TCP的三次握手和四次挥手

当我们使用拷贝构造函数的时候，如果我们不小心使用的是浅拷贝，那完了，危险了就。



## 一、拷贝构造函数
### 1.1 什么是拷贝构造函数
首先我们说一下什么是**拷贝构造函数**。\
 
**拷贝构造函数**（Copy Constructor）是c++中的一种特殊的构造函数，它用于创建一个对象并将其初始化为同一类中另一个对象的副本。拷贝构造函数通常以**引用方式**(``const MyClass& other``)接受一个同类对象作为参数，然后根据这个参数的值创建一个新的对象，使新对象与参数对象的内容相同。\
 
说的简单点就是用同一个类的实例构造一个新的实例。\
**注意：** 拷贝结束后被复制对象的资源依旧存在。
 
下面是一个拷贝构造函数的简单例子。
```cpp
class MyClass {
public:
 // 拷贝构造函数
 MyClass(const MyClass& other) {
 // 复制 other 的成员变量到当前对象
 // 通常使用深拷贝来确保新对象独立于原对象
 }

 // 其他成员和构造函数...
};
```

### 1.2 拷贝构造函数中的浅拷贝和深拷贝
#### 浅拷贝
浅拷贝其实就是通过拷贝构造函数构建的实例和传入参数的那个实例中的属性共用内存，当一个类的属性改变了另一个也会改变，而且如果``delete``了一个类，就是出现内存泄漏的问题。\
 
比如下面的代码。
```cpp
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <vector>

using namespace std;

class Str{
 public:
 char *value;
 Str(char s[])
 {
 cout<<"调用构造函数..."<<endl;
 int len = strlen(s);
 value = new char[len + 1];
 memset(value,0,len + 1);
 strcpy(value,s);
 }
 Str(Str &v)
 {
 cout<<"调用拷贝构造函数..."<<endl;
 this->value = v.value;
 }
 ~Str()
 {
 cout<<"调用析构函数..."<<endl;
 if(value != NULL)
 delete[] value;
 }
};

int main()
{

 char s[] = "I love BIT";
 Str *a = new Str(s);
 Str *b = new Str(*a);
 delete a;
 cout<<"b对象中的字符串为："<<b->value<<endl;
 delete b;
 return 0;
}
```
上面类的value是一个指针，两个类的指针都指向一个地方，delete了a，b的内存也会释放，后面又delete了一次b，属于重复释放了，会有安全的问题。\

#### 深拷贝
深拷贝就是重新为构造的实例进行内存分配，使两个实例拥有不同的内存，互不影响。\
 
比如说下面的代码。
```cpp
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <vector>

using namespace std;

class Str{
 public:
 char *value;
 Str(char s[])
 {
 cout<<"调用构造函数..."<<endl;
 int len = strlen(s);
 value = new char[len + 1];
 memset(value,0,len + 1);
 strcpy(value,s);
 }
 Str(Str &v)
 {
 cout<<"调用拷贝构造函数..."<<endl;
 int len = strlen(v.value);
 value = new char[len + 1];
 memset(value,0,len + 1);
 strcpy(value,v.value);
 }
 ~Str()
 {
 cout<<"调用析构函数..."<<endl;
 if(value != NULL)
 {
 delete[] value;
 value = NULL;
 }
 }
};

int main()
{

 char s[] = "I love BIT";
 Str *a = new Str(s);
 Str *b = new Str(*a);
 delete a;
 cout<<"b对象中的字符串为："<<b->value<<endl;
 delete b;
 return 0;
}
```
这样才不会出现资源泄漏和悬挂指针等问题。


### 1.3 拷贝构造注意事项
最后要注意的是，如果你没有显式定义拷贝构造函数，c++编译器会给你生成一个默认的拷贝构造函数，该构造函数会执行浅拷贝（即简单地复制成员变量的值）。\
 
在某些情况下，特别是当类中包含指针等动态分配的资源时，你可能需要显式定义自己的拷贝构造函数以执行深拷贝，以避免资源泄露和悬挂指针等问题。

## 二、拷贝赋值运算符
如果你理解了拷贝构造函数，那么拷贝赋值运算符就很急简单了。\
就是重载了``=``运算符，新实例化一个类时候可以直接等于一个现有的实例（通过拷贝）。\
传入的参数``const Foo&``是为了防止不必要的开销，而又不能更改传入的类。
```cpp
// 拷贝赋值运算符
// 返回值必须为引用值
Foo& operator=(const Foo& f) {
 s_ = f.s_;
 v_ = f.v_;
 std::cout << "Copy Assignment: " << Info() << std::endl;
 return *this;
}

// 使用
Foo f1("hello", v);
Foo f2 = f1; // 调用拷贝赋值运算符
 ```
 
 ## 三、移动构造函数
 移动构造函数是基于c++11的一个新特性``std::move()``实现的，具体的我也不太懂。它是强制将一个左值转换为右值，然后进行构造，避免构造过程中的拷贝造成性能损失。\
**作用：** 用于创建一个新对象，该对象获得另一个已存在对象的资源，并使原对象进入有效但未定义的状态。\
 **参数：** 通常接受一个同类对象的右值引用（&&）作为参数，该引用是被移动的对象。\
 偷走了什么资源，看你函数怎么写的，如果你新构建的实例的属性等于了一个被强制转换成右值的资源，那这个资源就被偷走了。例如``s_(std::move(f.s_))``，就相当于``s=std::move(f.s_))``，这就偷走了``s_``资源。
 ```cpp
 // 移动构造函数
// 传入的是右值引用&& std::move()是将左值转换为右值
Foo(Foo&& f) : s_(std::move(f.s_)), v_(std::move(f.v_)) {
 std::cout << "Move Constructor: " << Info() << std::endl;
}

// 使用
Foo f1("hello", v);
Foo f2(std::move(f1)); // 调用移动构造函数 调用后 f1中的资源都没了
```
 

## 四、移动赋值操作符
懂了移动构造函数，移动赋值运算符也是挺简单的。\
也是重载``=``，传入一个右值引用(&&)，然后返回对象本身。
这里偷走了什么资源就看你的函数里面了，这里是偷走了``s_``和``v_``。如果你把``v_ = std::move(f.v_);``删去，那么传入的对象是还拥有这个``v_``资源的。
```cpp
// 移动赋值操作符
Foo& operator=(Foo&& f) {
 s_ = std::move(f.s_);
 v_ = std::move(f.v_);
 std::cout << "Move Assignment: " << Info() << std::endl;
 return *this;
}

// 使用
Foo f1("hello", v);
f3 = std::move(f1);	// 调用移动赋值运算符 f1的资源也会没有
```

## 五、最后
上面代码完整版。
```cpp
#include <iostream>
#include <string>
#include <vector>

class Foo {
public:
 // 默认构造函数
 Foo() { std::cout << "Default Constructor: " << Info() << std::endl; }

 // 自定义构造函数
 Foo(const std::string& s, const std::vector<int>& v) : s_(s), v_(v) {
 std::cout << "User-Defined Constructor: " << Info() << std::endl;
 }

 // 析构函数
 ~Foo() { std::cout << "Destructor: " << Info() << std::endl; }

 // 拷贝构造函数
 // 就是用同类的其他对象进行初始化
 // 传入的参数类型：引用指向的数据是一个不可修改的常量
 Foo(const Foo& f) : s_(f.s_), v_(f.v_) {
 std::cout << "Copy Constructor: " << Info() << std::endl;
 }

 // 拷贝赋值运算符
 // 返回值必须为引用值
 Foo& operator=(const Foo& f) {
 s_ = f.s_;
 v_ = f.v_;
 std::cout << "Copy Assignment: " << Info() << std::endl;
 return *this;
 }


 // 移动构造函数
 // 传入的是右值引用 std::move()是将左值转换为右值
 Foo(Foo&& f) : s_(std::move(f.s_)), v_(std::move(f.v_)) {
 std::cout << "Move Constructor: " << Info() << std::endl;
 }


 // 移动赋值操作符
 Foo& operator=(Foo&& f) {
 s_ = std::move(f.s_);
 v_ = std::move(f.v_);
 std::cout << "Move Assignment: " << Info() << std::endl;
 return *this;
 }

 std::string Info() {
 return "{" + (s_.empty() ? " 'empty'" : s_) + ", " + std::to_string(v_.size()) + "}";
 }

private:
 std::string s_;
 std::vector<int> v_;

};

int main() {

 std::vector<int> v(1024);

 std::cout << "================== Copy ==================" << std::endl;
 Foo f1("hello", v);	 // 自定义运算符
 Foo f2(std::move(f1)); // 调用移动构造函数
 Foo f3;			// 调用默认构造函数
 f3 = std::move(f2);	// 调用移动赋值运算符
 Foo f4 = f3; // 调用拷贝赋值运算符
 return 0;

}
```
























































[参考博客1--现代 C++：右值引用、移动语意、完美转发](https://cloud.tencent.com/developer/article/1637076) \
[参考博客2--C++移动构造函数以及move语句简单介绍](https://www.cnblogs.com/qingergege/p/7607089.html)

拷贝构造函数、拷贝赋值操作符、移动构造函数，移动赋值操作符

讲解前置++和后置++的重载。



## 前置++重载
前置++没有中间量，一般我们返回一个引用，因为前置递增操作符通常用于修改对象本身，并且允许在单一语句中执行多个递增操作。
例如下面的代码，``++++i``没问题，但是``i++++``就会报错。因为前置递增是返回的对象本身，而后置递增虽然对象已经加了，但是却返回的是一个临时变量，临时变量就不能进行++了。
```cpp
#include <iostream>
int main() {
	int i = 1;
	++++i;
	std::cout <
前置++重载的一个例子，它返回了一个引用，并且是``*this``表示对象本身。

```cpp
// 前置++重载
iterator &operator++() {
 num = TO >= FROM ? num + 1 : num - 1;
 return *this;
}
```


## 后置++重载
后置++中，会在括号中加一个``int``表示这个是后置递增的重载，这个int没什么意义，就是告诉编译器这是个后置++。可以看到在下面的代码中定义了一个局部变量，中间虽然对对象进行了运算，但是返回的是临时变量。
```cpp
// 后置++重载
iterator operator++(int) {
 iterator ret_val = *this;
 ++(*this);
 return ret_val;
}
```

c++中前置++和后置++的重载

我这里转载别人的一篇文章，感觉写的挺直观的。


https://juejin.cn/post/7223962299307786301

c++构造函数的初始化列表

## 前言
每个进程都有一套自己的虚拟地址，尽管进程可能有相同的虚拟地址，但经过映射后就是不同的物理地址了，以此来实现进程隔离等功能。




## 内存分段
### 介绍
一开始使用分段来进行内存管理的，但是用多了会发现，使用分段管理会产生大量的外部碎片。\
说到分段，肯定要讲到**GDT(全局描述符表)** 和 **段选择子** 还有**段描述符**。\
简单来说，它们之间的关系就是GDT是一个数组，里面存着段描述符，通过段选择子(索引)找到对应的段描述符。
 

![分段.webp](https://img.ricemoon.cn/images/09/6505798c5b5b3.webp)
具体的**寻址方式就是**，**虚拟地址=段选择子+段内偏移量**。\
通过段选择子找到在GDT表中找到对应的段描述符，然后就是判断特权级，特权级允许后找到对应的段基址，然后再加上偏移量就是对应的物理地址了。\
 
段描述符的结构如下图：
![段描述符.webp](https://img.ricemoon.cn/images/09/650578949da9c.webp)
在进程中，我们一般将进程的**TSS描述符（一种特殊的段描述符，里面存着进程的数据段、代码段等段的位置和进程运行所需所有的寄存器的值，和进程特权级等）** 作为段内描述符，当进行任务切换的时候，系统加载进程对应的TSS结构来恢复进程。
```c
// 这是我做过的一个极简版32位操作系统中的代码
// 项目地址：https://github.com/xjintong/SimilarLinux0.11
typedef struct _tss_t {
 uint32_t pre_link; 
 uint32_t esp0, ss0, esp1, ss1, esp2, ss2;
 uint32_t cr3;
 uint32_t eip, eflags, eax, ecx, edx, ebx, esp, ebp, esi, edi;
 uint32_t es, cs, ss, ds, fs, gs;
 uint32_t ldt; 
 uint32_t iomap; 
}tss_t;
```

### 不足
分段会产生两个问题。
- **外部内存碎片**

分段会产生外部内存碎片。就是因为段的长度是不固定的，对于内存的分配有可能不是很合理，就比如说下面，空闲内存大于新进程的内存，但是由于两个空闲内存是分开的，导致新进程不能加载到内存中。\
 
![分段外部碎片.webp](https://img.ricemoon.cn/images/09/65057dfc985d5.webp) \
 

解决这个问题的方法就是**内存交换**。\
也就是先将进程2放到磁盘中去，然后把新进程放到内存中（挨着进程1放），然后再把磁盘中的进程2重新读取到内存，这个在磁盘上和内存进行数据交换的空间就是swap空间。

- **内存交换率低**

磁盘读写数据相对内存来说是非常慢的，如果是一个内存占用非常大的进程要从内从交换到磁盘，所消耗的时间是非常大的。

## 内存分页

### 一级页表
我们可以将所有的物理内存和虚拟均匀分成等份的（一般就是4KB）页，然后创建一个表，里面存储着虚拟页和物理页的映射关系，到时候就直接查表，找到对应的物理页，最后再加上页偏移就是物理地址了。\
一级页表的起始位置放在CR3寄存器中。

![一级分页.webp](https://img.ricemoon.cn/images/09/65058cc3e639f.webp)
 
采用分页很好的解决了外部内存碎片化和内存交换率低的问题。但是如果只用一级页表，还是有着很大的问题。\
 
我们以32位操作系统为例，内存总共4GB(2^32) ，一个页4KB(2^12)，那么就需要百万级(2^20)的映射关系，一个页表项需要4字节存储，然后所有的表项就需要4MB(2^22)内存存储。\
 
看着不是很多吧，但是**每个进程都需要一个这样的表**，如果进程变多了，这得多消耗多少没必要消耗的空间。\
而且我们必须有这个表的全部，因为是靠索引来找到对应的页的，你如果只取一部分那它的索引号就变了。所以我们需要多级页表来解决这个问题。

### 多级页表
32位操作系统用二级页表就够了，64位操作系统用四级页表，这里只讲32位的。\
我们先把内存分成1024（2^10）个大的页目录，一个页目录指向一个页表（一个页表含有1024个页目录），\
 
第一级是**页目录（page directory）**，一共1024（2^10）个目录项，一个目录项4字节大小，所以页目录占4KB(2^22)大小内存。\
第二级是**页表（page table）**，它也是1024（2^10）个页表项，一个页表也是4KB大小。一个页表的最大寻址空间是4MB（因为1024个页表项，对应1024个页物理地址，一个页物理地址是4KB）。\
 
一个目录项对应着一个页表，所以一个目录项最大寻址4MB，一个目录有1024个目录项，所以一个目录最大寻址4GB。\
![二级分页.webp](https://img.ricemoon.cn/images/09/650593d456b09.webp)
虚拟地址的高10位是页目录索引，中间10位是页表索引，最后12位是偏移量。\
 

页目录的结构和页表的结构是一样的，只不过他俩描述的主体不一样，一个描述的是页目录，一个描述的是页表。\
![页目录和页表结构.webp](https://img.ricemoon.cn/images/09/6505968e51b9d.webp)
通过页目录和页表可以获取物理地址的前20位，后12位就是加上虚拟地址的后12位。虚拟地址的后12位存储的权限，读写标志等等。\
通过二级页表我们不用保存所有的映射关系了。有一个页目录就能扫完4GB内存，然后再找对应的页表，如果没有就再创建。如果某个一级页表的页表项没有被用到，也就不需要创建这个页表项对应的二级页表了，即可以在需要时才创建二级页表 \
 
就像下面这样二级表有1024个，每个二级表有1024个表项并且索引都是从0开始的，这样我们单独拿出一个二级表，它的索引也不会变化。由于局部性原理，我们用不到那么多的页表项。
![二级页表.webp](https://img.ricemoon.cn/images/09/6505987a81f69.webp)

### TLB
从虚拟地址到物理地址的转换还需要查两次表，64位的还要查4次，时间也是有消耗的。TLB里面保存了一些之前已经转换好的虚拟地址和物理地址的映射关系。\
详细的请看我写的另一篇[文章](https://www.ricemoon.cn/post/101)


## Linux内存布局
inter处理器早期是用分段管理内存，后来发现不是很好用，后来又整了分页，但是还保留着分段，就是虚拟地址是通过分段获取的，然后再通过分页。\
![分段和分页.webp](https://img.ricemoon.cn/images/09/65059ab877d1c.webp)
可以看到最左边还有分段的，是通过分段获取的线性地址。\
 
但是分段确实有点弊端，Linux无法改变硬件，只能改变自身了。Linux用了一个技巧使分段相当于失效了。

>Linux 系统中的每个段都是从 0 地址开始的整个 4GB 虚拟空间（32 位环境下），也就是所有的段的起始地址都是一样的。这意味着，Linux 系统中的代码，包括操作系统本身的代码和应用程序代码，所面对的地址空间都是线性地址空间（虚拟地址），这种做法相当于屏蔽了处理器中的逻辑地址概念，段只被用于访问控制和内存保护。

Linux的地址空间分为内核空间和用户空间。\
 
![Linux内存分配.webp](https://img.ricemoon.cn/images/09/65059bb8b4d15.webp)
在内核空间是不开启分页机制的，所有进程共享内核内存。有人认为这是为了防止从用户态到内核态的性能消耗。

## 最后
每个进程都有完全属于自己的地址转换表，所以即便是相同的虚拟地址空间也会映射到不同的物理地址上，以此来达到隔离进程的效果。\
在进程看来，自己是独享整个内存，自己可以随便找个地址，但其实是通过页表映射到个各个物理上。

- 参考博客 \
[小林coding--为什么要有虚拟内存](https://xiaolincoding.com/os/3_memory/vmem.html#%E6%80%BB%E7%BB%93) \
[图文详解 Linux 分页机制！](https://heapdump.cn/article/6016536?from=pc) \
[MIT6.S081 4.3 页表（Page Table）](https://mit-public-courses-cn-translatio.gitbook.io/mit6-s081/lec04-page-tables-frans/4.3-ye-biao-page-table)