C+ +基础的知识

凤凰-郑楚杭

2026-08-28 14:50:29

发布于：浙江

5阅读

0回复

0点赞

整理了一下C+ +基础的知识
有二个版本哦！
版本一：
C+ +基础核心知识点教案
——输出、变量、输入、选择、循环、一维数组
一、前言
本次讲解聚焦C+ +基础核心知识点，涵盖输出、变量、输入、选择结构、循环结构、一维数组六大模块，仅讲解知识点本身（核心概念、语法格式、关键注意事项），跳过实操演示、教学准备、课堂练习、作业布置等无关环节，确保知识点连贯、精准，适配入门级学习需求。
二、核心知识点详解
（一）C+ +输出（cout）
1.核心概念
cout是C+ +中用于实现“屏幕输出”的关键字，作用是将指定内容（文字、数字、变量值等）显示在屏幕上，是程序与用户交互的基础输出方式。
2.核心依赖
需要配合头文件<iostream>和命名空间std使用，是C+ +输出功能的必要前提条件。
使用cout必须满足两个前提：① 引入输入输出流头文件<iostream>（头文件是cout的功能支撑，必须写在程序最开头）；② 使用标准命名空间std（可通过“using namespace std;”）。
3.语法格式
基础格式：cout << 输出内容;（<< 称为输出运算符，可连续使用，实现多内容同时输出）。
补充格式：cout << 输出内容 << endl;（endl表示换行，等价于键盘的回车键，用于拆分输出内容，提升可读性）。
4.关键注意事项
① 头文件和命名空间缺一不可，否则程序会报错；② 输出内容若为文字，需用双引号（""）括起来，若为变量、数字，直接书写即可；③ 语句末尾必须加英文分号（;），这是C+ +语句的基本规范。
5.代码演示
题目：输出“Hello C++!”，换一行，再输出“我正在学习C++输出操作，今天的数字是：100”，换一行，再输出“5 + 2”这个算式，并计算。
代码：
cpp
#include <iostream>
using namespace std;

int main()
{
cout << "Hello C++!" << endl; // endl表示换行
cout << "我正在学习C++输出操作，今天的数字是：100" << endl;
cout << "5 + 2 = " << 5 + 2;
return 0;
}

（二）变量
1.核心概念
变量是C+ +中用于“存储数据”的容器，本质是计算机内存中的一块存储空间，可用于存储整数、小数、字符等不同类型的数据，且存储的数据可随时修改（“变量”名称由此而来）。
核心规则：C+ +中变量必须“先定义，后使用”，未定义的变量无法直接赋值或调用。
2.常见数据类型（入门级）
变量的类型决定了其可存储的数据种类和存储空间大小，入门阶段重点掌握3种：
1.int：整型，专门存储-21亿~21亿的整数（如10、-5、0、100），无法存储小数或
-21亿~21亿以外的整数（推荐）；
2.long long：整型，专门存储除-21亿~21亿以外的整数，无法存储小数；
3.double：双精度浮点型，专门存储小数（如3.14、5.6、-2.3），精度较高，满足入门级小数存储需求（推荐）；
4.float：单精度浮点型，专门存储小数（如3.14、5.6、-2.3），精度较低，满足入门级小数存储需求；
3.定义与赋值语法
变量的使用分为“定义”和“赋值”两步，可分开操作，也可合并操作：
方式1：先定义，后赋值（分步操作）—— 语法：数据类型变量名; 变量名 = 赋值内容;
方式2：定义时直接赋值（合并操作，推荐）—— 语法：数据类型变量名 = 赋值内容;
4.变量命名规则（关键）
① 变量名只能由字母、数字、下划线（_）组成，不能包含@、#、$等特殊符号；
② 变量名不能以数字开头（如1age是错误的，age1是正确的）；
③ 变量名区分大小写（如age和Age是两个不同的变量）；
④ 不能使用C+ +关键字（如int、cout、if等，这些是C++自带的功能标识，不可作为变量名）。
5.代码演示
格式：
cpp
// 方式1：先定义，后赋值
数据类型变量名;
变量名 = 赋值内容;

