C++学习提问-CSDN博客

本文链接：https://blog.csdn.net/weixin_60819193/article/details/148252389

前言

在当今软硬件开发日益融合的时代，C++仍以其高性能、可控性与丰富的特性，成为系统软件、游戏引擎、嵌入式设备等领域的主力语言。对于初学者而言，面对其复杂的语法规则、丰富的标准库和多代特性，往往容易迷失在指针运算、内存管理、模板元编程等概念之中；而对于有经验的开发者，也常因对新标准、新范式了解不足而错失效率与安全的提升机会。

本篇文章基于作者在自学与项目实践过程中所遇到的疑难与思考，将 C++ 的核心能力要素、基础概念与进阶疑问全面梳理，力求做到：

体系化呈现：从“开发者应具备的能力”到“函数、结构体、指针、面向对象”等基础概念，再到“模板、并发、RAII、现代 C++ 特性”等进阶话题，层层递进、脉络清晰。
问题驱动：汇总学习过程中常见的提问与误区，让读者在阅读时即能自我检测理解盲点。
实用导向：结合示例与最佳实践，帮助你在今后的编码、调试与架构设计中少走弯路。
学习路径建议：针对不同阶段的学习者提供循序渐进的学习路线与资源推荐，让你做到有所学、有所问、有所悟。

无论你是初涉 C++、渴望打好根基，还是已有多年经验、希望掌握现代标准与高阶技巧，相信这份“C++ 基础概念整理及提问”都能成为你手边的思维导图与复习锦囊。愿它助你构建扎实的语言底座，提升编程效率，走得更远、更稳、更优雅。

本篇为学习提问篇，另一篇概念介绍篇:C++基础概念-CSDN博客

前言

基础概念提问

指针

1.为什么要先解引用 *p 再用 . 访问成员？

2.指针是不是主要用来访问数组？单个变量能否直接赋值？

3.为什么有的写 (*p).age，有的写 p->name？

4.指针访问数组时，只能访问和修改数组首元素吗？

5.智能指针（Smart Pointer）和原始指针（Raw Pointer）的区别

6.为什么指针只是存了数组第一个元素的地址？

基础问题提问 Part1

1.C++ 面向对象的构建能力

2.C++ 的基础特性

3.struct 的用法，以及为何用 struct 而不是 class？

4.如何在同一个项目中执行不同的main？除了把之前写的代码注释掉之外还有什么办法吗？

5.什么是“语法糖”？

6.using namespace std; 什么时候不适用？

1.for 语句的三个“部分”是否都必须写？

2.while 和 if 的“条件”写法

3.while vs. if，何时用哪一个？

4.Class和void的区别是什么？

5.介绍Json和XML

6.Encoding, UTF-8和Unicode是什么？UTF-8属于Unicode吗？

7.什么是左值引用？什么是右值引用？区别在哪

8.什么是完美转发？

9.什么是同一个作用域？

10.什么是全局作用域

11.除了main()前面的这一块属于全局作用域，其他的任何.h或者是.cpp文件中只要在任何函数、类或命名空间之外的那块最外层区域都属于全局作用域？

3.示例中函数重载，如果把func(10)改为func(int a)会报错吗？

封装

1. 在封装类中使用void setName(std::string name)，void setID(int StudentID)，和我直接在类中直接使用std::string name和int StudentID有什么区别？

2. 访问权限：public,protected,private这三个都是围绕类来展开的吗，但是如果在全局作用域下面写这三个是不是就没有什么区别了？

C++进阶概念

1.什么是序列化？

2.C++11 到 C++20 各版本的主要差异

3.C++ STL 容器（Container）概述

4.构造函数（Constructor）与析构函数（Destructor）

5.构建工具：CMake的作用是什么

6.for (int k = 0; k < N; ++k) { cout << arr[k] << ' '; } cout << endl;和 for (int k = 0; k < N; ++k) { cout << arr[k] << ' '<

7.冒泡排序中，两层for中的原理（即外层for和里层for）

8.C++中一维数组和二维数组的介绍

9.使用STL容器表达二维数组（推荐）

10.什么是C++的多态？

基础概念提问

指针

1.为什么要先解引用 *p 再用 . 访问成员？

运算符只能用于对象本身，不能直接作用于指针。
*p 是对指针的解引用，结果类型是它所指向的对象（即 Person&），这时就能用 . 来访问成员：
```
(*p).age = 31;  // 先 (*p) 得到 Person 对象，再 .age
```
-> 就是把这两步合并为一步，“取地址”与“解引用”合并成了直接访问成员。

2.指针是不是主要用来访问数组？单个变量能否直接赋值？

指针可以指向任何类型的对象——既可以是数组首元素，也可以是普通的单个变量、类实例、动态分配的内存等。

如果你操作的是本地的单个变量，像：

int age = 30;
age = 31;  // 直接修改最简单

那当然没必要用指针去间接访问。

指针的作用主要在于：

动态分配：在堆上分配一块内存，必须通过指针来引用它；
函数间传递：如果想让函数内部修改调用处的变量，常通过指针参数或引用；
数据结构：链表、树、图等节点间通过指针连接；
多态：基类指针指向派生类对象，用于运行时多态。

结论：只有在需要“间接引用”或“动态管理”时才用指针，否则直接变量名赋值最简单。

3.为什么有的写 (*p).age，有的写 p->name？

这两种写法其实等价，都是先对指针 p 做“解引用”（得到它指向的对象），再访问该对象的成员：

(*p).age       // 先 (*p)，再 .age
p->age         // 箭头运算符正是 (*p).age 的“语法糖”

为什么例子里同时出现两种？

(*p).age = 31; 强调了解引用再访问成员的过程，写法上要加括号，否者 *p.age 会被错误解析。
p->name = "Alice"; 就是箭头语法，编译器自动帮你做了解引用和再访问成员：

p->name      // 等价于  (*p).name

推荐风格：

日常中只要指针指向的是类/结构体，就统一用 ->，既简洁又避免括号。
只有在讲解原理或演示 operator-> 重载时，才会写出 (*p).member。

小结

指针并不限于数组，单个变量完全可以直接赋值，指针主要用于需要间接访问或动态管理的场合。
(*p).member 和 p->member 是一回事，后者是对前者的简写（语法糖），平时习惯用 ->。

4.指针访问数组时，只能访问和修改数组首元素吗？

不是的，指针只是存了数组第一个元素的地址，但利用 指针运算（也就是“指针加减”）就能访问数组中的任意元素。

1. 原理：指针加法

假设有一个整型数组：

int arr[5] = {10, 20, 30, 40, 50};
int* p = arr;  // 等价于 int* p = &arr[0];

p 当前指向 arr[0]。
指针加法：p + 1 会跳过一个 int 大小，指向 arr[1]；
一般地，p + i 就指向 arr[i]（前提是 0 <= i < 5）。

2. 访问和修改

#include <iostream>
using namespace std;

int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int* p = arr;  // 指向 arr[0]

    // 访问
    cout << p[0] << endl;        // 10
    cout << p[2] << endl;        // 30
    cout << *(p + 4) << endl;    // 50

    // 修改
    p[1] = 25;                   // 改变 arr[1]
    *(p + 3) = 45;               // 改变 arr[3]

    // 验证
    for (int i = 0; i < 5; ++i) {
        cout << arr[i] << ' ';   // 输出：10 25 30 45 50
    }
    cout << endl;

    return 0;
}

