C++基础入门

1 C++ 初始

1.1 注释

1. 单行注释

//单行注释

2. 多行注释

/*
* 多行注释
*/

1.2 变量

• 变量存在的意义：方便管理内存空间

int a = 10;

1.3 常量

作用:用于记录程序中不可改变的数据

1. 使用宏定义宏常量

#define constant_name "value"
#define BIGGEST 100

2. 使用const修饰的变量

const BIGGEST = 10；

1.4 关键字

作用：C++中与保留的关键字,不可作为常量与变量的名称

asm	do	if	return	typedef
auto	double	inline	short	typeid
bool	dynamic_cast	int	signed	typename
break	else	long	sizeof	union
case	rnum	mutable	static	unsigned
catch	explicit	namespace	static_cast	using
char	export	new	struct	virtual
class	extern	operator	switch	void
const	false	private	template	volatile
const_cast	float	protected	this	wchar_t
continue	for	public	throw	while
default	friend	register	true
delete	goto	reinterpret_cast	try

1.5 标识符命名规则

• 标识符不能是关键词
• 只能有字母、数字、下划线组成
• 第一个字符必须为字母或下划线
• 标识符中字母区分大小写
• 便于理解和阅读

2 数据类型

2.1 整型

作用：整型变量表示的是整型类型的数据

数据类型	占用空间	取值范围
short	2字节	($-2^{15} , 2^{15}-1$)
int	4字节	($-2^{31} , 2^{31}-1$)
long	Windows4字节，Linux32位4字节，64位8字节	($-2^{31} , 2^{31}-1$)
long long	8字节	($-2^{63} , 2^{63}-1$)

2.2 实数型

作用：用于表现小数

1. 单精度float
2. 双精度double

区别：有效数字范围不同

数据类型	占用空间	有效数字范围
float	4字节	7位有效数字
double	8字节	15-16位有效数字

• 默认情况下，输出小数至多保留6位有效数字

float f1 = 3.14f;//f声明3.14为单精度，减少性能损失与增加代码理解度
double f2 = 3.14;
float f3 = 3e2; 
double f4 = 3e-2;

2.3 字符型

作用：字符型变量用于显示单个字符

语法：char ch = 'a';

1. 不能使用双引号
2. 引号内只有一个字符，不可以是字符串

• 占用1个字节
• 字符型变量将ASCII编码放入到存储单元中
  • a - 97
  • A - 65
  • 0 - 48

char ch = 'a';

2.4 转义字符

作用：用于表示一些显示不出来的ASCII字符

转义字符	含义	ASCII码值（十进制）
\n	换行LF	010
\t	水平制表HT	009
\\	代表一个字符'\'	092

2.5 字符串型

**作用：**用于表示一串字符

两种风格

1. C风格字符串：char 变量名[] = "字符串值"

• 等号后使用双引号

char str1[] = "hello world"

2. C++风格字符串：string 变量名 = "字符串值"

• 需要引入额外文件 #include<string>

string str2 = "hello world"

2.6 布尔类型

作用：代表真和假

bool flag = true;
bool neg_flag = false;

2.7 数据的输入

从键盘获取输入cin

cin >> v;

3 运算符

作用： 用于执行代码的运算

3.1 算数运算符

运算符	操作
+	加
-	减
*	乘
/	除
%	取模（取余）
++	前置递增、后置递增
--	前置递减、后置递减

3.2 赋值运算符

运算符	操作	示例	结果
=	赋值	a=2	a=2
+=	加等于	a+=2	a=4
-=	减等于	a-=1	a=3
*=	乘等于	a*=3	a=9
/=	除等于	a/=3	a=3
%=	模等于	a%=2	a=1

3.3 比较运算符

运算符	术语	示例	结果
= =	相等于	4 = = 3	0
！=	不等于	4! =3	1
<	小于	4 < 3	0
>	大于	4 > 3	1
< =	小于等于	4 < = 3	0
> =	大于等于	4 > = 1	1

3.4 逻辑运算符

运算符	术语	示例
！	非	！a
&&	与	a && b
||	或	a || b

4 程序流程结构

C/C++支持的最基本三种运行结构：顺序结构、选择结构、循环结构

• 顺序结构：插恒旭按顺序执行，不发生跳转
• 选择结构：依据条件是否满足，有选择地执行相应功能
• 循环结构：依据条件是否满足，循环多次执行某段代码

4.1 选择结构

4.1.1 if语句

作用：执行满足条件的语句

• 单行if
• 多行格式if
• 多条件if

4.1.2 三目运算符

作用：实现简单的判断

语法：表达式1?表达式2：表达式3

a = b > c ? 1 : 0;
(a < b ? a : b) = 10;

4.1.3 switch语句

作用：执行多条件分支语句

• case 后真的值只能是一个整形或者字符型，不能是一个区间

• 执行效率高，空间换时间

switch(variable){
    case 1:
        //task
        break;
    case 2:
        // task
        break;
    default:
        //default task
        break;
}

4.2 循环结构

4.2 1 while循环语句

作用：满足循环条件，执行循环语句

语法：while(循环条件){循环语句}

• 只有循环条件为真时，执行循环语句

int i = 0;
while(i<10){
    cout << i++ << endl;
}

4.2.2 do-while语句

作用：满足循环条件，执行循环语句

语法:do{循环语句}while（循环条件）;

• do-while会执行一遍循环语句，再判断循环条件

4.2.3 for循环语句

作用：满足循环条件，执行循环语句

语法:for(其实表达式;条件表达式;末尾循环体){循环语句};

for(int i =0; i<10;i++){
    cout << i << endl;
}

4.3 转跳语句

4.3.1 break语句

作用：用于跳出选择结构或者循环结构

• 跳出switch
• 跳出循环
• 在嵌套循环中，跳出内存循环

switch(a){
    case 1:
        break;
}
while(a == 1){
    while(b+a < 100){
        if(b % 4 == 0){
            break;
        }
    }
}

4.3.2 continue语句

作用：再循环结构中，跳过本次循环中尚未执行的语句，直接执行下一次循环

for(int i =0;i<100;i++){
    if(i%7 ==0){
        continue;
    }
    cout << i << endl;
}

4.3.3 goto语句

作用：无条件跳转语句

语法：goto 标记；

• 如果标记的名称存在，执行到goto语句，会转跳到标记的位置
• 标记：name:

cout << '1' << endl;
goto FLAG;
cout << '2' << endl;
cout << '3' << endl;
cout << '4' << endl;
FLAG:
cout << '5' << endl;

5 数组

5.1 特点

• 一个集合，存放了相同类型的数据元素

• 数组是由连续的内存位置组成的

• 每个数据元素都是相同的数据类型

5.2 一维数组

一维数组定义的三种方式

int array1[10];
float flaots[5]={1, 2, 3, 4, 5};
char chars[] = {1,2,3,4,5};

• 初始化数据的时候，没有全部填写完，会用0来填补剩余数据

int arr[5] = {10, 20, 30};
// arr[5] = {10, 20, 30, 0, 0}

• 没有进行初始化的数组，其中的数据为随机值

• 从0开始索引

5.2.1 一维数组名

1. 可以统计整个数组在内存中的长度
2. 可以获取数组在内存中的首地址

int arr[3] = {1, 2, 3};
int length =  sizeof(arr)/sizeof(int);
int * arrAdd = &arr[0];

5.3 二维数组（多维数组）

二维数组在一维数组上，多加一个维度

5.3.1 二维数组定义方式

1. 数据类型 数组名[行数][列数]

2. 数据类型 数组名[行数][列数] = {{1, 2}, {3, 4}}

3. 数据类型 数组名[行数][列数] = {1,2,3,4}

4. 数据类型 数组名[][列数] = {1,2,3,4}

5.3.2 二维数组名

• 查看二维数组所占空间
• 获取二维数组首地址

int arr[2][3];
cou << sizeof(arr) << endl;

6 函数

6.1 概述

作用：讲一段经常使用的代码封装起来，减少重复代码

6.2 函数的定义

1. 返回值类型
2. 函数名
3. 参数列表
4. 函数体语句
5. return 表达式

返回值类型 函数名 （参数列表）{
    函数体语句
    return表达式
}

6.3 函数调用

• 函数名（参数）

int swap(int &a, int &b){
    int temp = a;
    a = b;
    b = a;
    return 0;
}
int main(){
    int a = 1;
    int b = 2;
    swap(a, b);
    cout << a << b << endl;
    return 0;
}

6.4 值传递

• 函数调用时实参将数值传入给形参
• 如果形参发生改变，不会影响到实参

int swap(int a, int b){
    int temp = a;
    a = b;
    b = a;
    return 0;
}
int main(){
    int a = 1;
    int b = 2;
    swap(a, b);
    cout << a << b << endl;
    return 0;
}

6.5 函数的常见样式

常见的函数样式有4种

1. 无参无返
2. 有参无返
3. 无参有返
4. 有参有返

6.6 函数的声明

• 告诉编译器函数名称及如何调用函数，函数的实际主题可以单独定义
• 函数的声明可以多次，但是函数的定义只能有一次

int max(int a, int b);
int max(int a, int b);

int max(int a, int b ){
    return a>b ? a : b
}

6.7 函数分文件编写

作用：让代码结构更加清晰

1. 创建后缀名为".h"的头文件
2. 创建后缀名为".cpp"的源文件
3. 在头文件中写函数的声明
4. 在源文件中写函数的定义

7 指针

7.1 指针的基本改变

• 通过指针间接访问内存

内存编号从0开始记录，一般用十六进制数字表示

可以利用指针变量保存地址

7.2 指针变量的定义和使用

指针变量定义语法数据类型 * 变量名；

7.3 指针所占内存空间

