我的C++学习笔记 （更新中）

一、深入学习C++语言先要练好的内功

1.1 掌握进程虚拟地址空间区域划分

任何的编程语言编译所产生的只有 指令和数据。

CPU运行程序，需要将.exe/.out文件加载到内存中，但不是直接加载到实际的物理内存中，而是加载到进程的虚拟地址空间。x86 32位Linux环境下，Linux内核会给当前进程分配一块2^32大小的空间，大小为4G。而虚拟地址空间不是物理内存，本质底层就是内核所创建的一系列数据结构。

在代码中定义的变量分别储存在虚拟空间的那个位置？

还需注意，每一个进程的用户空间是私有的，而内核空间是共享的。

1.2 从指令角度掌握函数调用堆栈

原理：函数调用堆栈是由操作系统管理的一块内存区域，它用于存储函数调用和返回的过程中的临时数据。在函数调用过程中，程序会将函数的参数和返回地址压入堆栈中，然后跳转到函数的入口地址执行函数代码。在函数返回过程中，程序会从堆栈中弹出返回地址和临时数据，然后跳转到返回地址执行函数调用后的代码。

栈指针（Stack Pointer）：指向堆栈顶部的指针。
帧指针（Frame Pointer）：指向当前函数的帧的指针。
在x86结构里，负责存放栈底指针的寄存器是ebp，负责存放栈顶指针的寄存器是esp

详细步骤：
1.将形参压入堆栈中。（参数的压入顺序是从右到左）
2.将返回地址压入堆栈中。（返回地址是指函数返回后跳转的地址，它通常是函数调用指令的下一条指令地址）
3.跳转到函数入口地址执行函数代码。（在x86架构中，函数入口地址是通过CALL指令设置的）
4.收回函数的内存空间（恢复堆栈指针的值）
5.弹出返回地址
6.恢复堆栈指针，收回形参空间，跳转到返回地址执行函数调用后的代码。
函数调用过程示意图如下：

1.3 从编译器角度理解C++代码的编译和链接原理

1.预处理：处理以“#”开头的预处理指令，如#include，#define 等（#pragma lib/link 等命令则是链接时使用）。预处理器会将头文件包含进来，展开宏定义等，生成一个经过预处理的源代码文件。
2.编译：在这个阶段，编译器将预处理后的源代码翻译成中间代码（通常是汇编代码），这个中间代码仍然是针对特定的硬件平台的抽象代码。
3.汇编：分为两种x86和AT&T；将汇编代码转变成机器可以执行的指令，汇编后生成二进制可重定位的目标文件.o/.obj，可以通过objdump命令来查看.o或.obj文件的相关信息（objdump -t main.o）。
.o文件的格式组成(elf文件头–.text–.data–.bss–.symbal–.section table)
4.链接(.o → a.out / .obj→.exe)：
（1）所有.o文件段的合并， 也就是main.o和sum.o的.text、.data等段合并到一起。
（2）符号解析，可以理解为： 所有对符合引用，都要找到该符号定义的地方；也就是链接器寻找main.o文件中UND（调用）符号定义的地方，如果找遍了所有地方都没有找到，那么链接器就会报错：符号未定义！，或者是在多个地方都找到了相同的符号定义，那么也会报错：符号重定义！
（3）符号的重定向，给所有的符号分配虚拟地址。

二、C++学习还必须掌握的-基础知识

2.1 malloc/free，new/delete

malloc/free和new/delete一般情况下的使用：

//    malloc/free
int *p = (int* ) malloc (sizeof (int) ); 
if (p == nullptr) return -1;
*p = 20;
free(p); 

//    new/delete
int *pl = new int (20);
delete p1;

malloc/free和new/delete的区别
new 先开辟内存，再调用构造函数； delete先析构函数，再释放内存。

1. malloc和free是函数，new和delete是操作符
2. malloc/free只会开辟，释放空间；而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理
3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可。
4. malloc开辟内存失败，是通过返回值和nullptr做比较；而new开辟内存失败，是通过抛出bad_alloc类型的异常来判断的。

什么是内存泄漏？
内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

new和delete能混用吗?
new delete new[ ] delete[ ]
对于普通的编译器内置类型int等（只有内存开辟,无析构），可以进行混用。
自定义的类类型，有析构函数，为了调用正确的析构函数，那么开辟对象数组的时候，会多开辟4个字节，记录对象的个数，故不能混用。

C++为什么区分单个元素和数组的内存分配和释放呢?
数组内存释放会多次调用析构函数。

2.2 引用与指针

指针：指针是一个变量，只不过这个变量存储的是一个地址，指向内存的一个存储单元，即指针是一个对象；
引用：和原来的变量实质上是同一个东西，相当于是原变量的一个别名。可以看作一种更安全的指针。