p[i] 就是 *(p + i) 的语法糖，用来访问第 i 个元素。
同理，你可以写 *(p + i) = newValue; 或者 p[i] = newValue;，都能修改对应元素。

3. 小结

指针本身只保存一个地址（初始时通常是数组首元素的地址）。
指针加法让你在内存中按元素大小“跳转”到数组的任意位置。
这样就能访问和修改整个数组，而不仅仅是第一个元素。

5.智能指针（Smart Pointer）和原始指针（Raw Pointer）的区别

6.为什么指针只是存了数组第一个元素的地址？

当你把一个数组名赋给一个指针变量时，发生的是“数组到指针”的衰变（decay）——它会变成第一个元素的地址：

int arr[5] = {10,20,30,40,50};
int* p = arr;    // 等价于 int* p = &arr[0];

为什么这样设计？

类型匹配
- int* p 表示“指向 int 的指针”。
- arr 本身不是指针，但在大多数表达式里，它会被隐式转换为 “指向第一个元素的指针”——int*。
- 这样 p = arr; 就是把 &arr[0]（类型为 int*）赋给 p。
方便遍历
- 数组在内存中是连续存放的：

[10][20][30][40][50]
 ↑    ↑    ↑    ↑    ↑
arr  arr+1 arr+2 arr+3 arr+4

有了“首元素地址”后，通过指针加法（p + i）或下标语法（p[i]）就能访问整个数组。

区分“数组地址”与“元素地址”

arr 衰变为 &arr[0]，类型是 int*。
如果你写 &arr，它的类型是 int (*)[5]（指向整个 5 元素数组的指针），虽然数值上也指向同一块内存的起始地址，但类型不同，做指针算术时就不一样。

int (*pa)[5] = &arr;   // pa 的类型是 “指向 5 个 int 的数组” 
// pa + 1 会跳过整个数组（5 个 int），而 p + 1 只跳过 1 个 int

小结

指针保存的地址类型 由它的声明决定：
- int* p → 它存的是 “一个 int” 的地址，所以赋 arr 时得到的是 &arr[0]。
- int (*pArr)[5] → 它存的是 “一个长度为 5 的 int 数组” 的地址，所以赋 &arr。
“数组名衰变为指针” 是 C/C++ 的语法规则，目的是方便你通过指针遍历和操作数组元素。

基础问题提问 Part1

1.C++ 面向对象的构建能力

C++ 支持面向对象编程（OOP），主要体现在以下几方面：

封装（Encapsulation）
- 用 class／struct 将数据与操作数据的函数（成员函数）组合在一起，并通过访问控制符 (public/protected/private) 隐藏内部细节。
继承（Inheritance）
- 派生类继承基类的成员，可以代码复用和扩展。支持单继承和多重继承（需注意菱形继承问题）。
多态（Polymorphism）
- 编译时多态：函数重载、运算符重载、模板实例化。
- 运行时多态：基类指针/引用调用派生类的虚函数，借助虚函数表（vtable）实现动态绑定。
抽象（Abstraction）
- 通过纯虚函数（virtual … = 0）定义接口，将具体实现留给派生类。

2.C++ 的基础特性

除了面向对象，C++ 语言本身还包含以下核心特性：

静态类型系统
- 编译期类型检查，auto 推导与显式类型声明并存。
指针与引用
- 直接操作内存地址（指针 T*），引用 T& 作为别名。
模板与泛型编程
- 函数模板、类模板，支持在编译期生成类型安全的代码。
标准模板库（STL）
- 容器（vector、map 等）、算法（std::sort、std::find_if）、迭代器。
RAII（资源获取即初始化）
- 通过栈对象的构造／析构管理资源（文件、锁、内存），保证异常安全。
异常处理
- try/catch/throw 提供统一的错误处理机制。
现代语法糖（C++11 及以后）
- Lambda、智能指针（unique_ptr/shared_ptr）、右值引用 (T&&)、constexpr、enum class 等。

3.struct 的用法，以及为何用 struct 而不是 class？

在 C++ 中，struct 和 class 唯一的语法区别是默认的成员访问权限不同：

struct：默认公有，即不加访问说明符的成员都是 public。
class：默认私有，即不加访问说明符的成员都是 private。

用法上它们功能完全相同，都可以定义成员变量、成员函数、继承、多态等。

常见习惯：

简单的数据聚合（Plain-Old Data）或只包数据、少逻辑的类型常用 struct；
需要封装、接口与实现分离、强访问控制的类常用 class。

struct S {
    int x;            // 等价于 public: int x;
};

class C {
    int x;            // 等价于 private: int x;
public:
    void set(int v) { x = v; }
};

4.如何在同一个项目中执行不同的main？除了把之前写的代码注释掉之外还有什么办法吗？

在一个 C++ 项目里，编译、链接阶段只能有一个有效的 main，否则会报“重定义 entry point”之类的错误。除了“注释掉”不想跑的那段 main，常用的几种做法是：

1. 把不同的 main 放在不同的 .cpp 里，按需“排除”／“包含”文件

实现方式

每个 main 写在独立的源文件里：

src/
  main1.cpp   // 包含 int main() { … }
  main2.cpp   // 包含 int main() { … }
  utils.cpp
  …

 在 Visual Studio 里右键某个 .cpp → 属性 → 排除生成（Exclude From Build），就可以在不同配置下只编译你想跑的那个 main。

优点：

不改代码，只改项目属性；

各个 main 之间互不干扰；

缺点：多了几个配置管理。

2. 用预处理器宏控制哪段 main 生效

// 在 project Settings → C/C++ → Preprocessor → Preprocessor Definitions
// 为不同的 Configuration 定义 RUN_MAIN1 或 RUN_MAIN2

#if defined(RUN_MAIN1)
int main() {
    // … main1 的逻辑 …
    return 0;
}
#elif defined(RUN_MAIN2)
int main() {
    // … main2 的逻辑 …
    return 0;
}
#endif

实现方式
- 给不同的 Debug/Release 配置分别定义宏 RUN_MAIN1、RUN_MAIN2。
- 编译时只有对应宏那段代码会被编译。
优点：不用改文件排除设置，全部源文件都在；
缺点：要手动切换预处理宏。

3. 统一一个 “真” main，把其他入口做成普通函数

// entrypoints.h
int main1();
int main2();

// main1.cpp
#include "entrypoints.h"
int main1() {
    // … 
    return 0;
}

// main2.cpp
#include "entrypoints.h"
int main2() {
    // …
    return 0;
}