• 在指针的大小不取决于它指向的数据类型
• 32位系统中，指针通常占用4字节
• 64位系统中，指针通常占用8字节

int main() {
    std::cout << "Size of a pointer: " << sizeof(void*) << " bytes\n";
    return 0;
}

7.4 空指针和野指针

空指针：指针变量指向内存中编号为0的空间

• 初始化指针变量

• 空指针指向的内存不可以访问

int* ptr = nullptr;  //c++11以后得版本
int* ptr = NULL;  //早期C++和C语言

野指针：指针变量指向非法的内存空间

• 未初始化的指针
• 已释放的指针
• 指针操作超出作用域

避免野指针的出现：

• 始终初始化指针
• 释放内存后，将指针设置为 nullptr 或 NULL
• 谨慎使用指向局部变量的指针，尤其实在变量的作用域结束之后
• 使用智能指针（如std::unique_ptr 或者std::shaed_ptr)来自动管理内存

7.5 const修饰指针

1. const 修饰指针 -> 常量指针

int * const ptr;

• 修饰指针本身
• 指针的地址不能改变，指向的数据可以改变

2. cosnt 修饰常量 -> 指针常量

const int * ptr;

• 指针修饰指针指向的数据
• 指针指向的地址可以修改，指向的数据不能修改

3. cosnt都修饰

const int * const ptr；

• 不能改变指向的地址，也不能通过它来修改所指向的数据

7.6 指针和数组

• 使用指针访问数组中的元素

int arr[] = {1,2,3,4,5,6};

int * p = arr;
// 第一个元素
cout << * p << endl;

7.7 指针和函数

• 地址传递

// 一个简单的函数，通过地址（指针）传递参数
void increment(int* ptr) {
    (*ptr)++;  // 递增指针指向的值
}

int main() {
    int a = 5;
    std::cout << "Before: " << a << std::endl;  // 输出 a 的初始值

    increment(&a);  // 将 a 的地址传递给函数

    std::cout << "After: " << a << std::endl;  // 输出修改后的 a
    return 0;
}

8 结构体

8.1 结构体基本概念

结构体属于用户自定义的数据类型，允许使用户存储不同的数据类型

8.2 结构体定义和使用

语法:struct 结构体名 {结构体成员列表};

创建方式：

1. struct 结构体名 变量名；
2. struct 结构体名 变量名 = {成员1值，成员2值...}; //使用初始化列表
3. 定义结构体时，顺便创建变量；
4. C++11开始，使用构造函数
5. 统一初始化

// 有构造函数
struct myStruct {
    int x;
    float y;
    myStruct(int a, floabt b):x(a), y(b){
        //初始化操作
    }
}instance2（1,2.5）；

myStruct s1; //无初始化
myStruct s2 = {10, 20.5}; //聚合初始化


// 无构造函数
struct myStruct2 {
    int x;
    float y;
} instance1;

myStruct2 s3(11,21.5); //直接初始化

8.3 结构体指针

作用：通过指针访问结构体中的成员

• 利用操作符->可以通过结构体指针访问结构体

struct student{
    string name;
    int age;
    int classNum;
}

struct student s = {"name", 18,100};

struct student * p = &s;
std::cout << p->name << std::endl;

8.4 结构体做函数参数

• 值传递
• 地址传递

8.5 结构体中const使用场景

• 用来防止误操作
• 在函数中使用值传递需要复制的信息可能太多，需要使用地址传递
• 使用地址传递可能会发生修改原始数据的情况，使用const避免结构体内数据被修改

void func(const Example& obj) {
    // 这个函数无法修改 obj 的任何成员
 }

C++核心编程

1 new与delete

• 使用new分配内存
• 使用delete释放内存
• 对数组需要使用new[]与delete[]

int * ptr =new int;
delete ptr;

int* arr = new int[10];
delete[] arr;

• 不要对同一个指针应用多次delete
• 释放了内存，应将指针设为'nullptr' ,避免悬空指针和重复释放

delete ptr;
ptr = nullptr;

2 引用

• 作用： 给变量启别名
• 语法：数据类型 &别名 = 原名

• 引用一旦被初始化后，就不能改变引用的对象。
• 不能有空引用，引用必须在创建时被初始化。
• 当使用引用时，需要确保引用的生命周期不超过它所引用的对象。
• 不要返回函数内部局部变量的引用

int a = 10;
int &b = a;

• 函数参数传递

void increment(int& num) {
    num++;  // 直接修改原始变量
}

• 引用作为返回类型

int& getElement(std::vector<int>& v, size_t index) {
    return v[index];  // 返回向量中元素的引用
}

3 函数提高

3.1 函数默认值

语法：返回值类型 函数名(参数=默认值){}

• 默认参数应该在函数声明中指定

// 函数声明
void func(int a, int b = 10);

// 函数定义
void func(int a, int b) {
    // 函数体
}

• 默认参数从右往左设置

void example(int a, int b = 5, int c = 10); // 正确
void example2(int a = 1, int b, int c = 3); // 错误，b 没有默认值

• 避免与函数重载混淆

void print(int a);
void print(int a, int b = 10); // 这可能导致与 print(int) 的调用混淆

3.2 函数占位参数

1. 与 C 语言的接口兼容：在一些与 C 语言库交互的情况下，可能需要确保函数签名与 C 语言中预期的一致，即使某些参数实际上没有被使用。
2. 预留参数位置：在设计 API 时，可能想为将来的扩展预留参数位置。这样，在未来需要添加新的参数时，可以避免改变函数的签名，从而保持与现有代码的兼容性。
3. 强制重载：在某些情况下，可能需要通过添加占位参数来强制函数重载，尽管这不是占位参数的典型或推荐用法。

void func(int a, int){} // 使用占位参数
func（10, 10); //占位的参数必须要输入

3.3 函数重载

3.3.1 函数重载概述

• 函数名可以相同，提高复用性

函数重载条件

1. 同一作用域
2. 函数名相同
3. 参数数量不同、参数类型不同、参数顺序不同

• 返回类型不影响重载
• 默认参数不构成重载
• 顶层const不影响重载(const 直接修饰变量)

// 参数数量不同
void print(int a);
void print(int a, int b);
// 参数类型不同
void print(int a);
void print(double a);
// 参数顺序不同
void print(int a, double b);
void print(double a, int b);

int getNumber();
double getNumber();  // 错误：不构成重载

void print(int a);
void print(int a, int b = 10);  // 错误：不构成重载

void set(int a);
void set(const int a);  // 错误：不构成重载

3.3.2 引用中的函数重载

• const修饰指针或引用的参数可以影响函数重载

void func(const int& a) {
    // 处理 const 引用
}

void func(int& a) {
    // 处理非 const 引用
}

func(10); // 调用func(const int& a)
int x = 5;
func(x);  // 调用func(int& a)

4 类和对象

C++ 面向对象的三大特性：封装、继承、多态

4.1 封装

4.1.1 封装的意义

• 将属性和行为作为一个整体
• 将属性和行为加以权限控制

class Box {
private:
    // 私有数据成员，外部无法直接访问
    double length;
    double width;
    double height;

public:
    // 公有方法，用于访问和操作数据成员
    void setDimensions(double len, double wid, double hei) {
        length = len;
        width = wid;
        height = hei;
    }

    double getVolume() {
        return length * width * height;
    }
};

• 访问权限

1. public 公共权限 内外都可以访问
2. private 私有权限 类内可以访问，类外不可以访问
3. protected 保护权限 类内可以访问，类外不可以访问 继承类可以访问父类

4.1.2 成员属性设置为私有

• 成员属性设置为私有，可以自己控制读写权限
• 对于写权限，我们可以检测数据的有效性

4.2 对象的初始化和清理

4.2.1 构造函数和析构函数

• 构造函数：创建对象时，为对象的成员属性赋值，构造函数由编译器自动订阅。无需手动调用

• 析构函数：对象销毁前自动调用，执行一些清理工作

构造函数语法：类名(){}

1. 没有返回值
2. 函数名称和类名相同
3. 构造函数可以有参数，因此可以发生重载
4. 程序在调用对象的时候会自动构造，无需手动调用

class MyClass {
public:
    MyClass() { /* 默认构造函数 */ }
    MyClass(int x, double y) : x_(x), y_(y) { /* 带参数的构造函数 */ }

private:
    int x_;
    double y_;
};

析构函数语法：~类名(){}

1. 析构函数，没有返回值也不写void
2. 析构函数不可以有参数，因此不可以发生重载
3. 对象销毁时会自动调用

class MyClass {
public:
    MyClass() { /* 分配资源 */ }
    ~MyClass() { /* 释放资源 */ }
};

4.2.2 构造函数的分类及调用

两种分类方式：

• 按参数分：有参构造和无参构造
• 按类型分：普通构造和拷贝构造

三种调用方式：

1. 括号法

2. 显示法

3. 隐式转换发

class MyClass{
public：
    Person(){} // 无参构造
    Person(int a){} // 有参构造
    Person(const Person &p){} // 拷贝构造
}

// 调用
// 括号
MyClass c1;
MyClass c2(10);
MyClass c3(c2);
// 显示法
MyClass c1;
MyClass c2 = MyClass(10);
MyClass c3 = MyClass(c2); // 匿名对象，当前行执行结束后，立刻回收
// 隐式转换法
MyClass c2 = 10;
MyClass c3 = c2;

4.2.3 拷贝构造函数调用时机

1. 使用一个已经创建完毕的对象来初始化另一个对象

MyClass obj1;
MyClass obj2 = obj1;  // 调用拷贝构造函数

2. 值传递的方式给函数参数传值

void func(MyClass obj);  // 调用拷贝构造函数传递参数
func(obj1);