int a=1;int *p=&a;
int a=1;int &b=a;

区别：
1.引用是必须初始化的，指针可以不初始化。
2.引用只有一级引用，没有多级引用；指针可以有一级指针，也可以有多级指针。
3.指针的值在初始化后可以改变，即指向其它的存储单元，而引用在进行初始化后就不会再改变了，从一而终。
4.sizeof引用”得到的是所指向的变量(对象)的大小，而”sizeof指针”得到的是指针本身的大小；

联系：
定义一个引用变量，和定义一个指针变量，其汇编指令是一模一样的；通过引用变量修改所引用内存的值，和通过指针解引用修改指针指向的内存的值，其底层指令也是一模一样的。

2.3 C++传递方式

2.3.1 传值（Pass by Value）

void foo(int x) { }；
当函数参数是以传值的方式传递时，实际上传递的是参数的副本，而不是参数本身。
优点：由于是操作副本，所以原始数据不会被修改，这在很多情况下是预期的行为。
缺点：如果参数是大型结构或类实例，那么复制整个对象可能会导致性能损耗。

void foo(int x) {  //此处传值
    x = 30; // 只修改了 x 的副本，不会影响到原始变量
}
int main() {
    int a = 10;
    foo(a);   // a 的值仍然是 10 
}

2.3.2 传引用（Pass by Reference）nice

void foo(int& x) { }；
传引用意味着传递的是参数的引用（实际上是内存地址），而非其副本。
优点：可以直接修改原始数据，对于大型数据结构或对象，传引用避免了复制的开销，可以提高程序的性能。
缺点：由于可以修改原始数据，如果不小心处理，可能会导致错误或不可预期的结果。

void foo(int& x) {
    x = 30; // 修改了引用的实际对象，即原始变量
}
int main() {
    int a = 10;
    foo(a); // 现在 a 的值变为了 30
}

2.3.3 传常引用（Pass by Constant Reference）

结合了传值和传引用的优点：它通过引用传递参数以提高效率，同时通过使参数为 const，防止函数修改参数值。

void foo(const int& x) {
    // x = 30; // 这行代码会导致编译错误，因为 x 是 const 的
}
int main() {
    int a = 10;
    foo(a);
    // a 的值仍然是 10，foo 函数不能修改 x
}

2.4 Const解析，Const与指针(引用)的结合

const的语义为只读。修饰的值不能改变；必须在定义时就给它赋予初值，无论是const还是非const变量都可以对其进行初始化；初始化后不能再作为左值。

c和c++中const的区别是什么?
const的编译方式不同。c中const就是当作一个变量来编译生成指令的；
C++中，所有出现const常量名字的地方，都被常量的初始化替换了! ! !

const int a = 20;
int array [a]= { }; // C中会报错，以变量来生成指令。 C++中可以执行
int *p = (int* ) &a;
*p = 30;
printf ("%d %d %d \n",20,*p,20 ) ; // C中输出为 30 30 30，C++中输出为 20 30 20

const修饰的量常出现的错误是:

1. 常量不能再作为左值 ⬅ 直接修改常量的值
2. 不能把常量的地址泄露给一个普通的指针或者普通的引用变量 ⬅ 可以间接修改常量的值大

const在C++中的语言规范：

1. const修饰的是离它最近的类型
2. const如果右边没有指针*的话， const是不参与类型的

const int *p = &a;  // *p = 20, p = & b
可以任意指向不同的int类型的内存，但是不能通过指针间接修改指向的内存的值。

int *const p = &a;//   p = &b;
常量指针指向的值不能改变，但是这并不是意味着指针本身不能改变，常量指针可以指向其他的地址。

总结const和指针的类型转换公式:
int* ⬅ const in* 是错误的!
!const int⬅int 是可以的!
int⬅const int* 是错误的!
const int ⬅ int* 是错误的!

2.5 函数重载

什么是函数重载?
一组函数，函数名相同，参数列表的个数或者类型不同，那么这一组函数就称作-函数重载。
—组函数要称得上重载，一定先是处在同一个作用域当中的。

函数重载需要注意些什么？
1.C++为什么支持函数重载，c语言不支持函数重载？
C++代码产生函数符号的时候，函数名+参数列表类型组成的！ 如：sum_int_int
c代码产生函数符号的时候，函数名来决定！ 如：sum
2.添加const不影响函数名，仅仅返回值不同不叫重载。

C++和C语言代码之间如何协调？
1.c调用C++:无法直接调用了!怎么办？
把c++源码括在extern “c”{ … }
2.C++调用c代码:无法直接调用了!怎么办?
把c函数的声明括在extern “c”{ … }

2.6 inline内联函数

