关于一维数组和字符串的详细讲解（从属于GESP三级）

本章内容

一维数组基础

字符串基础

 

就像打磨一串符号，每个位置都要精准对待，才能串起完整的风景。坚持下去，小细节终将成就大格局。

一、⼀维数组基础

---

1 📚 定义

典型写法	说明	易错/拓展
int a[5];	编译期长度常量，元素默认未初始化	写成 a[5] = {} 非法
const int N=1e5; int a[N];	朴素大数组，栈内存可能溢出 → 用 static 或全局
vector<int> a(n);	运行期决定长度，底层仍连续	考级重点仍以静态数组为主

内存模型

• • 连续区块；地址按元素大小递增
• • 指针算术：*(a+3) == a[3]
• • 越界访问 编译能过但运行 UB，考题常借此设陷阱

---

2 🔤 赋初值

场景	写法 (≤4 字母)	说明
完全列表	int a[3]={1,2,3};	列表短缺处默认补 0
全 0	int a[100]={0};	省略其余元素
运行期读入	for(int &x:a) cin>>x;	需已知 n
批量同值	fill(a,a+n,5);	<algorithm>
字符串	char s[]="ABC"; 长度 4 含 \0	易考点

⚠️ 越界陷阱

• • 初始化列表元素 > 长度 → 编译错误
• • 读入循环 i<n 必须用 <，写成 <= 会写到第 n 个非法位置

---

3 🧩 遍历

3.1 指定示例（标准 for）

for(int i=0;i<n;i++) cout<<a[i];

• • 保证 i 范围 0 … n-1
• • 常嵌套 if、sum += a[i] 等逻辑
• • 输出时可加空格/换行避免粘连

3.2 拓展写法

写法	适用	备注
for(int &x:a) …	C++11 范围for	不需要下标，读写皆可
指针	for(int *p=a;p<a+n;p++) …	体现连续存储思想
逆序	for(int i=n-1;i>=0;i--) …	i 为 int 足够时注意 i-- 条件

越界警示：循环上界必须与真实元素个数一致；考试常故意给 for(i<=n) 检错。

---

4 🌟 计数

4.1 基础计数：统计满足条件元素个数

int cnt=0;
for(int i=0;i<n;i++) if(a[i]%2==0) cnt++;
cout<<cnt;

• • 时空复杂度：O(n) / O(1)
• • 典型真题：统计负数、偶数、特定区间元素等

4.2 频次数组（桶）

const int M=101;          // 元素范围 0~100
int buc[M]={0};
for(int i=0;i<n;i++) buc[a[i]]++;

• • 空间 O(M)，查询任意值出现次数 buc[v] O(1)
• • 若 M 大，可用 unordered_map<int,int> (考级一般不超标)

4.3 前缀和计数（高级拓展）

vector<int> pre(n+1,0);
for(int i=1;i<=n;i++) pre[i]=pre[i-1]+(a[i-1]==x);
// 区间 [l,r) 中值 == x 的个数:
int ans=pre[r]-pre[l];

• • 适合多组区间统计，查询 O(1)，整体 O(n+q)
• • 为后续二级以上“区间和 / 差分”内容埋点

---

5 🌀 综合示范：输入 n 个数，输出最大值及其出现次数

#include<bits/stdc++.h>
using namespace std;int main(){int n; cin>>n;vector<int> a(n);for(int &x:a) cin>>x;int mx=a[0], cnt=0;for(int i=0;i<n;i++){if(a[i]>mx){ mx=a[i]; cnt=1; }else if(a[i]==mx) cnt++;}cout<<mx<<" "<<cnt<<"\n";return 0;
}

• • 变量命名：mx, cnt 均 ≤4 字母
• • 单趟遍历同时完成 “遍历+计数”
• • 无越界；vector 封装长度，安全友好

---

6 🛠️ 常见易错汇总