// 方式2：定义时直接赋值（推荐）
数据类型变量名 = 赋值内容;
（三）C++输入（cin）
1.核心概念
cin是C+ +中用于实现“键盘输入”的关键字，作用是从键盘获取用户输入的信息（如数字、字符），并将其存储到指定的变量中，与cout配合，实现程序与用户的双向交互。
2.核心依赖
与cout完全一致，需引入头文件<iostream>，并使用标准命名空间std，否则无法使用。
3.语法格式
基础格式：cin >> 变量名;（>> 称为输入运算符，可连续使用，实现多变量同时输入）。
补充说明：多变量输入时，用户可通过空格、回车或制表符分隔输入的内容，cin会自动将输入的内容匹配到对应的变量中。
4.关键注意事项
① cin后只能跟“变量名”，不能直接跟文字（如cin >> "请输入数字"; 是错误的）；
② 输入的内容类型需与变量的数据类型匹配（如给int变量输入小数，cin会自动截取整数部分，导致数据丢失）；
③ 与cout一样，语句末尾需加英文分号。
5.代码演示
格式：
cpp
cin >> 变量名; // >> 是输入运算符，可连续输入多个变量

（四）选择结构（if-else语句）
1.核心概念
选择结构是用于“根据条件判断，执行不同代码片段”的程序结构，核心是“分支执行”—— 满足条件执行一段代码，不满足条件执行另一段代码（或不执行），类比生活中的“选择判断”（如下雨带伞，不下雨不带伞）。
入门阶段重点掌握最基础的if-else语句，分为两种基本格式。
2.语法格式
格式1：单if语句（仅满足条件时执行）—— 适用于“只有一种判断，不满足条件时不执行任何操作”的场景。
语法：if (条件表达式) { 条件成立时执行的代码; }
格式2：if-else语句（双向分支）—— 适用于“两种对立判断，满足条件执行一种，不满足执行另一种”的场景（最常用）。
语法：if (条件表达式) { 条件成立时执行的代码; } else { 条件不成立时执行的代码; }
格式3：if-else if……else语句（详见下图）
代码格式演示：
cpp
// 格式1：单if（只有条件成立时执行）
if (条件表达式)
{
条件成立时执行的代码;
}

// 格式2：if-else（条件成立执行if体，不成立执行else体）
if (条件表达式)
{
条件成立时执行的代码;
}
else
{
条件不成立时执行的代码;
}
// 格式3：if-else if……else
if (条件表达式)
{
条件成立时执行的代码;
}
else if
{
条件不成立时执行的代码;
}
else
{
条件不成立时执行的代码;
}……

3.核心：条件表达式
条件表达式是选择结构的“判断依据”，其结果只有两种：“真”（非0的任意数值）或“假”（0），当结果为“真”时，才会执行if体内的代码；结果为“假”时，执行else体内的代码（或不执行）。
常见关系运算符（用于构建条件表达式）：>（大于） <（小于） ==（等于） !=（不等于） >=（大于等于） <=（小于等于）。
4.关键注意事项
① 条件表达式必须用圆括号()括起来，不可省略；② 代码块（if或else后面的代码）需用大括号{}括起来，（规范编程，避免逻辑错误）；③ 注意区分“= =”和“=”：==用于判断两个值是否相等；=用于给变量赋值，混淆会导致程序逻辑错误。
（五）循环结构（for循环、while循环）
1.核心概念
循环结构是用于“重复执行一段相同或相似代码片段”的程序结构，核心是“重复执行”—— 只要满足循环条件，就会反复执行循环体内的代码，直到循环条件不满足时，停止循环，类比生活中的“重复做事”（如每天重复起床、刷牙）。
入门阶段重点掌握两种循环：for循环（适合已知循环次数的场景）、while循环（适合未知循环次数的场景），两者可相互转换，根据使用场景选择即可。
2.for循环（已知循环次数）
语法格式：
cpp
for (初始化表达式; 循环条件; 更新表达式)
{
循环体（要重复执行的代码）;
}