// main.cpp
#include "entrypoints.h"
int main() {
#ifdef RUN_MAIN1
    return main1();
#elif defined(RUN_MAIN2)
    return main2();
#else
    // 默认或报错
    return 0;
#endif
}

优点：
- 源文件都编译，只改 main.cpp 的切换逻辑；
- 非常灵活，可在运行时或编译时切换。
缺点：有个总 main，其它入口变成子函数，略微改动逻辑。

4. 用 VS Solution 里多个 Project

做法：
- 把每个 main 放到不同的 Project（比如 Proj_Main1、Proj_Main2），都放在同一个 Solution 里。
- 切换启动项目（右键 Project → Set as Startup Project）。
优点：管理清晰，每个 exe 独立；
缺点：项目数量多，维护稍繁琐。

5.什么是“语法糖”？

语法糖（syntactic sugar） 指编程语言中用来让代码更易读、更简洁的语法，它本质上并不增加新能力，而是由编译器转换成更底层、更冗长的等价代码。

这里的 ptr->member 就是对 (*ptr).member 的语法糖：

ptr->name    // 等价于  (*ptr).name
ptr->func()  // 等价于  (*ptr).func()

6.using namespace std; 什么时候不适用？

在 C++ 里，using namespace std; 的确可以让你在后面写代码时不用每次都敲 std::，比如

其背后有几个主要原因和注意事项：

2. 可读性与维护性

显式来源更清晰
当你在代码里看到 std::string、std::move、std::map，立刻就能知道这是标准库的类型或函数；如果都省掉了前缀，读者必须去猜它们来自哪个命名空间。
大规模团队协作
在多人或跨模块协作时，大家更倾向于显式地写 std::，以防某人无意间引入了同名的自定义类型或函数，导致别处编译出奇怪的错误。

3. 头文件（.h/.hpp）绝对忌用

千万不要在头文件里写 using namespace std;，因为：

它会“传染”所有包含这个头文件的源文件。
你难以预料在别的源文件里会因此引入哪些名字冲突。

如果真的想让头文件里少写几次 std::，也只能用更局部的 using std::string; 这样的 using 声明，并且也要非常小心只引入少量标识符。

何时不该用 using namespace std;

任何头文件 —— 都不要写。
大型项目的全局或命名空间顶层 —— 会影响所有代码。
当你的工程里有多个命名空间，且有可能重名时 —— 绝对不要。

总结

小型、临时的示例代码（教学、Demo、快速原型）可以用 using namespace std;，让示例更简洁；
生产级代码、库/框架、头文件 则应显式地用 std:: 或者局部 using std::xxx;，以提升可读性、可维护性并防止名字冲突。

7.什么是自定义Node？

“自定义 Node”就是自己用 struct 或 class 定义一个“节点”类型，用来在链表、树、图等数据结构里串联各个元素。它不是标准库里提供的，而是程序员根据需求手写的。

1. 为什么要自定义 Node？

标准库里有像 std::list 这样封装好的链表容器，但如果你想自己实现一个链表学习原理，或者要在一个特殊场景下改造链表，就需要自己定义节点类型。

2. 常见的单向链表 Node 例子

// 一个简单的单向链表节点
template<typename T>
struct Node {
    T val;        // 节点保存的数据
    Node* next;   // 指向下一个节点的指针

    // 构造函数：初始化 val，并让 next 指向空
    Node(const T& v)
      : val(v), next(nullptr)
    {}
};

val：存放用户关心的数据，比如 int、string、或自定义对象。

next：指向链表中下一个节点，或为 nullptr 表示到达链表尾部。

3. 如何用自定义 Node 搭建链表？

#include <iostream>

int main() {
    // 1) 创建三个节点
    Node<int>* n1 = new Node<int>(10);
    Node<int>* n2 = new Node<int>(20);
    Node<int>* n3 = new Node<int>(30);

    // 2) 串联它们
    n1->next = n2;
    n2->next = n3;

    // 3) 遍历并打印
    for (Node<int>* p = n1; p != nullptr; p = p->next) {
        std::cout << p->val << ' ';
    }
    // 输出：10 20 30

    // 4) 记得释放内存
    delete n1;
    delete n2;
    delete n3;
}

4. 扩展：双向链表节点

如果要在链表中双向遍历，就再加一个 prev 指针：


template<typename T>
struct DNode {
    T val;
    DNode* prev;  // 指向前一个节点
    DNode* next;  // 指向下一个节点

    DNode(const T& v)
      : val(v), prev(nullptr), next(nullptr)
    {}
};

5. 小结

“自定义 Node”：自己写 struct Node{…}; 来描述“节点”是什么。
用途广泛：学习链表原理、实现各种链式或树形数据结构。
与 STL 区别：STL 已经封装好，你只要直接用；自定义则可完全控制底层逻辑。

8.std是什么意思？

在 C++ 中，std 是“standard”（标准）的缩写，用来表示标准库所定义的命名空间（namespace）。

命名空间的作用是把一组相关的名字（类、函数、常量、对象等）组织在一起，避免与其他库或用户定义的名字冲突。
C++ 标准库里的所有内容都放在 std 命名空间下，比如：
- 容器：std::vector、std::map
- 输入输出：std::cout、std::cin
- 字符串：std::string
- 算法：std::sort、std::find
- 智能指针：std::unique_ptr、std::shared_ptr
- …等等

9.所有void开头的都是属于函数？

不是的，并非凡是以 void 开头的语句都是函数。在 C++ 中，void 本身只是一个“无类型”（no-type）的标识符，常见用法有几种，不同用法对应不同的声明：

形式	含义	示例
`void f();`	函数声明：返回类型是 `void` 的函数 `f`	`cpp<br>void sayHello(); // 声明一个不返回值的函数<br>`
`void* p;`	指针声明：指向任意类型的通用指针 `p`	`cpp<br>void* buffer = malloc(1024);<br>`
`static_cast<void>(expr);`	丢弃值：把 `expr` 的结果转换成 `void`	`cpp<br>static_cast<void>(someFunction());<br>`
在参数列表中 `void`	无参函数（C 风格）：表示此函数不接受任何参数	`cpp<br>void foo(void); // 在 C++ 中写成 void foo() 等价<br>`
`template<typename T> using void_t = void;`	类型别名：元编程中占位用	见 `<type_traits>` 中的 `void_t`

怎么区分函数声明？

只有“标识符后紧跟圆括号”的，才是函数（或函数指针）：

函数声明／定义：

void f();         // 声明
void f() { … }    // 定义

函数指针：

void (*fp)();     // 指向无参无返回函数的指针

而像 void* p;、void* foo(int);（返回 void* 的函数）就不是“无返回值的函数”，要注意 void* 与 void 的区分。

小结

void 单独出现在函数名前，才表示“这是个不返回任何值的函数”。
如果是 void*，那是“指向任意类型的指针”。
而且函数声明／定义能被识别的关键在于——名字后面有 ()。

基础问题提问 Part 2