内联函数使用： inline关键字 + 函数。

inline内联函数 和 普通函数的区别？？？
内联函数：在编译过程中，就没有函数的调用开销了，在函数的调用点直接把函数的代码进行展开处理了
Iinline函数不再生成相应的函数符号。
普通函数：有标准的函数调用过程，参数压栈，函数栈帧的开辟和回退过程，有函数调用的开销。

注意：
inline只是建议编译器把这个函数处理成内联函数，但是不是所有的inline都会被编译器处理成内联函数。
debug版本上，inline是不起作用的；inline只有在release版本下才能出现

2.7 形参带默认值函数相关注意事项

1.给默认值的时候，从右向左给。
2.定义处可以给形参默认值,声明也可以给形参默认值。
3,形参给默认值的时候,不管是定义处给,还是声明处给,形参默认值只能出现一次。

三、C++面向对象

3.1 类和对象、this指针

C++（面向对象，this指针） 类 → 实体的抽象类型
实体（属性、行为）→ ADT（abstract data type )
对象 ⬅ (实例化) 类 (属性→成员变量 ，行为→成员方法)

ooP语言的四大特征是什么?
抽象、封装/隐藏、继承、多态

类的特点：
在类中，属性一般都是私有变量，通过给外部提供公有的成员方法，来访问私有的属性（如给成员变量提供一个getXXX或者setXXX方法）
类通过实例化来创建对象，每个类可以创建无数个对象，每个对象都有自己的成员变量，但是他们共享成员方法。
类的成员方法一经编译，所有的方法参数，都会加一个this指针，接收调用该方法的对象的地址。

3.2 构造函数和析构函数

构造函数(初始化) ：
1.语法：类名(){ … }
2.构造函数可以有参数，因此可以发生重载。
3.程序在调用对象时候会自动调用构造，无须手动调用，而且只会调用一次。
析构函数(释放内存)：
1.语法：~类名(){ … }
2.析构函数不可以有参数，因此不可以发生重载。
3.程序在对象销毁前会自动调用析构，无须手动调用，而且只会调用一次

构造函数的初始化列表：可以指定当前对象成员变量（私有变量中创建另一个类的对象，具有被包含关系）的初始化方式
在构造函数后接：进行初始化。

3.3 对象的浅拷贝和深拷贝