各部分作用（缺一不可）：
1.初始化表达式：定义循环变量并赋值（如int i = 1），仅在循环开始时执行1次；
2.循环条件：判断是否继续循环的依据（与if-else的条件表达式一致，结果为真则循环，假则停止）；
3.更新表达式：修改循环变量的值（如i++，表示i自增1；i--，表示i自减1），每次执行完循环体后执行，用于控制循环条件，避免死循环；
4.循环体：需要重复执行的代码，满足循环条件时执行。
3.while循环（未知循环次数）
语法格式：
cpp
初始化表达式;
while (循环条件) {
循环体;
更新表达式;
}

各部分作用：
1.初始化表达式：定义循环变量并赋值，需写在while语句之前，仅执行1次；
2.循环条件：与for循环一致，是循环的判断依据，结果为真则执行循环体，假则停止；
3.循环体：需要重复执行的代码；
4.更新表达式：写在循环体内，每次执行完循环体后执行，作用是修改循环变量，避免死循环。
4.关键注意事项
① 循环的核心是“循环条件可控”，必须确保循环条件在某个时刻能变为“假”，否则会出现“死循环”（程序一直重复执行循环体，无法停止，需强制关闭）；② for循环和while循环可相互转换，已知循环次数优先用for循环，未知循环次数优先用while循环；③ 循环体、更新表达式的位置不可混淆，否则会导致循环逻辑错误。
（六）一维数组
1.核心概念
一维数组是用于“批量存储相同类型数据”的容器，本质是一组连续的计算机内存空间，所有空间存储的数据类型一致，通过“下标”（索引）访问每个空间中的数据，类比生活中的“一排抽屉”（每个抽屉存储同一种物品，通过抽屉编号找到对应物品）。
核心优势：当需要存储多个相同类型的数据时（如5个学生的成绩、10个整数），使用数组可避免定义多个变量，简化代码，便于批量操作数据。
2.语法格式（定义与初始化）
数组的使用需先定义，再初始化（赋值），有3种常用方式：
方式1：指定数组长度，不初始化—— 语法：数据类型数组名[数组长度]; （注意：未初始化时，数组中元素的默认值不确定，不推荐使用）；
方式2：指定数组长度，部分初始化—— 语法：数据类型数组名[数组长度] = {值1, 值2, ..., 值n}; （注意：未赋值的元素，默认值为0）；
方式3：不指定数组长度，完全初始化—— 语法：数据类型数组名[] = {值1, 值2, ..., 值n}; （注意：数组长度会自动等于初始化值的个数，无需手动指定，推荐使用）。
补充说明：数组长度必须是整数（可直接写数字，如5、10；也可使用常量，入门阶段暂不讲解常量，直接用数字即可），且数组长度一旦定义，无法修改。
格式演示：
cpp
// 方式1：指定数组长度，不初始化（默认值不确定）（推荐）
数据类型数组名[数组长度];

// 方式2：指定数组长度，初始化（未赋值的元素默认为0）
数据类型数组名[数组长度] = {值1, 值2, ..., 值n};

// 方式3：不指定数组长度，初始化（数组长度等于初始化值的个数）（不推荐）
数据类型数组名[] = {值1, 值2, ..., 值n};

3.数组的访问与遍历
•数组访问：通过“数组名[下标]”访问单个元素，语法：数组名[下标]; （关键：数组下标从0开始，而非1，如数组长度为5，下标范围是0~4，对应数组的5个元素，下标0是第一个元素，下标4是第五个元素）；
•数组遍历：指依次访问数组中的所有元素，是数组最常用的操作，入门阶段优先使用for循环遍历（循环变量作为下标，从0开始，到数组长度-1结束），可实现批量输出、修改数组元素等操作。
4.关键注意事项
① 数组下标不能越界（即不能访问超出“0_{数组长度-1”范围的下标），如下标为5的元素，若数组长度为5（下标范围0}4），访问会导致程序报错（数组越界，是入门阶段常见错误）；② 数组中所有元素的数据类型必须一致，不能混合存储（如int数组不能存储小数、字符）；③ 遍历数组时，循环变量的范围必须准确，避免漏遍历或越界。
5.代码演示
题目：输入并输出数组。
代码：
cpp
#include <iostream>
using namespace std;
int main()
{
const int max = 1000;
int a[max + 5];
int n;
cin >> n;
for(int i = 1; i <= n; i++)
{
cin >> a[i];
}
for(int i = 1; i <= n; i++)
{
cout << a[i] << " ";
}
return 0;
}
三、知识点总结
本次讲解的六大知识点，是C++入门的核心基础，相互关联、层层递进：