易错	纠正	关联考点
int a[n]; 其中 n 为变量	静态数组需编译期常量；用 vector<int> a(n);	定义
char s[5]="GESP";	需长度 ≥5；含 \0	赋初值
for(int i=0;i<=n;i++)	上界应 < n	遍历
计数器未初始化	int cnt=0;	计数
忘记 return 0;	主函数末尾加	综合

---

📚 二、字符串专题

• • C-风格 char 数组字符串
• • C++ string 对象
• • 考试常见函数、易错陷阱与典型题型

---

🏗️ 1 总体对比

特性	char s[] （数组）	string （类对象）
申请	必须给定长度；手动保证结尾\0	无需显式长度；容量自动扩展
输入/输出	cin >> s / printf；getline需 cin.getline	cin >> s / cout << s；整行用 getline(cin,s)
长度	strlen(s)	s.size() / s.length()
拼接	手写循环或 strcat	直接 + 或 append
安全	易越界、需手动释放 new 空间	越界抛异常；RAII 自动管理
三级真题命中	长度含\0；下标越界无编译错	find / replace 、拼接、比较等

---

🔤 2 C-风格 char 串

2.1 定义与初始化

char t[6]="Hello";   // 长度=5+1('\0')
char s[1001] = {};  // 全部置 '\0'

考点：char str[]="Hello"; 实际长度 6（含结束符）

2.2 安全输入

场景	代码	说明
无空格	scanf("%1000s",s);	指定宽度防溢出
含空格	cin.getline(s,1001);	读取到回车

若前面用 cin >>，先 cin.ignore() 或者 getchar() 吃掉残留换行。

2.3 遍历

• • 用长度的方式进行遍历，类似普通数组：

char s[1001];    
cin >> s;            
int l;
l = strlen(s);
for (int i = 0; i < l; i++){    //字符串的首位是下标 0，故元素分布在 0 到 长度-1 cout << s[i] << " ";
}

• • 用数组类型字符串的特性遍历，即最后一位是结束符 '\0'：

char s[1001];    
cin >> s;
for (int i = 0; s[i] != '\0'; i++){        // 只要元素不等于'\0' ，就一直遍历cout << s[i] << " ";
}

思考，若一个数组类型字符串中出现多个结束符，会如何？

2.4 常用库函数

任务	函数	复杂度
长度	strlen(s)	O(n)
拷贝	strcpy(dst,src)	O(n)
拼接	strcat(a,b)	O(n)
查找	strchr(s,'x') / strstr(s,"ab")	O(n)
比较	strcmp(a,b)	O(n)

重叠内存用 memmove 不是 strcpy——真题多考。

2.5 易错清单

• • 忘记腾出 \0 空间 → 运行时覆盖内存
• • 将字面量 "hi" 赋给 char* p 后写入 → 只读区 UB
• • toupper(ch) 需 (unsigned char) 强转，防负值
• • 指针算术跨段越界考试常隐藏测试数据

---

3 🌟 string 对象

3.1 快速语法卡

string a="abc", b(5,'*');   // "*****"
string c=a+b;               // 拼接
a += "XYZ";
int n=a.size();             // 长度
a.insert(3,"OK");           // abcd → abcOKd
a.erase(1,2);               // 删除 abcde → ade
a.insert(2,b);                // 插入 a="abc", b="xyz" -> abxyzc
a.substr(2,4);                // 提取 abcde → cde
sort(s.begin(),a.end());    // 排序
size_t p=a.find('K');       // a.find('K') != string::npos 不等于 npos 则存在'K'，否则不存在
a.replace(0,5,"C++");       // 用 "C++"替换下标0开始的5个字符，a = "hello world" 输出 "C++ world"

3.2 直接比较

可以用 ==, <, > 直接比较大小，按字典序："Apple" < "banana"

三年内多次出现大小判断陷阱（忽略大小写需先 transform）

string str1 = "Hello";
string str2 = "hello";
transform(str1.begin(), str1.end(), str1.begin(), ::tolower);
transform(str2.begin(), str2.end(), str2.begin(), ::tolower);