1.for 语句的三个“部分”是否都必须写？

2.while 和 if 的“条件”写法

if (condition)
while (condition)

两者的括号里都只允许出现一个能转换为 bool 的表达式（条件），不能写三段式。常见写法包括：

关系表达式： i < 5、ptr != nullptr
逻辑表达式： x>0 && x<10、!flag
函数返回值： if (read() > 0) …

你可以把多个判断用逻辑运算符 &&、||、! 串起来，但整个 (...) 只有一个“条件表达式”。

3.while vs. if，何时用哪一个？

小结

for(...) 括号里可写三段，也可各自省略，但之间的分号不能少。
if(...) 和 while(...) 括号内都只要一个布尔表达式（可以通过 &&/||/! 组合）。
if 用于做一次性的条件分支；while 用于在条件为真时重复执行循环体。

4.Class和void的区别是什么？

在 C++（以及大多数面向对象语言）里，class 和 void 是两个完全不同层面的关键字，分别用于类型定义和类型说明。

一、class —— 定义“类”这种用户自定义类型

作用
- class 用来声明一个“类”（class），它是 C++ 的核心——封装数据（成员变量）和行为（成员函数）的模板。
- 通过 class，你可以创建任意复杂度的类型，实现封装（encapsulation）、继承（inheritance）、多态（polymorphism）等面向对象特性。

二、void —— 表示“没有类型”或“空”

小结

class：一种用户自定义的类型，用于封装成员变量和成员函数，是面向对象的基石。
void：一种类型说明符，表示“没有具体类型”——常用于标记“无返回值的函数”或“通用指针”。

它们在语法上和语义上完全不冲突，经常在同一份代码里“组合”使用：用 class 定义类型，用 void 指定那些不需要返回值的成员函数。

5.介绍Json和XML

JSON（JavaScript Object Notation）

定义

一种轻量级的数据交换格式，以文本形式表示结构化数据。
源自 JavaScript，但与语言无关，支持多数编程语言。

特点

简洁：使用少量符号，易读易写。
数据模型：仅支持两种结构：
- 对象（由 {} 包围，内部是键–值对，如 {"key": value}）
- 数组（由 [] 包围，内部是按顺序的值列表，如 [1,2,3]）
数据类型：字符串、数值、布尔、空、对象、数组。
无模式（Schema-less）：不强制定义字段类型或顺序。

优缺点

优点：体积小、解析快、与现代 Web/REST API 天然契合。
缺点：不支持注释；对非常复杂的文档标记（如文档格式）不如 XML 灵活。

应用场景

Web 前后端数据交换（AJAX/RESTful API）。
配置文件（如 .eslintrc.json、.babelrc）。
NoSQL 数据库（MongoDB 存储的是 BSON，一种二进制 JSON 变体）。

XML（eXtensible Markup Language）

定义

一种可扩展的、标记型的文本格式，用来表示复杂的文档和数据。
由 W3C 标准化，强调可读性和可验证性。

特点

标签（Tag）结构：数据通过开始标签 <tag> 与结束标签 </tag> 标识，支持自定义标签名。
层次化：天然树状结构，适合描述文档型数据（如网页、文档、配置）。
DTD/XSD：可配合文档类型定义（DTD）或 XML Schema（XSD）进行校验，保证结构与数据类型正确。
可混合内容：标签内部既可含文本也可嵌套子元素。

语法示例

优缺点

优点：标签自描述、支持注释、标准化的校验机制（XSD）、可混合文本和子元素。
缺点：冗长（标签成对出现）、解析比 JSON 慢、对简单数据交换稍显臃肿。

应用场景

配置文件（如 Ant、Maven 的 pom.xml）。
文档格式（如 XHTML、SVG、Office Open XML）。
企业级 Web 服务（SOAP，多用 XML 构建请求与响应）。

总结

选择 JSON：当你追求轻量、快速、与现代 Web/REST 接口无缝集成时。
选择 XML：当你需要严谨的结构校验、混合内容文档或标准化的企业级消息格式时。

6.Encoding, UTF-8和Unicode是什么？UTF-8属于Unicode吗？

Unicode 和 UTF-8 经常一起出现，但它们指的并不完全相同：

1. Unicode：字符集与代码点

Unicode 是一个国际标准，定义了全球绝大多数书写系统中所有字符的“码点”（code point）。
每个字符被分配一个唯一的编号，记作 U+XXXX，其中 XXXX 是 16 进制数。例如：
- U+0041 → 拉丁字母大写 A
- U+4F60 → 中文“你”
- U+1F600 → 表情“😀”
注意：
- Unicode 本身只是一张“表”和一套规范，不规定具体在内存或文件里如何存储这些码点。
- Unicode 的范围很大，目前可用的码点超过 140 000 个，分布在多个平面（Plane 0…Plane 16）。

2. 字符编码（Encoding）

要把这些“码点”保存到磁盘或发送到网络上，必须把它们转换成字节序列，这就叫字符编码。常见的 Unicode 编码包括：

名称	描述
UTF-8	可变长度编码：1~4 个字节表示一个码点。ASCII 范围（U+0000…U+007F）用单字节，高位字符用多字节。
UTF-16	可变长度：2 或 4 个字节。BMP（基本多文种平面；U+0000…U+FFFF）用 2 字节，超出部分用一对代理项（surrogate pair）。
UTF-32	固定 4 字节：每个码点都占用 4 字节。查表速度最快，但空间利用率最低。

3. 为什么选择 UTF-8？

向后兼容 ASCII：U+0000…U+007F 区间和 ASCII 完全相同，用单字节保存。
节省空间：对于英文文本，几乎和 ASCII 一样小；对多数字母文字也比 UTF-32 紧凑。
广泛支持：几乎所有 Web、Unix/Linux、现代编程语言和库都默认使用 UTF-8。
自同步性：从任意一个字节读取即可判断这是一个新字符的开始还是续字节，便于流式处理。

4. UTF-8 的编码规则示例

字节数	码点范围	编码格式（二进制）
1	U+0000 … U+007F	0xxxxxxx
2	U+0080 … U+07FF	110xxxxx 10xxxxxx
3	U+0800 … U+FFFF	1110xxxx 10xxxxxx 10xxxxxx
4	U+10000 … U+10FFFF	11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

5. 小结

Unicode：定义“字符 ↔ 码点”的映射，是字符的“编号表”。
UTF-8：把这些码点编码成 1～4 个字节的序列，是字符的“存储／传输格式”。

在文件头看到 encoding="UTF-8"，就是告诉程序：

“后面的文本内容用 UTF-8 编码，把字节流解析成 Unicode 码点，再渲染成真正的字符。”

UTF-8属于Unicode吗？

UTF-8 并不是“Unicode”本身，而是 Unicode 标准定义的一种 字符编码（Transformation Format），全称叫 UTF-8（Unicode Transformation Format – 8-bit）。