输出（cout）、输入（cin）：实现程序与用户的交互，是数据的“输出”和“输入”通道。输出（cout）：让电脑显示内容，配合endl换行；输入（cin）：从键盘获取输入，存储到变量中。
变量：存储输入、运算过程中的数据，是所有操作的“数据载体”，先定义后使用，常见类型int、long long、double、float。
选择结构（if-else）：让程序具备“判断能力”，实现分支执行。
循环结构（for、while）：让程序具备“重复执行能力”，简化批量操作，注意控制循环条件，避免死循环。
一维数组：批量存储相同类型数据，下标从0开始，配合循环结构，可实现高效的批量数据操作。
核心原则：所有知识点的使用，都需遵循C++的语法规范，重点掌握“定义-使用”的逻辑，理解各知识点的核心作用，为后续复杂编程学习奠定基础。
四、练习
基础题（必做）
1.编写程序：输入一个整数，判断其是否为偶数。
2.输出1~100中的奇数。
3.定义一个长度为4的数组，存储4个小数，遍历输出所有元素。
提升题（选做）
1.编写程序：输入一个正整数n，用while循环计算1~n的和。
2.定义一个长度为5的int数组，输入5个整数，找出数组中的最大值并输出。

版本二：
C+ +是一种功能强大且应用广泛的编程语言，它在系统软件、游戏开发、嵌入式系统和高性能计算等领域占据着核心地位。作为一门兼具高级语言易用性和低级语言高效性的“中级”语言，C+ +不仅继承了C语言的灵活性，还引入了面向对象、泛型编程等现代编程范式。
对于初学者而言，掌握C+ +的核心基础是开启编程世界大门的关键一步。本框架文档旨在为你提供一份清晰、系统的学习路线图，全面整合C+ +程序的基本结构、变量、输入输出、控制流（if分支、循环）以及一维数组等六大核心知识点。我们将以通俗易懂的方式，结合大量代码示例和实用建议，帮助你打下坚实的基础。通过循序渐进地学习，你将能够理解并编写出自己的第一个C++程序，并为后续深入学习类与对象、STL等高级特性做好准备。