3. 以值方式返回局部变量

MyClass func() {
    MyClass obj;
    return obj;  // 可能调用拷贝构造函数
}

4.2.5 浅拷贝与深拷贝

• 浅拷贝：简单的复制拷贝操作
• 深拷贝：在堆区重新申请空间，进行拷贝操作

浅拷贝是指复制对象的成员变量的值，而不考虑这些成员变量本身可能是指针或者引用。如果成员变量是指向动态分配内存的指针，浅拷贝只会复制指针值（内存地址），不会复制指针所指向的内存

问题：

• 悬空指针：如果原始对象被销毁或释放，拷贝对象中的指针可能变成悬空指针。
• 双重释放：如果两个对象都试图释放同一个内存地址，可能导致运行时错误。
• 数据共享：两个对象共享相同的资源，一个对象的修改可能会影响另一个对象。

class MyClass {
public:
    int* data;

    // 构造函数
    MyClass(int size) {
        data = new int[size];  // 动态分配内存
    }

    // 析构函数
    ~MyClass() {
        delete[] data;  // 释放内存
    }
};

void func() {
    MyClass obj1(10);
    MyClass obj2 = obj1;  // 浅拷贝：obj1 和 obj2 现在共享相同的 data
}  // obj1 和 obj2 被销毁，尝试释放相同的内存两次

在这个例子中，如果使用默认的拷贝构造函数（浅拷贝），obj1 和 obj2 将共享相同的 data 指针。当它们被销毁时，都会尝试释放相同的内存，导致双重释放错误。

为了解决这个问题，需要实现一个深拷贝拷贝构造函数：

MyClass(const MyClass& other) {
    // 分配新的内存，并复制数据
    data = new int[/* 假设 size 已知 */];
    std::copy(other.data, other.data + size, data);
}

4.2.6 初始化列表

初始化属性

语法：构造函数():属性1(值1)，属性2(值2)...{}

class MyClass {
private:
    int a;
    double b;
    std::string str;

public:
    MyClass(int x, double y, const std::string& s) : a(x), b(y), str(s) {
        // 使用初始化列表初始化成员变量
        // 构造函数体可以执行其他初始化操作或逻辑
    }
};

4.2.7 类对象作为类成员

C++类中的成员可以使另一个类的对象，成员为对象成员

class A{}
class B{
    A a;
}

先创建A，再创建B；释放时，先释放B，再释放A

4.2.8 静态成员

• 静态成员变量
  • 所有对象共享一份数据
  • 在编译阶段分配内存
  • 类内声明，类外初始化

class MyClass {
public:
    static int staticValue;  // 静态成员变量声明
};

int MyClass::staticValue = 0;  // 静态成员变量定义和初始化

int main() {
    MyClass::staticValue = 5;  // 通过类名访问
    MyClass obj;
    std::cout << obj.staticValue;  // 通过对象访问
}

• 静态成员函数
  • 所有对象共享同一个函数
  • 静态成员函数只能访问静态成员变量

class MyClass {
public:
    static void staticFunc() {
        // 静态成员函数体
    }

    void nonStaticFunc() {
        // 非静态成员函数体
    }
};

// 调用静态成员函数，无需创建 MyClass 的对象
MyClass::staticFunc();

4.3 C++对象模型和this指针

4.3.1 成员变量和成员函数分开存储

只有非静态的成员变量才属于类的对象上

4.3.2 this指针

• 自动传递给所有非静态成员函数的调用
• 指向调用函数的对象本身

• 在静态成员函数中，不可以使用 this 指针，因为静态成员函数不属于任何对象实例。
• this 是一个常量指针，不能被修改，即你不能改变它所指向的对象。
• 在构造函数和析构函数中，this 指针也是有效的，它指向正在被构造或析构的对象。

class MyClass {
private:
    int value;
public:
    void setValue(int value) {
        this->value = value;  // 使用 this 区分成员变量和局部变量
    }
};

• 支持链式调用

class MyClass {
public:
    MyClass& setX(int x) {
        // ...
        return *this;
    }

    MyClass& setY(int y) {
        // ...
        return *this;
    }
};

MyClass obj;
obj.setX(10).setY(20);  // 链式调用

4.3.3 空指针访问成员函数

class MyClass {
public:
    void myMethod() {
        // 一些操作
    }
};

MyClass *ptr = nullptr; 
ptr->myMethod();  // 危险操作：通过空指针调用成员函数

class MyClass {
public:
    void myMethod() const {
        std::cout << "Called myMethod" << std::endl;
    }
};

MyClass *ptr = nullptr;
ptr->myMethod();  // 还是未定义行为，即使可能不会导致崩溃

4.3.4 const修饰成员属性

常函数：

• 成员函数后使用const修饰
• 常函数不能修改成员属性
• 成员属性声明时加关键字mutable后，可以修改
• 可以在任何类型的对象上被调用，包括常对象

class MyClass {
public:
    void constFunction() const {
        // 这里不能修改任何成员变量
    }
};

常对象：

• 声明对象前加const
• 常对象只能调用常函数
• 任何非静态成员变量不能被修改

const MyClass obj;  // 常对象
obj.constFunction();  // 可以调用常函数
// obj.nonConstFunction();  // 错误：不能调用非常函数

4.4 友元

• 让一个函数或者类，访问另一个类中的私有成员

实现：

• 函数做友元

class MyClass {
private:
    int value;

public:
    MyClass(int val) : value(val) {}

    // 声明友元函数
    friend void FriendFunction(MyClass& m);
};

// 友元函数定义
void FriendFunction(MyClass& m) {
    std::cout << "Accessing private value: " << m.value << std::endl;
}

• 类做友元

class MyClass {
private:
    int value;

public:
    MyClass(int val) : value(val) {}

    // 声明友元类
    friend class FriendClass;
};

class FriendClass {
public:
    void accessMyClass(MyClass& m) {
        std::cout << "Accessing private value: " << m.value << std::endl;
    }
};

4.5 运算符重载

• 运算符重载：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

4.5.1 加号运算符重载

class MyClass {
public:
    MyClass operator+(const MyClass& obj) {
        // 实现重载逻辑
    }
};

// 成员函数形式调用
MyClass p3 = p1.operator+(p2);
// 全局函数形式调用
MyClass p3 = p1 + p2;

4.5.2 左移运算符

class Person{
    //设置为友元
friend ostream &  operator<<(ostream &cout, Person &p)
public:
    // 不利用成员函数重载<<，因为无法实现cout在左侧
     //void operator<<(cout)
    
    int m_A;
    int m_B;
}
ostream &  operator<<(ostream &cout, Person &p){
    //利用全局函数重载左移运算符
    return cout；
}

4.5.3 递增运算符重载

• 前缀递增

通常不需要参数，并返回对象的引用

MyClass& operator++() {
    // 增加操作
    return *this;
}
++mc;

• 后置递增

需要额外的int作为占位符以区分前缀版本，返回对象的值

MyClass operator++(int) {
    MyClass temp = *this;
    // 增加操作
    return temp;
}
mc++;

4.5.4 赋值运算符重载

1. 检查自赋值：检查赋值操作是否涉及将对象赋值给自身。这是通过比较 this 指针和传入对象的地址来完成的。
2. 释放旧资源：如果类包含指向动态分配内存的指针，首先释放这些资源。
3. 复制数据：从源对象复制数据到当前对象。对于动态分配的内存，需要进行深度拷贝。
4. 返回引用：返回当前对象的引用，以支持链式赋值（a = b = c）。

class MyClass {
public:
    MyClass& operator=(const MyClass& other) {
        if (this != &other) { // 1. 检查自赋值
            delete[] data;     // 2. 释放旧资源
            data = new int[other.size];  // 3. 分配新资源并复制数据
            std::copy(other.data, other.data + other.size, data);
        }
        return *this;  // 4. 返回当前对象的引用
    }

private:
    int* data;
    size_t size;
};

4.5.5 关系运算符重载

• 让两个自定义类型对象进行对比操作
• 添加const让函数成为常函数，不允许改变类数据

class MyClass {
public:
    bool operator==(const MyClass& other) const {
        return this->attribute == other.attribute;
    }
};

4.5.6 函数调用运算符重载

重载函数调用运算符 (operator()) 允许一个对象表现得像一个函数。这意味着你可以创建一个类的实例，然后使用函数调用语法来调用它的某个成员。这在创建函数对象或lambda表达式的类似行为时非常有用。

class Functor {
public:
    // 重载函数调用运算符
    int operator()(int x) {
        return x * x;
    }
};

int main() {
    Functor functor;
    int result = functor(5);  // 调用重载的 operator()
    std::cout << result;      // 输出 25
}

4.6 继承

• 允许一个类（称为子类）获得另一个类（称为基类）的属性和行为的机制。
• 面向对象编程的核心概念之一，用于实现代码重用、实现多态性和建立类之间的关系。
• 使用冒号 : 后跟访问修饰符（如 public）和基类名称来继承基类。

class BaseClass {
public:
    void commonMethod() {
        // 基类方法实现
    }
};

class DerivedClass : public BaseClass {
  // 子类可以添加额外的属性和方法  
};

1. 公共继承（Public Inheritance）：这是最常见的继承类型。在公共继承中，基类的公共和保护成员在子类中保持相同的访问级别。
2. 保护继承（Protected Inheritance）：在这种继承中，基类的所有公共和保护成员在子类中都成为保护成员。
3. 私有继承（Private Inheritance）：在私有继承中，基类的公共和保护成员在子类中都成为私有成员。

• 父类中私有成员，子类访问不到

• 父类中的所有静态成员都会被继承下去，只是私有成员被隐藏了，无法访问