Unicode：定义了一套“字符 ⇄ 码点”（code point）的映射表，比如 “A → U+0041”，“你 → U+4F60”。
UTF-8：是把这些 Unicode 码点转换成 1～4 字节 的二进制序列的方式之一。

换句话说：

Unicode 是一本“字符字典”，告诉你每个字符的编号（U+xxxx）。
UTF-8 是把这些编号按照规则打包成字节流的“打包格式”。

除了 UTF-8，Unicode 还定义了其他几种打包格式：

UTF-16（每个码点用 2 或 4 字节）
UTF-32（每个码点固定用 4 字节）

所以，UTF-8 是实现 Unicode 字符集的三种主要编码之一，而不是 Unicode 本身。

7.什么是左值引用？什么是右值引用？区别在哪

在 C++ 中，“引用”（reference）就是一个别名——它让你可以给一个已存在的对象取一个新名字。C++11 在原有“左值引用”（lvalue reference）的基础上，又引入了“右值引用”（rvalue reference），它们最大的区别就在于绑定对象类别不同，以及由此衍生出的语义用途也不一样：

一、左值引用（lvalue reference）

语法：T&
绑定规则：只能绑定到左值（lvalue），也就是具有持久存储、可取地址、有名字或能出现在赋值语句左边的表达式。
典型用途：
- 传参用来修改调用者的变量：

二、右值引用（rvalue reference）

语法：T&&
绑定规则：只能绑定到右值（rvalue），也就是临时对象、字面常量（如 20）、或 std::move(a) 之后返回的“可移动”对象。
典型用途：
- 实现移动语义（move semantics）：在拷贝代价昂贵的类型（如 std::vector）上，把资源（内存、文件句柄等）“偷走”而不是复制。
- 完美转发（perfect forwarding）：模板里用 T&& 接受任意值类别，再把它原样转发给另一个函数。

小结

左值引用 T&：给已有、持久的左值对象取别名，可以修改它。
右值引用 T&&：专门用来绑定右值（临时或可移动对象），核心在于移动语义与完美转发，让资源管理更高效。

8.什么是完美转发？

“完美转发”（Perfect Forwarding）是 C++11 引入的一种技术，允许函数模板把参数“完完全全”、“原封不动”地转发给另一个函数——既保持左值／右值的语义，也保留 const/volatile 限定。它的核心要素是：

当模板参数 T 用于 T&& 时，参数 arg 会根据调用时传入的是左值还是右值推导出不同类型：
- 传入左值：T 推导为引用类型（如 int&），此时 T&& 变成 int& &&，根据引用合成规则折叠为 int&。
- 传入右值：T 推导为非引用类型（如 int），此时 T&& 即 int&&。
std::forward
通过 std::forward<T>(arg)，编译器会根据 T 的类型决定是把 arg 当作左值传递，还是把它当作右值移动传递。

为什么需要完美转发？

避免不必要的拷贝／移动：传统地将所有参数都当作左值或右值传递，可能引发多余的拷贝或移动。
保留调用者本意：如果调用者传入的是右值（临时对象），你往往希望把它当作右值“移动”进去；如果传入的是左值，就应当保持左值语义。
通用代码库：在编写通用的模板库（比如工厂函数、容器、算法等）时，完美转发可让内部调用尽可能高效、语义正确。

小结

函数模板参数 用 T&& 来接收任意值类别的实参。
调用时 用 std::forward<T>(arg) 保持实参的左值／右值属性。
结果：被包装的函数（如 process）就能针对左值或右值各自优化或重载，达成“完美”转发。

9.什么是同一个作用域？

在 C++ 中，**作用域（scope）**就是一个名字（变量名、函数名、类型名……）被引入并且有效的区域。简单来说，作用域决定了“在哪儿可以访问这个名字”。

常见的几种作用域

全局作用域（global scope）
在所有函数和命名空间外部定义的名字，就属于全局作用域；从它被定义的点起，到整个程序结束，都可以访问。
命名空间作用域（namespace scope）
在某个 namespace { … } 块里定义的名字，只在该命名空间内可见（当然也可以用 using 或显式命名空间限定来访问）。
类作用域（class scope）
在类（或结构体）内部定义的成员函数、成员变量，都只在该类的内部或通过该类的对象/指针访问时可见。
函数作用域（function scope）
函数内部定义的名字（例如参数名、局部变量名），只在函数体内有效。
块作用域（block scope）
任何一对大括号 { … }（比如 if (...) { … }、for (…) { … }）内部定义的名字，只在这一对大括号内可见。

“同一个作用域” 是什么意思？

两个名字如果是在同一对大括号（或同一个命名空间块）里声明的，就说它们处于“同一个作用域”。

如果你把两个函数的声明都写在全局最外层（或同一个 namespace 块里），它们就在同一个作用域，可以进行重载。
如果一个函数声明在全局作用域，另一个在某个命名空间里，它们不在同一个作用域；必须用 namespace::func 才能引用。

小结

作用域由花括号 {} 或 namespace … {} 划定。
“同一个作用域”即“同一对 {} 或同一 namespace 块”内。
只有在同一个作用域中声明的名字，才互相可见、可重载（或隐藏）。

10.什么是全局作用域

在 C++ 中，全局作用域（Global Scope） 指的是在任何函数、类或命名空间之外的那块最外层区域。在全局作用域中声明的变量、函数或类型，具有以下特点：

可见性
- 在同一翻译单元（单个 .cpp 文件）里，任何地方（只要不被更内层作用域屏蔽）都能访问全局作用域中的名字。
- 如果在其他翻译单元里想使用，需要配合 extern 声明或把它放到头文件里并正确链接。
生命周期
- 全局变量从程序启动时就被分配，直到程序结束时才释放，生命周期覆盖整个程序执行期。
- 全局函数和类型自然“存在”于整个程序里，随时可被调用或实例化。
上面 g_counter、greetGlobal()、Person 都定义在全局作用域，所以无论在 main() 里，还是在其他非成员函数里，都可以直接访问它们。

总结：

全局作用域是程序中最外层的区域，放在这里的声明，对整个翻译单元（甚至多个翻译单元，经 extern）都是可见的，并且其生命周期与程序同长。

与之相对的局部作用域则只在小范围内可见且生存期有限。使用全局作用域时要谨慎，最好借助命名空间或文件作用域去控制可见性，避免命名冲突。

11.除了main()前面的这一块属于全局作用域，其他的任何.h或者是.cpp文件中只要在任何函数、类或命名空间之外的那块最外层区域都属于全局作用域？

对，全局作用域并不局限于 main() 前面那几行，而是指在任何源文件（.cpp）或头文件（.h）里，只要该声明或定义写在：

任意函数（包括 main）之外
任意类 或结构体之外
任意命名空间（显式的 namespace XXX { … }）之外的顶层位置（也叫文件作用域／file scope），它就属于全局作用域，也就是全局命名空间（global namespace）。