3.3 输入技巧与混用陷阱

int n;  cin>>n;
cin.ignore();          // 丢弃换行
string line;
getline(cin,line);     // 安全读取整行

未 ignore() 时 getline 会读到残余换行导致空串——23 年、24 年判题常设此坑。

---

🌀 4 高频真题模块

模块	真题示例	关键知识
长度含\0	23 年6月单选 #5	char 数组末尾结束符
find /replace	25 年3月单选 #13 （HelloC++）	返回值 npos；区间参数
toupper 大小写	24 年6月单选 #8（GESP IS INTERESTING）	逐字符转换
拼接 & 回文	24 年9月编程《回文拼接》	substr 切片；双指针
长度/容量题	strlen , sizeof 混淆；多在判断题考	区分“已用”与“空间”

---

🏁 小结

• • char 数组：记得“+1”留给 '\0'，scanf/getline 要限宽；库函数依赖结束符。
• • std::string：拼接、比较一行搞定；find/replace/substr 是三级命题最爱。
• • 混合输入：cin+getline 必用 ignore；跨越空格用 getline 接管。
• • 真题复现：长度计算、替换输出、大小写转换、npos 判断，每年必考。

🧩 三、条件复合判断全景梳理

本节聚焦 逻辑运算符组合、if-else if 嵌套 以及 执行顺序/陷阱。

---

1 🧪 逻辑运算符基础

运算符	说明	短路特性
&&	且 ：左假即假	左表达式为假则右侧不执行
`		`
!	取反	单目，无短路

短路副作用：右侧带函数调用或自增时要小心if(a!=0 && b/a>1) —— 当 a==0 时不做除法，避免异常。

---

2 📏 条件嵌套组合示例

int x; cin>>x;
if(x%2==0 && x%3!=0){           // 偶数且不能被 3 整除cout<<"A\n";
}else if((x%2 || x%3) && x<100){ // (2 或 3 不能整除) 且 <100cout<<"B\n";
}

• • 分析顺序：

1. 1. 1. 布尔运算符优先级：! > && > ||
   2. 2. 括号可提升可读性，避免误解

• • 常考陷阱：写成 x%2==0 && !x%3==0 实际含义不同

• • • !x%3 先取反再模 3 ⇒ 逻辑错误

---

3 🔍 多条件 if-else if 链

int sc; cin>>sc;
if(sc>=90)       cout<<"A";
else if(sc>=80)  cout<<"B";
else if(sc>=70)  cout<<"C";
else             cout<<"D";

1. 1. 自上而下 第一次为真就执行，后续分支全部跳过。
2. 2. 区间覆盖：条件应互斥，否则将出现永远执行不到的分支。

if(n>0)         ...
else if(n>10)   ...   // ⚠ 永远进不到；应把第二行写成 n>10 BEFORE n>0

1. 3. else 绑定最近 if

if(a)if(b) do1();else  do2();   // else 关联的是内层 if(b)

解决歧义：加 {} 或使用 else if 明确结构。

---

4 ⚖️ 执行顺序与短路细节

代码片段	实际执行顺序	典型问题
if(f1() && f2())	先 f1()，若返回假，f2() 不调用	初学者以为都会执行
`if(f1()		f2())`
int y = (x>0) ? fun1() : fun2();	三目运算同样短路	两函数只会调用一个

---

5 🔧 高频陷阱清单

⚠️ 误写	正解	原因
if(a=b)	if(a==b)	赋值代替比较，a=b 返回左值
if(x&1==1)	if((x&1)==1) 或 x&1	& 优先级低于 ==
忘记花括号	if(cond) stmt1; stmt2;	只控制第一条语句
冗余判断	if(x>10) … else if(x>20)…	第二分支永远假
多重否定	!!(x%2==0) 可直接写 x%2==0	可读性差

---

6 ✨ 真题式练习 2 例

练习 1 偶数但非 4 的倍数