C+ +程序的基本结构
一个标准的C+ +程序就像一座精心设计的房子，有其固定的组成部分。理解这些基本结构是编写任何C+ +程序的第一步。
1.1 程序构成要素
一个最简单的C+ +程序通常由以下几个关键部分组成：
• 预处理指令 #include：这行代码以#开头，告诉编译器在真正编译之前，先去包含一个指定的头文件。例如，#include <iostream>的作用就是引入标准输入输出流库，这样你的程序才能使用cin和cout进行键盘输入和屏幕输出。
• 命名空间声明 using namespace std;：C+ +标准库中的所有功能（如cout,cin,endl）都放在一个名为std的“命名空间”里。这行代码相当于说：“我接下来要使用std这个空间里的东西，所以请省略std :: 这个前缀。” 这样写可以让你的代码更简洁。不过，在大型项目中，为了防止命名冲突，不推荐直接使用std :: cout这样的完整写法。
• 主函数 int main()：这是整个程序的唯一入口点。无论你的程序有多复杂，操作系统总是从main()函数开始执行。每个可执行的C+ +程序都必须有且仅有一个main()函数。
• 函数体 {} 与返回值 return 0;：花括号{}定义了main()函数的边界，所有要执行的代码都放在这里面。return 0;表示程序已成功运行完毕，并向操作系统返回一个状态码0，代表“一切正常”。自C+ +11起，如果省略这行，编译器也会自动补上。
1.2 第一个C+ +程序示例
让我们来看一个经典的“Hello, World!”程序，它是每个程序员的起点：
#include <iostream>
using namespace std;
int main() {
cout << "Hello, World!" << endl;
return 0;
}
你可以将这段代码保存为hello.cpp文件。要在命令行中编译并运行它，需要使用如下命令：
g++ hello.cpp -o hello
./hello
这条g+ +命令会调用GNU C+ +编译器，将源代码编译成一个名为hello的可执行文件，然后你就可以运行它了。
1.3 关键组件详解
现在，我们来深入剖析一下这个简单程序中的每一个关键组件：
• <iostream> 头文件的作用：iostream是“input/output stream”的缩写。它包含了实现控制台输入输出所需的所有工具。没有它，你就无法使用cin和cout，程序将无法与用户交互。
• std 命名空间的意义：想象一下，如果全世界的人都叫同一个名字，那该多么混乱！命名空间就是用来解决这个问题的。std是“standard”的缩写，它是一个巨大的容器，里面装着C++标准库的所有成员。通过using namespace std;，我们避免了每次都要写std::cout的繁琐。
• main() 函数的唯一入口地位：main()函数是程序的“心脏”，是执行的起点。它的签名通常是int main()或int main(int argc, char* argv[])（后者用于接收命令行参数）。它的返回类型必须是int，不能是void。
• return 0 的含义：在计算机的世界里，0通常代表“成功”或“无错误”。当你在main()函数末尾写上return 0;时，你是在告诉操作系统：“我的任务完成了，而且完成得很顺利！” 非零的返回值则通常表示程序遇到了某种错误。
变量与数据类型
如果说程序是一场戏剧，那么变量就是演员，它们负责存储和处理数据。而数据类型则是给这些演员分配的角色，决定了它们能扮演什么样的角色（即能存储什么类型的数据）。
2.1 基本数据类型一览
C++提供了多种内置的基本数据类型，每种类型占用不同的内存空间，并有不同的取值范围。以下是初学者最常接触的几种类型：
类型字节范围/说明
short 2 -32768 ~ 32767，适用于数值较小的整数
int 4 -2147483648 ~ 2147483647，最常用的整数类型，足以应对大多数场景
long long 8 极大整数范围，适用于需要存储非常大数字的情况
float 4 单精度浮点数，有效数字约6-7位，例如3.14f
double 8 双精度浮点数，有效数字约15-16位，是处理小数的首选，例如3.1415926
char 1 字符类型，用于存储单个字符，如'A'或'z'，本质上是ASCII码
bool 1 布尔类型，只有两个值：true（真）和false（假），是逻辑判断的基础

2.2 变量定义与初始化
要使用一个变量，你需要先“定义”它，就像给一个空盒子贴上标签一样。
• 定义语法：最基本的语法是数据类型变量名 = 初始值;。例如，int age = 18;定义了一个名为age的整数变量，并将其初始化为18。这里的“初始化”非常重要，因为它确保了变量从一开始就有确定的值，而不是随机的垃圾数据。
• 统一初始化语法：C+ +11引入了一种更安全的初始化方式：int x{100};。这种使用花括号{}的语法被称为“列表初始化”或“统一初始化”。它的最大优点是能防止“窄化转换”（narrowing conversion），比如你不能用int x{3.14};，因为这会导致精度丢失，编译器会直接报错，从而帮你及早发现潜在问题。
• 变量命名规则：给变量起名字时，需要遵守一些规则，否则编译器会不高兴：
○ 名字只能由字母、数字和下划线_组成。
○ 不能以数字开头，比如1stPlace是非法的。
○ 区分大小写，myVar和myvar是两个不同的变量。
○ 不能使用C+ +的关键字（如int,for,while）作为变量名。
○ 最重要的一条建议是：见名知意。使用studentName比s要好得多，能让别人（包括未来的你）一眼就明白这个变量的用途。
2.3 常量定义方式
有些数据在程序运行过程中是绝对不能改变的，比如圆周率π。这时我们就需要用到常量。
• 宏常量 #define PI 3.1415926：这是一种来自C语言的传统方法。它会在编译前被简单地文本替换。虽然简单，但它没有类型检查，容易引发难以调试的问题，因此不推荐在现代C++中使用。
• const常量 const int MONTH = 12;（推荐）：这是C+ +中定义常量的正确方式。const关键字告诉编译器，这个变量的值一旦初始化后就不能再被修改。它具有类型，作用域明确，是强烈推荐的做法。例如，const double PI = 3.1415926;就是一个完美的圆周率常量。