浅拷贝：指复制对象时，只复制对象的指针，而不复制对象本身。这意味着新对象和原对象将共享相同的内存地址。如果原对象发生变化，新对象也会受到影响。
深拷贝：指复制对象时，先创建足够的空间，再把蓝本的内容拷贝过去。这意味着新对象和原对象不共享相同的内存地址。如果原对象发生变化，新对象不会受到影响。
编译器默认为浅拷贝，深拷贝需要自己进行编写。
示例（顺序栈-深拷贝）

   SeqStack(const SeqStack& src)  //拷贝构造函数，深拷贝
  {
	 _pstack = new int [src._size];
	 for(int i = 0; i <= src._top; ++i){
	 _pstack[i] = src._pstack[i];
  }
	 _top = src._top;
	 _size = src._size;

3.4类的各种成员方法以及区别

3.4.1 普通的成员方法(编译器会添加一个this形参变量)

属于类的作用域。
调用该方法时，需要依赖一个对象(常对象是无法调用的)。
可以任意访问对象的私有成员，protected继承 public private。

3.4.2 static静态成员方法(不会生成this形参)

属于类的作用域。
用类名作用域来调用方法。
可以任意访问对象的私有成员，仅限于不依赖对象的成员(只能调用其它的static静态成员)。
注意：static成员变量必须在类外定义且初始化，定义时不添加static关键字

class A
{
private:
	//声明
	static int count;
};
//定义
int A::count = 0;

3.4.3 const常成员方法(const 类 *this)

属于类的作用域。
调用依赖一个对象，普通对象或者常对象都可以。
可以任意访问对象的私有成员，但是只能读，而不能写。

3.5 指向类成员（成员变量、成员函数）的指针

3.5.1 指向成员变量的指针

如何新建类指向类成员变量的指针?

// 变量类型 类名::*pointer = &类名::变量名
string Student::*p = &Student::name;

想要具体使用指针,还是要使用类的对象去调用。

Student s1("zhangsan", 100);
Student s2("lisi", 95);
string Student::*p = &Student::name;

cout << s1.*p << endl;   //不同的对象可以调用同一个指针
cout << s2.*p << endl;   

3.5.2 指向类成员函数的指针

如何新建类指向类成员函数的指针?

// 返回值类型 (类名::*p)(函数参数) = &类名:: 成员函数
void (Test::*pfunc)(int) = &Student::func;

想要具体使用指针,还是要使用类的对象去调用。

class Test {
public： void func() { cout << "test" << endl;}
}

Test ti;
void (Test::*pfunc)(int) = &Student::func;
(t1.*pfunc)();

3.6 对象的优化

3.6.1 函数调用过程中对象背后的调用方法

调用对象该如何优化？
1.丞数参数传递过程中，对象优先按引用传递，不要按值传递
传值会调用拷贝构造函数，将函数调用变量传递到形参，增加函数调用开销。
2.函数返回对象的时候，应该优先返回一个临时对象，而不要返回一个定义过的对象
会少了出函数作用域时构造临时对象和析构的开销。

3.接收返回值是对象的函数调用的时候，优先按初始化的方式接收，不要按赋值的方式接收。
编译器会按照初始化方式进行调用，少了对象构造，析构，拷贝构造等开销。

四、模板编程-C++类库的编程基础

4.1 函数模板

模板的意义：对类型可以进行参数化。

函数模板：通过template定义一个模板参数列表，再在下面定义一个函数模板，例如：

bool compare（T a, T b）{ .. } //函数模板

模板的类型参数和非类型参数？
类型形参：出现在模板参数列表中，在class或者typename之后的参数类型名称
非类型形参：模板的一个参数，必须是整数类型（常量、地址），只能使用，不能修改。例子如下：

template <class T,int value>
T Add(const T& x)
{
    return x + value;
}

模板的实例化：在函数调用点，编译器根据用户指定的类型，从原模板实例化一份函数代码出来（将对应的T替换为指定类型的函数），这份代码叫做模板函数。

// 函数调用点
compare<int> (10, 20) ; 
compare (10, 20) ;	    // 函数模板实参推演，根据用户传入的实参类型，来推导出模板类型

故函数模板不进行编译，因为不知道类型；在函数调用点进行模板的实例化；模板函数则是被编译器所编译的。

模板的特例化： 不是编译器提供的，是开发者提供的实例化。
例：比较两个字符串大小，是比较其ASCII码的大小，而不是比较字符串地址大小。

template<>
bool compare<const char*>(const char *a, const char *b){
	return strcmp(a, b) > 0;
}

函数模板、模板特例化、非模板函数(普通函数)之间的关系？
以compare为例，编译器优先把compare处理成函数名字，没有的话，才去找compare模板代码。

注意：模板代码是不能在一个文件中定义，而在另外一个文件中使用。模板代码调用之前，一定要看到模板定义的地方，这样的话，模板才能够进行正常的实例化，产生能够被编译器编译的代码。所以，模板代码都是放在头文件当中的，然后在源文件当中直接进行#include包含。

4.2 类模板

为什么需要类模板？
类模板与函数模板的定义和使用类似，有时，有两个或多个类，其功能是相同的，仅仅是数据类型不同。

类模板由模板说明和类说明构成
模板说明同函数模板，如下：
template <类型形式参数表>
类声明

template  <typename Type>
class ClassName{ //模板名称+类型参数列表 = 类名称
public:
   //ClassName 的成员函数（构造和析构函数名不用加<T>，其它出现模板的地方都加上类型参数列表）
   bool compare<T>（T a, T b）{ .. } 
   
private:
   Type DataMember; 
}

类模板 -> 实例化 -> 模板类
通过对象调用成员函数才会进行相应的实例化，未调用部分不会实例化。

4.3 类模板实现vector容器（包括空间配置器allocator的实现）

空间配置器是什么？为什么要有空间配置器？
空间配置器（Allocator）是一种用来管理内存分配和释放的工具。它提供了一套标准的接口，用于内存分配、对象构造、对象销毁和内存释放。它提供了一种抽象机制，使得容器（如vector, list, map等）可以灵活地使用不同的内存分配策略。通过使用自定义的分配器，开发者可以优化内存使用，提高程序性能，或满足特定的内存管理需求。

主要思路：通过模板类定义Allocator类，空间配置器对象allocator来实现容器底层内存开辟，内存释放，对象构造和析构。vector容器，进行构造，析构，拷贝构造，拷贝赋值，以及一系列push_back等操作。以下为代码部分，相关备注已经写好。
包括容器的定义和空间配置器的定义。

#include <iostream>

using namespace std;

template<typename T>
struct Allocator 
{
    T* allocate(size_t size) {// 负责开辟内存
        return (T*)malloc(sizeof(T) * size);
    }
    void deallocate(void* p) {// 负责内存释放
        free(p);
    }
    void construct(T* p, const T &val) {// 负责对象构造
        new(p) T(val); //定位new，指定的内存上，构造一个值为val的对象
    }
    void destroy(T* p) {// 负责对象析构
        p->~T(); 
    }
};

// 容器底层内存开辟，内存释放，对象构造和析构，都通过allocator空间配置器来实现
template<typename T, typename Alloc = Allocator<T>>
class vector
{
public:
    vector(int size = 10) { // 构造
        // 需要把内存开辟和对象构造分开处理
        _first = _allocator->allocate(size);
        _last = _first;
        _end = _first + size;
    }
    ~vector(){ // 析构
        // 析构容器有效的元素，然后释放_first指针指向的堆内存
        for (T* p = _first; p != _last; p++) { _allocator->destroy(p); } // 把_first指向的数组有效元素进行析构
        _allocator->deallocate(_first);// 释放堆上的数组内存
        _first = _last = _end = nullptr;
    }
    vector(const vector<T>& rhs) { // 拷贝构造
        int size = rhs._end - rhs._first;
        _first = _allocator.allocate(size);
        int len = rhs._last - rhs._first;
        for (int i = 0; i < len; i++) {
            _allocator.construct(_first + i, rhs._first);
        }
        _last = _first + len;
        _end = _first + size;
    }
    vector<T>& operator=(const vector<T>& rhs) { // 拷贝赋值
        if (this = &rhs) return *this;

        for (T* p = _first; p != _last; p++) { _allocator.destroy(p); } // 把_first指向的数组有效元素进行析构
        _allocator.deallocate(_first);// 释放堆上的数组内存

        int size = rhs._end - rhs._first;

        _first = _allocator.allocate(size);
        int len = rhs._last - rhs._first;
        for (int i = 0; i < len; i++) {
            _allocator.construct(_first + i, rhs._first);
        }
        _last = _first + len;
        _end = _first + size;
        return *this;
    }
    void push_back(const T& val) { // 从容器末尾插入一个元素
        if (full()) { expand();}
        _allocator->construct(_last, val);
        _last++;
    }
    void pop_back() { // 删除容器末尾元素
        if (empty()) return;        
        --_last;//不仅要把_last指针--，还需要析构删除的元素
        _allocator->destroy(_last);
    }
    T back()const { // 返回容器末尾元素的值
        return *(_last - 1);
    }
    bool full()const { return _last == _end; }
    bool empty()const { return _first == _last; }
    int size()const { return _last - _first; }


private:
    T *_first;//指向数组起始位置
    T *_last;//指向数组中有效元素的后继位置
    T *_end;//指向数组空间的后继位置
    Alloc* _allocator;//定义容器的空间配置器对象

    void expand() { //容器二倍扩容
        int size = _end - _first;
        //T* ptmp = new T[2 * size];
        T* ptmp = _allocator->allocate(2 * size);
        for (int i = 0; i < size; i++) { _allocator->construct(ptmp + i, _first[i]); }
        for (T* p = _first; p != _last; p++) { _allocator->destroy(p); }
        _allocator->deallocate(_first);
        _first = ptmp;
        _last = _first + size;
        _end = _first + 2 * size;
    }
};

class Test {
public:
    Test() { cout << "Test()" << endl; }
    ~Test() { cout << "~Test()" << endl; }
    Test(const Test&) { cout << "Test(const Test&)" << endl; }
};

int main()
{
    Test t1, t2, t3;
    cout << "111111111111" << endl;
    vector<Test> vec;
    vec.push_back(t1);
    vec.push_back(t2);
    vec.push_back(t3);
    cout << "222222222222" << endl;

    vec.pop_back();
    cout << "333333333333" << endl;


    return 0;
}

五、C++运算符重载-使面向对象编程更加灵活

5.1运算符重载简介

为什么会有运算符重载？
由于无法对用户自定义数据类型进行运算，故需对已有的运算符重新进行定义，以适应不同的数据类型。例如复数，对象等。
重载运算符的基本格式：
返回类型 operator 运算符(参数…)
{
重载函数体；
}
主要有两种实现方式：
成员重载和全局重载
1、成员重载（this绑定到左侧的运算对象）

class Point{
public:
    Point(){};
    Point (int x, int y): x(x),y(y) {};
    Point operator+(const Point &b){ //类内重载，运算符重载函数作为类的成员函数
        Point ret;
        ret.x = this->x + b.x;
        ret.y = this->y + b.y;
        return ret;
    }
    int x,y;
};

2、全局重载 （一般通过友元函数实现）

class Point{
public:
    Point(){};
    Point (int x, int y): x(x),y(y) {};
    friend ostream &operator<<(ostream &out , const Point &a);  //因为 << 是C++提供的类，我们无法访问，只能用友元函数。
private:
    int x,y;
};

//<< 运算符重载的函数实现   ostream是输入输出流的类
ostream &operator<<(ostream &out , const Point &a){
    out << "<Point>( " << a.x << ", " << a.y << ")";
    return out;
}

5.2 迭代器iterator（vector实现）

迭代器（Iterator）是编程中一种用于遍历数据结构（如列表、集合、字典等）元素的对象。迭代器提供了一种统一的方式来访问容器中的元素，而不需要了解底层的实现细节。

迭代器一般实现成容器的嵌套类型，不同容器的迭代器实现不同。
但一般都包含构造函数，begin()和end()方法，!= ++ 解引用*()运算符重载等。
以下为vector容器的迭代器实现及使用的示例：

class iterator {
public:
    iterator(T* ptr = nullptr): _ptr(ptr){ }
        bool operator!=(const iterator& it)const {return _ptr != it._ptr; }
        void operator++() {_ptr++; }
        T& operator*() {return *_ptr; }// int data = *it; *it = 20
        const T& operator*() const{ return *_ptr; }// int data = *it;
    private:
        T* _ptr;
    };
    iterator begin() { return iterator(_first); }
    iterator end() { return iterator(_end); }
    
void main()
{
    auto it = vec.begin(); // vector<int>::iterator it = vec.begin();
    for (; it != vec.end(); ++it) { cout << *it << " "; }
}

迭代器失效问题？

1.迭代器为什么会失效?
a:当容器调用erase方法后，当前位置到容器末尾元素的所有的迭代器全部失效了
b:当容器调用insert方法后，当前位置到容器末尾元素的所有的迭代器全部失效了
迭代器依然有效 迭代器失效
首元素-→插入点/删除点-→末尾元素
c:insert来说，如果引起容器内存扩容原来容器的所有的迭代器就全部失效了
d:不同容器的迭代器是不能进行比较运算的

2.迭代器失效了以后，问题改怎么解决？
对插入/删除点的迭代器进行更新操作

5.3 对象池应用

通过new和delete运算符重载实现对象池的应用。

对象池解决什么问题？
减少频繁创建和销毁对象带来的成本，实现对象的缓存和复用，适用于创建对象的成本比较大且创建比较频繁的场景。

六、STL相关

6.1 顺序容器vector

vector： 向量容器
底层数据结构:动态开辟的数组，每次以原来空间大小的2倍进行扩容。

vector<int> vec; //定义
增加:
vec.push_back(20); // 末尾添加元素o(1)导致容器扩容
vec.insert(it,20); // it迭代器指向的位置添加一个元素20      o(n)     可能导致容器扩容

删除:
vec.pop_back(); // 末尾删除元素     o(1)
vec.erase (it); // 删除it迭代器指向的元素     o(n)

查询:
// operator[ ]  下标的随机访问vec[5]       o(1)
// iterator 迭代器进行遍历
// find,for_each

/*注意:对容器进行连续插入或者删除操作(insert/erase)，
一定要更新迭代器，否则第一次insert或者erase完成，迭代器就失效了*/
// 常用方法介绍:
vec.size ( ) //
vec.empty () //
vec.reserve ( 20) // vector预留空间的  只给容器底层开辟指定大小的内存空间，并不会添加新的元素
resize (20) //容器扩容用的，不仅给容器底层开辟指定大小的内存空间，还会添加新的元素
swap : 两个容器进行元素交换

顺序容器、容器适配器、关联容器。
参考博客 链接: link

6.2迭代器

迭代器是一种方便的工具，用于在容器中遍历元素并执行相关操作

6.2.1 定义和初始化

每种容器都定义了自己的迭代器类型，例如vector:

vector<int>::iterator    iter;    //定义一个名为iter的变量

每种容器都定义了一对名为begin和end的函数，用于返回迭代器。

vector<int>  vec;
// 正向遍历
vector<int>::iterator   iter1=vec.bengin();     //将迭代器iter1初始化为指向ivec容器的第一个元素
vector<int>::iterator   iter2=vec.end();   		 //将迭代器iter2初始化为指向ivec容器的最后一个元素的下一个
// 反向遍历
vector<int>::iterator   iter1=vec.rbengin();     //将迭代器iter1初始化为指向ivec容器的第一个元素
vector<int>::iterator   iter2=vec.rend();   		 //将迭代器iter2初始化为指向ivec容器的最后一个元素的下一个

6.2.2常用操作

*iter              	  //对iter进行解引用，返回迭代器iter指向的元素的引用
iter->men             //对iter进行解引用，获取指定元素中名为men的成员。等效于(*iter).men
iter++                //给iter加1，使其指向容器的下一个元素
iter--                //给iter减1，使其指向容器的前一个元素
iter1 == iter2        //比较两个迭代器是否相等，当它们指向同一个容器的同一个元素或者都指向同同一个容器的超出末端的下一个位置时，它们相等 

// 常用遍历
vector<int>  vec;
for (auto iter = vec.begin(); iter != vec.end(); it++)  //从容器开始循环到结束（auto自动将it设置为对应迭代器类型）
for (auto iter : vec) //从容器开始循环到结束（C14新特性）

// const_iterator类型的迭代器只能用于读不能进行重写
for(vector<int>::const_iterator iter=ivec.begin();iter!=ivec.end();++iter)
     cout<<*iter<<endl;       												//合法，读取容器中元素值
for(vector<int>::const_iterator iter=ivec.begin();iter!=ivec.end();++iter)
    *iter=0;       														    //不合法，不能进行写操作

6.3 函数指针和函数对象

指针函数本质是一个函数，其返回值为指针。
函数指针本质是一个指针，其指向一个函数。
优点：通过将不同函数对函数指针进行赋值，最终统一调用函数指针变量，实现统一接口调用不同函数的目的，简化函数调用过程。
缺点：通过函数指针调用函数，是没有办法内联的，效率很低，因为有函数调用开销。

函数对象又称之为仿函数
仿函数是一种重载了函数调用运算符operator()的类或结构体，它可以像函数一样被调用。
1.通过函数对象调用operator()，可以省略函数的调用开销，比通过函数指针调用函数(不能够inline内联调用)效率高。
2.因为函数对象是用类生成的，所以可以添加相关的成员变量，用来记录函数对象使用时更多的信息。

6.4 泛型算法

泛型算法= template ＋迭代器＋函数对象
特点一:泛型算法的参数接收的都是迭代器
特点二:泛型算法的参数还可以接收函数对象（c函数指针)
sort, find, find_if,binary_search, for_each