输入整数 n，若 n 为偶数且 不是 4 的倍数输出 Yes，否则输出 No。

#include<bits/stdc++.h>
using namespace std;
int main(){int n;cin>>n;// n 为偶数: n%2==0   不是 4 的倍数: n%4!=0cout<<( (n%2==0 && n%4!=0) ? "Yes":"No" );
}

考点：嵌套 && 与 !=；注意括号可省但推荐。

---

练习 2 区间分类（多分支）

读入成绩 s，按照 [≥90]、[80-89]、[60-79]、[<60] 输出等级 A/B/C/D。

#include<bits/stdc++.h>
using namespace std;
int main(){int s;cin>>s;if(s>=90)         cout<<'A';else if(s>=80)    cout<<'B';else if(s>=60)    cout<<'C';else              cout<<'D';
}

考点：else if 顺序必须由大到小保证互斥覆盖。

---

7 🔚 小结 & 应试技巧

1. 1. 先写括号再删：复杂逻辑先全包围，确认无歧义后可简化。
2. 2. 互斥顺序：else if 链按区间大小或优先级排序，避免“死分支”。
3. 3. 短路意识：带副作用的表达式必须确保其一定执行（或一定不执行）。
4. 4. 编译器警告：开启 -Wall -Wextra；多数误把 = 写成 == 会被提示。
5. 5. 调试断点：怀疑短路时，在每个函数或逻辑片段放打印/断点确认执行路径。

📊 四、数组 × 字符串组合技巧一览（统计 / 计数 / 提取）

1. 1. 读取整数串 → 统计奇数 &“美丽数”
2. 2. 数组桶法：统计 0 – 9 数字出现频次
3. 3. 从混合字符串提取数字与字母

---

1️⃣ 统计奇数 & “美丽数字”

美丽数字：各位数字之和是 10 的倍数（示例定义，可自行替换）

步骤

步	操作	说明
1	getline 读整行到 string s	允许空格
2	stringstream ss(s) 分词	依次取整数
3	保存到 vector<int> a	动态一维数组
4	遍历 a 计数	odd 、bea

代码

#include<bits/stdc++.h>
using namespace std;bool beau(int x){           // 判“美丽”int sum=0;for(;x;x/=10) sum+=x%10;return sum%10==0;
}int main(){string s; getline(cin,s);          // 1stringstream ss(s);               vector<int> a; int v;             while(ss>>v) a.push_back(v);       // 2-3int odd=0, bea=0;for(int x:a){                      // 4if(x&1)       ++odd;           // 奇数if(beau(x))   ++bea;           // 美丽数}cout<<"odd="<<odd<<" beau="<<bea<<"\n";
}

复杂度：O(n) 时间 / O(n) 空间（n = 整数个数）。

---

2️⃣ 数组桶：0 – 9 频次统计

当数值范围 有限且连续 时，一维数组可作“桶”存频次，比 map 快且省内存。

#include<bits/stdc++.h>
using namespace std;
int main(){string s; getline(cin,s);          // 输入如 "2 8 6 2 9 0 8 8"int buc[10]={0};                   // 0-9 桶stringstream ss(s);int x;while(ss>>x) if(0<=x && x<=9) ++buc[x];for(int i=0;i<10;i++)cout<<i<<":"<<buc[i]<<" \n"[i==9];
}

要点

• • 桶长 M=10，空间 O(1)。
• • 输入值需先判断合法区间，避免越界。
• • 若统计字母，可改 int buc[26] 并用 ch-'A' 作下标。

---

3️⃣ 从混合串提取数字 & 字母

#include<bits/stdc++.h>
using namespace std;
int main(){string t; getline(cin,t);                 // e.g. "Room 404 at 8:30PM!"string dig, alp;                          // 结果字符串for(char c:t){if(isdigit((unsigned char)c)) dig+=c; // 提取数字else if(isalpha((unsigned char)c)) alp+=c;}cout<<"num="<<dig<<"\nlet="<<alp<<"\n";
}