输入与输出操作
程序不能只是“自言自语”，它需要与外界交流。C++通过标准流（Standard Streams）来实现输入和输出。
3.1 标准流对象概述
你可以把标准流想象成几条通往不同目的地的管道：
对象含义默认连接设备
cin 标准输入键盘
cout 标准输出屏幕
cerr 标准错误屏幕（无缓冲）
clog 日志输出屏幕（缓冲）

其中，cin和cout是你最常用的伙伴。cin（读作"see-in"）负责从键盘读取数据，cout（读作"see-out"）负责向屏幕打印信息。记住一个口诀：<<出，>>进——cout <<是把数据“推出去”到屏幕，cin >>是从键盘“拿进来”数据。
3.2 基础输入输出示例
下面的代码演示了如何获取用户的输入并计算结果：
#include <iostream>
using namespace std;

int main() {
int a, b;
cout << "请输入两个整数：";
cin >> a >> b;
cout << "它们的和是：" << (a + b) << endl;
return 0;
}
在这个例子中，cin >> a >> b;可以连续读取两个整数，用户只需用空格或回车分隔输入即可。endl不仅会换行，还会强制刷新输出缓冲区，确保内容立即显示在屏幕上。
3.3 格式化输出（需包含 <iomanip>）
有时候，我们需要更精确地控制输出的格式，比如让数字对齐或者保留两位小数。这就需要引入<iomanip>头文件，并使用其中的“操纵符”（Manipulators）。
操纵符功能示例
dec/hex/oct 设置进制 cout << hex << num; 将num以十六进制形式输出
fixed/scientific 小数格式 cout << fixed << setprecision(2); 设置固定小数点模式，保留2位小数
setw(n) 设置宽度 cout << setw(10) << "ID"; 输出"ID"时，占10个字符的宽度，不足则用空格填充
setfill(c) 填充字符 cout << setfill('') << setw(10); 将填充字符设为，配合setw使用
boolalpha 输出true/false cout << boolalpha << flag; 让布尔值输出为"true"或"false"，而不是1或0

3.4 常见输入问题及解决
新手在使用cin时经常会遇到一些“坑”：
• 数据类型不匹配导致cin失效：如果你期望用户输入一个整数，但他却输入了"abc"，cin就会进入失败状态（fail state），后续所有的输入操作都会被忽略。解决方法是检查cin的状态并清除错误标志。
• 混合使用cin >>与getline()的换行符残留问题：cin >>在读取完数据后，会把最后的回车键（\n）留在输入缓冲区里。当你紧接着使用getline()读取一行时，它会立刻读到这个残留的\n，导致读取到一个空字符串。这是一个非常常见的陷阱。
• 使用cin.ignore()清除缓冲区的方法：为了解决上述问题，可以在cin >>之后调用cin.ignore()。例如，cin.ignore(10000, '\n');会忽略掉最多10000个字符，直到遇到一个换行符为止，从而清空缓冲区。一个更通用的写法是cin.ignore(numeric_limits<streamsize>::max(), '\n');，它会忽略掉直到行尾的所有字符。