g_value、foo()、main() 都是在全局作用域中声明／定义的。
Utils::helper() 在显式命名空间里，不属于全局作用域。
internalVar 虽然也是顶层声明，但因为加了 static，它的链接性（linkage）被限制在本 .cpp 文件；它仍然是文件作用域。
namespace { … }（unnamed namespace）里声明的名字也只在本文件可见，但依然是顶层作用域。

小结

“文件作用域”＝顶层作用域＝全局作用域，只要不在任何函数、类或（显式）命名空间内部。
放在头文件或源文件的最外层部分，都算全局作用域。

12.黑箱白箱/黑盒白盒

“黑箱”原本是控制论和系统工程里的术语，用在编程里也是类似的意思：把一个功能模块（比如一个函数、一个类或一个库）当成“黑箱”使用，意味着：

不关心内部实现
- 你只知道它的输入是什么、输出是什么，而不需要了解它内部是如何一步步运算、做分支、管理内存的。
- 这样做可以减少认知负担，让你专注在整体架构和流程上。
只看接口
- “黑箱”对外暴露的就是函数签名（参数列表和返回类型）、文档里描述的行为和副作用（比如修改了哪些状态、是否会抛异常）。
- 调用者只要按照接口传入正确参数，就能得到正确结果。
好处：封装与复用
- 封装：隐藏细节，内部可以随时优化或改写，只要保证接口兼容，调用它的代码不用修改。
- 复用：当你习惯把某段逻辑封装成黑箱后，下次直接调用，避免重复造轮子。

相对的，如果你打开这个“黑箱”——阅读甚至修改它的源码，理解其每行细节，就叫做“白箱”（White-box）或“透明箱”式使用。黑箱思想是软件工程里常用的抽象与封装原则，有助于降低系统复杂度。

为什么两套说法都存在？
- “箱”字稍显抽象，更常用在“黑箱操作”“黑箱算法”等泛化场景；
- “盒”字则沿自“Black-box”直译，更常见于“黑盒测试/白盒测试”这类标准术语中。
实际工程中怎么选？
- 提到测试时，建议用 黑盒测试/白盒测试；
- 要表达“内部实现全然不露”的系统或组件，写成 黑箱系统/黑箱模型 更自然。

总之，四个词汇指向的是同一对立概念，只是“盒”“箱”二字在不同语境下的偏好而已。

核心概念提问

函数提高

1. 什么是重载？

在 C++ 中，“重载”（Overloading）指的是在同一作用域内，同名的函数或运算符可以根据参数类型或参数个数的不同，绑定到不同的实现上。编译器在看到调用时，会根据传入实参的类型和数量，选择最合适的那个版本。

一、重载函数/函数重载（Function Overloading）

定义
同一个作用域里，允许多个同名函数只要它们的参数列表（类型、顺序、个数或顶层 const/引用修饰）不同，就构成重载。
规则
- 重载函数的 返回类型 可以相同，也可以不同；但不能仅凭返回类型来区分重载。
- 参数列表必须至少在一个参数的类型、顺序或个数上与其他重载版本有所区别。
- 默认参数会参与匹配，但可能导致二义；一般尽量避免让默认参数引起调用歧义。

示例：

// 版本 ①：两个 int 相加
int add(int a, int b) {
    return a + b;
}

// 版本 ②：两个 double 相加
double add(double a, double b) {
    return a + b;
}

// 版本 ③：三个 int 相加
int add(int a, int b, int c) {
    return a + b + c;
}

// 使用
int  i = add(1, 2);        // 调用①
double d = add(1.2, 3.4);  // 调用②
int  j = add(1, 2, 3);     // 调用③

二、运算符重载（Operator Overloading）

定义
通过给类提供特别的成员函数或全局函数，让内置运算符（如 +, -, [], ()）作用于自定义类型时也能表现出自然语义。

语法

// 作为成员函数
ReturnType operatorOpSymbol(参数列表) { /*…*/ }

// 或者作为全局（非成员）函数
ReturnType operatorOpSymbol(LeftType lhs, RightType rhs) { /*…*/ }

示例

struct Point {
    int x, y;
    Point(int x, int y): x(x), y(y) {}

    // 重载 “+” 运算符，绑定到成员函数
    Point operator+(const Point& rhs) const {
        return Point(x + rhs.x, y + rhs.y);
    }

    // 重载 “==” 运算符，绑定到全局函数
    friend bool operator==(const Point& a, const Point& b) {
        return a.x == b.x && a.y == b.y;
    }
};

// 使用
Point p1(1,2), p2(3,4);
Point sum = p1 + p2;         // 调用 operator+
bool eq  = (p1 == p2);       // 调用 operator==

三、为什么要重载？

接口统一
同一个功能（比如 “加法”）对不同类型或不同参数个数，用同一个名字就能搞定，调用处更直观。
可读性强
例如 a + b 比 add(a, b) 更像数学表达式，代码自然易懂。
可维护性
当新增一种类型或参数变化时，只需要添加一个重载版本，无需修改调用处。

四、注意事项

不要过度重载，以免让调用者难以判断到底执行哪个版本；
避免二义调用，尤其在存在默认参数和类型隐式转换时；
不要仅靠返回类型重载，编译器无法区分；
运算符重载要遵循“自然语义”：别让 + 做“删除”操作，否则容易造成使用混淆。

通过函数重载和运算符重载，C++ 实现了编译时多态，让同一个接口在不同上下文下“表现不同”，提高了语言的灵活性和可读性。

2. 重载函数里面的代码可以不一样吗？

可以的，从语法和编译器的角度来看，重载函数的各个版本只要签名（参数列表）不冲突，函数体里做什么事情都是你自己的自由。把其中一个版本的实现改成乘法操作是完全合法的：

注意事项

语义一致性
虽然编译器允许你这样做，但如果把名为 add 的函数改为做乘法，调用者就会感到困惑——建议保持函数名和实现逻辑的一致性，或者给乘法版本取个更恰当的名字（比如 mul）。
重载解析
重载解析只关心函数名和参数列表（签名），绝不看函数体。因此修改 return a + b → return a * b 不会影响编译器如何选择调用哪个版本。

问：是不是函数的参数列表不冲突就行，多了也可以，比如一个有int a,另一个是int a, b ,c

对，只要重载函数的“形参列表”互不冲突，编译器就能区分它们，无论是参数个数不同，还是参数类型不同，都可以构成重载。参数的名字并不影响重载，只看：

参数个数
参数类型（包括引用／指针、顶层 const／volatile）
参数顺序

例如，你可以这样写：

需要注意的地方

返回类型不参与重载：你不能仅靠改变返回值类型来重载。
默认参数可能引起二义：如果两个重载版本通过默认值能够互相匹配，就会变得模糊不清，编译器会报二义调用错误。

3.示例中函数重载，如果把func(10)改为func(int a)会报错吗？

封装

1. 在封装类中使用void setName(std::string name)，void setID(int StudentID)，和我直接在类中直接使用std::string name和int StudentID有什么区别？

1. 封装／信息隐藏