• 当子类对象被创建时，首先调用的是父类的构造函数，然后才是子类的构造函数

  • 对象销毁时，顺序则相反：首先调用的是子类的析构函数，然后才是父类的析构函数

4.6.1 继承同名成员处理方式

• 访问子类同名成员 直接访问即可
• 访问父类同名成员 需要加作用域

4.6.2 多继承语法

C++允许一个类继承多个类

语法：class 子类:继承方式 父类1, 继承方式 父类2...

可能引发父类中有同名成员出现，需要加作用于区分

C++实际开发中不建议使用多继承

class BaseClass1 {
    // 基类1的成员
};

class BaseClass2 {
    // 基类2的成员
};

class DerivedClass : public BaseClass1, public BaseClass2 {
    // 派生类的成员
};

4.6.3 虚继承

虚继承在 C++ 中是通过关键字 virtual 实现的。它主要用于解决菱形继承问题，确保通过不同路径继承来的同一基类只有一个共享实例。在虚继承中，基类称为虚基类。

class VirtualBase {
    //...
};

class Derived1 : virtual public VirtualBase {
    //...
};

class Derived2 : virtual public VirtualBase {
    //...
};

class FinalDerived : public Derived1, public Derived2 {
    //...
};

是否应将所有继承定义为虚继承：

• 不建议。虚继承会增加复杂性和运行时开销。
• 通常仅在解决特定的菱形继承问题时使用。

4.7 多态

多态分为两类：

• 静态多态：函数重载和运算符重载，复用函数名
• 动态多态：派生类和虚函数实现运行时多态

区别：

• 静态多态的函数地址早绑定 - 编译阶段确定函数地址
• 动态多态的函数地址晚绑定 - 运行阶段确定函数地址

多态满足条件

• 有继承关系
• 子类重写父类中的虚函数
• 重写：函数返回值类型、函数名、参数列表完全一致

使用

• 父类指针或引用指向子类对象

// 基类
class Animal {
public:
    virtual void makeSound() {
        std::cout << "Some animal sound" << std::endl;
    }
};

// 派生类1
class Dog : public Animal {
public:
    void makeSound() override {
        std::cout << "Bark" << std::endl;
    }
};

// 派生类2
class Cat : public Animal {
public:
    void makeSound() override {
        std::cout << "Meow" << std::endl;
    }
};

int main() {
    Animal* myAnimal = new Dog();
    myAnimal->makeSound(); // 输出：Bark

    myAnimal = new Cat();
    myAnimal->makeSound(); // 输出：Meow

    delete myAnimal;
    return 0;
}

4.7.1 纯虚函数和抽象类

纯虚函数语法：virtual 返回值类型 函数名 (参数列表) = 0;

包含纯虚函数的类，称为抽象类

• 无法实例化对象
• 子类必须重写抽象类中的纯虚函数，否则也属于抽象类，无法实例化对象

// 抽象类
class Shape {
public:
    // 纯虚函数
    virtual double area() const = 0;
};

// 派生类
class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}
    double area() const override {
        return 3.14159 * radius * radius;
    }
};

Shape 是一个抽象类，它有一个纯虚函数 area()。Circle 类继承自 Shape 并实现了 area() 函数。因为 Shape 类含有纯虚函数，所以不能直接实例化。Circle 类提供了 area() 的具体实现，因此它不是抽象类，可以实例化。这个模式允许定义一组接口（在 Shape 中），然后由不同的派生类（如 Circle）以不同的方式实现这些接口。

4.7.2 虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码

解决方法：将分类中的析构函数改为虚析构或者纯虚析构

虚析构和春虚析构共性：

• 可以解决父类指针释放子类对象
• 都需要有具有的函数实现

区别：

• 包含纯虚析构的类属于抽象类，无法实例化对象

虚析构语法：virtual ~类名(){}

纯虚析构语法:virtual ~类名() = 0;

#include<iostream>
#include<string>
using namespace std;

class Animal{
public :
    virtual void speak() =0;
    Animal(){
        cout << "animal create" << endl;
    }
    // 利用虚析构可以解决 父类指针释放子类对象时不干净的问题
//    virtual ~Animal(){
//        cout << "animal delete" << endl;
//    }
    //使用纯虚析构，类变为抽象类，无法实例化对象
    virtual  ~Animal() = 0;
};
// 对于纯虚析构需要有具体实现
Animal::~Animal(){
    cout << "animal delete" << endl;
}
class Cat: public Animal{
public:
    Cat(string name){
        cout << "cat create " << endl;
        m_Name = new string(name);
    }
     void speak()  override {
        cout << * m_Name <<"cat speak" << endl;
    }
    string * m_Name;
    ~Cat(){
        cout << "Cat delete" << endl;
        if(m_Name != NULL){
            delete m_Name;
            m_Name = nullptr;
        }
    }
};

int main(){
    Animal * animal = new Cat("Tom");
    animal->speak();
    // 父类指针在析构的时候 不会调用子类中的析构函数，导致子类如果有堆区属性，出现内存泄露
    delete animal;
    return 0;
}

5 文件操作

通过文件操作将数据进行持久化

C++中对文件操作需要包含头文件<fstream>

文件分类：

• 文本文件 - 文件以文本的ASCII码形式存储在计算机中
• 二进制文件 - 文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂他们

操作文件的三大类:

1. ofstream : 写操作
2. ifstream : 读操作
3. fstream : 读写操作

5.1 文本文件

5.1.1 写文件

写文件步骤如下

1. 包含头文件

include

2. 创建流对象

ofstream ofs;

3. 打开文件

fos.open("文件路径", 打开方式);

4. 写数据

ofs << "写入的数据";

5. 关闭文件

ofs.close();

文件打开方式：

打开方式	解释
ios::in	为读文件而打开文件
ios::out	为写文件而打开文件
ios::ate	初试位置：文件尾部
ios::app	追加方式写文件
ios::trunc	如果文件存在先删除，在创建
ios::binary	二进制方式

注意：文件打开方式可以配合使用，利用|操作符

例如：用二进制方式写文件ios::binary | ios::out

include<fstream>
ofstream ofs;
ofs.open("test.txt", ios::out);
ofs << "name: Natsukiz" << endl;
ofs << "gender: male" << endl;
ofs.close();

• 文件操作必须包含头文件fstream
• 读文件可以利用ofstram或者fstream
• 打开问价时候需要制定操作文件的路径、以及打开方式
• 利用 <<可以向文件中写数据
• 操作完毕，要关闭文件

5.1.2 读文件

读文件步骤：

1. 包含头文件

#include

2. 创建流对象

ifstream ifs;

3. 打开文件并判断文件是否打开成功

ifs.open("文件路径", 打开方式);

4. 读数据

四种方式读取

5. 关闭文件

ifs.close()

#include <iostream>
#include <fstream>
#include <string>

int main() {
    std::ifstream file("example.txt");
    std::string line;
    if (file.is_open()) {
        while (std::getline(file, line)) {
            std::cout << line << '\n';
        }
        file.close();
    } else {
        std::cout << "Unable to open file";
    }
    return 0;
}

读取数据的不同方式

// 1
char buf[1024] = {0}
while(ifs >> buf){
    cout << buf << endl;
}
// 2
char buf[1024] = { 0 };
while(ifs.getline(buf), 1024){
    cout << buf << endl;
}
// 3
string buf;
while(getline(ifs, buf)){
    cout << buf << endl;
}
// 4 不推荐
char c;
while((c=ifs.get()) != EOF){
    cout << c;
}

5.2 二进制文件

以二进制的方式对文件进行读写操作

打开方式要指定为ios::binary

5.2.1 写文件

// 在写入数据之前，将数据转为const char* 的类型

#include <fstream>

int main() {
    std::ofstream outfile("example.bin", std::ios::binary);
    if (outfile.is_open()) {
        int data = 123;
        outfile.write(reinterpret_cast<const char*>(&data), sizeof(data));
        outfile.close();
    }
    return 0;
}

5.2.2 读文件

二进制方式读文件主要利用流对象调佣成员函数read

函数原型：istream& read(char *buffer, int len);

buffer是内存中一段存储空间。len是读写的字节数

#include <fstream>

int main() {
    std::ifstream infile("example.bin", std::ios::binary);
    if (infile.is_open()) {
        int data;
        infile.read(reinterpret_cast<char*>(&data), sizeof(data));
        infile.close();
    }
    return 0;
}

C++提高编程

• C++泛型编程
• STL技术

1 模板

1.1 模板的概念

• 建立通用的模具， 大大提高复用性

1.2 函数模板

• 建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表

1. 定义模板：使用关键字 template 定义函数模板，并在尖括号中指定一个或多个模板参数。
2. 实现函数：编写函数体，使用模板参数作为数据类型。
3. 调用函数：在代码中使用函数时，编译器会根据传入参数的类型自动实例化适当的函数版本。

template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    // 使用模板函数
    int sum = add(1, 2);        // 实例化为 int 版本
    double doubleSum = add(1.5, 2.3); // 实例化为 double 版本
}

• 自动类型推导，必须推导出一直的数据类型T才可以使用,不可混用

• 模板必须要确定出T的数据类型，才可以使用

1.2.1 普通函数与函数模板的调用规则

1. 如果函数模板和普通函数都可以实现，优先调用普通函数
2. 可以通过空模板参数列表来强制调用函数模板
3. 函数模板也可以发生重载
4. 如果函数模板可以产生更好地匹配优先调用函数模板

1.2.6 模板的局限性

template<typename T>
void f(T a, T b){
    a = b;
}

上述代码提供的复制操作，传入a和b是一个数组，就无法实现

template<typename T>
void f(T a, T b){
    if(a > b){...}
}

上述代码的T是自定义数据类型，也无法正常运行