延伸：转成整数数组再统计

vector<int> nums;
for(size_t i=0;i<dig.size();i++)nums.push_back(dig[i]-'0');               // '7'→7

---

🚩 常见陷阱速记

⚠️	说明	修正
strtok 对 const char*	会修改原串	先拷贝到可写缓冲
桶数组越界	下标来自输入值	先判断范围
isdigit(c) 负值 UB	unsigned char 转型	(unsigned char)c
混用 >> 与 getline	残留换行导致空读	cin.ignore() 抛掉换行
统计字母忽略大小写	需统一大小写	toupper / tolower

---

🧩 小练习

1. 1. 手机号识别：输入一行文本，抽取所有连续 11 位数字串并统计出现次数。
2. 2. 最高频字母：读入一段英文句子，输出出现次数最多的字母（忽略大小写）。
3. 3. 数字之和是质数：给定整数数组，统计数字和为质数的元素个数（可借助桶加素数筛）。

---

五、精选选择题（10 题）

✅ 1.【一维数组 · 真题】

题目：double a[3]; 能访问的最大合法下标是
A. 0 B. 2 C. 3 D. 4
答案：B
解析：长度为 3 的数组下标范围 0…2，3 越界。

---

✅ 2.【char 字符串】

题目：char s[] = "GESP"; 语句执行后 sizeof(s) 的结果为
A. 4 B. 5 C. 6 D. 8
答案：B
解析：字面量 4 字节，编译器自动添加结束符 '\0'，共 5 字节。

---

✅ 3.【std::string · 真题】

题目：已知 string t="HelloWorld";，下列哪条语句能直接将 t 变成 "HelloC++"？
A.t.replace(0,5,"C++");
B.t.replace(5,5,"C++");
C.t.insert(5,"C++");
D.t.erase(5,5);
答案：B
解析：从下标 5 开始替换 5 个字符 "World"。

---

✅ 4.【数组存储】

题目：关于数组在内存中的布局，下列说法正确的是
A. 元素可能不连续
B. 连续且地址按元素大小递增
C. 下标与物理顺序无必然关系
D. 数组名代表首元素的值
答案：B
解析：C/C++ 规定数组元素连续存放，地址递增。

---

✅ 5.【char 函数】

题目：若 char s[6]="abcde";，以下调用能把数组内容复制到dst并保证以\0结尾的是
A.strcpy(dst,s);
B.strncpy(dst,s,5);
C.memcpy(dst,s,5);
D.strncat(dst,s,5);
答案：A
解析：strcpy复制到遇\0为止并写入结束符；strncpy不会自动写\0，memcpy同理，strncat 需目标串已有结束符。

---

✅ 6.【std::string 比较】

题目：string a="apple", b="Banana"; 执行 cout<<(a<b); 输出（假设 true 为 1）
A. 0 B. 1 C. 不确定 D. 取决于长度
答案：A
解析：字典序逐字符比较；首字符 'a'(97) > 'B'(66)，故 a<b 为假，输出 0。

---

✅ 7.【混合输入】

题目：下面代码意在读取整数 n 后再读取一整行字符串 line，正确的空缺语句是

int n; string line;
cin >> n; ________;        // ←此处
getline(cin,line);

A.cin.flush(); B.cin.ignore(); C.cin.sync(); D. 不需要任何语句
答案：B
解析：cin >> n 保留换行符；需 ignore() 丢弃，否则 getline 读取空行。

---

✅ 8.【数组初始化】

题目：以下数组定义中合法的是
A.int a[];
B.int b[0];
C.char c[5] = {};
D.double d[3.5];
答案：C
解析：静态数组须给出正整数常量长度；{} 可全部初始化为 0。

---

✅ 9.【string 查找】

题目：若 string s="GESP";，下列表达式返回 string::npos 的是
A.s.find('S');
B.s.find("ES");
C.s.find('Z');
D.s.rfind('G');
答案：C
解析：'Z' 不存在，其余均能匹配。