用 setName()、setID()
这些方法是类对外暴露的“接口”。类的内部（包括成员名字、类型、将来如何存储名字、ID）对使用者是隐藏的。如果你以后要
- 在设置名字时做长度检查、过滤敏感字符
- 或者把名字改成 wstring、ID 从 int 改成 long long
  你只需要改 setName()、setID() 的实现，调用者的代码不用改。
直接用公有成员
任何地方都可以直接写入、读出，完全没法在写入前或写入后做校验或额外操作，也没法在以后悄悄地更改成员类型或内部存储而不影响外部代码。

解释：

3. 日志、线程安全、二次加工

日志：你可以在 setName() 里顺便打个日志，或通知 UI 刷新。
锁（mutex）：多线程环境下，加一把锁也只要在这两个方法里做。

如果直接给成员设为公有，这些额外动作就无法集中管理。

4. 接口稳定性

把成员暴露出去，一旦它的名字或类型变了，所有直接访问它的代码都要改——极不利于后期维护。通过 setXXX()／getXXX()，你至少保留了“方法名”这个不变的接口层。

小结

Setter/Getter 方法：✔ 良好封装、✔ 可控可验证、✔ 未来易扩展／重构
公有成员直接访问：✘ 无校验、✘ 内外耦合、✘ 维护困难

因此，推荐把成员变量设为 private，把真正对外的读写操作都放到 setXXX()/getXXX() 里。这样你的类才是真正符合面向对象设计原则的“黑盒”──使用者只能通过你提供的接口跟它打交道。

2. 访问权限：public,protected,private这三个都是围绕类来展开的吗，但是如果在全局作用域下面写这三个是不是就没有什么区别了？

是的，public、protected、private 这三大访问说明符只在 类（class/struct/union）内部 有意义，用来控制成员对外的可见性／可访问性。

为什么全局作用域下写它们没用（甚至会报错）

在命名空间（包括全局命名空间）或者函数外的顶层作用域，根本不存在「成员」的概念，只有自由（free）函数和全局变量。
C++ 标准并没有规定在类定义之外允许写访问说明符，绝大多数编译器都会直接报：

vbnet

error: access specifier ‘public’ not allowed here

即使极端情况下某些编译器仅把它当成“标签”（类似 goto 标签），也对访问权限一丁点影响都没有——它不会拦截谁能访问哪个符号。

全局／命名空间作用域下的可见性控制

默认：全局函数和全局变量都是 外部链接（external linkage），任意翻译单元都能看到。
想限制“只在本文件可见”，要用
- static 关键字（C 风格）
- 或者更现代的 匿名命名空间：

cpp

namespace {

void helper() { /* ... */ } // helper 只在本 .cpp 文件可见

}

公有／私有／保护这些概念，只在继承、对象封装、成员访问 的场景下才派得上用场。

小结：

public/protected/private 只能写在类／结构体／联合体的定义体内部，控制类的成员的访问。
在全局（命名空间）作用域下写它们，要么编译错，要么被当成无意义的标签，并不会限制任何东西。
若要在全局层面隐藏符号，用 static 或匿名命名空间来管理可见性。

C++进阶概念

1.什么是序列化？

Thought for a few seconds

序列化（Serialization）指的是将程序运行时内存中的数据结构或对象，转换成可存储或传输的格式（如二进制流、JSON、XML 等）的过程；与之相对的“反序列化”（Deserialization）则是把这些存储／传输格式还原回原始的数据结构或对象。

1. 为什么要序列化？

持久化存储：将对象状态保存到硬盘（文件、数据库），下次运行时读取还原。
网络传输：在不同机器或进程间传输对象，需要把内存结构打包成字节流。
跨语言／跨平台：不同语言或平台间交换数据，通过标准格式（JSON、Protocol Buffers）保证兼容。

小结

序列化 = 对象 → 字节流／文本
反序列化 = 字节流／文本 → 对象
选择合适的格式和库，既能保证性能，也能兼顾可维护性和跨平台兼容。

2.C++11 到 C++20 各版本的主要差异

建议：

从 C++11 的核心特性（lambda、移动语义、智能指针）入手；
依次学习 C++14/17 的增强；
最后重点掌握 C++20 的 Concepts、Ranges 和协程，这些是现代高质量库和框架（如 ranges-v3、asio）的基石。

3.C++ STL 容器（Container）概述

序列式容器 Sequence Containers
- std::vector：动态数组，连续内存，随机访问高效。
- std::deque：双端队列，支持头尾高效插入／删除。
- std::list：双向链表，中间插入／删除高效，但不支持随机访问。
- std::array<T,N>：定长数组，编译期大小，栈上分配。
关联式容器 Associative Containers
- std::set / std::multiset：基于红黑树的有序集合，元素唯一（或可重复）。
- std::map / std::multimap：基于红黑树的有序键值对映射。
无序关联容器 Unordered Containers
- std::unordered_set、std::unordered_map：基于哈希表，平均常数时间查找。
容器适配器 Container Adapters
- std::stack：默认基于 deque 或 vector，只允许栈操作（LIFO）。
- std::queue：队列（FIFO）。
- std::priority_queue：优先级队列（最大堆或最小堆）。
算法与迭代器
- <algorithm> 提供 sort、find、transform、accumulate 等通用算法，可与任何符合迭代器要求的容器配合使用。

4.构造函数（Constructor）与析构函数（Destructor）

构造函数（Constructor）

作用：在对象创建时初始化成员、分配资源。
类型：
- 默认构造 MyClass() { … }
- 参数化构造 MyClass(int x, std::string s) { … }
- 拷贝构造 MyClass(const MyClass& other)
- 移动构造 MyClass(MyClass&& other)（C++11）
- 委托构造（一个构造函数调用另一个）
初始化列表：在冒号后初始化成员，比在函数体中赋值更高效。

析构函数（Destructor）

作用：在对象生命周期结束时释放资源（delete、文件句柄、网络连接等）。
语法：~MyClass() { … }，无参数，无返回值，不可重载或带参数。
自动调用时机：
- 对象离开作用域时（栈对象）。
- delete 一个 new 出来的对象时。
- 智能指针析构时（unique_ptr/shared_ptr 引用计数为 0）。

5.构建工具：CMake的作用是什么

CMake 是一个跨平台的开源构建系统生成器，其核心作用包括：

生成平台／编译器无关的构建脚本
- 在不同操作系统（Windows、Linux、macOS）和不同编译器（MSVC、GCC、Clang）之间，只需编写一套 CMakeLists.txt，CMake 就能生成对应平台下的原生工程文件（如 Visual Studio solution、Makefile、Xcode 工程等）。
统一管理项目结构与依赖
- 通过 find_package()、find_library()、find_path() 等指令搜索并配置第三方库和头文件路径。
- 使用 target_link_libraries()、target_include_directories() 等命令将依赖显式关联到目标（可执行文件或库）。
简化多模块／多平台编译流程
- 支持按目录递归添加子项目（add_subdirectory()），轻松组织大型工程。
- 提供配置选项（option()）和变量缓存，方便打开／关闭不同功能（如启用测试、启用优化、切换后端库）。
自动化生成安装与打包规则
- 内置 install() 命令可自动生成安装脚本，把编译产物、头文件和资源拷贝到指定目录结构。
- 配合 CPack，可进一步自动创建 .zip、.tar.gz、.deb、.rpm、.msi 等打包文件。
支持编译器特性检测与条件编译
- 通过 check_cxx_compiler_flag()、check_symbol_exists() 等检测目标编译器／平台支持哪些语言特性和库函数，动态设置编译选项或启用兼容性补丁。

