C++ 基础入门

输出：A destructedB destructed

访问 weak_ptr 指向的对象： 需通过lock()方法获取 shared_ptr ，若对象已释放， lock() 返回 nullptr

std::shared_ptr sp = std::make_shared(1); std::weak_ptr wp = sp; // 从shared_ptr构造weak_ptr // 方式1：用lock()获取shared_ptr if (auto locked_sp = wp.lock()) { locked_sp->show(); // 访问对象 } else { std::cout <show(); } else { std::cout << \"Object has been destructed.\\n\"; } sp.reset(); // 释放对象 if (wp.expired()) { std::cout << \"Object has been destructed.\\n\"; } 

输出：Test 1 constructedTest 1 is aliveTest 1 is aliveTest 1 destructedObject has been destructed

函数

函数包含逻辑代码，可被程序多次调用，一个完整的函数定义主要包括：返回类型、函数名、参数列表和函数体

返回类型 函数名(参数列表) { // 函数体 }

返回类型： 指定返回值的数据类型（如 void 表示无返回值）

函数名称： 这是函数的实际名称。函数名和参数列表一起构成了函数签名（告知编译器）

参数列表： 参数就像是占位符，可为空或包含多个参数，参数按值传递（拷贝副本）或引用传递（修改原始数据）

函数体： 函数要执行的语句块，函数的主体

高级特性

函数重载： 是 C++ 中编译时多态的核心机制之一，重载函数的声明和定义与普通函数类似，但需保证参数列表不同，通过不同参数列表实现同名函数，需满足参数类型、个数或顺序差异

1. 参数个数不同

void fun() void fun(int a)

2. 参数类型不同

void fun(int a) void fun(double a)

3. 参数顺序不同： 不同顺序中需要有不同的类型

void fun(int a, double b) void fun(double a, int b)

void fun(int a, int b) void fun(int b int a)// 这种是不行的, 形参名的调换不构成重载

注意：返回值类型不同不能作为函数重载的依据

// 无法重载，编译器会报错“重定义”int fun()void fun()

引用参数的特殊处理

当重载函数包含引用参数（ int& 、const int& 、int&& ）时，编译器会根据实参的左值/右值属性匹配

1. int&： 匹配可修改的左值（如变量）

2. const int&： 匹配不可修改的左值（如 const 变量）或右值（如表达式结果）

3. int&&： 匹配右值（如临时对象、表达式结果）

void fun(int& a) { cout << \"左值引用: \" << a << endl; } void fun(const int& a) { cout << \"const左值引用: \" << a << endl; } void fun(int&& a) { cout << \"右值引用: \" << a << endl; } int main() { int a = 10; // 左值 const int b = 20; // const左值 fun(a);  // 调用 fun(int&) fun(b);  // 调用 fun(const int&) fun(a + b); // 调用 fun(int&&)（a+b是右值） return 0;}

输出：左值引用: 10 const左值引用: 20 右值引用: 30 

函数重载仅在同一作用域内有效：

void fun() { cout << \"全局函数\" << endl; } // 全局作用域 class MyClass { public: void fun() { cout << \"类成员函数\" << endl; } // 类作用域}; int main() { fun(); // 调用全局函数 MyClass obj; obj.fun(); // 调用类成员函数 return 0;}

上述代码不会报错，因为两个fun函数属于不同作用域

默认参数

在声明或定义中为参数指定默认值，调用时可省略

void display(int a = 10, int b = 20) { /* ... */ }display();

内联函数

使用 inline 关键字建议编译器展开函数体，也就是代码直接嵌入调用处，减少调用开销

适用于： （通常 ≤ 10行代码）且频繁调用（如循环内部）、类成员访问器（ getter/setter ）

不适用于： 函数体含循环/递归、代码较长（导致代码膨胀）

// 正确方式：定义时加 inline 关键字（声明中加无效）inline int add(int a, int b) { return a + b;} // 类内定义自动内联（无需显式写 inline）class Circle {private: double radius;public: double getArea() { // 自动视为内联 return 3.14 * radius * radius; }}; // 类外定义需显式 inline class Circle {public: double getArea();};inline double Circle::getArea() { return 3.14 * radius * radius; }

递归函数

函数直接或间接调用自身，需设置基准条件避免无限递归

int factorial(int n) { return n == 1 ? 1 : n * factorial(n-1); }

Lambda 函数与表达式

C++11 提供了对匿名函数的支持,称为 Lambda 函数(也叫 Lambda 表达式)，它们通常用于需要一个小型、临时的函数，以便在某个上下文中使用

[capture_list](parameter_list) mutable -> return_type { function_body; }

捕获列表 (capture_list)： 指定哪些外部变量可以被 Lambda 函数访问，以及是以值还是引用的方式访问

**mutable：**允许修改值捕获的副本（默认不可修改）

#include int main() { int x = 10; // 使用 mutable 关键字允许修改按值捕获的变量 auto lambda = [x]() mutable { x += 5; std::cout << \"x inside lambda: \" << x << std::endl; // 输出: x inside lambda: 15 }; lambda(); std::cout << \"x outside lambda: \" << x << std::endl; // 输出: x outside lambda: 10 return 0;}

常见的捕获方式包括

[]： 不捕获任何变量，使用未定义变量会引发错误

[&]： 捕获所有外部变量的引用，任何被使用到的外部变量都隐式地以引用方式加以引用

[=]： 捕获所有外部变量的值（副本），任何被使用到的外部变量都隐式地以传值方式加以引用

[a, &b]： 变量 a 按值捕获，变量 b 按引用捕获

[=, &a, &b]： 除 a 和 b 按引用捕获外，其他变量按值捕获

[&, a, b]： 除 a 和 b 按值捕获外，其他变量按引用捕获

[this]： 捕获指向当前对象的 this 指针（访问成员变量）

#include int main() { int x = 10; int y = 5; // 按值捕获 x，按引用捕获 y auto lambda = [=, &y]() -> int { x += 2; y += 3; return x + y; }; int result = lambda(); std::cout << \"Result: \" << result << std::endl; // 输出: Result: 20 std::cout << \"x: \" << x << \", y: \" << y << std::endl; // 输出: x: 10, y: 8 return 0;}

参数列表 (parameter_list)： Lambda 函数的参数列表，类似于普通函数

返回类型 (return_type)： Lambda 函数的返回类型，可以省略，编译器会自动推断

函数体 (function_body)： Lambda 函数的具体实现代码

虚函数和纯虚函数

虚函数允许子类重写父类的方法。纯虚函数是一种没有实现的方法，要求子类必须实现

class Base {public: virtual void display() = 0; // 纯虚函数};class Derived : public Base {public: void display() override { std::cout << \"Derived class\" << std::endl; }};

友元函数

友元函数是一种非成员函数，但可以访问其私有和受保护的成员。友元函数通过在类内部使用 friend 关键字声明，从而获得访问类私有成员的权限。友元函数不是类的成员函数，因此不能使用 this 指针

class Box {private: int width;public: Box(int w) : width(w) {} friend int friendGetArea(Box box);};int friendGetArea(Box box) { return box.width * box.width;}int main() { Box box(5); std::cout << friendGetArea(box) << std::endl; // 输出: Area: 25}

构造函数和拷贝构造函数

构造函数在创建对象时自动调用，用于初始化资源和状态。拷贝构造函数用于从现有对象复制数据到新对象

class A {public: A() {} // 构造函数 A(const A& other) {} // 拷贝构造函数};

引用

引用是C++中的一种特殊的数据类型描述，用于在程序的不同部分使用两个以上的变量名指向同一块地址，使得对其中任何一个变量的操作实际上都是对同一地址单元进行的操作。引用的声明方式为：类型名称 & 引用名 = 原名

int a = 10;int& b = a; // b是a的引用 b = 20; // 修改b会同步修改acout << a; // 输出20 [3]()

引用的核心特点

1. 必须初始化： 声明时必须绑定目标变量，如 int& b = a

2. 无独立内存空间： 引用与目标变量共享内存地址，&b == &a

3. 不可重新绑定： 一旦绑定目标变量，无法再指向其他变量

4. 安全性优势： 不能为 NULL，避免空指针风险

5. 引用作为函数参数： 使用引用传递参数能避免数据副本，提高效率，且更清晰

#include using namespace std;void exchange(int& x, int& y) { int temp = x; x = y; y = temp;}int main() { int a, b; cout << \"请输入两个数字: \" <> a >> b; exchange(a, b); cout << \"交换后: \" << a << \" \" << b << endl; return 0;}

常量

常量是固定且不可变的值，一旦初始化，其值在程序中不可改变。常量通常使用 const 关键字修饰，常量的作用域与其他变量相同，可以是块作用域、函数作用域、文件作用域或命名空间作用域

void example() { const int BLOCK_CONSTANT = 5; // 块作用域 // BLOCK_CONSTANT 只能在 example 函数内部使用}const int GLOBAL_CONSTANT = 10; // 文件作用域// GLOBAL_CONSTANT 可以在整个文件中使用

常量可以是任何基本数据类型或复合数据类型，包括指针（但指针指向的内容可以被修改，除非指针本身也是指向常量的指针）

const int* ptr; // 指针指向的值是常量int* const ptr2; // 指针本身是常量const int* const ptr3; // 指针本身和指向的值都是常量

常量引用可以初始化为左值或右值，但初始化为右值时，只能使用 const T& 类型

int a = 10;const int& ref = a; // 正确const int& ref2 = 20; // 正确int& ref3 = 30; // 错误

常量函数： 通过在函数名后添加 const 关键字声明为常量函数，这些函数不能改变对象的值，且只能由非常量对象调用

class Example {public: int getValue() const { return value; } private: int value;};

四、 运算符

包括算术运算符（+, -, *, /, %）、关系运算符（==, !=, >, =, <=）、逻辑运算符（&&, ||, !）等

算术运算符

#include using namespace std;int main() { int a = 10, b = 20; cout << \"加法: \" << a + b << endl; // 输出: 30 cout << \"减法: \" << a - b << endl; // 输出: -10 cout << \"乘法: \" << a * b << endl; // 输出: 200 cout << \"除法: \" << b / a << endl; // 输出: 2 cout << \"取模: \" << b % a << endl; // 输出: 0 return 0;}

关系运算符

#include using namespace std;int main() { int a = 10, b = 20; cout << \"等于: \" << (a == b) << endl; // 输出: 0 (false) cout << \"不等于: \" << (a != b) << endl; // 输出: 1 (true) cout << \"大于: \" < b) << endl; // 输出: 0 (false) cout << \"小于: \" << (a < b) << endl; // 输出: 1 (true) cout << \"大于等于: \" <= b) << endl; // 输出: 0 (false) cout << \"小于等于: \" << (a <= b) << endl; // 输出: 1 (true) return 0;}

逻辑运算符

#include using namespace std;int main() { bool x = true, y = false; cout << \"逻辑与: \" << (x && y) << endl; // 输出: 0 (false) cout << \"逻辑或: \" << (x || y) << endl; // 输出: 1 (true) cout << \"逻辑非: \" << (!x) << endl; // 输出: 0 (false) return 0;}

赋值运算符

#include using namespace std;int main() { int a = 10; int b = a; // 基本赋值 int c = 20; c += a; // 加法赋值，等价于 c = c + a c -= a; // 减法赋值，等价于 c = c - a c *= a; // 乘法赋值，等价于 c = c * a c /= a; // 除法赋值，等价于 c = c / a c %= a; // 取模赋值，等价于 c = c % a cout << \"基本赋值: \" << b << endl; // 输出: 10 cout << \"加法赋值: \" << c << endl; // 输出: 30 cout << \"减法赋值: \" << c << endl; // 输出: 20 cout << \"乘法赋值: \" << c << endl; // 输出: 200 cout << \"除法赋值: \" << c << endl; // 输出: 20 cout << \"取模赋值: \" << c << endl; // 输出: 0 return 0;}

指针运算符

#include using namespace std;int main() { int var = 20; int *ptr = &var; // 取地址 cout << \"变量的地址: \" << ptr << endl; cout << \"通过指针访问变量的值: \" << *ptr << endl; // 解引用 return 0;}

位运算符

#include using namespace std;int main() { int a = 60; // 二进制表示为 0011 1100 int b = 13; // 二进制表示为 0000 1101 cout << \"按位与: \" << (a & b) << endl; // 输出: 12 (二进制 0000 1100) cout << \"按位或: \" << (a | b) << endl; // 输出: 61 (二进制 0011 1101) cout << \"按位异或: \" << (a ^ b) << endl; // 输出: 49 (二进制 0011 0001) cout << \"左移: \" << (a << 2) << endl; // 输出: 240 (二进制 1111 0000) cout << \"右移: \" <> 2) << endl; // 输出: 15 (二进制 0000 1111) return 0;}

五、控制结构

包括 if-else 、switch 、for 、while 等循环和条件语句

if (x > 0) { cout << \"Positive number\";} else if (x == 0) { cout << \"Zero\";} else { cout << \"Negative number\";}

#include using namespace std;int main() { char op; float num1, num2; cout <> op; cout <> num1 >> num2; switch(op) { case \'+\': cout << num1 + num2; break; case \'-\': cout << num1 - num2; break; case \'*\': cout << num1 * num2; break; case \'/\': if(num2 != 0.0) cout << num1 / num2; else cout << \"Divide by zero situation\"; break; default: cout << \"Error! operator is not correct\"; break; } return 0;}

for (int i = 0; i < 10; i++) { if (i == 5) break; cout << i << \" \";}int i = 0;while (i < 10) { cout << i << \" \"; i++;}int i = 0;do { cout << i << \" \"; i++;} while (i < 10);

4. 面向对象编程（OOP）

C++ 是一种面向对象的编程语言，支持 OOP 的核心概念

1. 类（Class）

定义对象的蓝图，包含数据成员和成员函数

2. 对象（Object）

类的实例，具有类定义的属性和行为

3. 封装（Encapsulation）

通过访问修饰符（ public , private , protected ）控制类的内部成员的访问

4. 继承（Inheritance）

子类可以继承父类的属性和方法，实现代码复用

5. 多态（Polymorphism）

通过虚函数实现不同类对象的统一接口，提高代码的灵活性

#include class Rectangle {public: int width, height; Rectangle(int w, int h) : width(w), height(h) {} int area() const { return width * height; }};int main() { Rectangle rect(5, 10); std::cout << \"Area: \" << rect.area() << std::endl; return 0;}

输出：Area: 50

5. 标准模板库（STL）

C++ 的 STL 提供了丰富的容器、算法和迭代器，简化了开发过程

容器

管理数据的集合，封装存储结构

常用的容器包括

向量（vector）： 动态数组，支持随机访问

push_back(value)：在向量末尾添加一个元素pop_back()：移除向量的最后一个元素at(index)：返回指定索引位置的元素，如果索引越界会抛出异常operator[]：返回指定索引位置的元素，不进行越界检查front()：返回向量的第一个元素back()：返回向量的最后一个元素begin()：返回指向向量第一个元素的迭代器end()：返回指向向量末尾元素后一个位置的迭代器size()：返回向量中元素的数量capacity()：返回当前向量分配的内存大小resize(new_size, value)：调整向量大小，如果新大小大于当前大小，则用指定值填充新元素；如果新大小小于当前大小，则删除多余元素reserve(new_capacity)：预先分配足够的内存空间，避免频繁的内存重新分配clear()：清空向量中的所有元素empty()：判断向量是否为空swap(other_vector)：交换两个向量的内容insert(position, value)：在指定位置插入一个元素erase(position)：删除指定位置的元素sort()：对向量中的元素进行排序

#include #include #include  // for sort functionusing namespace std;int main() { // 声明一个整数向量 vector vec; // 使用 push_back 添加元素 vec.push_back(10); vec.push_back(20); vec.push_back(30); // 使用 at 访问元素 cout << \"Element at index 1: \" << vec.at(1) << endl; // 使用 operator[] 访问元素 cout << \"Element at index 2: \" << vec[2] << endl; // 使用 front 和 back 访问首尾元素 cout << \"First element: \" << vec.front() << endl; cout << \"Last element: \" << vec.back() << endl; // 使用 begin 和 end 遍历向量 cout << \"Vector elements: \"; for (auto it = vec.begin(); it != vec.end(); ++it) { cout << *it << \" \"; } cout << endl; // 使用 size 获取向量大小 cout << \"Size of vector: \" << vec.size() << endl; // 使用 capacity 获取向量容量 cout << \"Capacity of vector: \" << vec.capacity() << endl; // 使用 resize 调整向量大小 vec.resize(5, 0); // 调整为5个元素，新元素初始化为0 cout << \"After resizing, size: \" << vec.size() << endl; cout << \"After resizing, elements: \"; for (int num : vec) { cout << num << \" \"; } cout << endl; // 使用 reserve 预先分配内存 vec.reserve(10); cout << \"After reserving, capacity: \" << vec.capacity() << endl; // 使用 clear 清空向量 vec.clear(); cout << \"After clearing, size: \" << vec.size() << endl; // 使用 empty 判断向量是否为空 if (vec.empty()) { cout << \"Vector is empty.\" << endl; } // 使用 insert 插入元素 vec.insert(vec.begin(), 5); vec.insert(vec.begin() + 1, 15); cout << \"After inserting elements, vector: \"; for (int num : vec) { cout << num << \" \"; } cout << endl; // 使用 erase 删除元素 vec.erase(vec.begin() + 1); cout << \"After erasing element at index 1, vector: \"; for (int num : vec) { cout << num << \" \"; } cout << endl; // 使用 sort 对向量进行排序 vector numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}; sort(numbers.begin(), numbers.end()); cout << \"Sorted vector: \"; for (int num : numbers) { cout << num << \" \"; } cout << endl; return 0;}

列表（list）： 双向链表，支持插入和删除操作

构造函数

list a{1, 2, 3};：初始化一个包含元素1, 2, 3的列表list a(n);：声明一个包含n个元素的列表，每个元素都是0list a(n, m);：声明一个包含n个元素的列表，每个元素都是mlist a(first, last);：声明一个列表，其元素的初始值来源于由区间所指定的序列中的元素，first和last是迭代器

插入元素

push_front(value)：将元素从前面推入列表push_back(value)：在列表末尾插入一个新元素insert(pos_iter, ele_num, ele)：在指定位置插入指定数量的元素emplace_front(args...)：在列表开头构造元素emplace_back(args...)：在列表末尾构造元素

删除元素

pop_front()：从正面弹出或删除列表中的元素pop_back()：从末尾弹出或删除列表中的元素remove(value)：删除所有与给定值相等的元素remove_if(predicate)：删除所有对谓词返回true的元素clear()：删除列表容器的所有元素，使其大小为0

检查状态

empty()：检查列表容器是否为空。size()：返回列表中元素的数量。

其他操作

assign(first, last)：将新内容分配给列表容器，并用新内容替换旧内容sort()：对列表进行排序reverse()：反转列表中元素的顺序merge(other_list)：合并两个已排序的列表unique()：删除连续重复的元素

#include #include using namespace std;int main() { list mylist{1, 2, 3, 4, 5}; mylist.push_front(6); // 在前面插入6 mylist.push_back(7); // 在末尾插入7 for (auto it = mylist.begin(); it != mylist.end(); ++it) cout << \' \' << *it; return 0;}

映射（map）： 键值对集合，支持快速查找，map 中的键必须是唯一的。如果插入一个已经存在的键，新的值不会替换原有值，而是忽略插入操作，map 内部会自动根据键的大小进行排序，因此遍历时元素是按顺序排列的，由于 map 基于红黑树实现，查找、插入和删除操作的时间复杂度为 O(log n)，适合需要频繁查找和修改的场景

插入元素：insert(pair val)：插入一个键值对operator[]：通过键访问或插入值。如果键不存在，则插入默认值访问元素：operator[]：通过键访问值at(const Key& key)：通过键访问值，如果键不存在则抛出异常查找元素：find(const Key& key)：返回指向键为 key 的元素的迭代器，如果不存在则返回 end()count(const Key& key)：返回键为 key 的元素数量（对于 map，返回 0 或 1）删除元素：erase(iterator position)：删除指定位置的元素erase(const Key& key)：删除键为 key 的元素clear()：清空所有元素遍历元素：使用迭代器遍历，例如 for (auto it = m.begin(); it != m.end(); ++it)。

#include #include 

集合（set ）： 有序集合，支持唯一元素，集合中的元素不能重复，可以添加或删除元素，但不能修改现有元素的值，插入元素时自动排序，元素通过键引用，而非容器中的位置

insert()：用于向set中插入元素erase()：用于从set中删除元素clear()：用于清除set中的所有元素empty()：用于检查set是否为空size()：用于返回set的大小begin()：返回指向第一个元素的迭代器end()：返回指向最后一位元素的下一位的迭代器find()：查找指定元素，返回其迭代器或结束迭代器count()：统计集合中特定元素的数量lower_bound()：返回第一个大于等于给定值的值的地址upper_bound()：返回第一个大于给定值的值的地址equal_range()：返回一个pair，first为第一个大于等于目标的迭代器，second为第一个大于目标的迭代器

#include #include using namespace std;int main() { set s; s.insert(10); s.insert(20); s.insert(30); // 遍历set for (int a : s) { cout << a << \" \"; } cout << endl; // 检查元素是否存在 if (s.find(20) != s.end()) { cout << \"20 exists in set\" << endl; } // 删除元素 s.erase(20); // 检查set是否为空 if (!s.empty()) { cout << \"Set is not empty\" << endl; } // 获取set的大小 cout << \"Size of set: \" << s.size() << endl; return 0;}

迭代器

提供遍历容器的统一接口，连接容器与算法，begin() , end() , 迭代器是STL中泛化的指针，提供统一接口遍历不同容器（如 vector、list 、map ）的元素

1. 基础遍历（所有容器通用）

#include #include using namespace std;int main() { vector vec = {1, 2, 3, 4}; // 正向遍历 for (auto it = vec.begin(); it != vec.end(); ++it) { cout << *it << \" \"; // 输出：1 2 3 4 } // C++11范围for循环（底层基于迭代器） for (int val : vec) { cout << val << \" \"; // 同上 } return 0;}// 范围 for 循环内部实现基于迭代器，因此在循环中不能随意增加或删除元素，否则会导致未定义行为

2. 反向遍历（双向/随机访问迭代器支持）

list words = {\"hello\", \"world\"};for (auto rit = words.rbegin(); rit != words.rend(); ++rit) { cout << *rit << \" \"; // 输出：world hello }

3. 插入与删除操作

vector v = {10, 20, 30};auto it = v.begin() + 1;it = v.insert(it, 15); // 插入后v={10,15,20,30}，it指向15 it = v.erase(it); // 删除15，it指向20（需更新迭代器！）

4. 关联容器特例（set/map）

set s = {5, 2, 8, 1};// 遍历自动排序结果：1 2 5 8for (auto it = s.begin(); it != s.end(); ++it) { cout << *it << \" \";}// 查找操作（返回迭代器）auto pos = s.find(5); if (pos != s.end()) { s.erase(pos); // 安全删除}

vector的push_back()可能引发扩容，导致所有迭代器失效；erase()使被删元素及之后的迭代器失效

对vector/deque插入/删除元素后，必须重新获取迭代器。关联容器（如set）删除元素时，优先使用it = container.erase(it) 语法

算法

独立于容器的通用操作（排序、查找等），sort() , find() , copy()

// sort(): 对容器进行排序sort(a.begin(), a.end()); // 默认升序排序sort(a.begin(), a.end(), greater()); // 使用greater对象进行降序排序// distance(): 计算两个迭代器之间的距离int dist = distance(a.begin(), a.end()); // 计算a的大小// copy(): 将一个范围内的元素复制到另一个范围vector b(a.size());copy(a.begin(), a.end(), b.begin()); // 将a的内容复制到b// next_permutation(): 生成下一个排列sort(a.begin(), a.end()); // 先排序do { // 处理当前排列} while (next_permutation(a.begin(), a.end())); // 生成所有排列// set_intersection(): 计算两个集合的交集vector a{1, 2, 3, 4, 5};vector b{3, 4, 5, 6, 7};vector result;set_intersection(a.begin(), a.end(), b.begin(), b.end(), back_inserter(result)); // 计算交集

函数对象

函数对象是重载了 operator() 的类对象，可像函数一样被调用。本质是类实例，而非函数指针，实现定制化操作，谓词（如 greater ），函数对象可包含成员变量，记录调用间的状态（普通函数无法做到）

#include #include #include struct GreaterThan { bool operator()(int a, int b) const { return a > b; }};int main() { std::vector vec = {5, 3, 8, 1, 2}; std::sort(vec.begin(), vec.end(), GreaterThan()); for (int num : vec) { std::cout << num << \" \"; } std::cout << std::endl; return 0;}

适配器

修改组件接口（如容器→栈/队列），栈 stack ， 队列 queue， 优先队列 priority_queue

栈（stack）

栈是一种后进先出（LIFO）的数据结构。栈适配器可以基于 deque、vector 或 list。默认情况下，栈适配器使用 deque 作为底层容器，只能从栈顶进行插入和删除操作，提供 push()、pop()、top()、empty() 和 size() 等操作

#include #include #include int main() { // 创建一个使用 list 作为基础容器的 stack 适配器 std::list values{1, 2, 3}; std::stack<int, std::list> my_stack(values); // 查看 my_stack 存储元素的个数 std::cout << \"size of my_stack: \" << my_stack.size() << std::endl; // 将 my_stack 中存储的元素依次弹栈，直到其为空 while (!my_stack.empty()) { std::cout << my_stack.top() << std::endl; // 输出栈顶元素 my_stack.pop(); // 弹出栈顶元素 } return 0;}

队列（queue）

队列是一种先进先出（FIFO）的数据结构。队列适配器默认使用 deque 作为底层容器，也可以使用 list，元素在队尾插入并在前端删除，提供 push()、pop()、front()、back()、empty() 和 size() 等操作

#include #include int main() { std::queue q; // 在队尾压入新元素 q.push(1); q.push(2); q.push(3); // 查看队列长度 std::cout << \"size of queue: \" << q.size() << std::endl; // 将队列中的元素依次弹出，直到其为空 while (!q.empty()) { std::cout << q.front() << std::endl; // 输出队首元素 q.pop(); // 弹出队首元素 } return 0;}

优先队列（priority_queue）

优先队列是一种不遵循 FIFO 或 LIFO 原则的数据结构，元素的排序基于优先级（使用最大堆），因此具有最高优先级的元素始终位于前端。优先队列适配器默认使用 vector 作为底层容器，也可以使用 deque，元素的排序基于优先级，提供 push()、pop()、top()、empty() 和 size() 等操作，优先队列适配器不能基于 list，因为 list 不支持随机访问操作，可以自定义比较函数来实现不同的优先级规则

#include #include #include struct Node { int x, y; Node(int a = 0, int b = 0) : x(a), y(b) {}};struct cmp { bool operator()(Node a, Node b) { if (a.x == b.x) return a.y > b.y; return a.x > b.x; }};int main() { std::priority_queue<Node, std::vector, cmp> q; for (int i = 0; i < 10; ++i) q.push(Node(rand(), rand())); while (!q.empty()) { std::cout << q.top().x << \' \' << q.top().y << std::endl; q.pop(); } return 0;}

分配器

管理堆内存的对象，管理内存分配策略（默认基于 new/delete），allocator

分配器提供了多种成员函数

allocate(size_t n)：分配n个对象所需的内存deallocate(T* p, size_t n)：释放由allocate分配的内存construct(T* p, const T& val)：在已分配的内存上构造对象destroy(T* p)：销毁对象但不解分配内存

#include #include int main() { std::allocator alloc; int* p = alloc.allocate(5); // 分配5个int的内存 for (int i = 0; i < 5; ++i) { alloc.construct(p + i, i * 10); // 构造对象 } for (int i = 0; i < 5; ++i) { std::cout << p[i] << \" \"; // 输出: 0 10 20 30 40 } std::cout << std::endl; for (int i = 0; i < 5; ++i) { alloc.destroy(p + i); // 销毁对象 } alloc.deallocate(p, 5); // 释放内存 return 0;}

6. 文件操作

在C++中，文件 I/O（输入/输出）是程序与外部世界交换信息的重要手段。它允许程序从文件中读取数据或将数据写入文件。C++标准库提供了多种文件流类来处理文件操作，文件 I/O 操作主要通过 库实现

常用的文件操作包括

ifstream： 用于从文件读取数据，输入文件流（读操作），继承自 istream

ofstream： 用于将数据写入文件，输出文件流（写操作），继承自 ostream

fstream： 用于文件的输入输出，兼具读写功能

打开文件： 通过构造函数或 open() 成员函数打开文件，并指定文件名和打开模式

读写操作： 使用插入（<>）操作符读取或写入文件中的数据

关闭文件： 使用 close() 函数显式关闭文件，或者让文件 I/O 变量超出作用域（文件I/O类的析构函数会自动关闭文件

要在 C++ 中进行文件处理，必须在 C++ 源代码文件中包含头文件 和

#include #include int main() { std::ifstream src(\"source.png\", std::ios::binary); // 二进制读 std::ofstream dest(\"copy.png\", std::ios::binary); // 二进制写 if (!src || !dest) { std::cerr << \"文件打开失败！\" << std::endl; return 1; } // 高效逐块复制 const int BUFFER_SIZE = 4096; char buffer[BUFFER_SIZE]; while (src.read(buffer, BUFFER_SIZE)) { dest.write(buffer, src.gcount()); // 写入实际读取的字节 } dest.write(buffer, src.gcount()); // 写入剩余字节 src.close(); dest.close(); return 0;}

结果：copy.png和 source.png一样了

文件打开模式

要从文件读取信息或者向文件写入信息之前，首先要打开文件，在C++中，文件打开模式可以通过 std::ios_base 类中的标志来指定

ios::in： 以读取模式打开文件

ios::out： 以写入模式打开文件

ios::app： 以追加模式打开文件，所有新数据写入到文件的末尾

ios::ate： 将文件指针定位到文件的末尾

ios::binary： 以二进制模式打开文件，而不是文本模式

ios::trunc： 如果文件已存在，则删除文件内容

ios::nocreate： 如果文件不存在，则打开失败

ios::noreplace： 如果文件已存在，则打开失败

#include #include using namespace std;void main(){ ofstream outFile; outFile.open(\"number.txt\", ios::app); if (!outFile.is_open()) { cout << \" problem with opening the file \"; } else { outFile << 200 << endl; cout << \"done writing\" << endl; } outFile.close();}

输出：done writing

读取文件

读取文件时，可以使用 std::ifstream 类，使用 >> 或 getline 读取文件内容

1. 包含头文件：

#include // 核心文件流库

#include // 用于getline等操作

2. 创建流对象： std::ifstream fin; // ifstream 专用于输入（读取）

3. 打开文件并校验：

fin.open(\"data.txt\", std::ios::in); // 文本模式打开 if (!fin.is_open()) { // 必须检查是否成功打开 std::cerr << \"文件打开失败！\"; return -1;}

模式选项（可组合使用）： std::ios::in（读）、std::ios::binary（二进制）、std::ios::ate（初始定位到文件末尾）

4. 读取数据： 四种核心读取方法

方法 1： 运算符 >>（简单但有限制），适用场景： 读取无空格的数据（如数字、单词），缺陷： 忽略空格和换行，不保留原始格式

char buffer[100];while (fin >> buffer) { // 遇空格/换行终止 std::cout << buffer << std::endl;}

方法 2： std::getline（推荐按行处理），优势： 保留行内空格，内存安全（自动处理字符串内存）

std::string line;while (std::getline(fin, line)) { // 读取整行（含空格） std::cout << line << std::endl; }

方法 3： 流对象的 getline 方法，注意： 需预设缓冲区大小，避免溢出

char buffer[100];while (fin.getline(buffer, 100)) { // 读取到字符数组 std::cout << buffer << std::endl;}

方法 4： 逐字符读取（ get() ），用途： 需精细控制字符时（如解析特殊结构）缺点： 效率低，大文件不推荐

char ch;while (fin.get(ch)) { // 逐个字符读取 std::cout << ch;}

特殊场景处理：二进制文件读取 必须指定 std::ios::binary 模式

std::ifstream binFile(\"data.bin\", std::ios::binary);char* data = new char[1024];binFile.read(data, 1024); // 直接读取字节块binFile.close(); 

5. 关闭文件： fin.close(); // 显式关闭释放资源

二进制模式比文本模式更快（无换行符转换）

写入文件

std::ofstream（输出文件流）： 专用于写入文件，需包含头文件

#include int main() { std::ofstream fout(\"data.txt\"); // 创建或覆盖文件 if (fout.is_open()) { fout << \"Hello, World!\\n\"; // 写入文本 fout.close(); // 必须关闭 } return 0;}

std::fstream（多功能文件流）： 支持读写操作，通过模式参数控制

std::fstream file(\"data.txt\", std::ios::out | std::ios::app); // 追加模式 file << \"New line\\n\";file.close();

写入数据方法

1. 文本写入： 使用 << 操作符（类似 cout ）

fout << \"Integer: \" << 42 << \"\\nFloat: \" << 3.14;

2. 二进制写入： 用 write() 直接写入内存数据

int data = 100;fout.write(reinterpret_cast(&data), sizeof(data)); // 二进制写入

3. 格式化控制： 设置精度与宽度

fout.precision(2); // 保留2位小数 fout.width(10); // 输出宽度10字符fout << 3.14159; // 输出 \" 3.14\"

性能优化与安全

1. 缓冲区管理： 默认有缓冲区，手动刷新可避免数据丢失

fout <pubsetbuf(buffer, sizeof(buffer));

2. 错误处理： 检查文件是否成功打开

if (!fout) { std::cerr << \"File open failed!\"; return -1;}

3. 线程安全： 多线程写入时需加锁（如 std::mutex ）

高级场景

1. 追加数据

std::ofstream log(\"log.txt\", std::ios::app);log << \"Event: User login\\n\";

2. 大文件处理： 分块写入避免内存溢出

std::vector largeData(1000000, \'A\'); // 1MB数据 fout.write(largeData.data(), largeData.size()); 

3. 跨平台路径处理： 使用 std::filesystem（C++17起）

#include std::ofstream fout(std::filesystem::path(\"data/demo.txt\")); 

#include #include  int main() { // 1. 打开文件（追加模式） std::ofstream fout(\"output.txt\", std::ios::app); if (!fout) { std::cerr << \"Error opening file!\"; return 1; } // 2. 写入数据 fout << \"---- New Entry ----\\n\"; fout << \"Timestamp: \" << time(nullptr) << \"\\n\"; // 3. 检查写入状态 if (fout.fail()) std::cerr << \"Write failed!\"; // 4. 关闭文件 fout.close(); return 0;}

文件常见问题及解决方案

1. 检查文件是否成功打开： 使用 is_open() 成员函数检查文件是否成功打开，如果未成功，则采取相应措施

2. 显式关闭文件： 尽管C++流对象在析构时会自动关闭文件，显式调用 close() 函数可以提高代码的清晰度和控制力

3. 使用追加或读写模式： 如果需要在文件末尾追加内容，可以使用 ios::app 模式；如果需要读写同一文件，可以使用 ios::in | ios::out 模式

4. 注意字符编码： 明确文件的编码格式，必要时使用第三方库处理不同编码的读写