sort (vec.begin(), vec.end(), greater<int>() ); //从大到小排序

绑定器＋二元函数对象=》一元函数对象
bindlst:把二元函数对象的operator( ) (a，b)的第一个形参绑定起来
bind2nd:把二元函数对象的operator ( ) (a，b)的第二个形参绑定起来

auto it2 = find_if (vec.begin(), vec.end(), bindlst( greater<int>(), 48));
vec.insert (it2,48 );

七、继承与多态

7.1 继承的本质和原理

继承的本质： 代码的复用
继承： a kind of … 一种的关系
用法： class B : public A A 基类/父类 B 派生类/子类
派生类拥有基类的所有内容， 如人是基类，学生是派生类。学生拥有人的所有特性，还具有自己的特性。

继承方式	基类的访问限定	派生类的访问限定	(main)外部的访问限定
public	public	public	Y
.	protected	protected	N
.	private	不可见	N
protected	public	protected	N
.	protected	protected	N
.	private	不可见	N
private	public	private	N
.	protected	private	N
.	private	不可见	N

总结：
1.外部只能访问对象public的成员，protected和private的成员无法直接访问
2.在继承结构中，派生类从基类可以继承过来private的成员，但是派生类却无法直接访问
3.protected和private的区别?在基类中定义的成员，想被派生类访问，但是不想被外部访问.那么在基类中，把相关成员定义成protected保护的；如果派生类和外部都不打算访问，那么在基类中，就把相关成员定义成private私有的。