6.for (int k = 0; k < N; ++k) { cout << arr[k] << ' '; } cout << endl;和 for (int k = 0; k < N; ++k) { cout << arr[k] << ' '<<endl; } 有什么区别？

总结：

如果想把数组元素都打印在一行，用写法 A，把 endl 放在循环外。
如果要每打印一个元素就换行，用写法 B，把 endl 放在循环内。
尽量少用 endl，必要时用 '\n' 替代（'\n' 只是换行，不刷新缓冲区），以提高性能。

7.冒泡排序中，两层for中的原理（即外层for和里层for）

1. 外层 for (int i = 0; i < N-1; ++i)

控制“趟数”：每一趟都要把当前「未排序部分」里最大的元素“冒”到它该去的尾部位置。
共需要做 N-1 趟才能保证整个数组有序——最后一趟剩下两个元素比完就一定对了。

经过第 i 趟冒泡之后，数组的末尾 i+1 个元素已经是最终排好序的最大元素了，所以下一趟就不必再碰它们。

2. 内层 for (int j = 0; j < N-i-1; ++j)

遍历未排序区域：下标从 0 比到 N-i-2，每次比较 arr[j] 和 arr[j+1]。
交换逻辑：如果前面的元素更大，就和后面的交换——这样「大」的元素就往右跑了一格。
这一趟跑完以后，最大的那个元素就会“冒泡”到 N-i-1 这个位置。

举个小例子

假设 arr = {5, 2, 7, 3}，N=4：

第 0 趟（i=0），j 从 0 到 2：
1. 比较 (5,2) → 交换 → {2,5,7,3}
2. 比较 (5,7) → 不交换 → {2,5,7,3}
3. 比较 (7,3) → 交换 → {2,5,3,7}
  ⇒ 最大的 7 跑到末尾（索引 3）。
第 1 趟（i=1），j 从 0 到 1（N-i-1=2）：
1. 比较 (2,5) → 不交换 → {2,5,3,7}
2. 比较 (5,3) → 交换 → {2,3,5,7}
  ⇒ 第二大的 5 跑到索引 2。
第 2 趟（i=2），j 只到 0（N-i-1=1）：
1. 比较 (2,3) → 不交换 → {2,3,5,7}
  ⇒ 剩下的也都在正确位置。

这样三趟过后（N-1 = 3），整个数组就变成 {2,3,5,7}，排序完成。

小结

外层控制「要做几趟冒泡」，每做完一趟，未排序区域就少一个元素。
内层在每趟里「不断比较—交换」，把当前未排序区里的最大值一步步推到右边。

这种「一趟确定一个最大值、总共做 N-1 趟」的思路，就是冒泡排序的精髓。

8.C++中一维数组和二维数组的介绍

下面从定义语法、内存布局、初始化与访问以及动态／STL 方式四个方面，分别介绍一维数组和二维数组。

原生静态

STL

小结

一维数组：T a[N]，连续内存，随下标或指针算术访问。
二维数组：T a[M][N]，也是连续内存（行主序），可用 a[i][j] 或指针算术 *(*(a+i)+j)。
动态需求：推荐用 std::vector 或手动 new + 扁平化方案，更灵活也可控制内存布局。

9.使用STL容器表达二维数组（推荐）

你可以先把一维数组包装成一个 std::vector<int>，然后按行切分成若干个 std::vector<int>，最后收集到一个二维 std::vector<std::vector<int>>。下面给出两种常见写法：

10.什么是C++的多态？

C++ 的多态（Polymorphism）指同一个接口在不同上下文下、表现出不同行为的能力。通俗地说，就是“同样的操作作用于不同的对象，可以产生不同的效果”。

一、多态的两大分类

类型	特点	实现机制
编译时多态	在编译阶段就能确定调用哪个函数；也称为静态多态（Static Polymorphism）	- 函数重载 - 运算符重载 - 模板（泛型编程）
运行时多态	在运行时根据对象的实际类型选择调用；也称为动态多态（Dynamic Polymorphism）	- 虚函数（virtual）与虚表（vtable）

1. 函数重载（Function Overloading）

#include <iostream>

int add(int a, int b) {
    return a + b;
}

double add(double a, double b) {
    return a + b;
}

int main() {
    std::cout << add(1, 2)      << "\n";  // 调用 add(int,int)
    std::cout << add(1.5, 2.3)  << "\n";  // 调用 add(double,double)
    return 0;
}

2. 运算符重载（Operator Overloading）

#include <iostream>

struct Point {
    int x, y;
    Point(int x,int y):x(x),y(y){}
    // 重载 “+” 运算符，使 Point 相加语义更自然
    Point operator+(const Point& rhs) const {
        return Point(x + rhs.x, y + rhs.y);
    }
};

int main() {
    Point p1(1,2), p2(3,4);
    Point sum = p1 + p2;  // 等价于 p1.operator+(p2)
    std::cout << sum.x << "," << sum.y << "\n";  // 输出 4,6
    return 0;
}

3. 模板（Template）

#include <iostream>

// 泛型函数模板：支持任意加法操作
template<typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    std::cout << add<int>(1, 2)       << "\n";  // 3
    std::cout << add<double>(1.1, 2.2) << "\n";  // 3.3
    return 0;
}

三、运行时多态示例

1. 基类和派生类 + 虚函数

#include <iostream>

// 抽象基类（也可不纯抽象）
class Shape {
public:
    virtual ~Shape() {}                // 虚析构保证派生类资源正确释放
    virtual void draw() const {        // 虚函数：允许派生类重写
        std::cout << "Drawing Shape\n";
    }
};

class Circle : public Shape {
public:
    void draw() const override {       // override 可选，但推荐标明重写意图
        std::cout << "Drawing Circle\n";
    }
};

class Square : public Shape {
public:
    void draw() const override {
        std::cout << "Drawing Square\n";
    }
};

int main() {
    Shape* s1 = new Circle;
    Shape* s2 = new Square;

    s1->draw();  // 运行时根据实际类型调用 Circle::draw
    s2->draw();  // 运行时根据实际类型调用 Square::draw

    delete s1;
    delete s2;
    return 0;
}

原理：每个含虚函数的类都有一张“虚表”（vtable），对象创建时携带一张指向该表的指针（vptr）；运行时通过 vptr 找到对应函数地址并调用。

四、为什么要用多态