• 使用模板的重载，为特定的类型提供具体的模板

class Person{
public:
    Person(string name, int age){
        this->m_Name = name;
        this->m_Age = age;
    }
    string m_Name;
    int m_Age;
}
// 不同函数模板
template<typename T>
bool myCompare(T& a, T& b){
    if(a == b){
        return true;
    }else{
        return false;
    }
}
//具体化，显示具体化的原型和定意思以template<>开头，并通过名称来指出类型
//具体话优先于常规模板
template<> bool myCompare(Person &p1, Person & p2){
    if(p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age){
        return true;
    }else{
        return false;
    }
}

bool test01(){
    int a = 10;
    int b = 20;
    // 内置数据类型可以直接使用通用的函数模板
    bool ret = myCompare(a, b);
    if(ret){
        return true;
    }else{
        return false;
    }
}

• 利用具体化的模板，可以解决自定义类型的通用化
• 学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

1.3 类模板

• 建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型来代表

1. 义类模板：使用关键字 template，然后在尖括号 < > 中定义一个或多个模板类型参数。
2. 实现类：在类定义中，使用模板参数作为类型来声明成员变量或函数。
3. 实例化类：当使用类模板创建对象时，需要指定具体的类型参数，这会生成相应类型的类实例。

template <typename NameType, typename AgeType, typename dataType>
class Person {
    dataType* array;
    NameType m_Name;
    AgeType m_Age;
    int size;
public:
    Person(NameType name, AgeType age, int size) :m_Name(name),m_Age(age), size(size) {
        array = new dataType[size];
    }
    ~MyArray() {
        delete[] array;
    }
    // 类中的其他方法...
};

int main() {
    Person<string, int, int> a("1212",5,10); // 创建 int 类型的数组
    Person<string, int, double> b("dsfads",10,5); // 创建 double 类型的数组
    cout << a.m_Name << endl;
    cout << b.m_Name << endl;
}

1.3.2 类模板与函数模板的区别

• 类模板没有自动推导的使用方法
• 类模板在模板参数列表中可以有默认参数

template<typename NameType, typename AgeType = int>
class Person{
public:
    Person(NameType name, AgeType age){
        this->m_Name = name;
        this->m_Age = age;
    }
    void show(){
        cout << this->m_Name << " " << this->m_Age << endl;
    }
    NameType m_Name;
    AgeType m_Age;
}
void test01(){
    // 无法使用自动类型推导
    Person p("name", 1000);
    // 正确使用方法
    Person<string, int> p("name", 1000);
    p.show();
}
 void test02(){
     // 类模板有默认参数，只提供一个，可以使用
     Person<string>p("name2", 100);
     p.show();
 }

1.3.3 类模板成员函数创建时机

• 普通类中的成员函数在一开始就可以创建
• 类模板中的成员函数在调用时才创建

1.3.4 类模板对象做函数参数

传入方式：

1. 指定传入的类型 --- 直接显示对象的数据类型
2. 参数模板化 --- 将对象中的参数变为模板进行传递
3. 整个类模板化 --- 将这个对象类型 模板化进行传递

class Person{
public:
    Person(NameType name, AgeType age){
        this->m_Name = name;
        this->m_Age = age;
    }
    void show(){
        cout << this->m_Name << " " << this->m_Age << endl;
    }
    NameType m_Name;
    AgeType m_Age;
};
// 1. 指定传入类型 最常用
void printPerson1(Person<string, int> &p){
    p.show();
}

void test01(){
    Person<string, int>p("name", 100);
    printPerson1(p);
}

// 2.参数模板化
template<typename T1, typename T2>
void printPerson2(Person<T1, T2> &p){
    p.show();
}

void test02(){
    Person<string, int>p("name2", 100);
    printPerson1(p);
}

// 3.整个类模板化
void test02(){
    Person<string, int>p("name2", 100);
    printPerson2(p);
}
template<typename T>
void printPerson3(T & p){
    p.show();
    cout << "T :" << typeid(T).name() << endl;
}

1.3.5 类模板与继承

当类模板碰到继承时：

1. 当子类继承的父类是一个类模板时，子类在声明的时候，要指出父类中T的类型
2. 如果不指定，编译器无法给子类分配内存
3. 如果想灵活制定出父类中T的类型，子类也需要变为类模板

template<typename T>
class Base{
    T m;
};

//class Son:public Base{ // 错误，必须要知道父类中的T类型，才能继承给子类
class Son:public Base<int>{
};
// 子类也为类模板，可灵活指定父类T类型
template<typename T1,typename T2>
class templeSon:public Base<T2>{
    T1 obj;
};

void test(){
    Son p;
    templeSon<string, int> p1;
}

1.3.6 类模板成员函数类外实现

// 类模板声明
template <typename T>
class MyClass {
public:
    void myFunction(T value);
};

// 类模板成员函数的类外实现
template <typename T>
void MyClass<T>::myFunction(T value) {
    // 函数实现...
}

1.3.7 类模板份文件编写

问题：

• 类模板中成员函数创建时机是在调用阶段，导致文件编写时链接不到

解决：

• 直接包含.cpp源文件
• 将声明和实现写到同一文件中，并更改后缀为.hpp，hpp是约定的名称，并不是强制

1.3.8 类模板与友元

全局函数类内实现 - 直接再类内声明友元即可

全局函数类外实现 - 需要提前让编译器知道全局函数的存在

template<typename T1, typename T2>
class Person;

template<typename T1, typename T2>
void printPerson2(Person<T1,T2> p){
    cout << p.m_Name << " " << p.m_Age << endl;
}

template<typename T1, typename T2>
class Person{
    //全局函数 类内实现
    friend void printPerson(Person<T1,T2> p){
        cout << p.m_Name << " " << p.m_Age << endl;
    }
    //全局函数类外实现
    //加空模板参数列表
    //如果全局函数是类外实现，需要让编译器知道函数的存在
    //即先声明模板类、全局函数实现
    friend void printPerson2<>(Person<T1,T2> p);
public:
    Person(T1 name, T2 age);
private:
    T1 m_Name;
    T2 m_Age;
};


template<typename T1, typename  T2>
Person<T1, T2>::Person(T1 name, T2 age){
    this->m_Name = name;
    this->m_Age = age;
}

int main() {
    Person<string,int>p("Tom",  20);
    printPerson(p);
    Person<string,int>p1("Jerry",  20);
    printPerson2(p1);
}

总结：建议全局函数做类内实现，用法简单，而且编译器可以直接识别

2 STL初识

2.1 STL的诞生

• 建立可重复利用的东西
• 面向对象和泛化编程思想，目的就是复用性的提升
• 大多数情况下，数据结构和算法都未能有一套标准，导致被迫从事大量重复工作
• 建立数据结构和算法的一套标准，诞生了STL

2.2 STL基本概念

• STL（Standard Template Library，标准模板库）
• STL从广义上分为：容器（container）、算法（algorithm）、迭代器（iterator）
• 容器和算法之间通过迭代器无缝衔接
• STL几乎所有的代码采用了模板类或者模板函数

2.3 STL六大组件

• 容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

1. 容器：各种数据结构，如vector、list、deque、set、map等，用来存放数据
2. 算法：各种常用的算法，如sort、find、copy、for_each
3. 迭代器：扮演了容器与算法之间的胶合剂
4. 仿函数：行为类似函数，可作为算法的某种策略
5. 适配器：一种用来修饰容器或者仿函数或迭代器借口的东西。
6. 空间配置器：负责空间的配置和管理

2.4 STL中容器、算法、迭代器

容器

最广泛的数据结构：数组、链表、树、栈、队列、集合、映射表等

• 序列式容器：强调值的排序，每个元素均有固定的位置
• 关联式容器：二叉树结构，个元素之间灭有严格的物理上的顺序关系

算法

• 质变算法：运算过程中会更改区间内的元素的内容。例如拷贝、替换、删除等
• 废纸边算法：运算过程中不会更改区间内的元素内容，例如：查找、计数、遍历、寻找极值等

迭代器

• 每个容易都有自己专属的迭代器
• 迭代器使用非常类似于指针

种类	功能	支持运算
输入迭代器	对数据的只读访问	只读，支持++、==、!=
输出迭代器	对数据的只写访问	只写，支持++
前向迭代器	读写操作，并能向前推进迭代器	读写，支持++、==、!=
双向迭代器	读写操作，并能向前和向后操作	读写、支持++、--
随机访问迭代器	读写操作，可以以跳跃的方式访问任意数据，功能最强的迭代器	读写、支持++、--、[n]、<、<=、>、>=

常用的容器中迭代器种类为双向迭代器、随机访问迭代器

2.5容器算法迭代器初识

最常用的容器Vector ，可以理解为数组

容器：vector

算法：for_each

迭代器：vector::iterator

2.5.1 vector存放内置数据类型

#include<vector>
#include<algorithm>
using namespace std;

void myPrint(int val){
    cout << val << endl;
}

void test01(){
    vector<int> v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);

    vector<int>::iterator itBegin = v.begin();
    vector<int>::iterator itEnd = v.end();//结束迭代器，指向容器中最后一个元素的下一个位置

    while(itBegin != itEnd){
        cout << *itBegin << endl;
        itBegin++;
    }

    for(vector<int>::iterator  it = v.begin(); it != v.end(); ++it){
        cout << *it << endl;
    }

    for_each(v.begin(), v.end(), myPrint);
};

2.5.2 Vector存放自定义数据类型

class MyClass {
public:
    int value;
    MyClass(int v) : value(v) {}
};

int main() {
    std::vector<MyClass> myVector;

    // 添加元素
    myVector.push_back(MyClass(10));
    myVector.emplace_back(20);

    // 访问元素
    for (const auto& item : myVector) {
        std::cout << item.value << std::endl;
    }
}

