【C++笔记】STL知识铺垫

Ne0inhk

— 16 min read
【C++笔记】STL知识铺垫

前言： 

        在前面的学习中，我们已经掌握了C++的基础语法和编程概念，本文将深入探讨C++标准库的使用，并详细介绍迭代器、auto关键字以及范围for循环等相关知识。

        

一、STL简介

        

1.1 什么是STL

        

STL（Standard Template Library，标准模板库）是C++标准库的核心组成部分，它不仅提供了可复用的组件库，更是一个集成了高效数据结构与算法的软件框架。

        

1.2 STL的六大组件

        

由于历史原因，string 类型先于 STL 出现，STL 后来由惠普实验室开发并开源，因此人们通常不将 string 归入 STL 范畴。

        

        

二、迭代器

        

        迭代器（Iterator）是 C++ STL 中最精妙的设计之一，如果把 STL 的容器比作各种不同类型的仓库（数组、链表、树），那么迭代器就是一把万能钥匙，它让你不用关心仓库内部的具体构造，就能以统一的方式访问里面的每一个货物。

        

2.1 迭代器的本质：泛化的指针

        

迭代器的行为在视觉和操作上都非常像普通的 C 语言指针，你可以对它进行解引用（获取数据）和移动（指向下一个数据）。

        

例如：vector<int>:: iterator it        

        

注：这里的 iterator 是通过 内置类型（一般来说是指针） 进行 typedef 重命名，即泛化后的产物

        

迭代器的一般操作如下所示：   

        

① *it (解引用)：获取迭代器当前指向的元素的值。

        

② ++it 或 it++ (递增)：让迭代器移动到容器中的下一个元素。

        

③ == 和 != (比较)：判断两个迭代器是否指向同一个位置。

        

        

温馨提示：对于迭代器，我们可以初步简单认为其是一个高级版本的指针。

        

2.2 核心区间的概念：左闭右开

                

一般而言有如下两个函数返回特定位置的迭代器：

                

① begin()：返回指向容器中第一个元素的迭代器。

        

② end()：返回指向容器中最后一个元素之后位置的迭代器，它不指向任何实际存在的元素，可以理解为一个“越界哨兵”。

        

因此，在C++中，容器和算法使用迭代器时都严格遵循左闭右开区间这一基本原则，即 [begin, end) 

        

温馨提示：

        

A. 这种设计有一个巨大的好处：当 begin() == end() 时，可以直接用来判断容器是否为空。

        

B. end() - begin() 的大小即为容器中的元素个数

                

2.3 代码演示：如何使用迭代器

        

我们以一个简单的 vector 为例，看看最经典的迭代器遍历方式：

#include <iostream> #include <vector> using namespace std; int main() { //vector容器 可以简单理解为是一个顺序表 vector<int> numbers = { 10, 20, 30, 40, 50 }; // 声明一个迭代器 it，类型为 vector<int>::iterator vector<int>::iterator it = numbers.begin(); // 它从 begin() 开始，一直循环直到等于 end() while (it != numbers.end()) { // 使用 *it 获取当前指向的值 cout << *it << " "; ++it; } //预计输出: 10 20 30 40 50 return 0; }

        

2.4 迭代器的分类（初步了解）

        

不同的数据结构底层内存分布不同，因此它们提供的迭代器能力也不同，这是连接数据结构与算法的关键：

        

①随机访问迭代器 ：最强大的迭代器，支持像指针一样进行算术运算，比如 it + 5（直接跳到 5 个位置后）。

        

注：底层是连续内存的容器拥有它，比如 std::vector 和 std::deque，只有拥有这种迭代器的容器，才能使用 std::sort 进行快速排序。

        

②双向迭代器 ：支持向前 (++) 和向后 (--) 移动，但不能跨越式跳跃。比如基于链表实现的 std::list。

        

③单向迭代器：只能单步向前移动 (++)，比如单向链表 std::forward_list。

        

如下如所示：

        

        

三、auto关键字

       

在现代 C++11以后，auto 绝对是提升开发效率和代码可读性的“神器”，它能帮你省去大量敲击键盘的时间，并有效避免类型拼写错误。

        

3.1 核心概念：编译期类型推导

        