默认的继承方式是什么?
要看派生类是用class定义的，还是struct定义的?
class定义派生类，默认继承方式就是private私有的。struct定义派生类，默认继承方式就是public公有的。

派生类从继承可以继承来所有的成员(变量和方法)，以及构造函数和析构函数。
派生类怎么初始化从基类继承来的成员变量呢?
解答:通过调用基类相应的构造函数来初始化
Class Derive : public Base
构造： Derive(int data) :Base(data), Derive成员变量（data）

派生类的构造函数和析构函数，负责初始化和清理派生类部分
派生类从基类继承来的成员，的初始化和清理由谁负责呢?是由基类的构造和析构函数来负责

派生类对象构造和析构的过程是:
1.派生类调用基类的构造函数，初始化从基类继承来的成员。
2.调用派生类自己的构造函数，初始化派生类自己特有的成员。
3.调用派生类的析构函数，释放派生类成员可能占用的外部资源（堆内存，文件)。
4.调用基类的析构函数，释放从基类继承来的成员可能占用的外部资源（堆内存，文件)。

重载、隐藏、覆盖？
1.重载关系
一组函数要重载，必须处在同一个作用域当中;而且函数名字相同，参数列表不同
2.隐藏(作用域的隐藏)的关系
在继承结构当中，派生类的同名成员，把基类的同名成员给隐藏调用了
3.覆盖:
虚函数表中虚函数地址的覆盖