3 STL常用容器

3.1 string容器

3.1.1 string 基本概念

本质：

• string是C++风格的字符串，饿的人string本质上是一个类

string和char 的区别：*

• char* 是一个指针
• string是一个类，类内部封装了char*， 管理这个字符串，是一个char*形状的的容器

特点：

string类内部封装了很多成员方法

• find、copy、delete、replace、insert

string管理char*所分配的内存，不用担心复制越界和取值越界等，由类内部进行负责

3.1.2 string构造函数

1. 直接初始化：使用 = 赋值一个字符串字面量。

   std::string str1 = "Hello";
   

2. 拷贝构造：从另一个 std::string 对象复制。

   std::string str2(str1);
   

3. 列表初始化：使用花括号 {}。

   std::string str3{"World"};
   

4. 重复字符：使用字符和重复次数。

   std::string str4(5, 'a');
   

5. 子字符串：从另一个字符串的指定部分创建。

   std::string str5(str1, 1, 3); // "ell"
   

6. 从 C 风格字符串：使用字符数组。

   const char* cstr = "C++";
   std::string str6(cstr);
   

3.1.3 string 赋值操作

string& operator=(const char* s); // char*类型字符串 赋值给当前字符串

string& operator=(const string &s); // 把字符串s赋值给当前的字符串

string& operator=(char c); // 字符复制给当前的字符串

string& assign(const char *s); // 把字符串s赋值给当前的字符串

string& assign(const char * s, int n); // 把字符串s的前n个字符付给当前的字符串

string& assign(const string &s); // 把字符串s赋给当前字符串

string& assign(int n, char c); // 用n个字符c复制给当前字符串

std::string str1 = "Hello";
std::string str2;
str2 = str1;  // 使用 = 赋值

std::string str3;
str3.assign(str1, 1, 3);  // 赋值为 str1 的子串

3.1.4 string字符串拼接

• 实现字符串末尾拼接字符串
• 主要使用+=、append

string& operator+=(const char* str);

string& operator+=(const char c);

string& operator+=(const string& str);

string& append(const char *s);

string& append(const char *s, int n);

string& append(cosnt string &s);

string& append(const string &s, int pos, int n);

1. 使用 += 运算符：简单直接，可以添加一个字符、字符串字面量、另一个 std::string 对象或字符数组。

   std::string str = "Hello";
   str += ", World";  // 结果为 "Hello, World"
   

2. 使用 append 方法：提供了更多控制，可以指定要添加的字符串的特定部分、重复次数等。

   • 添加另一个字符串：

     std::string str1 = "Hello";
     std::string str2 = " World";
     str1.append(str2);  // 结果为 "Hello World"
     

   • 添加子串：

     std::string str3 = "123";
     str1.append(str3, 1, 2);  // 从 str3 的索引 1 开始，长度为 2 的子串，结果为 "Hello World23"
     

   • 添加字符数组：

     const char* cstr = "!!!";
     str1.append(cstr, 3);  // 添加 3 个字符，结果为 "Hello World23!!!"
     

+= 适合简单的拼接操作，而 append 适用于需要更多控制的情况。

3.1.5 string查找和替换

• 查找：查找指定字符串是否存在
• 替换：在指定的位置替换字符串

int find(const string& str, int pos = 0) const;

int find(const char* s, int pos =0) const;

int find(const char* s, int pos, int n) const;

int find(const char c, int pos = 0) const;

int rfind(const string& str, int pos = npos) const;

int rfind(const char* s, int pos = npos) const;

int rfind(const char* s, int pos = npos) const;

int rfind(const char c, int pos = 0) const;

string & replace(int pos, int n, const string& str);

string & replace(int pos, int n, const char* s);

std::string str = "Hello World";
size_t pos = str.find("World");  // pos 将是 6

size_t rpos = str.rfind("o");  // rpos 将是 7（"World"中的'o'）

str.replace(6, 5, "Universe");  // str 变为 "Hello Universe"

• find从左往右找，rfind从右往左找
• find找到字符串后返回查找的第一个字符位置，找不到返回-1
• replace在替换时，要制定从哪个位置起，多少个字符，替换成什么样的字符串

3.1.6 string字符串比较

• 相等返回0, >返回1,<返回-1,按照ascll码进行对比

int compare(const string &s) const;

int compare(const char *s) const;

if (str1.compare(str2) == 0){...}

3.1.7 string字符存取

单个字符存取的方式

char& operator[](int n);

char& at(int n);

for(int i=0;i<str.size();i++){
    cout << str1[i] << endl;
}

for(int i=0;i<str.size();i++){
    cout << str1.at(i) << endl;
}

3.1.8 string子串

string substr(int pos = 0, int n = npos)const; // 返回由pos开始的n个字符组成的字符串

string str = "abcdef";
string subStr = str.substr(1, 3);
cout << "subStr = " << subStr << endl;

3.2 vector容器

3.2.1 vector基本概念

• vector数据结构和数组非常相似，也称为单端数组
• 可以动态扩展

动态扩展：

• 并不是在元空间之后接新空间，而是找更大的内存空间，然后将源数据拷贝新空间，释放原空间

• vector容器的迭代器支持随机访问

3.2.2 vector构造函数

vector v;

vector(v.begin(),. v.end()); //v[begin(), end())

vector(n, elem);

vector(const vector &vec);

3.2.3 vector 赋值操作

vector& operator=(const vector &vec);

assgin(begin, end);

assgin(n, elem)

std::vector<int> vec1 = {1, 2, 3};
std::vector<int> vec2;
vec2 = vec1;  // vec2 现在包含 vec1 的所有元素

vec2.assign(vec1.begin(), vec1.end());  // 用 vec1 的元素赋值
vec2.assign(5, 10);  // vec2 现在包含 5 个元素，每个元素都是 10

std::vector<int> vec3 = {4, 5, 6};  // 初始化 vec3

3.2.4 vector容量和大小

empty(); // 判断容器是否为空

capacity(); // 容器的容量

size(); // 返回容器中元素的个数

resize(int num); // 重新指定容器的长度，增加默认填充，减少删除末尾

resize(int num, elem); // 重新指定容器的长度，增加填充elem，减少产出末尾

3.2.5 vector插入和删除

功能描述：

• 对vector容器进行插入、删除操作

push_back(ele); // 尾部插入元素ele

pop_back(); // 删除最后一个元素

insert(const_iterator pos, ele); // 迭代器指向位置pos插入元素ele

insert(const_iterator pos, int count, ele); // 迭代器指向位置pos插入count个元素ele

erase(const_iterator pos); // 删除迭代器指向的元素

erase(const_iterator start, const_iterator end); // 删除迭代器从start到end之间的元素

clear(); // 删除容器中所有元素

std::vector<int> vec;

// 尾部插入元素
vec.push_back(10); 

// 删除最后一个元素
vec.pop_back();

// 在指定位置插入元素
vec.insert(vec.begin(), 20); 

// 在指定位置插入多个元素
vec.insert(vec.begin(), 3, 30);

// 删除指定位置的元素
vec.erase(vec.begin());

// 删除指定范围内的元素
vec.erase(vec.begin(), vec.end());

// 清空 vector
vec.clear();

3.2.6 vector数据存取

at(int idx);

operator[];

front(); // 返回容器中第一个数据元素

back(); // 返回容器中最后一个元素

std::vector<int> vec = {1, 2, 3, 4, 5};

// 使用 at 访问元素
std::cout << "Element at index 2: " << vec.at(2) << std::endl;

// 使用 [] 运算符访问元素
std::cout << "Element at index 2: " << vec[2] << std::endl;

// 获取第一个元素
std::cout << "First element: " << vec.front() << std::endl;

// 获取最后一个元素
std::cout << "Last element: " << vec.back() << std::endl;

3.2.7 互换容器

• swap(vec); // 将vec与本身的元素互换

v1.swap(v2);

在 C++ 中，swap 函数可以用于减少 vector 占用的内存。当 vector 在动态增长过程中，其分配的内存可能会超过当前存储元素所需的实际内存。为了收缩到恰好匹配当前元素数量的内存大小，可以使用创建一个临时空 vector 并与原 vector 使用 swap 进行交换的技巧。这样做会将原 vector 的内容移到临时 vector，并释放多余的内存。例如：

std::vector<int> vec;
// 添加元素到 vec
// ...

std::vector<int>(vec).swap(vec);  // 创建临时 vector 并与 vec 交换

在这个例子中，通过 std::vector<int>(vec).swap(vec) 代码行，原 vec 和一个新的具有相同内容的临时 vector 发生交换，然后临时 vector 被销毁，释放了多余的内存。

3.2.8 预留空间

• 减少vector在动态扩展容量时的扩展次数

函数原型：

• reverse(int len);
• 预留len个元素长度，预留位置不初始化，元素不可访问

在 C++ 中，容器的 reserve 方法用于预先分配内存空间，以提高容器存储元素时的效率。当你知道容器将要存储大量元素时，使用 reserve 可以减少多次内存分配导致的性能损耗。例如：

std::vector<int> vec;
vec.reserve(100);  // 为 vec 分配足够存储 100 个整数的空间

// 添加元素到 vec，不会导致额外的内存重新分配，直到超过 100 个元素

在这个例子中，reserve(100) 为 vector 分配足够存储 100 个整数的空间。这意味着在向 vec 中添加元素时，至少在元素数量达到 100 之前，不会发生内存重新分配。

3.3 deque容器

3.3.1 deque基本概念

• 双端数组，可以对头端进行插入删除操作

• 对头部的插入速度比vector快

• vector访问元素的速度比deque快