---

✅ 10.【数组大小】

题目：int arr[100]; 在 64 位系统中占用字节数为
A. 100 B. 200 C. 400 D. 与平台无关
答案：C
解析：int 4 字节，100×4 = 400 字节。

---

六、精选判断题（10 题）

✅ 1.【一维数组 · 真题】

题目：数组下标越界在编译阶段必定能被检测出来。
答案：错
解析：仅极少数常量情况，绝大多数运行期才表现未定义行为。

---

✅ 2.【char 字符串】

题目：strlen("ABC") 结果与 sizeof("ABC") 相同。
答案：错
解析：前者 3，不含 \0；后者 4。

---

✅ 3.【string · 真题】

题目：string 的 size() 与 length() 返回值完全等价。
答案：对
解析：两函数互为别名。

---

✅ 4.【char 字符串】

题目：char *p="abc"; p[0]='A'; 在多数实现上会崩溃。
答案：对
解析：字面量在只读区，写入 UB 通常触发段错。

---

✅ 5.【string 函数】

题目：执行 s.find('x')==-1 判断“未找到”是安全的写法。
答案：错
解析：应与 string::npos 比较；-1 先转为无符号可能误用。

---

✅ 6.【大小写转换 · 真题】

题目：直接调用 toupper(-1) 会导致未定义行为。
答案：对
解析：需先转为 unsigned char

---

✅ 7.【大小写转换】

题目：toupper(ch) 的参数可直接传 char，不考虑其符号性。
答案：错
解析：负值 char 未定义行为，应强转 unsigned char。

---

✅ 8.【string 函数】

题目：调用 reserve() 后 string::capacity() 一定等于请求值。
答案：错
解析：只保证 ≥ 请求值

---

✅ 9.【数组 · 真题】

题目：数组元素在内存中可以不连续存放。
答案：错
解析：必须连续

---

✅ 10.【字符 · 真题】

题目：字符常量 '\0' 与 '0' 等价。
答案：错
解析：前者 ASCII 0，后者 ASCII 48

---

七、精选编程题（2 题）

✅ 1.【数组】求最大值与出现次数

题目
输入整数 n (1 ≤ n ≤ 10⁵) 以及 n 个整数，输出数组中的最大值及其出现次数。

解题思路

• • 一趟遍历：维护当前最大值 mx 与计数器 cnt。
• • 当读到新元素 x

• • • 若 x>mx ⇒ 更新 mx=x, cnt=1
  • • 若 x==mx ⇒ cnt++

参考代码

#include<bits/stdc++.h>
using namespace std;int main(){ios::sync_with_stdio(false);cin.tie(nullptr);int n; cin >> n;vector<int> a(n);for(int &x : a) cin >> x;int mx = a[0], cnt = 0;         // 当前最大与计数for(int x : a){if(x > mx){ mx = x; cnt = 1; }   // 更新最大else if(x == mx) ++cnt;          // 同值计数}cout << mx << ' ' << cnt << '\n';return 0;
}

复杂度：时间 O(n)，空间 O(1)。

---

✅ 2.【字符串】删除数字并互换大小写（25 分）

题目
输入一行字符，删除所有数字字符，并将英文字母大小写互换，输出结果。

解题思路

• • 遍历原串：

1. 1. 1. 若 isdigit(c) → 跳过
   2. 2. 若 isalpha(c) → islower?toupper:tolower
   3. 3. 其它字符直接保留

• • 使用结果串 res 收集。

参考代码

#include<bits/stdc++.h>
using namespace std;int main(){string s; getline(cin, s);string res;for(char c : s){if(isdigit((unsignedchar)c)) continue;           // 删除数字if(isalpha((unsignedchar)c))                     // 字母互换大小写c = islower(c) ? toupper(c) : tolower(c);res.push_back(c);                                 // 追加至结果}cout << res << '\n';return 0;
}

复杂度：时间 O(n)，空间 O(n)。