#创作计划# 从零开始复习C++ 第一章
2025-08-30 17:17:05
发布于：浙江
49阅读
0回复
0点赞
从零开始复习 C++ 第一章
持续更新的哦
目录:
- 一. C++ 语言简介
- 二. 基础知识
-
- 前情提要
-
- 必背内容
-
- 输入输出
-
- 数据类型
-
- 运算符
-
- 列表
-
- 队列&栈
-
- 常用字符的ASCII码 & 十，二，八，十六进制中相等数字的不同表示方式
-
一. C++ 语言简介（可跳过，略读）
C++ 是一种通用、高效、静态类型的编程语言，由丹麦计算机科学家 Bjarne Stroustrup 于 1979 年在贝尔实验室开始设计，最初命名为 “C with Classes”（带类的 C 语言），1983 年正式更名为 C++（“++” 是 C 语言中的自增运算符，象征对 C 语言的扩展）。
1. 核心定位：C 语言的超集与面向对象扩展
C++ 的核心设计目标是兼容 C 语言的高效性与底层访问能力，同时引入面向对象编程（OOP） 特性，解决大型复杂程序的模块化、可维护性问题：
- 兼容 C 语言：绝大多数 C 代码可直接在 C++ 环境中编译运行，支持指针、内存直接操作（如 malloc/free）、底层硬件访问，保留了 C 语言 “接近硬件、运行高效” 的优势。
- 扩展面向对象：新增类（class）、对象、继承、多态、封装等 OOP 核心特性，让代码更易组织、复用和扩展（例如用 class 定义 “学生”“汽车” 等抽象实体，通过继承实现特性复用）。
2. 关键特性：不止于面向对象
随着标准迭代（如 C++98、C++11、C++17、C++20），C++ 不断丰富功能，形成 “多范式编程语言” 的特点，支持多种编程风格：
- 面向对象编程（OOP）：通过类和对象封装数据与行为，通过继承扩展类，通过虚函数实现多态。
- 泛型编程：通过模板（template）实现 “代码复用不依赖具体类型”，例如 C++ 标准库中的 vector（动态数组）、map（键值对容器），可适配 int、string 等任意类型。
- 函数式编程元素：C++11 后引入 lambda 表达式、std::function 等，支持函数作为参数传递，简化复杂逻辑（如算法中的自定义比较规则）。
- 高效性能：无垃圾回收（GC）机制，内存由程序员手动管理（或通过智能指针 unique_ptr/shared_ptr 自动管理），避免 GC 带来的性能开销，适合对速度、内存占用敏感的场景。
3. 应用领域：哪里在用 C++？
C++ 因 “高效性 + 灵活性” 的特点，长期活跃在对性能、底层控制要求高的领域：
- 系统开发：操作系统内核（如 Windows、Linux 部分模块）、驱动程序、嵌入式系统（如单片机、物联网设备）。
- 高性能软件：数据库（MySQL、PostgreSQL 核心模块）、游戏引擎（Unity 部分模块、Unreal Engine 核心）、图形渲染引擎（如 OpenGL/Vulkan 绑定）。
- 科学与工程计算：数值模拟、气象预测、量子计算等需要海量数据高速处理的场景。
- 工业软件：自动驾驶控制系统、航空航天导航软件、工业机器人编程等对实时性和稳定性要求极高的领域。
4. 标准与生态：持续迭代的语言
C++ 由 ISO/IEC（国际标准化组织) 制定标准，重要版本包括：
- C++98：第一个正式国际标准，奠定 OOP 基础。
- C++11：里程碑版本，新增 lambda、智能指针、auto 类型推导等，大幅提升开发效率。
- C++17 / C++20：新增模块化（解决头文件依赖问题）、协程、concepts（模板约束）等，进一步优化大型项目开发体验。
其核心生态是 C++ 标准库（STL），包含容器（vector/map）、算法（sort/find）、输入输出（iostream）等，避免重复造轮子，是 C++ 开发的基础工具。
总结
C++ 的核心优势是 “高效性与灵活性的平衡”—— 既保留底层访问能力，又支持复杂程序的模块化设计，因此在需要 “高性能 + 大规模” 的领域（如系统、游戏、科学计算）至今无法被替代，是计算机科学领域的基础且重要的编程语言。
二. 基础知识
0. 前情提要：
在写C++代码时，一定得在每行代码后面加上; ，但是有例外，比如 #include<bits/stdc++.h> 和 int main(){}，这些后面不用写。
1. 必背内容：
首先写C++代码时，必须要写头文件，我一般喜欢用万能头文件，如下：
#include<bits/stdc++.h>//万能头文件
using namespace std;//命名空间
int main(){
return 0;//可写可不写，但尽量养成写return的习惯哦
}
那么命名空间是干什么的呢?
举个栗子吧:
(某受害例题)
- 写了 命名空间 的代码：
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin >> a >> b;
cout << a + b;
return 0;
}
- 没写 命名空间 的代码：
#include<bits/stdc++.h>
int main(){
int a,b;
std::cin >> a >> b;
std::cout << a + b;
return 0;
}
（试过了都能AC）
我相信细心地人已经发现了，没写命名空间的代码在cin(输入)，cout(输出)的前面加上了std::，这样才能运行成功。
2. 输入输出：
简单的常用的输入输出：
cin; //输入
cout; //输出
它的格式为：
cin >> x; //输入x
cout << x; //输出x
（当然 x 需要提前定义，怎么定义后面会讲）
当然除了简单的也有不简单的：
scanf(); //输入
printf(); //输出
它的格式为：
scanf("%d",x); //输入整型的 x
printf("%d",x); //输出整型的 x
（当然 x 需要提前定义，怎么定义后面会讲；还有 输入输出 中 "" 中写的内容可以写其他很多的，它定义了输入的）
还有一些“冷门”的：
getline(cin); //保留空格的输入(x必须为string类型）
cin.get(); //仅输入一个字符（x必须为char类型）
cin.getline(); //读取一行字符到字符数组中，包括空格，直到遇到换行符或达到最大字符数。(x必须为char类型的数组）
fgets(x, 3, stdin); //读取一行字符到字符数组中，包括空格，直到遇到换行符或达到最大字符数（x必须为char类型的数组）
它的格式为：
getline(cin,x); //保留空格的输入(x必须为string类型）
cin.get(x); //仅输入一个字符（x必须为char类型）
cin.getline(x,2); //读取一行字符到字符数组中，包括空格，直到遇到换行符或达到最大字符数。(x必须为char类型的数组）
//这一行指输入一行，直到遇到换行符或达到最大字符，比如输入 1234 5，输出只会有 1 一个字符（还有一个字符——终止符'\0'）
fgets(x, 3, stdin); //读取一行字符到字符数组中，包括空格，直到遇到换行符或达到最大字符数（x必须为char类型的数组）（与cin.getline很像）
//这一行指输入一行，直到遇到换行符或达到最大字符，比如输入 1234 5，输出只会有 1 一个字符（还有一个字符——终止符'\0'）
（当然 x 需要提前定义，怎么定义后面会讲）
还有很多种输入输出，可以上网查一查，问问AI（可以看看我（也不一定全））
3. 数据类型：
常用的标注了"※"，不常用的标注了"/"
| 是否常用 | 数据类型名称 | 描述 | 范围 |
|---|---|---|---|
| ※ | int | 基本整数类型，通常占 4 字节（32 位），用于存储整数值 | -2147483648 到 2147483647 |
| / | short | 短整数类型，通常占 2 字节（16 位），适用于较小范围的整数 | -32768 到 32767 |
| / | long | 长整数类型，通常占 4 字节（32 位）或 8 字节（64 位，依系统而定） | 32 位：-2147483648 到 2147483647；64 位：-9223372036854775808 到 9223372036854775807 |
| ※ | long long | 超长整数类型，通常占 8 字节（64 位），用于存储大范围整数 | -9223372036854775808 到 9223372036854775807 |
| / | unsigned int | 无符号整数类型，通常占 4 字节，仅存储非负整数 | 0 到 4294967295 |
| / | unsigned short | 无符号短整数，通常占 2 字节，仅存储非负小整数 | 0 到 65535 |
| / | unsigned long | 无符号长整数，通常占 4 字节或 8 字节，仅存储非负长整数 | 32 位：0 到 4294967295；64 位：0 到 18446744073709551615 |
| / | unsigned long long | 无符号超长整数，通常占 8 字节，仅存储非负超大整数 | 0 到 18446744073709551615 |
| ※ | float | 单精度浮点数，占 4 字节，用于存储小数，精度较低 | 约 ±3.4×10³⁸，有效数字 6-7 位 |
| ※ | double | 双精度浮点数，占 8 字节，精度高于 float，默认浮点类型 | 约 ±1.7×10³⁰⁸，有效数字 15-17 位 |
| / | long double | 扩展精度浮点数，占 8/10/16 字节（依系统而定），精度更高 | 精度和范围不低于 double |
| ※ | char | 字符类型，占 1 字节，存储单个字符或小整数（有符号性依编译器而定） | 有符号：-128 到 127；无符号：0 到 255 |
| / | unsigned char | 无符号字符类型，占 1 字节，存储非负字符或小整数 | 0 到 255 |
| / | signed char | 有符号字符类型，占 1 字节，存储带符号的字符或小整数 | -128 到 127 |
| ※ | bool | 布尔类型，存储逻辑值 | true（通常为 1）或 false（通常为 0） |
定义方式：数据类型名称 变量名
举几个栗子：
int a;double b;bool c;
typedef 声明:
您可以使用 typedef 为一个已有的类型取一个新的名字。下面是使用 typedef 定义一个新类型的语法：
例如，下面的语句会告诉编译器，LL 是 long long 的另一个名称：
typedef long long LL;
那下面的定义就是合法的
LL a;//定义一个长整型
#define （与typedef可以说一模一样）声明:
您可以使用 #define 为一个已有的类型取一个新的名字。下面是使用 define 定义一个新类型的语法：
例如，下面的语句会告诉编译器，LD 是 long double 的另一个名称：
#define LD long double
那下面的定义就是合法的
LD b;//定义一个长双精度浮点型
4. 运算符：
还有很多种输入输出，可以上网查一查，问问AI（可以看看我（也不一定全））
| 操作符 | 描述 | 栗子 | 返回值 |
|---|---|---|---|
| + | 返回第一个操作数加上第二个操作数的和 | 1 + 1 | 2 |
| - | 返回第一个操作数减去第二个操作数的差 | 2 - 1 | 1 |
| * | 返回第一个操作数乘以第二个操作数的积 | 2 * 2 | 4 |
| / | 返回第一个操作数除以第二个操作数的商 | 4 / 2 | 2 |
| % | 返回第一个操作数除以第二个操作数的余数（） | 5 % 2 | 1 |
| ++（后缀） | 将此数自增（先使用后+1） | x = 4; x++ | 表达式返回4，x最终为5 |
| ++（前缀） | 将此数自增（先+1后使用） | x = 4; ++x | 表达式返回5，x最终为5 |
| --（后缀） | 将此数自减（先使用后-1） | x = 4; x-- | 表达式返回4，x最终为3 |
| --（前缀） | 将此数自减（先-1后使用） | x = 4; --x | 表达式返回3，x最终为3 |
| == | 判断两个值是否相等（等于返回true；否则返回false） | 1 == 1 | true |
| > | 判断第一个值是否大于第二个值（大于返回true；否则返回false） | 1 > 2 | false |
| < | 判断第一个值是否小于第二个值（小于返回true；否则返回false） | 1 < 2 | true |
| >= | 判断第一个值是否大于等于第二个值（大于等于返回true；否则返回false） | 1 >= 1 | true |
| <= | 判断第一个值是否小于等于第二个值（小于等于返回true；否则返回false） | 1 <= 2 | true |
| != | 判断第一个值是否不等于第二个值（不等于返回true；否则返回false） | 1 != 1 | false |
| && | 两个值都为true那么为true,否则为false（短路求值） | 1 == 1 && 2 == 3 | false |
| || | 两个值只要有一个值为true那么为true,否则为false（短路求值） | 1 == 1 || 2 == 3 | true |
| ! | 将true变为false，将false变为true | !(1 == 1) | false |
| = | 将第一个操作数赋值为第二个值 | int x = 0; x = 8 | x = 8 |
| += | 将第一个操作数赋值为第一个操作数加上第二个值的和（a += b 等价于 a = a + b） | int x = 1; x += 2 | x = 3 |
| -= | 将第一个操作数赋值为第一个操作数减去第二个值的差（a -= b 等价于 a = a - b） | int x = 2; x -= 1 | x = 1 |
| *= | 将第一个操作数赋值为第一个操作数乘第二个值的积（a *= b 等价于 a = a * b） | int x = 2; x *= 2 | x = 4 |
| /= | 将第一个操作数赋值为第一个操作数除以第二个值的商（a /= b 等价于 a = a / b） | int x = 4; x /= 2 | x = 2 |
| %= | 将第一个操作数赋值为第一个操作数除以第二个值的余数（a %= b 等价于 a = a % b） | int x = 4; x %= 3 | x = 1 |
| Condition ? X : Y | 条件运算符。如果 Condition 为真则值为 X，否则值为 Y | int x = (1 == 1 ? 2 : 4) | x = 2 |
| >> | 二进制右移运算符。将一个数的各二进制位右移若干位，正数左补0，负数左补1 | int x = 100; x = x >> 2 | x = 25 |
| << | 二进制左移运算符。将一个数的各二进制位左移若干位，右边补0 | int x = 100; x = x << 2 | x = 400 |
| & | 取地址运算符，返回变量的内存地址 | int a; &a | 变量a的内存地址（如0x7ffd2a3b4560） |
| * | 指针解引用运算符，获取指针指向的变量值 | int a=5, *p=&a; *p | 5 |
| . | 成员访问运算符，用于访问对象的成员 | struct S{int a;}; S s={3}; s.a | 3 |
| -> | 指针成员访问运算符，通过指针访问对象成员 | struct S{int a;}; S* p=&s; p->a | 3 |
| sizeof | 计算数据类型或变量的字节数 | sizeof(int) | 4（通常情况下） |
| ~ | 按位取反运算符，将二进制位0变1、1变0 | 5（二进制000...0101） | -6（补码表示） |
| ^ | 按位异或运算符，对应位不同则为1，相同则为0 | 3 ^ 5（011 ^ 101） | 6（110） |
| | | 按位或运算符，对应位有1则为1，否则为0 | 3 | 5（011 | 101） | 7（111） |
| , | 逗号运算符，按顺序执行表达式，返回最后一个结果 | int x=(2+3, 4*5); | x=20 |
| :: | 范围解析运算符，访问命名空间或类的成员 | std::cout | 输出流对象 |
5. 数组:
(1). 一维数组:
定义方式: 数据类型名称 数组名[长度]
举个栗子:
int a[100];//一维
(2). 二维数组:
定义方式: 数据类型名称 数组名[长度][长度]
举个栗子:
double b[100][100];//二维
(3). n维数组:
定义方式: 数据类型名称 数组名(n个)[长度]……[长度]
举个栗子:
string c[100][100][100];//三维
6. 单向队列&栈:
(1).单向队列：
单向队列基本常用操作：
| 函数 | 栗子 | 效果 |
|---|---|---|
| queue<数据类型> 队列名 | queue<int> a | 定义名叫 a 的 整型 队列 |
| 队列名.push(x) | a.push(1) | 将1加入名叫a的队列中 |
| 队列名.pop() | a.pop() | 删除a的队列的队首元素 |
| 队列名.front() | a.front() | 获取名叫a的队列的队首元素 |
| 队列名.back() | a.back() | 获取名叫a的队列的队尾元素 |
| 队列名.empty() | a.empty() | 检测名叫a的队列是否为空，为空返回true，不为空返回false |
| 队列名.size() | a.size() | 获取名叫a的队列的元素个数（长度） |
(2).栈：
栈基本常用操作：
| 函数 | 栗子 | 效果 |
|---|---|---|
| stack<数据类型> 栈名 | stack<int> a | 定义名叫 a 的 整型 栈 |
| 栈名.push(x) | a.push(1) | 将1加入名叫a的栈中 |
| 栈名.pop() | a.pop() | 删除a的栈顶元素 |
| 栈名.top() | a.top() | 获取名叫a的栈顶元素 |
| 栈名.empty() | a.empty() | 检测名叫a的栈是否为空，为空返回true，不为空返回false |
| 栈名.size() | a.size() | 获取名叫a的栈的元素个数（长度） |
7. 常用字符的ASCII码 & 十，二，八，十六进制中相等数字的不同表示方式:
(1). 常用字符的ASCII码 :
| 字符(char) | ASCII码 |
|---|---|
| 0 | 48 |
| 9 | 57 |
| a | 97 |
| z | 122 |
| A | 65 |
| Z | 90 |
| 空格 | 32 |
(2). 十，二，八，十六进制中相等数字的不同表示方式:
| 十进制 | 二进制 | 八进制 | 十六进制 |
|---|---|---|---|
| 1 | 1 | 1 | 1 |
| 2 | 10 | 2 | 2 |
| 3 | 11 | 3 | 3 |
| 4 | 100 | 4 | 4 |
| 5 | 101 | 5 | 5 |
| 6 | 110 | 6 | 6 |
| 7 | 111 | 7 | 7 |
| 8 | 1000 | 10 | 8 |
| 9 | 1001 | 11 | 9 |
| 10 | 1010 | 12 | A |
| 11 | 1011 | 13 | B |
| 12 | 1100 | 14 | C |
| 13 | 1101 | 15 | D |
| 14 | 1110 | 16 | E |
| 15 | 1111 | 17 | F |
| …… | …… | …… | …… |
（以此类推，生成代码我放这了）
预告 没想好……
有问题就提醒我啊！
打个广告吧！
我祝大家每题AC！大家一起加油！拜拜！
全部评论 7
但是#define有个缺点，你没点出来，我给你看一段代码你就知道了
以下是A37.[CSP-J 2020] 方格取数我刚开始的写法#include <bits/stdc++.h> #define int long long using namespace std; /* 三方向路径d解法 */ const long long N = 1e3 + 10; long long n , m , a[N][N]; long long up[N];//up[i][j] 从下往上走到i,j途经数之和的max long long down[N]; long long dp[N]; //signed int main( ) { cin >> n >> m; for (int i = 1 ; i <= n ; i++) { for (int j = 1 ; j <= m ; j++) { scanf("%lld" , & a[i][j]); } } dp[1] = a[1][1]; for (int i = 2 ; i <= n ; i++) dp[i] = dp[i - 1] + a[i][1]; for (int j = 2 ; j < m ; j++) { memset(up , 0 , sizeof up); memset(down , 0 , sizeof down); down[1] = dp[1] + a[1][j]; up[n] = dp[n] + a[n][j]; for (int i = 2 ; i <= n ; i++) down[i] = max(down[i - 1] , dp[i]) + a[i][j]; for (int i = n - 1 ; i >= 1 ; i--) up[i] = max(up[i + 1] , dp[i]) + a[i][j]; for (int i = 1 ; i <= n ; i++) dp[i] = max(up[i] , down[i]); } dp[1] += a[1][m]; for (int i = 2 ; i <= n ; i++) { dp[i] = max(dp[i] , dp[i - 1]) + a[i][m]; } cout << dp[n] << endl; return 0; }很明显，你放进编译器会说：天哪，为啥CE了，这就是#define的缺点，int main应写成signed main
以下是更改代码2025-10-01 来自 福建
0更改后的代码
#include <bits/stdc++.h> #define int long long using namespace std; /* 三方向路径d解法 */ const long long N = 1e3 + 10; long long n , m , a[N][N]; long long up[N];//up[i][j] 从下往上走到i,j途经数之和的max long long down[N]; long long dp[N]; signed main( ) { cin >> n >> m; for (int i = 1 ; i <= n ; i++) { for (int j = 1 ; j <= m ; j++) { scanf("%lld" , & a[i][j]); } } dp[1] = a[1][1]; for (int i = 2 ; i <= n ; i++) dp[i] = dp[i - 1] + a[i][1]; for (int j = 2 ; j < m ; j++) { memset(up , 0 , sizeof up); memset(down , 0 , sizeof down); down[1] = dp[1] + a[1][j]; up[n] = dp[n] + a[n][j]; for (int i = 2 ; i <= n ; i++) down[i] = max(down[i - 1] , dp[i]) + a[i][j]; for (int i = n - 1 ; i >= 1 ; i--) up[i] = max(up[i + 1] , dp[i]) + a[i][j]; for (int i = 1 ; i <= n ; i++) dp[i] = max(up[i] , down[i]); } dp[1] += a[1][m]; for (int i = 2 ; i <= n ; i++) { dp[i] = max(dp[i] , dp[i - 1]) + a[i][m]; } cout << dp[n] << endl; return 0; }2025-10-01 来自 福建
0定义方式：数据类型名称 变量名
举几个栗子：int a;
double b;
bool c;
typedef 声明:
您可以使用 typedef 为一个已有的类型取一个新的名字。下面是使用 typedef 定义一个新类型的语法：
例如，下面的语句会告诉编译器，LL 是 long long 的另一个名称：
typedef long long LL;
那下面的定义就是合法的
LL a;//定义一个长整型#define （与typedef可以说一模一样）声明:
您可以使用 #define 为一个已有的类型取一个新的名字。下面是使用 define 定义一个新类型的语法：
例如，下面的语句会告诉编译器，LD 是 long double 的另一个名称：
#define LD long double
那下面的定义就是合法的
LD b;//定义一个长双精度浮点型2025-10-01 来自 福建
0
有帮助，赞一个