在使用 auto 声明的变量，它的类型不是在运行的时候决定的，而是在编译代码时，编译器根据你给变量赋予的初始值，自动推断出来的。        

        

代码示例：使用auto关键字，进行推导变量的类型。

#include <iostream> #include <vector> using namespace std; int main() { auto a = 10; // 编译器推导 a 为 int auto b = 3.14; // 编译器推导 b 为 double auto c = "Hello"; // 编译器推导 c 为 const char* return 0; }

        

温馨提示：

        

①正因为是根据初始值推导，所以使用 auto 声明变量时，必须同时进行初始化。

        

② 写 auto x;  是无法通过编译的。

        

3.2  auto的关键使用场景

        

1.拯救极其冗长、复杂的类型声明

        

在学习 STL 和算法时，你经常会遇到嵌套极深的数据结构。如果没有 auto，代码会写得非常痛苦且容易出错。

        

代码示例：简化数据类型的代码量

#include<iostream> #include <string> #include <map> using namespace std; int main() { map<string, string> dict = { { "apple", "苹果" },{ "orange","橙子" }, {"pear","梨"} }; //过于冗余 map<string, string>::iterator it = dict.begin(); //通过auto进行简化 auto it = dict.begin(); }

       

3.3 注意事项

        

A. 引用和 const 限定符的推导规则

        

使用 auto 时，最容易出错的地方在于它对引用和 const 限定符的推导规则：auto 默认会“剥离”顶层 const 和引用。

        

代码示例：

int x = 10; int& rx = x; const int cx = 10; auto a = rx; // a 的类型是 int （引用属性被丢弃），属于值拷贝 auto b = cx; // b 的类型是 int （顶层 const 被丢弃）

        

详情介绍：

        

1. 拆解 auto a = rx; （为什么引用属性被丢弃？）

        

前情回顾： int x = 10;  int& rx = x;  其中rx 是 x 的引用。

        

在 C++ 里，引用仅仅是个别名（就像 x 的小名）。当你使用 rx 的时候，你实际上就是在操作 x 本身，它的值是 10。

        

发生推导时： 当你写下 auto a = rx; 

        

编译器的内心戏是这样的：“你想用 rx 的值（也就是 10）来初始化一个新的变量 a，既然你没写 &（比如 auto& a），说明你不想让 a 也变成别名，你只是想要那个数字 10 而已。”

        

结果： 编译器把 a 推导为普通的 int。它在内存里挖了一块全新的空间，把 10 复制了进去。

        

      

2.拆解 auto b = cx; （为什么顶层 const 被丢弃？）

        

前情回顾： const int cx = 10;

        

cx 是一个被 const 锁住的整数。这里的 const 叫做顶层 const（Top-level const），意思是这个变量本身是不允许被修改的。

        

发生推导时： 当你写下 auto b = cx;

        

编译器又开始思考了：你想把 cx 里的值（10）掏出来，放进一个新变量 b 里，虽然 cx 本身是被锁住的（不能改），但这跟你新创建的 b 有什么关系呢？”

        

结果： 编译器把 b 推导为普通的 int，把 10 复制了进去。b 是一个自由的、可以随意修改的普通变量。     

        

代码示例：保留引用和 const的写法

int x = 10; int& rx = x; const int cx = 10; auto& c = rx; // c 是 int&，修改 c 会改变 x const auto d = cx; // d 是 const int，常用于只读访问

        

因此，C++ 规定：auto 默认只给你最纯粹的底层类型（如 int、double），给你最大的自由，如果你想要引用（&）或者只读（const），你必须自己动手明确地写出来。

        

        

B. 不能用于函数参数（C++20 之前）

        

在 C++20 之前，普通函数的参数不能用 auto，而需要使用模板。

        

代码示例：非法的写法

// 不能做参数 void func2(auto a) {}

        

        

C. auto可以做函数返回值

        

核心机制：编译器会通过阅读你函数体内的 return 语句，来反向推导出这个函数到底该返回什么类型。

        

1. 基础用法：让编译器替你算类型