把继承结构，也说成从上(基类)到下(派生类)的结构
在继承结构中进行上下的类型转换，默认只支持从下到上的类型的转换。

7.2 虚函数、静态绑定和动态绑定

静态绑定：静态 (编译时期)的绑定 (函数的调用)
动态绑定：动态 (运行时期)的绑定 (函数的调用)
如果调用函数是发现函数为普通函数，就进行静态绑定。若为虚函数，则进行动态绑定。

虚函数：虚函数是基类中通过关键字 virtual 声明的函数，允许在派生类中被重写。当基类指针或引用指向派生类对象时，可以通过基类指针或引用调用派生类中重写的函数，从而实现动态绑定（Dynamic Binding）。
1.一个类里面定义了虚函数，那么编译阶段，编译器给这个类类型产生一个唯一的vftable虚函数表，虚函数表中主要存储的内容就是RTTI指针和虚函数的地址。当程序运行时，每一张虚函数表都会加载到内存的.rodata区。
2.一个类里面定义了函数数，那么这个类定义的对象y基运行时，内存中开始部分，多存储一个vfptr虚函数指针，指向相应类型的虚函数表vftable。一个类型定义的n个对象，它们的额vfpt指向的都是同一张虚函数表。
3.一个类里面虚函数的个数，不影响对象内存大小(vfptr)，影响的是虚函数表的大小。
4.如果派生类中的方法，和基类继承来的某个方法，返回值、函数名、参数列表都相同，而且基类的方法是virtual虚函数，那么派生类的这个方法，自动处理成虚函数。