if条件分支结构
程序的智能之处在于它能根据不同的情况做出不同的反应。这就是条件分支的用武之地，它让程序不再是“一条路走到黑”。
4.1 分支语句语法形式
C++提供了三种主要的if语句形式：
• 单独if：当某个条件满足时，才执行一段代码。cpp
if (score >= 60) {
cout << "恭喜你，及格了！" << endl;
}
• if-else：二选一，非此即彼。cpp
if (score >= 60) {
cout << "及格" << endl;
} else {
cout << "不及格" << endl;
}
• 多重else if：用于处理多个互斥的条件，像一个多路开关。cpp
if (score >= 90) {
cout << "优秀" << endl;
} else if (score >= 80) {
cout << "良好" << endl;
} else if (score >= 60) {
cout << "及格" << endl;
} else {
cout << "加油" << endl;
}
4.2 条件表达式组成
if后面的括号里是一个条件表达式，它的结果必须是true或false。
• 比较运算符：（等于）、!=（不等于）、>（大于）、<（小于）、>=（大于等于）、<=（小于等于）。注意不要把=（赋值）和（比较）搞混了，这是一个致命的错误。
• 逻辑运算符：&&（逻辑与，相当于“并且”）、||（逻辑或，相当于“或者”）、!（逻辑非，相当于“取反”）。例如，score >= 60 && score < 80表示分数在60到80之间。
4.3 三元运算符
当你只需要根据一个条件来选择两个值中的一个时，可以使用更简洁的三元运算符。
• 语法：result = (condition) ? val1 : val2;
• 应用场景：简化简单的条件赋值。例如，string result = (score >= 60) ? "Pass" : "Fail";。这比写一个完整的if-else语句要短小精悍。
4.4 switch语句（等值判断）
当你的判断是基于一个变量是否等于几个特定的值时，switch语句比一长串的else if更清晰。
switch (dayOfWeek) {
case 1:
cout << "星期一" << endl;
break;
case 2:
cout << "星期二" << endl;
break;
// ... 其他天
default:
cout << "无效日期" << endl;
}
4.5 注意事项
• 避免悬空else：当if语句嵌套时，else总是与最近的、未配对的if相关联。为了避免歧义，始终使用花括号{}来明确代码块的范围。
• 必须使用大括号包裹多行代码块：即使if后面只有一行代码，也强烈建议加上花括号。这不仅能提高代码的可读性，还能防止日后添加代码时因忘记加花括号而导致的逻辑错误。
• case后不要忘记break防止穿透：⚠️ 这是switch语句最大的陷阱！如果没有break，程序会“穿透”到下一个case继续执行，直到遇到break或switch结束。这通常不是你想要的结果。
循环结构
重复是编程中最常见的需求之一。与其一遍遍地复制粘贴代码，不如使用循环让它自动重复执行。
5.1 for循环（已知次数）
当你事先知道要循环多少次时，for循环是最佳选择。它的语法将初始化、条件和更新三个步骤集中在一起，非常紧凑。
for (int i = 0; i < 5; i++) {
cout << i << " ";
}
// 输出：0 1 2 3 4
• int i = 0;：循环开始前执行一次，初始化循环变量。
• i < 5;：每次循环前都要检查的条件，为真则继续。
• i++：每次循环体执行完毕后执行，更新循环变量。
5.2 while循环（未知次数）
当你不知道确切的循环次数，而是依赖于某个动态条件时，应该使用while循环。
int n = 3;
while (n > 0) {
cout << n-- << " ";
}
// 输出：3 2 1
while循环会先判断条件，如果为真，则执行循环体，然后再回到条件判断，如此反复。
5.3 do-while循环（至少一次）
do-while循环的特点是，它会先执行一次循环体，然后再去判断条件。这意味着循环体至少会被执行一次。
int input;
do {
cout << "请输入一个正数: ";
cin >> input;
} while (input <= 0);
5.4 范围for循环（C+ +11）
这是C+ +11引入的一个非常方便的特性，专门用于遍历数组或容器中的每一个元素。
int arr[] = {1, 2, 3, 4, 5};
for (int num : arr) {
cout << num << " ";
}
这个循环会自动取出arr中的每一个元素，赋值给num，然后执行循环体。代码简洁明了，不易出错。
5.5 循环控制语句
• break：立即终止整个循环，跳出循环体。
• continue：跳过本次循环剩余的代码，直接进入下一轮循环的条件判断。
• goto：可以跳转到函数内的任意标签位置。虽然功能强大，但会使代码变得混乱不堪，因此一般不推荐使用。
5.6 常见错误警示
• for循环后误加分号造成空循环：for (int i=0; i<5; i++);这个分号会让循环体变成一个空语句，导致{}里的代码只执行一次。
• while循环中忘记更新变量导致死循环：如果在while循环体内没有改变影响条件的变量，循环将永远进行下去，程序会“卡死”。
• 浮点数作为循环变量引发精度问题：由于浮点数在计算机中的存储存在精度误差，用它来做循环变量可能导致循环次数不准确。应尽量使用整数。
一维数组
当需要处理一组相同类型的、相关的数据时，比如一个班级所有学生的成绩，一维数组就是最合适的工具。你可以把它想象成一排整齐的、带编号的储物柜。
6.1 定义与初始化方式
方式示例
全部初始化 int arr[5] = {10, 20, 30, 40, 50};
省略长度 int arr[] = {1, 2, 3, 4, 5}; // 编译器自动推断长度为5
部分初始化 int arr[5] = {1, 2}; // 后三位会被自动初始化为0
先定义后赋值 int arr[3]; arr[0]=11; arr[1]=22; arr[2]=33;