deque内部工作原理：

deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据

中控器维护的是每个缓冲区的地址，是的使用deque时像一片连续的内存空间

3.3.2 deque构造函数

功能描述:

• deque容器构造

函数原型：

deque deqT; // 默认构造函数

deque(beg, end); // 构造函数将beg-end区间中的元素拷贝给本身

deque(n, elem); // 构造函数将n个elem拷贝给本身

deque(const deque & deq); // 拷贝构造函数

deque<int> d1;

array<int, 3> arr = {1, 2, 3};
deque<int> d3(arr.begin(), arr.end());

deque<int> d2(5, 10);

deque<int> d4(d3); // 用 d3 的副本来构造 d4

deque<int> d5(std::move(d4));  // 移动构造,用另一个 deque 的内容来构造（C++11 之后）

deque<int> d6 = {1, 2, 3, 4, 5};

3.3.3 deque赋值操作

• 功能描述：
• 给deque容器赋值

函数原型：

deque& operator=(const deque & deq);

assign(beg, end);

assgin(n, elem);

3.3.4 deque大小操作

deque.empty();

deque.size();

deque.resize(num); // 重新指定容器的长度，增加默认填充，减少删除末尾

deque.resize(num, elem); // 重新指定容器的长度，增加填充elem，减少产出末尾

3.3.5 deque插入和删除

• 向deque容器中插入和删除数据

两端插入操作

push_back(elem);

push_front(elem);

pop_back();

pop_front();

指定位置操作

insert(pos, elem);

insert(pos, n, elem);

insert(pos, beg, end);

clear();

erase(beg, end);

erase(pos);

3.3.6 deque数据存储

• 对deque中的数据的存取操作

at(int idx);

operator[];

front(); //第一个

back(); //第二个

3.3.7 deque排序

• 利用算法实现对deque容器进行排序
• sort(iterator beg, iterator end);

#include <algorithm>
#include <deque>
using namespace std;
deque<int> dq = {4, 1, 3, 5, 2};
sort(dq.begin(), dq.end());

3.5 stack容器

• 先进后出
• 不允许有遍历行为

使用方法：

• 构造函数

stack stk;

stack<const stack & stk);

• 赋值操作

stack& operator=(const stack & stk);

• 数据存取

push(elem);

pop();

top();

• 大小操作

empty();

size();

3.6 queue容器

• 先进先出
• 不允许遍历

使用方法：

• 构造函数

queue que;

stack<const queue & que);

• 赋值操作

queue& operator=(const queue & que);

• 数据存取

push(elem);

pop();

back();

front();

• 大小操作

empty();

size();

3.7 list 容器

3.7.1 基本概念

• 将数据进行链式存储
• 一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的
• 链表的组成：链表由一系列节点组成
• 结点的组成：一个属存储数据元素的数据域，另一个是存储下一个节点地址的指针域
• list是一个双向循环链表

3.7.2 list构造函数

list lst;

list<beg, end);

list(n, elem);

list(const list & lst);

list<int> lst1;
list<int> lst2(5, 10); // 5 个元素，每个元素值为 10

array<int, 3> arr = {1, 2, 3};
list<int> lst3(arr.begin(), arr.end());

list<int> lst4(lst3);

list<int> lst5(std::move(lst4)); // 移动构造（C++11）：使用另一个 list 的内容来构造新的 list。

list<int> lst6 = {1, 2, 3, 4, 5};

3.7.3 list赋值和交换

• 给list容器进行赋值， 以及交换list容器

assgin(beg, end);

assgin(n, elem);

list& operator=(const list & list);

swap(lst);

3.7.4 list大小操作

• 对list容器的大小进行操作

size();

empty();

resize(num);

resize(num, elem);

3.7.5 list插入和删除

• 对list容器进行数据的插入和删除

push_back(elem);

pop_back();

push_front(elem);

pop_front();

insert(pos, elem);

insert(pos, n, elem);

insert(pos, beg, end);

clear();

erase(beg, end);

erase(pos);

remove(elem); // 删除容器中所有与elem匹配的值

3.7.6 list数据存取

• 从list容器中获取元素

front();

back();

不可以使用at访问list中的元素，不支持随机访问

3.7.7 list反转和排序

• 将容器中的元素反转，以及将容器中的数据进行排序

reverse();

sort();

3.8 set/multiset 容器

• 所有元素都会在插入的时候自动排序

• 关联式容器，底层结构使用二叉树

• set不允许容器中有重复的元素

• multiset允许有重复的元素

3.8.1 set构造和赋值

set st;

set(const set &st);

set& operator=(const set &st);

3.8.2 set大小和交换

size();

empty();

swap(st);

3.8.3 set插入和删除

• set容器进行插入数据和删除数据

insert(elem);

clear();

erase(pos)

3.8.4 set查找和统计

• 对set容器进行查找数据以及统计数据

find(key); // 查找key是否存在，若存在，返回元素的迭代器；不存在返回set.end();

count(key); // 统计key的元素个数

3.8.6 set和mutltiset的区别

• set不可以插入重复数据，而multise可以
• set插入数据的同时会返回插入结果，表示插入是否成功
• multiset不会检测数据，因此可以插入重复数据

3.8.7 pair对组创建

• 成对出现的数据，利用对组可以返回两个数据

pair<type, type> p (value1, value2);

pair<type, type> p = make_pair(value1, value2)；

#include <utility>
#include <string>

int main() {
    // 使用构造函数直接创建
    std::pair<int, std::string> p1(1, "Apple");

    // 使用 make_pair 函数
    auto p2 = std::make_pair(2, "Banana");

    // 使用 C++11 的列表初始化
    std::pair<int, std::string> p3 = {3, "Cherry"};

    // 访问 pair 元素
    int num = p1.first;          // num = 1
    std::string fruit = p2.second; // fruit = "Banana"
}

3.8.8 set容器排序

• set容器默认排序规则为从小到大，掌握如何改变排序规则

• 利用仿函数，可以改变排序规则

#include <set>
#include <functional>

// 自定义比较函数
bool customCompare(int lhs, int rhs) {
    return lhs > rhs;  // 降序排序
}

int main() {
    // 使用自定义函数
    std::set<int, decltype(&customCompare)> mySet1(customCompare);

    // 使用 lambda 表达式
    auto compareFunc = [](int lhs, int rhs) { return lhs > rhs; };
    std::set<int, decltype(compareFunc)> mySet2(compareFunc);

    // 使用标准库提供的比较对象
    std::set<int, std::greater<int>> mySet3;

    // ...
}

3.9 map/mutlimap容器

• map中的所有元素都是pair
• pair中的第一个元素为key， 起到索引作用，第二个元素为value（实值）
• 所有元素都会根据元素的键值自动排序

本质：

• 关联式容器，底层使用二叉树实现

优点：

• 可以根据key值快速找到value值

区别：

• map不允许重复key值元素
• multimap允许容器中有重复key值元素

3.9.2 map构造和赋值

map<T1,T2> mp;

map(const map &map);

map& operator=(const map & mp);

1. ** 默认构造**：创建一个空的 map。

   map<int, std::string> map1;
   

2. 列表初始化：使用初始化列表赋值。

   map<int, std::string> map2 = {{1, "one"}, {2, "two"}};
   

3. 拷贝构造：用一个已存在的 map 构造新的 map。

   map<int, std::string> map3(map2);
   

4. 赋值：使用 = 运算符将一个 map 赋值给另一个。

   map<int, std::string> map4;
   map4 = map3;
   

5. 插入元素：使用 insert 或 operator[] 向 map 中插入或修改元素。

   map4.insert(std::make_pair(3, "three"));
   map4[4] = "four";
   

std::map 是基于红黑树的，保证了元素按键排序和高效的查找、插入、删除操作。

3.9.3 map大小和交换

size();

empty();

swap(st);

3.9.4 map插入和删除

insert(elem);

clear();

erase(pos);

erase(beg, end);

erase(key);

3.9.5 map查找和统计

find(key);

count(key);

3.9.6 map容器排序

• map容器默认按照key值从小到大排列，
• 利用仿函数，改变排序方式

struct customCompare {
    bool operator() (const int& lhs, const int& rhs) const {
        return lhs > rhs; // 例如，基于大于的比较进行降序排序
    }
};

int main() {
    std::map<int, std::string, customCompare> myMap;
    // 使用自定义比较规则的 map
}

4 STL函数对像

4.1 函数对象

4.1.1 概念

• 重载函数调用操作符的类， 其对象常称为函数对象
• 函数对象使用重载的()时，行为类似函数调用，也叫仿函数

本质：函数对象（仿函数）是一个类，不是一个函数

4.1.2 使用

• 函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
• 函数对象超出普通函数的概念，函数对象可以有自己的状态
• 函数对象可以作为参数传递

#include <iostream>

// 函数对象的定义
class Increment {
    int num;
public:
    Increment(int n) : num(n) {}

    // 重载 () 操作符
    int operator()(int arr_num) const {
        return num + arr_num;
    }
};

int main() {
    Increment inc(5);
    std::cout << inc(10); // 输出 15，等同于执行 inc.operator()(10)
}

class MyAdd{
    public:
    int operator()(int v1, int v2){
        return v1 + v2;
    }
}

void test01(){
    MyAdd myadd;
    cout << myadd(10, 10) << endl;
}

4.2 谓词

4.2.1 概念

• 返回bool类型的仿函数称为谓词
• 如果operator()接受一个参数，称一元谓词
• 如果operator()接受二个参数，称二元谓词

4.2.2 一元谓词

• 谓词通常用于算法中，用于定义某种条件或比较操作。

• 一元谓词的典型用途包括定义排序准则、执行特定的检查或条件操作等。