问题一：哪些函数不能实现成虚函数?
虚函数依赖:
1.虚函数能产生地址，存储在vftable当中
2.对象必须存在(vfptr -> vftable ->虚函数地址)
virtual+ 构造函数 NO！构造函数中(调用的任何函数，都是静态绑定的）调用虚函数，也不会发生动态绑定派生类对象构造过。
static静态成员方法 NO！virtual + static 静态成员方法不会产生对象。

问题二：
虚析构函数析构函数调用的时候，对象是存在的！ YES！
什么时候把基类的析构函数必须实现成虚函数？
基类的指针(引用）指向堆上new出来的派生类对象的时候, delete pb(基类的指针)，它调用析构函数的时候，必须发生动态绑定，否则会导致派生类的析构函数无法调用。

问题三：虚函数和动态绑定问题:是不是虚函数的调用一定就是动态绑定?
肯定不是的。在类的构造函数当中，调用虚函数，也是静态绑定，不会发生动态绑定。
如果不是通过指针或者引用变量来调用虚函数，那也是静态绑定。

Base b;
Derive d;
//静态绑定用对象本身调用虚函数，是静态绑定
b.show ( ); //虚函数call Base : : show
d.show ( ); //虚函数call Derive : : show

//动态绑定（虚函数通过指针或者引用变量调用，才发生动态绑定)
Derive *pdl = &d;
pdl->show ( ) ;
Derive &rdl = & ;
rd1.show ( );

7.3 多态

如何解释多态?
静态(编译时期)的多态:函数重载、模板（函数模板和类模板)

bool compare (int, int) { }
bool compare (double, double) { }
compare (10，20); call compare_int_int 			 //在编译阶段就确定好调用的函数版本
compare(10.5，20.5); call compare_douoble_double //在编译阶段就确定好调调用的函数版本

template<typename T>
bool compare(T a, T b) { }
compare (10，20);				//=> int实例化一个compare<int>
compare (10.5，20.5); 		 	//=> double实例化一个compare<double>

动态(运行时期)的多态: Base Derive
在继承结构中，基类指针（引用）指向派生类对象，通过该指针（引用）调用同名覆盖方法（虚函数），基类指针指向哪个派生类对象，就会调用哪个派生类对象的同名覆盖方法，称为多态。
pbase->show ();
多态底层是通过动态绑定来实现的，pbase→访问谁的vfptr→继续访问谁的vftable→调用对应的派生类对象的方法。

继承的好处是什么?
1.可以做代码的复用I
⒉.在基类中给所有派生类提供统一的虚函数接口，让派生类进行重写，然后就可以使用多态了。

抽象类和普通类有什么区别? 一般把什么类设计成抽象类(基类)?
//动物的基类 泛指 类-→抽象一个实体的类型
定义Animal的初衷，并不是让Animal抽象某个实体的类型
1.string _name;让所有的动物实体类通过继承Animal直接复用该属性
2.给所有的派生类保留统一的覆盖/重写接口
注意：
拥有纯虚函数的类，叫做抽象类!(Animal)
抽象类不能再实例化对象了，但是可以定义指针和引用变量

C++多重继承-菱形继承问题？
优点：可以做更多的代码复用；
缺点：派生类有多份基类数据。
如何解决缺点？
用虚继承的方式，添加一个虚基类指针表vbptr，将基类移动至继承类数据下方。