语法基础 (15小节)
约 10689 字大约 36 分钟
2026-11-11
1.输入输出
#include<iostream>
using namespace std;
int main()
{
int a;
char ch;
cout << "请输入一个字母: " << endl;
cin >> ch;
cout << "请输入一个常数: " << endl;
cin >> a;
cout << "字母为" << ch << endl;
cout << "常数为" << a << endl;
return 0;
}2.注释
#include <iostream>
using namespace std;
int main() {
// 这是一个注释
/* 这是注释 */
/* C++ 注释也可以
* 跨行
*/
cout << "Hello World!";
cout << "Hello World!"; // 输出 Hello World!
return 0;
}3.变量
常见类型
- 布尔类型 (bool)
- 字符类型 (比如: char)
- 整数类型 (比如: int)
- 浮点类型 (比如:float double)
- 枚举类型 (enum)
- 指针类型 (比如: int*)
- 数组类型 (比如: char [])
- 引用类型 (比如: double&)
声明
bool
//首先,按照定,true具有值1, false具有值0(也就是true可以转换为1, false可以转换为0)
//另外,非0的整数转换为true, 0转换为false
bool b = 2; //bool(2)是true, 所以等价于 bool b = true;
int i = true;//int(true)是1, 所以等价于 int i = 1;
bool x = 2 + 3;//bool(5)是true, 所以等价于 bool x = true;需要注意的是指针也可以隐式转换到 bool, 非零指针转换为 true, 空指针转为 false
字符类型
类型为 char 的变量可以保存具体实现的字符集里的一个字符.
char ch = 'b';//注意是单引号!
char c;
std::cin >> c;//从键盘输入c的值
std::cout << c << " 的值为: " << int(c) << std::endl;整数类型
int, signed int 和 unsigned int. 此外整数还有大小,如:short long
浮点类型
三种:float (单精度), double (双精度)
float (单精度) 占用空间:4 个字节 有效数字范围:7 位有效数字
double (双精度) 占用空间:8 个字节
默认的类型为 double, 如 1.2 是 double; 1.2f 或者 1.2F 这样写代表 float 型;
auto关键字
auto 的作用是让变量成为自动变量,代替冗长复杂,变量使用范围专一的变量声明
std::vector<std::string> vec;
for (auto iter = vec.begin(); iter != vec.end(); ++iter) {}auto 变量必须在定义时进行初始化操作
如果不进行初始化操作,那么 auto 关键字就不能进行变量类型的推导
auto a = 1
auto a = 1, b = 24.数组
概念
一个数组就像一个变量,但是它可以存储一组值,所有值均具有相同的数据类型。这些值一起存储在连续的内存位置。
声明数组
在 C++ 中要声明一个数组,需要指定元素的类型和元素的数量
type arrayName [ arraySize ];
double balance[10];初始化数组
在 C++ 中,可以逐个初始化数组,也可以使用一个初始化语句
double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};遍历
int n[ 10 ]; // n 是一个包含 10 个整数的数组
// 初始化数组元素
for ( int i = 0; i < 10; i++ )
{
n[ i ] = i + 100; // 设置元素 i 为 i + 100
}
for ( int i = 0; i < 10; i++ )
{
cout<<n[i]<<endl;
}二维数组
//1.数据类型 数组名[行数][列数]:
int arr1[3][3];
for(int i=0;i<3;i++)
{
for(int j=0;j<3;j++)
{
cin>>arr1[i][j];
}
}
for(int i=0;i<3;i++)
{
for(int j=0;j<3;j++)
{
cout<<arr1[i][j]<<" ";
}
cout<<endl;
}
// 2.数据类型 数组名[行数][列数]={{数据1,数据2,数据3},{数据4,数据5,数据6}}
int arr2[3][3]={
{1,2,3},
{4,5,6},
{7,8,9}
};
for(int i=0;i<3;i++)
{
for(int j=0;j<3;j++)
{
cout<<arr2[i][j]<<" ";
}
cout<<"\n";
}
//3.数据类型 数组名[][列数]={数据1,数据2,数据3,数据4,数据5,数据6} 编译器可以自动捕捉到行数
int arr4[][3]={1,2,3,4,5,6,7,8,9};
for(int i=0;i<3;i++)
{
for(int j=0;j<3;j++)
{
cout<<arr4[i][j]<<" ";
}
cout<<"\n";
}
return 0;✅ 重点小笔记:
- 数组下标从0开始
- 二维数组初始化时,列数不能省略,行数可以交给编译器自动推导
5.string 字符串
C++标准库提供了 string 类型,支持字符串相关操作,功能比字符数组更丰富。 头文件:#include <string>
#include <iostream>
#include <string>
using namespace std;
int main ()
{
string str1 = "bc";
string str2 = "zwj";
string str3;
int len ;
// 连接 str1 和 str2
str3 = str1 + str2;
cout << "str1 + str2 : " << str3 << endl;
// 获取 str3 的总长度
len = str3.size();
cout << "str3.size() : " << len << endl;
return 0;
}运行结果:
str1 + str2 : bczwj
str3.size() : 5✅ 常用要点:
+直接拼接两个string(很方便,char数组不能直接用+拼接).size()/.length():获取字符串有效字符个数,两个作用一样- 下标同样从0开始,可以
str3[0]访问单个字符
顺带整理string其他高频函数:substr、find、erase、replace、比较
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s = "hello world";
cout << "原始字符串:" << s << endl;
// 1. 访问字符 [] 和 at()
cout << "\n【访问字符】" << endl;
cout << "s[0] = " << s[0] << endl;
cout << "s.at(1) = " << s.at(1) << endl;
// 2. append 追加
cout << "\n【append追加】" << endl;
s.append("!");
cout << "append之后:" << s << endl;
// 3. find 正向查找
cout << "\n【find查找】" << endl;
size_t pos = s.find("wo");
if (pos != string::npos)
{
cout << "找到 wo,下标:" << pos << endl;
}
else
{
cout << "没有找到" << endl;
}
// rfind 反向查找
pos = s.rfind("l");
cout << "rfind找最后一个l,下标:" << pos << endl;
// 4. substr 截取
cout << "\n【substr截取】" << endl;
string sub = s.substr(0, 5);
cout << "substr(0,5):" << sub << endl;
// 5. erase 删除
cout << "\n【erase删除】" << endl;
string s1 = "hello world";
s1.erase(6, 5);
cout << "erase(6,5)之后:" << s1 << endl;
// 6. replace 替换
cout << "\n【replace替换】" << endl;
string s2 = "hello world";
s2.replace(6, 5, "c++");
cout << "replace之后:" << s2 << endl;
// 7. 比较
cout << "\n【字符串比较】" << endl;
string a = "apple", b = "banana";
if (a < b)
{
cout << a << " 字典序小于 " << b << endl;
}
cout << "compare结果 a.compare(b) = " << a.compare(b) << endl;
// 8. empty clear push_back c_str
cout << "\n【其他接口】" << endl;
string s3;
cout << "s3是否为空:" << boolalpha << s3.empty() << endl;
s3.push_back('A');
cout << "push_back后 s3:" << s3 << endl;
cout << "c_str():" << s3.c_str() << endl;
s3.clear();
cout << "clear之后,是否为空:" << s3.empty() << endl;
return 0;
}运行输出参考:
原始字符串:hello world
【访问字符】
s[0] = h
s.at(1) = e
【append追加】
append之后:hello world!
【find查找】
找到 wo,下标:6
rfind找最后一个l,下标:9
【substr截取】
substr(0,5):hello
【erase删除】
erase(6,5)之后:hello !
【replace替换】
replace之后:hello c++
【字符串比较】
apple 字典序小于 banana
compare结果 a.compare(b) = -1
【其他接口】
s3是否为空:true
push_back后 s3:A
c_str():A
clear之后,是否为空:true6.结构体
基本概念
结构体属于用户自定义的数据类型,可以把多种不同类型的数据打包放在一起。
语法
struct 结构体名{
结构体成员列表
};创建结构体变量的三种方式
#include <iostream>
#include <string>
using namespace std;
// 1. 定义结构体(学生:姓名、年龄、分数)
struct Stu {
string name;
int age;
double score;
}s3; // 方式3:定义结构体的同时直接创建变量 s3
int main() {
// 方式1:先定义结构体,再单独创建变量(C++中struct可以省略)
struct Stu s1;
s1.name = "张三";
s1.age = 25;
s1.score = 87.5;
cout << "姓名:" << s1.name << " 年龄:" << s1.age << " 分数:" << s1.score << endl;
cout << endl;
// 方式2:创建变量的时候直接初始化赋值
Stu s2 = {"李四",26,92.8};
cout << "姓名:" << s2.name << " 年龄:" << s2.age << " 分数:" << s2.score << endl;
cout << endl;
// 方式3:上面定义时已经创建好s3,直接使用
s3.name = "王五";
s3.age = 24;
s3.score = 76.8;
cout << "姓名:" << s3.name << " 年龄:" << s3.age << " 分数:" << s3.score << endl;
return 0;
}运行输出:
姓名:张三 年龄:25 分数:87.5
姓名:李四 年龄:26 分数:92.8
姓名:王五 年龄:24 分数:76.8✅ 重点要点
- 访问结构体成员用
.点运算符:s1.name、s1.age - C++ 使用结构体变量时,
struct关键字可以省略(C语言不能省) - 结构体里面成员可以是:
int、double、string、数组,甚至别的结构体 - 初始化大括号里面的顺序,必须和结构体成员声明顺序保持一致
拓展:结构体数组(很常用)
Stu arr[2] = {
{"小明",18,90},
{"小红",19,95}
};
cout << arr[0].name;要不要继续学结构体指针(->箭头访问)
结构体指针 & -> 箭头运算符
普通结构体变量:用
.访问成员 结构体指针:用->箭头访问成员
#include <iostream>
#include <string>
using namespace std;
struct Stu {
string name;
int age;
double score;
};
int main()
{
Stu s = {"小张", 20, 88.5};
// 定义结构体指针,存放结构体变量的地址
Stu *p = &s;
// 两种写法等价,推荐箭头 ->
cout << p->name << endl;
cout << p->age << endl;
cout << p->score << endl;
// 等价写法(不常用):(*p) 先解引用拿到结构体,再用 .
cout << (*p).name << endl;
return 0;
}输出:
小张
20
88.5
小张✅ 核心区分
- 变量(实体):
s.name - 指针(地址):
p->name
搭配结构体数组(高频考题)
Stu stuArr[3] = {
{"A",18,90},
{"B",19,91},
{"C",20,92}
};
Stu *p = stuArr; // 数组名本身就是首元素地址
cout << p->name << endl; // A
p++; // 指针向后移动一个Stu大小,指向下一个元素
cout << p->name << endl; // B补充:结构体做函数参数(两种传法)
- 值传递:拷贝一份,修改不会影响原数据,开销大
void print(Stu s)
{
cout << s.name;
}- 地址传递(指针):不拷贝,直接操作原数据,效率高
void print(Stu *p)
{
cout << p->name;
}
// 调用:print(&s);一般优先用指针/引用传参,避免拷贝浪费内存
练习题(结构体 + 结构体指针)
题目: 定义一个 Person 结构体,包含成员:string name、int height(身高)、int weight(体重)。
- 创建2个Person变量;
- 写一个函数,参数是Person指针,功能:打印这个人的全部信息;
- 调用这个函数,分别打印两个人的数据。
#include <iostream>
#include <string>
using namespace std;
struct Person
{
string name;
int height;
int weight;
};
// 结构体指针做形参
void showInfo(Person *p)
{
cout << "姓名:" << p->name
<< ",身高:" << p->height
<< ",体重:" << p->weight << endl;
}
int main()
{
Person p1 = {"老王", 175, 70};
Person p2 = {"小李", 168, 55};
showInfo(&p1);
showInfo(&p2);
return 0;
}输出:
姓名:老王,身高:175,体重:70
姓名:小李,身高:168,体重:557.共用体 (联合体 union)
核心概念
union 共用体:多个成员共享同一块内存,同一时刻只能存其中一个成员的值。 对比 struct 结构体:结构体所有成员同时独立存在、内存分开;共用体成员抢同一块内存,改一个,其他成员数据直接失效。
共用体占用内存大小 = 它里面最大成员的字节大小 结构体占用内存 = 所有成员大小之和(还要考虑内存对齐)
基础语法
union one4all
{
int int_val;
long long_val;
char sex;
double double_val;
};这块 union 的内存大小由 double 决定(8字节),四个成员共用这8个字节。
示例:
#include <iostream>
using namespace std;
union Test
{
int a;
char b;
};
int main()
{
Test u;
u.a = 100;
cout << u.a << endl; // 100
u.b = 'A'; // 覆盖了同一块内存
cout << u.a << endl; // 数值被破坏,不再是100
return 0;
}嵌套共用体
struct Product
{
char brand[20];
int type;
// 共用体作为结构体的成员
union id
{
int id_int;
char id_char[20];
}id_val;
};业务含义:
type == 1:编号存成整数id_val.id_inttype !=1:编号存成字符串id_val.id_char
访问写法:
Product prize;
if(prize.type == 1)
{
cin >> prize.id_val.id_int;
}
else
{
cin >> prize.id_val.id_char;
}匿名共用体(简化写法,C++支持)
不写共用体名字、成员变量名,直接嵌入:
struct Product
{
char brand[20];
int type;
union
{
int id_int;
char id_char[20];
};
};访问的时候可以少写一层:
if(prize.type == 1)
cin >> prize.id_int;
else
cin >> prize.id_char;✅ union 重点考点总结
- 同一时间只有一个成员有效,赋值新成员会覆盖旧数据
- 内存大小:取最大成员的尺寸
- 用途:节省内存、同一个位置复用存储不同类型数据;协议解析、底层硬件开发很常用
- 常和结构体嵌套搭配使用(类型标记+共用体,就是“带判别标签的联合体”)
小提醒:日常业务开发用得不多;在嵌入式、底层、网络协议里非常常见。
8.枚举 enum
概念
枚举是用户自定义的一组枚举常量的集合,本质上是整数常量,用来给一组固定选项起名字,可读性更好。
定义语法
enum 类型名 {枚举常量表};示例1:默认从0开始自增
enum color_set1 {
RED, BLUE, WHITE, BLACK
};默认值:
- RED = 0
- BLUE = 1
- WHITE = 2
- BLACK = 3
示例2:手动指定某个常量的值,后面自动+1
enum example {
Aa, Bb = 10, Cc
};- Aa = 0
- Bb = 10
- Cc = 11 ✅ 重点:后面的自动在上一个基础上加1
核心规则
- 枚举常量本质是整数,枚举值可以直接赋值给int变量
int x = RED; // ✅ 合法- 不能直接把整数赋值给枚举变量(C老式enum,C++11强类型enum class不一样)
color_set1 c;
c = 1; // ❌ 老式enum不推荐、很多编译器警告
c = BLUE;// ✅ 正确,只能用枚举里定义好的常量完整可运行demo
#include <iostream>
using namespace std;
enum color_set1 {
RED, BLUE, WHITE, BLACK
};
enum example {
Aa, Bb = 10, Cc
};
int main()
{
color_set1 c = RED;
cout << "RED = " << RED << endl;
cout << "BLUE = " << BLUE << endl;
cout << "Aa = " << Aa << endl;
cout << "Bb = " << Bb << endl;
cout << "Cc = " << Cc << endl;
int num = BLACK; // 枚举值给int没问题
cout << "BLACK对应的数字:" << num << endl;
return 0;
}输出:
RED = 0
BLUE = 1
Aa = 0
Bb = 10
Cc = 11
BLACK对应的数字:3补充:C++11 强类型枚举 enum class(推荐,更安全)
老式enum有缺陷:常量全局可见、和int随便混;enum class强类型隔离:
enum class Color {
RED, BLUE
};
Color c = Color::RED;
// int x = Color::RED; 不能隐式转int,必须强转✅ 一句话适用场景:状态、选项、类型标记(比如订单状态、开关、颜色),固定有限几个值,优先用枚举代替魔法数字0、1、2。
9.指针与引用
一、指针(pointer)
一句话:指针是一个变量,专门存另一个变量的内存地址,直接操作内存,是一把双刃剑,灵活但容易出bug。
符号区分(最容易混)
&变量:取地址符,拿到变量的内存地址*指针:解引用符,根据地址,取出这个地址里面存的值int *p:定义指针变量,p是int类型指针
*指针:也叫解引用
int a = 3;
int *p = &a; // p里面存放a的地址,p指向a
*p = 10; // 解引用,修改a的值,等价于 a = 10;内存示意图理解:
a占一块内存,里面放数值3p是另外一块独立内存,里面写着a的起始地址*p就是顺着p存的地址,找到a那块空间
指针版swap交换函数
void swapint(int *a, int *b)
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}
// 调用:swapint(&x, &y); 传变量地址小demo
#include <iostream>
using namespace std;
int main()
{
int num = 4;
int *intPtr = #
cout << "num的地址是:" << &num << endl;
cout << "指针intPtr存的值(就是num地址):" << intPtr << endl;
if(intPtr != nullptr) // 判断指针不是空指针
{
cout << "指针指向的数字:" << *intPtr << endl;
}
return 0;
}二、引用(reference,C++独有,C没有)
一句话:引用是变量的别名、第二个标签,它和原变量是同一块内存,不是独立变量
语法:
类型 &别名 = 原变量;
int i;
int &r = i; // r是i的别名,r和i完全是同一个东西
i = 5;
cout << i << " " << r << endl; // 5 5
r = 6;
cout << i << " " << r << endl; // 6 6✅ 硬性规则(必考)
- 引用定义的时候必须初始化,不能先定义再赋值
- 一旦绑定,不能再改成绑定别的变量
- 引用本身没有独立内存,它和原变量地址一模一样
引用版swap(写起来更干净,工程里优先用)
void swapint(int &a, int &b)
{
int temp;
temp = a;
a = b;
b = temp;
}
// 调用:swapint(x, y); 直接传变量,不用写&取地址三、指针 VS 引用 核心对比(背诵)
| 指针 int *p | 引用 int &r | |
|---|---|---|
| 本质 | 独立变量,存地址,自己有内存 | 别名,和原变量共享同一块内存,无独立空间 |
| 初始化 | 可以先定义,后面再赋值;可以是空指针nullptr | 定义时必须初始化,不能空 |
| 重定向 | 可以随时改成指向别的变量 | 绑定之后,不能换目标 |
| 使用符号 | 取值*p,访问成员-> | 直接当普通变量用,.访问成员 |
| 传参 | swap(&x,&y) | swap(x,y),写法简洁 |
简单选型: 不需要空、不需要换指向 → 优先引用,安全简洁; 需要可以为空、需要动态改变指向、数组遍历 → 用指针。
补充:容易踩坑的误区
int* p这里的*只是标记这是指针;*p才是解引用,两个*不是一回事- 引用的
&只在定义的时候代表引用,别的地方&依旧是取地址 - 空指针
nullptr:指针可以等于nullptr代表不指向任何有效内存;引用不存在空引用
指针版swap和引用版swap
我们写一个同时包含指针swap、引用swap的完整程序,跑一遍直观感受差别? 好嘞,下面这份完整代码,同时放了指针版swap和引用版swap,加了打印,一眼看出区别:
#include <iostream>
using namespace std;
// 指针版 swap:需要传地址,形参是指针
void swap_ptr(int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
// 引用版 swap:形参是引用,别名
void swap_ref(int &a, int &b)
{
int temp = a;
a = b;
b = temp;
}
int main()
{
int x = 10, y = 20;
cout << "原始 x = " << x << ", y = " << y << endl;
// 指针版本调用:必须加 & 取地址
swap_ptr(&x, &y);
cout << "指针swap后 x = " << x << ", y = " << y << endl;
// 再换回来,给引用swap测试
swap_ptr(&x, &y);
cout << "换回原值 x = " << x << ", y = " << y << endl;
// 引用版本调用:直接传变量,不用&
swap_ref(x, y);
cout << "引用swap后 x = " << x << ", y = " << y << endl;
return 0;
}输出结果:
原始 x = 10, y = 20
指针swap后 x = 20, y = 10
换回原值 x = 10, y = 20
引用swap后 x = 20, y = 10关键点小结
- 指针版:定义
int *a,调用swap_ptr(&x, &y),函数内部用*a操作原值 - 引用版:定义
int &a,调用swap_ref(x, y),函数内部直接把a当成x的别名 - 效果完全一样,只是写法不同;日常C++优先引用,更简洁安全
拓展思考题: 如果写成下面这个(值传递版本),交换会失效,你知道为什么吗? 因为是形参
void swap_err(int a, int b)
{
int temp = a;
a = b;
b = temp;
}int* p 和int *p有什么区别
int* p 和 int *p 在语法上完全没有区别,编译器看待它们是一模一样的。* 紧贴类型,还是紧贴变量名,只是书写风格习惯。
int* p;
int *p;两行等价,都表示:p 是一个 int*(int指针)。
但是坑在这里!(非常重要)
如果一行同时定义多个指针,两种写法的视觉误导差别就出来了:
// 写法A:*贴类型(容易误导新手)
int* p1, p2;
// 等价于 int *p1, p2;
// p1:int* 指针 ✔
// p2:普通int变量 ❗ 不是指针!// 写法B:*贴变量名(推荐风格,不容易看错)
int *p1, *p2;
// p1、p2 两个都是int指针 ✔原因:
*属于变量,不属于类型。int是基础类型,*修饰紧跟它的那个变量。
两种风格圈子习惯
int* p:C++ 部分风格,把int*当成一个整体类型(int指针类型)int *p:传统C风格,强调*p是解引用,*属于变量
✅ 个人建议:
- 只定义单个指针:两种随便写
- 一行多个变量:
int *p1, *p2;,不容易踩坑 - 不要写
int* p1, p2;这种,很容易误以为p2也是指针
顺带区分容易混的符号
int a = 10;
int *p = &a;
// 这里三个*含义完全无关:
// 1. int *p 里的 *:声明指针标记
// 2. &a 里的 &:取地址
// 3. *p 里的 *:解引用10.分支语句 if switch
1. 单分支 if
if (布尔表达式)
{
// 条件为true才执行这里
}要点:
- 括号里面结果只有两种:true(非0) / false(0)
- if 后面没有分号!大括号成对;
- 如果只有一行代码,大括号可以省略,但新手建议永远带上大括号,防止踩坑
2. 双分支 if-else
if (布尔表达式)
{
// 条件成立
}
else
{
// 条件不成立
}3. 多分支 else if(顺序判断,命中一个就结束)
if (a == 1)
{
}
else if (a == 2)
{
}
else if (a == 3)
{
}
else // 前面全都不满足才进else,可选
{
}⚠️ 规则:从上往下依次判断,只要一个条件满足,后面所有 else if 全部跳过。
区别:if嵌套是if里面再写if;else if是并排多条件。
4. switch 语句(适合离散常量匹配)
语法:
switch(表达式)
{
case 常量1:
语句;
break;
case 常量2:
语句;
break;
default: // 可选,都不匹配时执行
语句;
}✅ 硬性规则(高频考点)
switch()里面表达式只能是整数、char、枚举;不能是浮点、字符串!case后面必须是常量,不能写变量、不能写区间(不能case a>60:)- break 非常关键:没有break会发生「case穿透」,继续往下执行后面case的代码
default放哪里都行,一般放最后
示例(图里的成绩代码,修正笔误)
#include <iostream>
using namespace std;
int main()
{
char grade = 'D';
switch(grade)
{
case 'A':
cout << "很棒!" << endl;
break;
case 'B':
case 'C': // B和C共用同一段逻辑,利用穿透
cout << "做得好" << endl;
break;
case 'D':
cout << "您通过了" << endl;
break;
case 'F':
cout << "最好再试一下" << endl;
break;
default:
cout << "无效的成绩" << endl;
}
cout << "您的成绩是 " << grade << endl;
return 0;
}输出:
您通过了
您的成绩是 D✅ if 和 switch 怎么选
- 用
if:范围判断(score >=60 && score <90)、多复杂条件、浮点数判断 - 用
switch:固定几个整数/字符选项等值匹配,代码清爽
易错小坑汇总
if(a=5)是赋值!不是判断相等;相等必须是if(a==5)(少一个=经典bug)- if后面多加分号:
if(a>0); { ... }→ 分号代表if结束,大括号代码永远执行 - switch case 漏写break,发生穿透
- case后面放变量或者小数,直接编译报错
来一道小练习:输入分数,90以上A,80~89 B,70~79 C,60~69 D,60以下F,你想用if还是switch?要不要写一下?
版本1:else if 版本(区间判断,推荐)
#include <iostream>
using namespace std;
int main()
{
int score;
cout << "请输入分数:";
cin >> score;
char grade;
if (score >= 90)
{
grade = 'A';
}
else if (score >= 80)
{
grade = 'B';
}
else if (score >= 70)
{
grade = 'C';
}
else if (score >= 60)
{
grade = 'D';
}
else
{
grade = 'F';
}
cout << "等级:" << grade << endl;
return 0;
}版本2:switch 版本(整除转常量,了解即可)
#include <iostream>
using namespace std;
int main()
{
int score;
cout << "请输入分数:";
cin >> score;
char grade;
int key = score / 10;
switch (key)
{
case 10:
case 9:
grade = 'A';
break;
case 8:
grade = 'B';
break;
case 7:
grade = 'C';
break;
case 6:
grade = 'D';
break;
default:
grade = 'F';
break;
}
cout << "等级:" << grade << endl;
return 0;
}对比总结
else if:适合分数区间判断,逻辑直观,修改条件方便,优先使用;switch:本身只能等值判断,这里利用score/10把区间压缩成数字;一旦边界不是整十,写法会很麻烦;- 共同规则:90及以上A,80~89 B,70~79 C,60~69 D,60以下F。
11.循环语句
C++三种循环:while / do while / for
1. while 循环
先判断条件,条件成立才执行;有可能一次都不执行
while (condition)
{
statement(s);
}示例:输出 1~5
#include <iostream>
using namespace std;
int main()
{
int i = 1;
while (i <= 5)
{
cout << i << " ";
i++;
}
return 0;
}2. do while 循环
先执行一次循环体,再判断条件;最少执行1次
注意:末尾
while(条件)后面有分号,这个是高频易错点!
do
{
statement(s);
} while (condition);示例:输出 1~5
#include <iostream>
using namespace std;
int main()
{
int i = 1;
do
{
cout << i << " ";
i++;
} while (i <= 5);
return 0;
}3. for 循环(最常用,适合已知循环次数)
for (init; condition; increment)
{
statement(s);
}执行顺序:
init:初始化变量,只跑1次- 判断
condition,true → 执行循环体;false → 结束循环 - 循环体跑完,执行
increment(i++这类) - 回到第2步,重新判断条件
示例:输出 1~5
#include <iostream>
using namespace std;
int main()
{
for (int i = 1; i <= 5; i++)
{
cout << i << " ";
}
return 0;
}4. 无限循环写法
// for无限循环
for (;;)
{
cout << "无限循环" << endl;
}// while无限循环
while (true)
{
cout << "无限循环" << endl;
}✅ 三者对比小结
- while:先判后执行,次数可能0次;适合不知道循环次数的场景
- do while:先执行后判,至少1次;比如输入校验(先输入再判断是否合法)
- for:初始化、条件、增量放一起;已知循环次数首选
小练习
用循环求 1+2+3+...+100,你想先用哪个循环写?
break
直接跳出整个循环,循环彻底结束
#include <iostream>
using namespace std;
int main()
{
for (int i = 1; i <= 10; i++)
{
if (i == 5)
{
break; // i等于5,直接跳出for,后面不再循环
}
cout << i << " ";
}
return 0;
}输出:
1 2 3 4遇到 break → 循环终止。
continue
跳过本次循环剩下的代码,直接进入下一轮条件判断,循环本身不结束
#include <iostream>
using namespace std;
int main()
{
for (int i = 1; i <= 10; i++)
{
if (i == 5)
{
continue; // i等于5,跳过这次剩下语句,直接i++,下一轮
}
cout << i << " ";
}
return 0;
}输出:
1 2 3 4 6 7 8 9 105 没有打印,但是循环继续跑。
嵌套循环里的注意点(重点!)
break / continue 只管离它最近的那一层循环,不会一次性跳出多层:
#include <iostream>
using namespace std;
int main()
{
for (int i = 1; i <= 3; i++)
{
for (int j = 1; j <= 3; j++)
{
if (j == 2)
{
break; // 只跳出内层j循环,外层i还会继续
}
cout << "i=" << i << ", j=" << j << endl;
}
}
return 0;
}一句话区分
break:不干了,循环结束 ✋continue:这次不算,下一个!⏭️
小练习题
输出 1~20,遇到 7 的倍数就跳过,遇到 16 直接停止程序,你来写一下?
遍历数组
C++11 新增的范围for循环(range-based for),专门用来遍历数组、vector这类容器,写法简洁很多。
基础语法
for (auto 变量 : 容器/数组)
{
// 变量依次拿到里面每一个元素的值
}示例1:遍历普通数组(只读)
#include <iostream>
using namespace std;
int main()
{
int arr[] = {10, 20, 30, 40};
for (auto a : arr)
{
cout << a << " ";
}
return 0;
}输出:10 20 30 40
这里的
auto a是拷贝一份元素,修改a不会改变原数组。
示例2:引用版本,能修改原数组元素(加 &)
#include <iostream>
using namespace std;
int main()
{
int arr[] = {10, 20, 30, 40};
for (auto &a : arr)
{
a *= 2;
cout << a << " ";
}
return 0;
}输出:20 40 60 80
示例3:const引用,只读、避免拷贝(推荐大对象)
#include <iostream>
using namespace std;
int main()
{
int arr[] = {10, 20, 30, 40};
for (const auto &a : arr)
{
cout << a << " ";
}
return 0;
}⚠️ 重要限制(考点)
- 范围for 只能遍历整个容器/数组,不能直接控制起点、终点、步长(比如只遍历第2个到倒数第2个,就做不到);
- 普通C风格数组如果传到函数里退化成指针,不能用范围for;
- 和老式for区分:
// 老式for:控制自由度高
for(int i = 0; i < 4; i++)
{
cout << arr[i];
}一句话总结
for(auto a : arr):方便从头到尾挨个读取全部元素,写起来省事;- 要跳着遍历、控制下标、中途从中间退出,还是用传统for循环。 先说重点:范围for遍历二维数组稍微绕一点,二维数组本质是「数组里面每一个元素,本身又是一个一维数组」。
#include <iostream>
using namespace std;
int main()
{
int arr[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
// 外层:每一行是一个 int[4] 的一维数组
for (auto &row : arr)
{
// 内层:遍历这一行里面每个数字
for (auto &val : row)
{
cout << val << " ";
}
cout << endl;
}
return 0;
}✅ 一定要加
&! 如果写for(auto row : arr),会尝试拷贝数组,数组不能拷贝,直接编译报错。
输出:
1 2 3 4
5 6 7 8
9 10 11 12三种写法区分
- 想要修改二维数组里面的值:
auto &row、auto &val
for (auto &row : arr)
{
for (auto &val : row)
{
val *= 2;
}
}- 只读取、不修改,推荐(避免拷贝开销):
const auto &
for (const auto &row : arr)
{
for (const auto &val : row)
{
cout << val << " ";
}
}- 传统下标for对比(更好控制下标、跳行)
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
cout << arr[i][j] << " ";
}
cout << endl;
}⚠️ 坑点提醒
- 二维数组作为函数参数传进去退化成指针之后,不能直接用范围for;
- 范围for只能从头到尾完整遍历,不能指定从第2行开始、步长2这种;
- 只有大小固定的原生二维数组可以这么写;
int**动态数组不能直接for(auto &row : arr)。
拓展:如果是 vector 二维容器(vector<vector<int>>),写法一模一样,更好用
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<vector<int>> vec = {{1,2},{3,4},{5,6}};
for (auto &row : vec)
{
for (auto &v : row)
{
cout << v << " ";
}
cout << endl;
}
return 0;
}练习答案
第一题:输出1~20,7的倍数跳过,碰到16直接停止
#include <iostream>
using namespace std;
int main()
{
for (int i = 1; i <= 20; i++)
{
if (i == 16)
{
break;
}
if (i % 7 == 0)
{
continue;
}
cout << i << " ";
}
return 0;
}输出:1 2 3 4 5 6 8 9 10 11 12 13 15
说明:到16直接break结束;7、14是7的倍数,被continue跳过。
第二题:1+2+…+100,三种循环版本放一起给你对照
for版本(最推荐,已知循环次数)
#include <iostream>
using namespace std;
int main()
{
int sum = 0;
for (int i = 1; i <= 100; i++)
{
sum += i;
}
cout << "sum = " << sum << endl;
return 0;
}while版本
#include <iostream>
using namespace std;
int main()
{
int sum = 0;
int i = 1;
while (i <= 100)
{
sum += i;
i++;
}
cout << "sum = " << sum << endl;
return 0;
}do while版本
#include <iostream>
using namespace std;
int main()
{
int sum = 0;
int i = 1;
do
{
sum += i;
i++;
} while (i <= 100);
cout << "sum = " << sum << endl;
return 0;
}三个代码结果都是 sum = 5050
12.函数
一、函数定义格式
返回值类型 函数名(参数列表)
{
函数体;
}示例:求两个数较大值(图里的例子,注意:局部变量不要和函数重名,容易报错,我改一下)
#include <iostream>
using namespace std;
int max(int num1, int num2)
{
int res;
if (num1 > num2)
res = num1;
else
res = num2;
return res;
}
int main()
{
cout << max(3, 7);
return 0;
}return:把结果返回给调用处;- 返回类型写
void代表无返回值,可以不写return,也可以写单独return;。
二、三种传参方式(重点,面试常考)
1. 值传递(拷贝,改不了外面变量)
#include <iostream>
using namespace std;
void swap(int x, int y)
{
int temp = x;
x = y;
y = temp;
}
int main()
{
int a = 1, b = 2;
swap(a, b);
cout << a << " " << b; // 还是1 2,交换失败
return 0;
}原理:x,y 只是a,b的副本,函数内部修改的是副本,和外面无关。
2. 指针传递(传地址,可以修改原值)
#include <iostream>
using namespace std;
void swap(int *x, int *y)
{
int temp = *x;
*x = *y;
*y = temp;
}
int main()
{
int a = 1, b = 2;
swap(&a, &b); // 取地址传入
cout << a << " " << b; // 2 1,交换成功
return 0;
}3. 引用传递(C++推荐,写法简单)
#include <iostream>
using namespace std;
void swap(int &x, int &y)
{
int temp = x;
x = y;
y = temp;
}
int main()
{
int a = 1, b = 2;
swap(a, b); // 调用和值传递一样,不用加&
cout << a << " " << b; // 2 1,交换成功
return 0;
}✅ 对比一句话:
- 值传递:拷贝一份,不能改外面
- 指针传递:传地址,能改,调用要加
&,函数内解引用*x - 引用传递:别名,能改,写法干净,C++优先用
三、参数默认值
规则:带默认值的参数必须放在参数列表靠右的位置;不传这个参数,自动使用默认值;传了就用传入的值。
#include <iostream>
using namespace std;
int sum(int a, int b = 20)
{
return a + b;
}
int main()
{
cout << sum(100, 200) << endl; // 100+200=300
cout << sum(100) << endl; // 只传a,b用默认20 → 120
return 0;
}⚠️ 错误写法:int sum(int a=20, int b) 默认参数放左边,编译报错。
补充:函数声明(函数原型)
如果函数写在main后面,需要提前声明,否则找不到函数:
#include <iostream>
using namespace std;
int max(int num1, int num2); // 函数声明
int main()
{
cout << max(2,9);
return 0;
}
int max(int num1, int num2)
{
return num1>num2 ? num1 : num2;
}小练习
写一个函数,求1~n的累加和,n用默认值100。 要不要你来写,或者我直接给答案?
#include <iostream>
using namespace std;
// 函数:求1~n累加和,n默认值100
int getSum(int n = 100)
{
int sum = 0;
for (int i = 1; i <= n; i++)
{
sum += i;
}
return sum;
}
int main()
{
// 不传参数,使用默认n=100
cout << "1~100的和:" << getSum() << endl;
// 传入参数,覆盖默认值
cout << "1~10的和:" << getSum(10) << endl;
return 0;
}输出:
1~100的和:5050
1~10的和:55补充说明:
- 默认参数
n = 100写在形参里; - 调用
getSum()不填实参,自动取n=100; - 调用
getSum(10)传入实参,就会覆盖默认值。
13.函数指针
一句话:函数名本身就是函数的入口地址;函数指针就是用来存放这个函数地址的指针变量。
语法
返回值类型 (*指针名)(参数类型列表);⚠️ 括号不能少!int (*p)(int,int) ✅ 如果写成 int *p(int,int) 就变成函数声明(返回int*的函数)❌
含义:p 是一个指针,只能指向:返回值int、接收两个int参数的函数。
完整示例(图里的add例子,补全头文件)
#include <iostream>
using namespace std;
int add(int a, int b)
{
return a + b;
}
int main()
{
// 定义函数指针p
int (*p)(int, int);
// 函数名add就是地址,赋值给p
p = add;
// 两种调用方式,效果完全一样
cout << (*p)(14, 25) << endl;
cout << p(14, 25) << endl;
return 0;
}输出:
39
39说明:
p(14,25)是简写,C++允许直接像函数一样调用,不用强制解引用(*p)。
再写一个对比:之前的max函数,用函数指针
#include <iostream>
using namespace std;
int max(int a, int b)
{
return a > b ? a : b;
}
int main()
{
int (*funcPtr)(int, int) = max;
cout << funcPtr(9, 3) << endl;
return 0;
}using 简化写法(C++11推荐,方便阅读)
函数指针原生写法很绕,可以给这个类型起别名:
#include <iostream>
using namespace std;
int add(int a, int b)
{
return a + b;
}
// FuncType 代表:返回int,两个int参数的函数类型
using FuncType = int (*)(int, int);
int main()
{
FuncType p = add;
cout << p(2, 8);
return 0;
}核心考点小结
- 函数指针有严格的匹配要求:返回值、参数数量、参数类型必须一致,不然不能赋值;
- 作用:可以把函数当成参数传递(回调函数)、做函数表;
- 区分:
int (*p)(int,int):函数指针int *p(int,int):一个函数,返回int*
拓展小例子:函数指针做参数(回调)
#include <iostream>
using namespace std;
int add(int a, int b)
{
return a + b;
}
int calc(int x, int y, int (*f)(int,int))
{
return f(x, y);
}
int main()
{
cout << calc(10, 20, add);
return 0;
}14.函数重载(Overload)
核心规则:函数名字相同,参数列表(函数签名)不同,构成重载;仅返回值不一样,不能作为重载依据!
参数列表不同包含三种情况:
- 参数个数不同
- 参数类型不同
- 参数类型的顺序不同
❌ 重点坑:只有返回值不一样,不算重载,直接编译报错
// 错误!不算重载,冲突
int fun(int a);
void fun(int a);完整示例
#include <iostream>
using namespace std;
// 1. 参数类型不同
void f(char b)
{
cout << "f(char)" << endl;
}
void f(int a)
{
cout << "f(int)" << endl;
}
// 2. 参数个数不同
void f(int a, char b)
{
cout << "f(int, char)" << endl;
}
// 3. 参数类型顺序不同
void f(char b, int a)
{
cout << "f(char, int)" << endl;
}
int main()
{
f(10); // 调用 f(int)
f('a'); // 调用 f(char)
f(1, 'x'); // 调用 f(int, char)
f('y', 2); // 调用 f(char, int)
return 0;
}编译器怎么选?
调用的时候,编译器根据你传入实参的数量、类型去匹配最合适的重载版本。
和默认参数一起用的时候容易踩坑(高频考点)
void func(int a);
void func(int a, int b = 10);
// func(5); 报错!歧义,编译器不知道调用哪一个一句话总结
同名函数,靠参数区分,不靠返回值区分,这就是重载。
补充区分(容易混淆)重载与重写
- 重载:同一个作用域,同名、参数不同
- 重写(覆盖):继承里面,子类重写父类虚函数(后面面向对象才学)
要不要给你来一道判断哪些能构成重载的小题?
判断下面哪些是合法重载(同一作用域下)
1. void test(int a);
int test(int a);
2. void test(int a);
void test(double a);
3. void test(int a, int b);
void test(int b, int a);
4. void test(int a, char b);
void test(char a, int b);
5. void test(int a);
void test(int a, int b = 10);
6. void test(int* p);
void test(const int* p);你可以先自己判断,我之后给答案+解析。
需要我等你回答,还是直接公布? ✅ 答对的:2、4 我们逐条解析:
1. void test(int a);
int test(int a);❌ 不构成重载。仅仅返回值不同,参数列表完全一样,编译报错。
2. void test(int a);
void test(double a);✅ 合法重载。参数类型不一样。
3. void test(int a, int b);
void test(int b, int a);❌ 不构成重载。两个都是 (int, int),只是参数名字换了,类型顺序没变,签名相同。参数名不参与签名。
4. void test(int a, char b);
void test(char a, int b);✅ 合法重载。类型顺序:int,char 和 char,int,签名不一样。
5. void test(int a);
void test(int a, int b = 10);❌ 语法上可以同时存在,但是调用 test(1) 的时候会产生二义性,实际使用有坑,考试一般判定为有歧义、不推荐。
6. void test(int* p);
void test(const int* p);✅ 其实这个也是合法重载(指针的底层const不同,属于签名差异),这个属于稍微进阶一点的考点,容易忽略。
总结标准答案清单: ✅ 合法重载:2、4、6 ❌ 非法:1、3;5存在调用歧义
15.内联函数 inline
inline 内联函数 与 #define,const的区别
作用
普通函数:调用的时候 → 跳转、保存现场、执行、返回,有一点点调用开销。 inline 内联函数:编译器尝试把函数代码直接“粘贴”到调用的地方,不发生函数跳转,省去调用开销。
注意:
inline只是给编译器的建议,不是强制!编译器觉得不合适,会自动忽略inline,当成普通函数。
语法
inline 返回值 函数名(参数)
{
函数体
}例子
#include <iostream>
using namespace std;
inline int max(int a, int b)
{
return a > b ? a : b;
}
int main()
{
cout << max(3,5);
return 0;
}编译后近似等价于直接展开:
cout << (3 > 5 ? 3 : 5);✅ 适合写成 inline 的情况
函数很短、代码少(比如一两行,简单计算),频繁调用。 比如求最大值、判断、简单四则运算。
❌ 不适合 inline(编译器大概率拒绝)
- 函数里面有循环、
if分支很多、代码很长 - 递归函数(自己调用自己)
- 包含复杂逻辑的大函数
⚠️ 重要考点
- inline 函数的定义一般要放在头文件里 因为编译器需要看见函数本体,才能做代码展开;如果只声明不写定义在头文件,展开失败。
普通函数:声明放.h,定义放.cpp;inline大多.h里面直接写完整函数。
- 和宏
#define的对比(选择题高频)
// 宏(预处理直接文本替换,有坑,不做类型检查)
#define MAX(a,b) ((a)>(b)?(a):(b))
// inline函数(C++推荐,有类型检查,安全)
inline int Max(int a,int b)
{
return a>b?a:b;
}宏的坑示例:
MAX(i++, 5); // 会把i++执行两次,结果出错!
// inline不会有这个问题,参数只计算一次- inline 只是建议,不是命令,编译器有权不内联。
一句话区分
- 宏:预处理文本替换,没有类型检查,不安全
- inline内联函数:编译期尝试展开,有类型检查,优先选inline代替宏
小练习题
下面哪个适合写成inline? A. 一个里面有for循环求和的函数 B. 两行代码,取两个数最小值的函数 C. 递归求阶乘函数
✅ 正确答案:B 解析:
- A:里面有for循环,代码较长,不适合inline,编译器基本不会展开
- B:简短的取最小值函数,频繁调用,非常适合inline
- C:递归函数,不能内联
const 常量(C++里非常高频)
const 核心:修饰的变量只读,不能修改
const int a = 10;
a = 20; // ❌ 报错,不能修改注意:const变量定义的时候必须初始化
几种常见写法(重点区分)
1. const 修饰普通变量
const int num = 100;num只读,不能改。
2. const 修饰指针(最容易混淆,考试常客)
口诀:看const离谁近,就锁住谁
// 情况1:const 在 * 左边 → 锁住【指向的内容】,内容不能改;指针本身可以改
const int *p;
int a = 1, b = 2;
p = &a;
// *p = 100; ❌ 不能改*p
p = &b; // ✅ p自己可以换指向
// 情况2:const 在 * 右边 → 锁住【指针本身】,指针不能换指向;内容能改
int * const p = &a;
*p = 200; // ✅ 内容可以改
// p = &b; ❌ 指针p不能改指向
// 情况3:两边都加const → 内容、指针都锁死,全都不能改
const int * const p = &a;3. const 修饰函数形参(保护参数不被误改)
// 不想函数内部修改str,加const
void print(const string &str)
{
cout << str;
}4. const 修饰成员函数(后面学类的时候用,先记一句)
void fun() const; 代表这个成员函数不能修改类里面的成员变量
const 和 #define 宏常量对比
#define N 100 // 预处理替换,没有类型
const int N = 100; // 有类型,编译器做类型检查,更安全,C++优先用const小选择题
int x = 10;
const int *p = &x;
*p = 20;请问会不会报错?
指针常量
int * const p = &x;const 在 * 的右边,锁住指针变量p本身,p一旦绑定了x的地址,就不能再指向别的变量,所以 p = &y; 报错。 但是 *p = 20; 是合法的,可以修改它指向的数据。
再汇总一遍口诀,方便背
const int *p:指向常量的指针 → 值不能改,指针能换指向int * const p:常量指针 → 指针不能换指向,值能改const int * const p:都锁住 → 值和指针全都不能改