struct IsEven {
    bool operator()(int x) const {
        return x % 2 == 0;
    }
};

class IsOdd {
public:
    bool operator()(int x) const {
        return x % 2 != 0;
    }
};

4.2.3 二元谓词

• 通常用于需要两个输入值的比较或条件检查场景

class Compare {
public:
    bool operator()(int a, int b) const {
        return a < b;  // 按照升序排序
    }
};

4.3 内建函数对象

4.3.1 内建函数对象

• STL内建的函数对象

分类：

• 算数仿函数
• 关系仿函数
• 逻辑仿函数

用法：

• 这些仿函数所产生的对象，用法和一般函数完全相同
• 使用内建函数对象，需要引入头文件#include<functional>

4.3.2 算数仿函数

• 实现四则运算
• 其中negate是一元运算，其他都是二元运算

template T plus

template T minus

template T multiplies

template T divides

template T modulus

template T negate //取反

negate<int> n;
cout << n(50) << endl;
plus<int> p;
cout << p(1, 2) << endl;

4.3.2 关系仿函数

• 实现关系对比

template bool equal_to

template bool not_equal_to

template bool greater

template bool greater_equal

template bool less

template bool less_equal //取反

4.3.4 逻辑仿函数

• 实现逻辑运算

template bool logical_and

template bool logical_or

template bool logical_not

5 STL常用算法

5.1 常用遍历算法

• 头文件、、

• 是所有STL头文件最大的一个，范围涉及到比较、交换、查找、便利操作、赋值、修改等等

• 只包括几个在序列上面进行简单数学运算的模板函数

• 定义了一些模板类，用以声明函数对象

• for_each 遍历容器

• transform 搬运容器到另一个容器中

5.1.1 for_each

• 实现遍历容器

for_each(iterator beg, iterator end, _func);

#include <algorithm>
#include <vector>
#include <iostream>

void print(int val) {
    std::cout << val << " ";
}

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::for_each(vec.begin(), vec.end(), print);
}

5.1.2 transform

• 搬运容器到另一个容器中

transform(iterator beg1, iterator end1, iterator beg2, _func);

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> src = {1, 2, 3, 4, 5};
    std::vector<int> dest(src.size());

    std::transform(src.begin(), src.end(), dest.begin(),
                   [](int i) { return i * 2; });

    // 输出结果
    for (int i : dest) {
        std::cout << i << ' ';
    }
}

5.2 常用查找算法

• 掌握常用的查找算法

find // 查找元素

find_if // 按条件查找元素

adjacent_find // 查找相邻重复元素

binary_search // 二分查找法

count // 统计元素个数

count_if // 按条件元素个数

5.2.1 find

• 查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()

find(iterator beg, iterator end, value);

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    auto it = std::find(vec.begin(), vec.end(), 3);

    if (it != vec.end()) {
        std::cout << "Found: " << *it << std::endl;
    } else {
        std::cout << "Not found" << std::endl;
    }
}

5.2.2 find_if

• 按照条件查找元素

find_if(iterator beg, iterator end, _Pred);

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    auto it = std::find_if(vec.begin(), vec.end(), [](int i) { return i > 3; });

    if (it != vec.end()) {
        std::cout << "Found: " << *it << std::endl;  // 输出第一个大于 3 的元素
    } else {
        std::cout << "Not found" << std::endl;
    }
}

5.2.3 adjacent_find

• 查找第一对相邻重复元素

adjacent_find(iterator beg, iterator end);

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 3, 4};

    auto it = std::adjacent_find(vec.begin(), vec.end());

    if (it != vec.end()) {
        std::cout << "Found adjacent elements: " << *it << " and " << *(it + 1) << std::endl;
    } else {
        std::cout << "No adjacent elements found" << std::endl;
    }
}

5.2.4 binary_search

• 查找制定元素是否存在

bool binary_search(iterator beg, iterator end, value);

无序序列中不可用，即要求序列已经排序

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    bool found = std::binary_search(vec.begin(), vec.end(), 3);

    if (found) {
        std::cout << "Element found" << std::endl;
    } else {
        std::cout << "Element not found" << std::endl;
    }
}

5.2.5 count

• 统计该值在序列中出现的次数

std::vector<int> vec = {1, 2, 3, 4, 3, 3};
int num = std::count(vec.begin(), vec.end(), 3); // 计算值为 3 的元素数量

统计自定义数据类型需要在自定义数据类型中重载=运算符

5.2.6 count_if

• 接受一个谓词函数来定义计数的条件

int numOdd = std::count_if(vec.begin(), vec.end(), [](int i){ return i % 2 != 0; }); // 计算奇数的数量

• 统计自定义数据类型

class MyType {
public:
    int value;
    MyType(int v) : value(v) {}
};

bool isSpecial(const MyType& obj) {
    return obj.value > 10; // 一个假设的条件
}

int main() {
    std::vector<MyType> vec = {{5}, {15}, {20}};
    int count = std::count_if(vec.begin(), vec.end(), isSpecial);
    std::cout << "Special objects count: " << count << std::endl;
}

5.3 常用排序算法统计

• sort
• random_shuffle
• merge
• reverse

5.3.1 sort

• 对容器内元素进行排序

sort(iterator beg, iterator end, _Pred);

#include<algorithm>
vector<int> v = {4, 2, 1, 3, 5};
sort(v.begin(), v.end()); //默认从小到大
sort(v.begin(), v.end(), greater<int>()); //改为降序

5.3.2 random_shuffle

• 洗牌 指定范围内元素随机调整次序

#include<algorithm>
vector<int> v = {4, 2, 1, 3, 5};
random_shuffle(v.begin(), v.end());

5.3.3 merge

• 将两个容器元素合并，并存储到另一容器中
• 两个容器必须是有序的

merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

vector<int> v1 = {1, 3, 5, 7, 9};
vector<int> v2 = {2, 4, 6, 8};
vector<int> target;

merge(v1.begin(), v1.end(), v2.begin(), v2.end(), target.begin());

5.3.4 reverse

• 将元素内容进行翻转

reverse(iterator beg, iterator end);

vector<int> v1 = {1, 2, 3, 4, 5};
reverse(v1.begin(), v2.end());

5.4 常用拷贝和替换函数

• copy
• replace
• replace_if
• swap

5.4.1 copy

• 容器内指定范围的元素拷贝到另一容器中

copy(iterator beg, iterator end, iterator dest);

vector<int> src = {1, 2, 3, 4, 5};
vector<int> dest(src.size());

copy(src.begin(), src.end(), dest.begin());

5.4.2 replace

• 将制定范围内的旧元素改为新元素

replace(iterator beg, iterator end, oldvalue, newvalue);

vector<int> vec = {1, 2, 3, 2, 5};

    // 将所有的 2 替换为 4
replace(vec.begin(), vec.end(), 2, 4);

5.4.3 replace_if

• 将区间内满足条件的元素， 替换成指定元素

replace_if(iterator beg, iterator end, _Pred, newvalue);

vector<int> vec = {1, 2, 3, 4, 5};

    // 将所有大于 2 的元素替换为 99
replace_if(vec.begin(), vec.end(), [](int i) { return i > 2; }, 99);

5.4.5 swap

• 互换两个容器的元素

swap(container c1, container c2);

std::vector<int> vec1 = {1, 2, 3}, vec2 = {4, 5, 6};
std::swap(vec1, vec2);

class MyClass {
    // ...
};
MyClass obj1, obj2;
std::swap(obj1, obj2);

• 在交换时不需要额外空间，通常比手动交换更高效

5.5 常用算术生成算法

• accumulate
• fill

5.5.1 accumulate

• 计算区间内，容器元素累计总和

accumulate(iterator beg, iterator end, value, _pred);

vector<int> nums = {1, 2, 3, 4, 5};
    
    // 求和
int sum = accumulate(nums.begin(), nums.end(), 0);

    // 使用自定义操作，例如求乘积
int product = accumulate(nums.begin(), nums.end(), 1, std::multiplies<int>());

5.5.2 fill

• 向容器中填充制定的元素

fill(iterator beg, iterator end, value);

#include <algorithm>
#include <vector>

int main() {
    std::vector<int> vec(5); // 创建一个有 5 个元素的向量

    // 使用 fill 将所有元素赋值为 10
    std::fill(vec.begin(), vec.end(), 10);

    // 现在 vec 中的所有元素都是 10
}

5.6 常用集合算法

• set_intersection
• set_union
• set_difference

5.6.1 set_intersection

• 求两个容器的交集

set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

vector<int> v1 = {1, 2, 3, 4, 5};
vector<int> v2 = {4, 5, 6, 7, 8};
vector<int> v_intersection;

set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), std::back_inserter(v_intersection));

5.6.2 set_union

• 求两个容器的并集

set_union(terator beg1, iterator end1, iterator beg2, iterator end2, iterator dest)

#include <algorithm>
#include <vector>

int main() {
    std::vector<int> v1 = {1, 2, 3, 4, 5};
    std::vector<int> v2 = {4, 5, 6, 7, 8};
    std::vector<int> v_union;

    std::set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), std::back_inserter(v_union));

    // v_union 现在包含 {1, 2, 3, 4, 5, 6, 7, 8}
}

5.6.3 set_difference

• 求两个容器的差集

set_difference(terator beg1, iterator end1, iterator beg2, iterator end2, iterator dest)

#include <algorithm>
#include <vector>

int main() {
    std::vector<int> v1 = {1, 2, 3, 4, 5};
    std::vector<int> v2 = {4, 5, 6, 7, 8};
    std::vector<int> v_diff;

    std::set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), std::back_inserter(v_diff));

    // v_diff 现在包含在 v1 中但不在 v2 中的元素 {1, 2, 3}
}