6.2 元素访问与遍历
• 下标从0开始：这是最重要的规则！第一个元素的下标是0，最后一个元素的下标是长度-1。例如，一个长度为5的数组，其下标范围是0到4。
• 数组越界警告：⚠️ 绝对不能访问arr[length]或arr[-1]！这会导致“未定义行为”（undefined behavior），轻则程序崩溃，重则产生难以预料的错误。
• 遍历模板：使用for循环是最常见的遍历方式。cpp
for (int i = 0; i < len; i++) {
cout << arr[i] << " ";
}
6.3 获取数组长度
在一个函数内部，如果你想获取一个本地数组的长度，可以使用这个技巧：
int len = sizeof(arr) / sizeof(arr[0]);
sizeof(arr)返回整个数组占用的字节数，sizeof(arr[0])返回一个元素占用的字节数，两者相除就得到了元素个数。但请注意，这个方法只对本地数组有效，当数组作为参数传递给函数时，它会退化为指针，此时sizeof得到的是指针的大小，而非数组大小。
6.4 常见操作示例
• 求最大值：cpp
int maxVal = arr[0];
for (int i = 1; i < len; i++) {
if (arr[i] > maxVal) maxVal = arr[i];
}
• 数组逆序：cpp
for (int i = 0; i < len / 2; i++) {
swap(arr[i], arr[len - 1 - i]);
}这里使用了swap函数，它能交换两个变量的值。
6.5 内存特性与注意事项
• 数组名代表首地址：数组名arr本身就是一个指向数组第一个元素的指针。
• 长度固定不可变：一旦数组被创建，它的大小就无法改变。
• 不能整体赋值：你不能写b = a;来复制一个数组。必须逐个元素复制，或使用std :: copy等函数。
• 推荐使用std :: vector替代原生数组：⚠️ 原生数组有很多限制和安全隐患。在现代C++中，你应该优先使用std::vector<int>。它是一个动态数组，可以随时改变大小，提供了.size()方法获取长度，并且更加安全。

总结与进阶建议
恭喜你！你已经系统地学习了C+ +最核心的六大基础知识点：从程序的基本结构，到变量、输入输出，再到控制流程（if和循环），最后是一维数组的使用。你现在已经具备了编写简单C+ +程序的能力。
回顾一下我们的学习路径：我们从搭建程序的“骨架”开始，然后学会了如何定义和使用“变量”这个存储单元，接着掌握了与用户交互的“输入输出”技能。在此基础上，我们赋予了程序“思考”的能力（if分支）和“重复劳动”的能力（循环）。最后，我们学习了如何批量管理数据的“数组”。
这些知识构成了C+ +编程的基石。然而，这仅仅是开始。C+ +的精彩世界远不止于此。下一步，你应当探索：
• 指针与引用：它们是理解C+ +内存模型和实现高级功能（如动态内存分配）的关键。
• 函数：学会将代码模块化，写出更清晰、更易维护的程序。
• 类与对象：这是C+ +面向对象编程的核心，让你可以用“对象”的方式来建模现实世界。
为了巩固所学，我建议你动手实践以下项目：