auto multiply(int a, double b) { return a * b; // 编译器知道 int * double 的结果是 double，所以自动推导返回类型为 double }

        

2. 避坑指南

坑点一：多个 return 语句的类型必须“完全一致”

        

如果你的函数里有 if-else 分支，并且包含多个 return，那么所有 return 后面的表达式类型必须一模一样。编译器不会帮你做隐式类型转换。

        

代码示例：if-else 返回的类型不同

auto check_number(int x) { if (x > 0) { return 1; // 类型是 int } else { return 1.5; // 编译报错！类型是 double，与上面的 int 冲突 } }

        

解决办法： 强制统一类型，比如把 return 1; 改成 return 1.0;。

        

坑点二：auto 依然会丢弃引用（&）和 const

        

这跟我们之前讨论的变量推导规则是一模一样的，默认情况下，auto 作为返回值永远是“值拷贝”。

        

代码示例：返回引用 和 const类型的值

int global_var = 100; // 你本意是想返回 global_var 的引用 auto get_ref() { int& ref = global_var; return ref; } // 实际结果：get_ref() 返回的是一个普通的 int（发生了值拷贝），引用属性被丢弃了！

        

解决办法： 如果你确实想返回引用，必须显式地写成 auto& 或者 const auto&

int global_var = 100; // 你本意是想返回 global_var 的引用 auto& get_ref() { int& ref = global_var; return ref; }

      

四、范围for循环

        

        范围 for 循环 是 C++11 引入的一项极其重要且实用的特性，它极大地简化了遍历数组和容器（如 std::vector, std::string, std::map 等）的代码，使其更具可读性，同时也减少了数组越界等常见错误。

        

4.1  基本语法        

        

范围 for 的语法非常直观：

for (元素类型 元素变量名 : 遍历对象) { // 循环体 }

        

相关参数讲解：

        

①元素类型：遍历对象中元素的类型（通常搭配 auto 关键字使用）。

        

②元素变量名：每次循环时，用来接收当前元素的变量。

        

③遍历对象：必须是一个可以确定范围的集合（如定长数组、标准库容器等）。

        

        

4.2 三种最常用的遍历方式

        

A. 按值遍历

        

核心特征：每次循环都会将容器中的元素拷贝给变量，修改变量不会影响容器内原本的数据。

        

适用场景：遍历基础数据类型（如 int, char, float），且不需要修改原数据。

        

代码示例：遍历基础类型int

vector<int> nums = {1, 2, 3}; for (int x : nums) { cout << x << " "; // 输出 1 2 3 }

        

B. 按引用遍历        

        

核心特征：加上 & 符号，变量直接引用容器内的元素，修改变量就等于修改了容器内的原数据。

        

适用场景：需要修改容器内元素的内容时。

        

代码示例：遍历基础类型int，并修改其内容

vector<int> nums = {1, 2, 3}; for (int& x : nums) { x *= 2; // 原数组变为 {2, 4, 6} }

        

C. 按常量引用遍历

        

核心特征：加上 const 和 &，既不会发生拷贝（节省内存和时间），又保证了数据不被意外修改（只读）。        

        

适用场景：遍历复杂对象（例如：string,  结构体,  自定义类）且只需读取时，这是最推荐的写法。

        

代码示例：遍历复杂对象string类

vector<string> words = {"Hello", "World"}; for (const string& word : words) { cout << word << endl; }

        

        

4.3 结合 auto 关键字

        

在实际开发中，我们通常不需要手动写出繁琐的类型名，直接让编译器用 auto 推导即可：

        

写法一： for (auto x : container)   （ 按值拷贝）

        

写法二：for (auto& x : container)   （按引用，可修改）

        

写法三：for (const auto& x : container)  （按常量引用，只读且高效）

        

代码示例：通过使用关键字auto遍历容器

vector<string> words = {"Hello", "World"}; for (const auto &word : words) { cout << word << endl; }

        

4.4 范围for的本质

        

范围 for 并不是什么神奇的魔法，它本质上是编译器提供的一层“语法糖”。

        

当编译器看到范围 for 时，会自动将其转化为使用迭代器 (Iterator) 的 循环：

// 你的代码 for (auto& x : container) { /*...*/ } // 编译器实际转化为类似这样的代码： //_begin指向头部元素的迭代器 auto _begin=container.begin(); //_end 指向尾部元素下一个位置的迭代器 auto _end=container.end(); for( ; _begin !=_end ; ++_begin ) { //遍历迭代器，将容器的值赋值给x auto& x = *_begin; /*...*/ }

既然看到这里了，不妨关注+点赞+收藏，感谢大家，若有问题请指正。

        

Read more

Java连接电科金仓数据库（KingbaseES）实战指南

Java连接电科金仓数据库（KingbaseES）实战指南

摘要：本文分享了KingbaseES V8.6数据库与SpringBoot 2.7.x框架的集成实战经验。内容包括：1. 环境准备（Ubuntu系统安装配置、驱动获取方式）；2. JDBC基础操作（连接、查询、事务处理）；3. SpringBoot项目完整配置（pom依赖、数据源配置）；4. MyBatis-Plus集成（实体类、Mapper、Service层实现）；5. RESTful接口开发示例。文章提供了详细的代码示例，涵盖从数据库安装到应用开发的完整流程，帮助开发者快速实现国产数据库适配。 目录 前言 一、环境准备与驱动获取 1.1 数据库安装与配置 1.2 JDBC驱动获取与配置 1.3 创建测试数据库 二、基础JDBC连接与操作 2.1 最基础的JDBC连接示例 2.

By Ne0inhk
【Linux系统】理解管道通信，匿名管道实现进程池+命名管道实现服务端客户端通信模型（附源码）

【Linux系统】理解管道通信，匿名管道实现进程池+命名管道实现服务端客户端通信模型（附源码）

文章目录 * 一、进程间通信是什么 * 二、管道 * 1. 什么是管道 * 2. 匿名管道 * 3. 命名管道 * 三、实例：匿名管道实现进程池 * 四、实例：命名管道实现服务端客户端通信模型 一、进程间通信是什么 进程间通信（IPC），顾名思义，进程之间需要进行信息交换。 如：数据传输、资源共享、通知事件、进程控制。 进程间通信的方式有：管道、System V IPC、POSIX IPC。 由于进程具有独立性，进程间通信的前提就是，不同的进程能看到同一份资源。 二、管道 1. 什么是管道 管道是类Unix系统中最古老的进程间通信的方式。我们把从一个进程连接到另一个进程的数据流称为一个“管道”。 管道是单向通信的，称为单工通信。 管道分为匿名管道和命名管道。 2. 匿名管道

By Ne0inhk
【Java 开发日记】我们来说一下无锁队列 Disruptor 的原理

【Java 开发日记】我们来说一下无锁队列 Disruptor 的原理

目录 一、为什么需要 Disruptor？—— 背景与问题 二、核心设计思想 三、核心组件与原理 1. 环形缓冲区（Ring Buffer） 2. 序列（Sequence） 3. 序列屏障（Sequence Barrier） 4. 等待策略（Wait Strategy） 5. 事件处理器（EventProcessor） 6. 生产者（Producer） 四、工作流程示例（单生产者 -> 单消费者） 五、多消费者与依赖关系 六、总结：Disruptor 高性能的秘诀 一、为什么需要 Disruptor？—— 背景与问题 在高并发编程中，传统的队列（如 java.

By Ne0inhk
Java-Spring入门指南（十四）利用IDEA教你构建第一个SpringMVC系统

Java-Spring入门指南（十四）利用IDEA教你构建第一个SpringMVC系统

Java-Spring入门指南（十四）SpringMVC项目实战搭建 * 前言 * 一、首先导入我们的Maven * 二、接着导入SpringMVC相关的包 * 三、创建Servlet_web环境 * （1）配置springmvc.xml * （2）配置web.xml里面的中央处理器 * （3）为什么需要配置前端控制器？ * 五、配置最新的tomcat 11 * 六、运行项目 前言 * 在上一篇博客中，我们系统学习了SpringMVC的核心流程与组件分工，明确了DispatcherServlet（前端控制器）、HandlerMapping（处理器映射器）等组件的协作逻辑。 * 理论之后更需实践，如何从0到1搭建一个可运行的SpringMVC项目，如何将核心组件配置落地，是本次实战的核心目标。 * 本文将基于Maven+IDEA+Tomcat 11环境，一步步完成SpringMVC项目的搭建、配置与运行，让你直观感受“理论”到“实战”的转化过程。 我的个人主页，欢迎来阅读我的其他文章 https:

By Ne0inhk