C++
C++ 字符串基础操作学习笔记
admin SU @ 2025-6-29 20:31:12

C++ 字符串操作学习笔记

一、字符串基础概念

字符串就是把很多字符排成一串，像 “hello”“I am a student” 这样。在 C++ 里，字符串是一种特殊的数据类型，有点像我们学过的 int（整数）、double（小数），但它存的是一串字符，就像一个装着字符的特殊“数组” 。

二、字符串的定义与初始化

（一）基本定义方式

我们可以用 string 类型来定义字符串，有两种常见办法：

#include<iostream>
// 用 string 类型要包含这个头文件（有时候编译器没写也能跑，但规范写法要加）
#include<string> 
using namespace std;

int main() {
    // 方法 1：先定义一个空的字符串变量，之后再给它赋值
    string s1; 
    // 方法 2：定义的时候直接给初始值
    string s2 = "Hello world!"; 
    cout << "s2 的值是：" << s2 << endl;
    return 0;
}

解释：string 就像一个“容器”，能装下我们输入或写好的字符。s1 刚开始是空的，s2 一开始就存了 “Hello world!” 。

三、字符串的输入输出

（一）简单输入输出（`cin` 和 `cout`）

用 cin 可以输入字符串，cout 输出字符串，不过 cin 遇到空格、换行就会停下：

#include<iostream>
using namespace std;

int main() {
    string a;
    cin >> a;  // 比如输入 “hello hi” ，只会读入 “hello” ，因为空格是分隔符
    cout << a << endl;  // 输出 “hello”
    return 0;
}

解释：cin 像个“挑剔”的读取器，碰到空格、换行就不读了，适合读单个单词。

（二）读取一整行（`getline`）

如果要读像 “I am happy” 这样带空格的一整行，就得用 getline：

#include<iostream>
using namespace std;

int main() {
    string s;
    getline(cin, s);  // 输入 “I am happy” ，会完整读这一行
    cout << s << endl;  // 输出 “I am happy”
    return 0;
}

注意：如果 cin 和 getline 一起用，可能会有小问题（比如 cin 留下的换行符干扰 getline ），后面会讲解决办法。

（三）示例：输入两个单词并分行输出

需求：输入两个单词（用空格隔开），分两行输出它们。

#include<iostream>
#include<string>
using namespace std;

int main(){
    string s1, s2;
    cin >> s1 >> s2;  // 依次读两个单词，空格分开
    cout << s1 << endl << s2 << endl;  // 分两行输出
    return 0;
}
// 输入：hello world
// 输出：
// hello
// world

解释：cin >> s1 >> s2 会自动跳过空格，依次把两个单词存到 s1 和 s2 里。

（四）示例：根据数字选择输出句子

需求：输入一个数字（1 或 2），再输入两行句子，数字是 1 就输出第一句，是 2 就输出第二句。

#include<iostream>
#include<string>
using namespace std;

int main() {
    int n;
    string s1, s2;
    cin >> n;
    // 关键！清理 cin 留下的换行符，不然 getline 会出错
    cin.ignore(); 
    getline(cin, s1);
    getline(cin, s2);
    if (n == 1) {
        cout << s1 << endl;
    } else {
        cout << s2 << endl;
    }
    return 0;
}
/*
输入：
1
I am a student.
My name is Hanmeimei.
输出：I am a student.
*/

解释：cin.ignore() 是为了删掉 cin >> n 后留在输入里的换行符，这样 getline 才能正确读后面的句子。

四、字符串长度计算

字符串的长度就是它包含的有效字符个数（比如 “hello” 长度是 5 ），有两种常用方法：

（一）`size()` 和 `length()` 方法

#include<iostream>
using namespace std;

int main() {
    string a = "hello";
    // 方法 1：用 size() 算长度
    cout << "用 size() 算，长度是：" << a.size() << endl; 
    // 方法 2：用 length() 算长度（和 size() 效果差不多）
    cout << "用 length() 算，长度是：" << a.length() << endl; 
    return 0;
}
// 输出：
// 用 size() 算，长度是：5
// 用 length() 算，长度是：5

解释：size() 和 length() 功能几乎一样，一般推荐用 size() ，因为它更符合 C++ 里“容器”（像字符串、数组这些可以装东西的类型）的习惯。

（二）示例：计算带空格字符串的长度

需求：输入一行可能带空格的字符串，输出它的长度。

#include<iostream>
#include<string>
using namespace std;

int main(){
    string s1;
    getline(cin, s1);  // 读一整行（包括空格）
    int len = s1.size();  // 用 size() 算长度
    cout << "字符串长度是：" << len << endl;
    return 0;
}
// 输入：My name is Hanmeimei.
// 输出：字符串长度是：21（数一下字符，包括空格和标点）

解释：getline 把整行内容（包括空格）存到 s1 ，size() 就能算出所有字符的个数。

五、字符串的字符访问

我们可以像访问数组元素一样，单独取出字符串里的某个字符，有两种方式：

（一）`[]` 和 `at()` 方法

#include<iostream>
using namespace std;

int main() {
    string a = "hello";
    // 方法 1：用 [] 访问第 0 个字符（字符串索引从 0 开始！）
    cout << "用 [] 访问，第 0 个字符是：" << a[0] << endl; 
    // 方法 2：用 at() 访问第 0 个字符（更安全，越界会报错提醒）
    cout << "用 at() 访问，第 0 个字符是：" << a.at(0) << endl; 
    return 0;
}
// 输出：
// 用 [] 访问，第 0 个字符是：h
// 用 at() 访问，第 0 个字符是：h

解释：字符串里的字符像排队一样，第一个字符（比如 “hello” 的 'h' ）是第 0 号，[] 和 at() 都能取到它。但如果取的位置超出字符串长度，at() 会明确报错，[] 可能让程序出问题，所以追求安全时用 at() 。

六、数字转字符串（`to_string`）

有时候我们需要把数字变成字符串（比如把 35 变成 "35" ），可以用 to_string ：

#include<iostream>
using namespace std;

int main() {
    string a = "hello";
    // to_string 把数字 35 转成字符串 "35" ，赋值给 a
    a = to_string(35); 
    // 输出转换后字符串的第 0 个字符（就是 '3' ）
    cout << a[0] << endl; 
    return 0;
}
// 输出：3

解释：to_string 能把整数、小数等转成对应的字符串形式，方便我们拼接、处理。

七、拓展：`sizeof` 运算符（了解）

sizeof 可以算数据类型或变量占多少字节（电脑存数据的“空间”大小），比如：

#include<iostream>
using namespace std;

int main() {
    // 字符串常量 "hello " 占的字节数（包括结尾隐藏的 '\0' ）
    cout << sizeof("hello ") << endl; 
    // 整数 5 占的字节（一般 int 是 4 字节）
    cout << sizeof(5) << endl; 
    // 小数 5.2 占的字节（一般 double 是 8 字节）
    cout << sizeof(5.2) << endl; 
    return 0;
}

注意：sizeof(string) 算的是 string 这个“容器”本身的大小，不是字符串内容的长度，内容长度还是用 size() 或 length() 算。

总结

这节课我们学了 C++ 里字符串的好多操作：

怎么定义、初始化字符串；
用 cin、cout 和 getline 做输入输出，还解决了它们一起用的小问题；
用 size() 或 length() 算字符串长度；
访问字符串里的单个字符；
把数字转成字符串；
还简单了解了 sizeof 。多动手写代码练习，就能越来越熟练啦！

admin SU @ 2025-6-29 20:44:55

计算机存储容量教程（适合中小学生）

一、什么是计算机存储容量？

计算机存储容量就像我们的"数字书包"，用来衡量计算机能存多少东西。比如：

存一张照片需要多少空间
装一个游戏需要多大容量
硬盘能存多少部电影

存储容量的最小单位是位（bit），也叫"比特"，但我们常用更大的单位，比如字节（Byte）、KB、MB、GB、TB等。

二、存储容量的基本单位

（一）位（bit）

最小的存储单位，只能存0或1（像开关的"开"和"关"）
1位就像1个小灯，只能亮（1）或灭（0）

（二）字节（Byte，简称B）

最常用的基本单位，1字节=8位
1字节可以存1个英文字母、1个数字或1个符号（比如'A'、'5'、'!'）
就像1个小盒子，能装1个字符

（三）更大的单位（换算关系）

1 KB（千字节）= 1024 Byte（大约1000字节）
1 MB（兆字节）= 1024 KB（大约100万字节）
1 GB（吉字节）= 1024 MB（大约10亿字节）
1 TB（太字节）= 1024 GB（大约1万亿字节）

记忆小技巧：每一级都是乘以1024（近似1000），就像数字计数里的个、十、百、千，只是这里用1024进位。

三、生活中的存储容量例子

1字节（1B）：存1个字母（如'A'）
100字节：存1句简短的话（如"今天天气真好！"）
1KB：存半篇作文（约500个汉字，1个汉字占2字节，所以1KB≈500汉字）
1MB：
- 一张普通照片（约2-5MB）
- 一首MP3音乐（约3-10MB）
1GB：
- 一部高清电影（约1-2GB）
- 1000首MP3音乐
1TB：
- 200-300部高清电影
- 一个普通家用硬盘的容量（如1TB硬盘）

四、用C++代码查看存储容量（字节数）

（一）查看数据类型占用的字节数

#include <iostream>
using namespace std;

int main() {
    // sizeof 是C++的运算符，用来计算数据类型或变量占多少字节
    cout << "1个字符（char）占：" << sizeof(char) << " 字节" << endl;
    cout << "1个整数（int）占：" << sizeof(int) << " 字节" << endl;
    cout << "1个小数（double）占：" << sizeof(double) << " 字节" << endl;
    cout << "1个字符串（string）的基本信息占：" << sizeof(string) << " 字节" << endl;
    
    // 定义变量并查看字节数
    int age = 12;
    cout << "age变量占：" << sizeof(age) << " 字节" << endl;
    
    return 0;
}

运行结果（常见情况）：

1个字符（char）占：1 字节
1个整数（int）占：4 字节
1个小数（double）占：8 字节
1个字符串（string）的基本信息占：32 字节
age变量占：4 字节

解释：

char 存1个字符，占1字节
int 存整数，占4字节（可存-20亿到20亿之间的数）
double 存小数，占8字节，比float（4字节）更精确
string 存字符串，基本信息占32字节（不包括字符串内容本身）

（二）计算存储容量换算（代码演示）

#include <iostream>
using namespace std;

int main() {
    // 定义基本单位
    long long byte = 1;           // 1字节
    long long kb = 1024 * byte;   // 1KB = 1024字节
    long long mb = 1024 * kb;     // 1MB = 1024KB
    long long gb = 1024 * mb;     // 1GB = 1024MB
    long long tb = 1024 * gb;     // 1TB = 1024GB
    
    // 输出换算结果
    cout << "1字节 = " << byte << " B" << endl;
    cout << "1KB = " << kb << " B = " << kb / 1024 << " KB" << endl;
    cout << "1MB = " << mb << " B = " << mb / 1024 << " KB = " << mb / (1024*1024) << " MB" << endl;
    cout << "1GB = " << gb << " B = " << gb / 1024 << " KB = " << gb / (1024*1024) << " MB = " << gb / (1024*1024*1024) << " GB" << endl;
    cout << "1TB = " << tb << " B = " << tb / 1024 << " KB = " << tb / (1024*1024) << " MB = " << tb / (1024*1024*1024) << " GB = " << tb / (1024*1024*1024*1024) << " TB" << endl;
    
    return 0;
}

运行结果（部分）：

1KB = 1024 B = 1 KB
1MB = 1048576 B = 1024 KB = 1 MB
1GB = 1073741824 B = 1048576 KB = 1024 MB = 1 GB
1TB = 1099511627776 B = 1073741824 KB = 1048576 MB = 1024 GB = 1 TB

解释：

代码用变量计算了各级存储单位的换算关系
1MB等于1024×1024=1048576字节
1GB等于1024×1024×1024=1073741824字节（约10亿字节）

（三）计算文件存储容量（示例）

#include <iostream>
using namespace std;

int main() {
    // 假设一张照片2MB，计算1GB能存多少张
    long long photoSize = 2;  // 照片大小：2MB
    long long totalStorage = 1;  // 总存储：1GB
    
    // 统一单位为MB
    long long totalStorageMB = totalStorage * 1024;  // 1GB=1024MB
    
    // 计算能存多少张照片
    long long photoCount = totalStorageMB / photoSize;
    
    cout << "1GB存储能存 " << photoSize << "MB的照片：" << photoCount << " 张" << endl;
    
    // 假设一部电影1.5GB，计算1TB硬盘能存多少部
    double movieSize = 1.5;  // 电影大小：1.5GB
    double hardDiskSize = 1;  // 硬盘大小：1TB
    
    // 统一单位为GB
    double hardDiskSizeGB = hardDiskSize * 1024;  // 1TB=1024GB
    
    // 计算能存多少部电影（用小数计算更精确）
    double movieCount = hardDiskSizeGB / movieSize;
    
    cout << "1TB硬盘能存 " << movieSize << "GB的电影：" << movieCount << " 部" << endl;
    
    return 0;
}

运行结果：

1GB存储能存 2MB的照片：512 张
1TB硬盘能存 1.5GB的电影：682.666667 部（约682部）

解释：

1GB=1024MB，所以2MB的照片能存1024÷2=512张
1TB=1024GB，1.5GB的电影能存1024÷1.5≈682部

五、存储容量的应用场景

（一）常见设备的存储容量

U盘：8GB、16GB、32GB（存文档、照片）
手机内存：128GB、256GB、512GB（存APP、照片、视频）
电脑硬盘：512GB、1TB、2TB（存系统、软件、文件）
服务器硬盘：几十TB甚至PB级（存大量数据，如网站文件、数据库）

（二）如何选择存储设备？

存少量文档、照片：选8GB-32GB的U盘
存电影、游戏：选128GB以上的移动硬盘或大内存手机
电脑存储：一般选512GB-1TB硬盘，够用且性价比高

六、总结（重点知识）

基本单位：
- 位（bit）：最小单位，存0或1
- 字节（Byte，B）：常用基本单位，1B=8bit
- 更大单位：KB→MB→GB→TB，每级×1024

换算关系：

1KB = 1024B （≈1000B）
1MB = 1024KB （≈100万B）
1GB = 1024MB （≈10亿B）
1TB = 1024GB （≈1万亿B）

代码应用：
- 用sizeof查看数据类型占多少字节
- 用数学计算存储容量换算和存储数量

记住这些知识，你就知道如何衡量计算机能存多少东西啦！下次买U盘或手机时，就能看懂"64GB""128GB"是什么意思咯～

admin SU @ 2025-6-29 20:37:53

转义序列字符教程（适合中小学生）

一、什么是转义序列字符？

在编程里，有些字符（像换行、制表符）没办法直接用普通字符表示，这时候就需要转义序列。简单说，转义序列就是用反斜杠 \ 加上一个或多个字符，告诉计算机：“嘿，这个字符不是字面意思，要特殊处理！”

比如 \n 不是字母 n ，而是“换行”的意思；\t 不是字母 t ，而是“空几格（制表符）” 。

二、常见转义序列字符表

下面是最常用的转义序列，记几个常用的就好：

转义序列	意义（干什么用）	类似现实中的操作
`\n`	换行（让光标跳到下一行开头）	按键盘的“Enter”键换行
`\t`	水平制表符（空出一段距离，像按 `Tab` 键）	按键盘的“Tab”键空几格
`\\`	表示一个普通的反斜杠 `\`	直接显示 `\` 符号
`\'`	表示一个单引号 `'`	在字符串里显示 `'`
`\"`	表示一个双引号 `"`	在字符串里显示 `"`
`\b`	退格（删除前一个字符，像按 `Backspace` 键）	按键盘的“Backspace”删除字符
`\r`	回车（让光标回到行开头）	老式打字机的“回车”操作
`\0`	空字符（表示字符串结束，很少直接用）	没啥实际显示效果，内部用得多

三、在 C++ 里用转义序列（代码示例+解释）

（一）`\n`：换行符

#include <iostream>
using namespace std;

int main() {
    cout << "第一行文字\n第二行文字";
    // 解释：
    // 输出 "第一行文字" 后，遇到 \n 就换行，再输出 "第二行文字"
    return 0;
}

运行结果：

第一行文字
第二行文字

（二）`\t`：制表符（空几格）

#include <iostream>
using namespace std;

int main() {
    cout << "姓名\t年龄\t城市";
    cout << "\n小明\t10\t北京";
    // 解释：
    // \t 会空出一段整齐的距离，让输出像表格一样对齐
    return 0;
}

运行结果：

姓名    年龄    城市
小明    10      北京

（不同环境下 \t 空的格数可能不同，一般是 4 或 8 个空格宽度）

（三）`\\`：显示反斜杠

#include <iostream>
using namespace std;

int main() {
    cout << "这是反斜杠：\\";
    // 解释：
    // 如果直接写 "\" ，计算机分不清是转义还是普通字符，
    // 所以用 \\ 表示一个普通的 \
    return 0;
}

运行结果：

这是反斜杠：\

（四）`\'` 和 `\"`：在字符串里用引号

#include <iostream>
using namespace std;

int main() {
    // 用 \' 显示单引号
    cout << "他说：\'你好呀！\'";
    cout << "\n她说：\"明天见！\"";
    // 解释：
    // 字符串本身用双引号括起来时，想显示单引号就用 \' ；
    // 想显示双引号就用 \" ，不然计算机以为字符串结束了
    return 0;
}

运行结果：

他说：'你好呀！'
她说："明天见！"

（五）`\b`：退格（删除前一个字符）

#include <iostream>
using namespace std;

int main() {
    cout << "abc\bdef";
    // 解释：
    // 先输出 "abc" ，遇到 \b 就删除前一个字符 'c' ，
    // 然后输出 "def" ，所以最终显示 "abdef"
    return 0;
}

运行结果：

abdef

（有些终端可能对 \b 支持不太好，效果可能不明显，理解意思就行）

（六）`\r`：回车（回到行开头）

#include <iostream>
using namespace std;

int main() {
    cout << "12345\rabc";
    // 解释：
    // 先输出 "12345" ，遇到 \r 光标回到行开头，
    // 再输出 "abc" ，把原来的 "12345" 覆盖成 "abc45"（不同环境可能有差异）
    return 0;
}

运行结果（可能因终端而异）：

abc45

（老式终端里 \r 会完全覆盖前面的内容，现代终端可能部分覆盖，了解即可）

四、转义序列的常见使用场景

（一）让输出更整齐（用 `\t`）

比如打印表格：

#include <iostream>
using namespace std;

int main() {
    cout << "科目\t成绩\n数学\t95\n语文\t92\n英语\t98";
    return 0;
}

输出：

科目    成绩
数学    95
语文    92
英语    98

（二）处理带引号的字符串（用 `\'` 或 `\"`）

比如输出对话：

#include <iostream>
using namespace std;

int main() {
    cout << "老师说：\"明天要带文具！\"";
    return 0;
}

输出：

老师说："明天要带文具！"

（三）控制换行（用 `\n`）

比如分段输出故事：

#include <iostream>
using namespace std;

int main() {
    cout << "从前有座山，\n山里有座庙，\n庙里有个老和尚讲故事...";
    return 0;
}

输出：

从前有座山，
山里有座庙，
庙里有个老和尚讲故事...

五、总结

转义序列就是用 \ 加上特殊字符，告诉计算机要特殊处理：

\n：换行，让文字另起一行
\t：空几格，让输出更整齐
\\：显示反斜杠本身
\' 和 \"：在字符串里显示单引号、双引号
其他转义序列（\b、\r 等）了解即可，遇到时能认出作用就好

多写代码试试这些转义序列，比如用 \t 做个课程表，用 \n 写段小诗，很快就能掌握啦！

admin SU @ 2025-6-29 20:36:47

ASCII 码教程（适合中小学生）

一、ASCII 码是什么？

ASCII 码（American Standard Code for Information Interchange）是一种让计算机能够“看懂”人类文字的编码方式。计算机只认识 0 和 1 这样的数字，为了让它能表示字母、数字和各种符号，人们就制定了 ASCII 码表，给每个字符都分配了一个唯一的数字。

比如：

字母 'A' 的 ASCII 码是 65
字母 'a' 的 ASCII 码是 97
数字 '0' 的 ASCII 码是 48（注意和数字 0 不同！）
空格 ' ' 的 ASCII 码是 32

ASCII 码一共定义了 128 个字符，涵盖了英文大小写字母、数字 0-9、标点符号，还有一些“控制字符”（比如换行、回车等）。

二、ASCII 码表快速认识

下面是 ASCII 码表的一部分，帮助你快速找到常用字符的 ASCII 码：

字符	ASCII 码（十进制）	字符	ASCII 码（十进制）
'A'	65	'a'	97
'B'	66	'b'	98
'C'	67	'c'	99
...
'Z'	90	'z'	122
'0'	48	' '	32
'1'	49	'!'	33
'2'	50	'?'	63
...

规律小总结：

大写字母 'A'-'Z' 的 ASCII 码是 65-90
小写字母 'a'-'z' 的 ASCII 码是 97-122
数字字符 '0'-'9' 的 ASCII 码是 48-57
小写字母的 ASCII 码比对应的大写字母大 32（比如 'A' 是 65，'a' 是 97）

三、在 C++ 中使用 ASCII 码

在 C++ 里，我们可以很方便地查看字符的 ASCII 码，或者用 ASCII 码生成字符。

（一）查看字符的 ASCII 码

#include <iostream>
using namespace std;

int main() {
    char ch = 'A';  // 定义一个字符变量，存字母 'A'
    // 把字符变量转成整数输出，就能看到它的 ASCII 码
    cout << "字符 '" << ch << "' 的 ASCII 码是：" << (int)ch << endl;
    
    ch = 'a';  // 把字符变量改成 'a'
    cout << "字符 '" << ch << "' 的 ASCII 码是：" << (int)ch << endl;
    
    ch = '0';  // 注意：这里是字符 '0'，不是数字 0
    cout << "字符 '" << ch << "' 的 ASCII 码是：" << (int)ch << endl;
    
    return 0;
}

输出结果：

字符 'A' 的 ASCII 码是：65
字符 'a' 的 ASCII 码是：97
字符 '0' 的 ASCII 码是：48

解释：在 C++ 中，char 类型的变量其实存的就是 ASCII 码数字。当我们用 (int) 把 char 变量强制转成整数时，就会显示出对应的 ASCII 码值。

（二）用 ASCII 码生成字符

反过来，我们也可以用数字（ASCII 码）生成对应的字符：

#include <iostream>
using namespace std;

int main() {
    int code = 65;  // 定义一个整数变量，存 ASCII 码 65
    // 把整数变量转成字符输出，就能看到对应的字符
    cout << "ASCII 码 " << code << " 对应的字符是：" << (char)code << endl;
    
    code = 97;  // 改成 ASCII 码 97
    cout << "ASCII 码 " << code << " 对应的字符是：" << (char)code << endl;
    
    code = 48;  // 改成 ASCII 码 48
    cout << "ASCII 码 " << code << " 对应的字符是：" << (char)code << endl;
    
    return 0;
}

输出结果：

ASCII 码 65 对应的字符是：A
ASCII 码 97 对应的字符是：a
ASCII 码 48 对应的字符是：0

解释：当我们用 (char) 把整数转成 char 类型时，计算机就会把这个数字当作 ASCII 码，输出对应的字符。

（三）示例：输出字母表的 ASCII 码

我们可以用循环来输出整个字母表（大写和小写）的 ASCII 码：

#include <iostream>
using namespace std;

int main() {
    cout << "大写字母表的 ASCII 码：" << endl;
    // 从 'A' 的 ASCII 码 65 开始，到 'Z' 的 ASCII 码 90 结束
    for (int i = 65; i <= 90; i++) {
        cout << (char)i << " 的 ASCII 码是：" << i << endl;
    }
    
    cout << "\n小写字母表的 ASCII 码：" << endl;
    // 从 'a' 的 ASCII 码 97 开始，到 'z' 的 ASCII 码 122 结束
    for (int i = 97; i <= 122; i++) {
        cout << (char)i << " 的 ASCII 码是：" << i << endl;
    }
    
    return 0;
}

输出结果：

大写字母表的 ASCII 码：
A 的 ASCII 码是：65
B 的 ASCII 码是：66
C 的 ASCII 码是：67
...（中间省略）...
X 的 ASCII 码是：88
Y 的 ASCII 码是：89
Z 的 ASCII 码是：90

小写字母表的 ASCII 码：
a 的 ASCII 码是：97
b 的 ASCII 码是：98
c 的 ASCII 码是：99
...（中间省略）...
x 的 ASCII 码是：120
y 的 ASCII 码是：121
z 的 ASCII 码是：122

四、ASCII 码的简单应用

（一）大小写字母转换

我们可以利用 ASCII 码的规律（小写字母比大写字母的 ASCII 码大 32）来实现大小写转换：

#include <iostream>
using namespace std;

int main() {
    char ch = 'A';
    // 把大写字母转成小写字母：加上 32
    cout << ch << " 转成小写是：" << (char)(ch + 32) << endl;
    
    ch = 'b';
    // 把小写字母转成大写字母：减去 32
    cout << ch << " 转成大写是：" << (char)(ch - 32) << endl;
    
    return 0;
}

输出结果：

A 转成小写是：a
b 转成大写是：B

（二）判断字符类型

我们可以通过 ASCII 码范围来判断一个字符是字母、数字还是其他符号：

#include <iostream>
using namespace std;

int main() {
    char ch;
    cout << "请输入一个字符：";
    cin >> ch;
    
    // 判断字符类型
    if (ch >= 'A' && ch <= 'Z') {
        cout << "你输入的是大写字母，ASCII 码是：" << (int)ch << endl;
    } else if (ch >= 'a' && ch <= 'z') {
        cout << "你输入的是小写字母，ASCII 码是：" << (int)ch << endl;
    } else if (ch >= '0' && ch <= '9') {
        cout << "你输入的是数字字符，ASCII 码是：" << (int)ch << endl;
    } else {
        cout << "你输入的是其他符号，ASCII 码是：" << (int)ch << endl;
    }
    
    return 0;
}

示例运行结果：

请输入一个字符：B
你输入的是大写字母，ASCII 码是：66

请输入一个字符：5
你输入的是数字字符，ASCII 码是：53

请输入一个字符：!
你输入的是其他符号，ASCII 码是：33

五、总结

ASCII 码是计算机世界和人类文字之间的“翻译器”，通过给每个字符分配一个数字，让计算机能够存储和处理文字。主要内容总结：

ASCII 码给每个字符（字母、数字、符号）分配了 0-127 之间的一个数字
大写字母 'A'-'Z' 的 ASCII 码是 65-90，小写字母 'a'-'z' 是 97-122
在 C++ 里，可以用 (int)ch 查看字符的 ASCII 码，用 (char)code 把数字转成字符
利用 ASCII 码的规律，可以实现大小写转换、字符类型判断等功能

掌握了 ASCII 码，你就更能理解计算机是如何处理文字的啦！多动手写代码练习，比如自己做一个 ASCII 码查询工具，会让你记得更牢哦！

admin SU @ 2025-6-29 20:32:16

C++ 字符串及相关操作学习笔记

一、字符串基础

（一）字符串定义与初始化

在 C++ 里，string 是用于处理字符串的常用类型，使用它一般要包含头文件 <iostream>（若涉及输入输出相关操作，处理纯字符串定义等基础场景也可仅依托其自身特性，但通常配合输入输出时需 <iostream> ，严格来说完整使用 string 建议包含 <string> 头文件），有以下常见定义方式：

#include<iostream>
// 严格使用 string 类型建议包含 <string> 头文件，这里演示基础用法
// #include<string> 
using namespace std;

int main() {
    // 方式一：定义一个空的字符串变量，后续可通过输入或赋值填充内容
    string s1; 
    // 方式二：定义字符串变量并直接初始化为指定字符串常量
    string s2 = "Hello world!"; 
    cout << "s1 初始为空，这里暂未赋值输出；s2 的值为：" << s2 << endl;
    return 0;
}

注释：string 类型把字符串当作一个整体来处理，比传统的字符数组（如 char arr[100] ）使用更便捷，不用手动管理内存（如担心数组越界等问题）。

（二）字符串输入输出

1. 简单输入输出（`cin`、`cout`）

cin 读取字符串时，遇到空格、换行等分隔符会停止，适合读取单个单词形式的字符串：

#include<iostream>
using namespace std;

int main() {
    string a;
    cin >> a;  // 输入如 hello hi ，只会读取到 hello ，因为空格是分隔符
    cout << a << endl;  // 输出 hello
    return 0;
}

2. 读取一整行字符串（`getline`）

当需要读取包含空格的一整行字符串时，getline 就派上用场了，它会读取到换行符为止（换行符会被消耗，但不会被存入字符串）：

#include<iostream>
using namespace std;

int main() {
    string s;
    getline(cin, s);  // 输入如 I am a student ，会完整读取这一行
    cout << s << endl;  // 输出 I am a student
    return 0;
}

不过要注意，当 cin 和 getline 混合使用时，可能会因为 cin 留下的换行符导致 getline 异常，后面会讲解决办法。

3. 输入输出示例 - 处理两个单词

需求：输入两个单词，用空格隔开，然后分两行分别输出这两个单词。

#include<iostream>
#include<string>
using namespace std;

int main(){
    string s1, s2;
    cin >> s1 >> s2;  // 依次读取两个单词，空格分隔
    cout << s1 << endl << s2 << endl;  // 分两行输出
    return 0;
}
// 输入：hello world
// 输出：
// hello
// world

4. 输入输出示例 - 数字选择句子

需求：输入一个数字（1 或 2 ），然后分两行输入两个英文语句。如果是 1 就输出第一个句子，如果是 2 就输出第二个句子。

#include<iostream>
#include<string>
using namespace std;

int main() {
    int n;
    string s1, s2;
    cin >> n;
    // 处理 cin 留下的换行符，避免影响后续 getline
    cin.ignore(); 
    getline(cin, s1);
    getline(cin, s2);
    if (n == 1) {
        cout << s1 << endl;
    } else {
        cout << s2 << endl;
    }
    return 0;
}
/*
输入：
1
I am a student.
My name is Hanmeimei.
输出：I am a student.
*/

这里 cin.ignore(); 作用是忽略掉 cin >> n; 之后留在输入缓冲区的换行符，保证 getline 能正确读取后面的整行内容。

二、字符串长度相关操作

字符串的长度指的是字符串内有效字符的个数（不包含字符串结束符 \0 ，不过 string 类型内部处理了这些细节），有两种常用方法获取长度：

（一）`size()` 方法（推荐）和 `length()` 方法

#include<iostream>
using namespace std;

int main() {
    string a = "hello";
    // size() 方法，获取字符串长度
    cout << "通过 size() 获取长度：" << a.size() << endl; 
    // length() 方法，效果和 size() 类似，也能获取字符串长度
    cout << "通过 length() 获取长度：" << a.length() << endl; 
    return 0;
}
// 输出：
// 通过 size() 获取长度：5
// 通过 length() 获取长度：5

注释：size() 和 length() 在功能上对于 string 类型基本一致，size() 更符合 STL（标准模板库）中容器获取大小的命名习惯，所以推荐使用 size() 。

（二）求字符串长度示例

需求：输入一行字符串（可能包含空格），输出它的长度。

#include<iostream>
#include<string>
using namespace std;

int main(){
    string s1;
    getline(cin, s1);  // 读取一整行，包含空格
    int n = s1.size();  // 用 size() 获取长度
    cout << n << endl;  // 输出长度
    return 0;
}
// 输入：My name is Hanmeimei.
// 输出：21（包含空格和标点等字符的个数总和 ）

三、字符串元素访问

可以像访问数组元素一样访问 string 中的单个字符，有两种常用方式：

（一）下标运算符 `[]` 和 `at()` 方法

#include<iostream>
using namespace std;

int main() {
    string a = "hello";
    // 下标运算符 [] ，访问第 0 个字符（字符串索引从 0 开始 ）
    cout << "通过 [] 访问第 0 个字符：" << a[0] << endl; 
    // at() 方法，同样访问第 0 个字符，好处是如果索引越界会抛出异常，更安全
    cout << "通过 at() 访问第 0 个字符：" << a.at(0) << endl; 
    return 0;
}
// 输出：
// 通过 [] 访问第 0 个字符：h
// 通过 at() 访问第 0 个字符：h

注释：[] 访问越界时，行为是未定义的（可能程序崩溃等）；at() 访问越界会抛出 out_of_range 异常，在对安全性要求高的场景，at() 更合适。

四、类型转换（数字转字符串）

可以使用 to_string 函数把数字转换成对应的字符串形式，方便拼接等操作，它需要包含头文件（一般在 <string> 中，不同环境可能有差异，配合 <iostream> 等通常可使用）：

#include<iostream>
using namespace std;

int main() {
    string a = "hello";
    // to_string 将数字 35 转换成字符串 "35" ，然后赋值给 a
    a = to_string(35); 
    // 输出转换后字符串的第 0 个字符，即 '3'
    cout << a[0] << endl; 
    return 0;
}
// 输出：3

注释：to_string 可以用于多种数值类型，如 int、double 等，会按照合理的格式把数值转成字符串，比如 to_string(3.14) 会得到 "3.14" 这样的字符串。

五、`sizeof` 运算符补充（拓展知识，和字符串相关场景结合）

sizeof 是 C++ 中的运算符，用于计算数据类型或变量所占用的字节大小，在字符串相关场景中，常用来测试不同常量、类型的字节数：

#include<iostream>
using namespace std;

int main() {
    // 字符串常量 "hello " 占用的字节数，包含末尾的 '\0' ，这里是 6 个字节（h,e,l,l,o,空格,\0？不对，实际 "hello " 是 h e l l o 空格 ，加上 '\0' 共 6 个字符，所以 sizeof 是 6 ）
    cout << sizeof("hello ") << endl; 
    // 错误写法，正确应该是 sizeof("hello ") 带括号，这里演示错误形式（实际编译可能有问题，正确用法要加括号包裹操作数 ）
    // cout<<sizeof "hello "<<endl; 
    // 整数 5 ，默认是 int 类型，在常见系统中 int 占 4 个字节
    cout << sizeof(5) << endl; 
    // 5.2 默认是 double 类型，占 8 个字节
    cout << sizeof(5.2) << endl; 
    // long long 类型，通常占 8 个字节
    cout << sizeof(long long) << endl; 
    // int 类型，通常占 4 个字节
    cout << sizeof(int) << endl; 
    // float 类型，通常占 4 个字节
    cout << sizeof(float) << endl; 
    // char 类型，占 1 个字节
    cout << sizeof(char) << endl; 
    return 0;
}

注释：sizeof 计算的是类型或变量的静态字节大小，对于 string 类型，sizeof(string) 得到的是 string 类对象本身的大小（包含一些成员变量如指针、长度记录等），而不是字符串内容的长度，字符串内容长度要用 size() 或 length() 获取。

以上就是本次 C++ 字符串及相关操作学习的主要内容，涵盖了字符串的定义、输入输出、长度获取、元素访问以及和其他类型转换、sizeof 运算符配合等常见用法，多结合示例练习就能更好掌握啦。

字符	ASCII 码（十进制）	字符	ASCII 码（十进制）
'A'	65	'a'	97
'B'	66	'b'	98
'C'	67	'c'	99
...
'Z'	90	'z'	122
'0'	48	' '	32
'1'	49	'!'	33
'2'	50	'?'	63
...

字符	ASCII 码（十进制）	字符	ASCII 码（十进制）
'A'	65	'a'	97
'B'	66	'b'	98
'C'	67	'c'	99
...
'Z'	90	'z'	122
'0'	48	' '	32
'1'	49	'!'	33
'2'	50	'?'	63
...

C++ 字符串基础操作学习笔记

C++ 字符串操作学习笔记

一、字符串基础概念

二、字符串的定义与初始化

（一）基本定义方式

三、字符串的输入输出

（一）简单输入输出（cin 和 cout）

（二）读取一整行（getline）

（三）示例：输入两个单词并分行输出

（四）示例：根据数字选择输出句子

四、字符串长度计算

（一）size() 和 length() 方法

（二）示例：计算带空格字符串的长度

五、字符串的字符访问

（一）[] 和 at() 方法

六、数字转字符串（to_string）

七、拓展：sizeof 运算符（了解）

总结

4 条评论

计算机存储容量教程（适合中小学生）

一、什么是计算机存储容量？

二、存储容量的基本单位

（一）位（bit）

（二）字节（Byte，简称B）

（三）更大的单位（换算关系）

三、生活中的存储容量例子

四、用C++代码查看存储容量（字节数）

（一）查看数据类型占用的字节数

（二）计算存储容量换算（代码演示）

（三）计算文件存储容量（示例）

五、存储容量的应用场景

（一）常见设备的存储容量

（二）如何选择存储设备？

六、总结（重点知识）

转义序列字符教程（适合中小学生）

一、什么是转义序列字符？

二、常见转义序列字符表

三、在 C++ 里用转义序列（代码示例+解释）

（一）\n：换行符

（二）\t：制表符（空几格）

（三）\\：显示反斜杠

（四）\' 和 \"：在字符串里用引号

（五）\b：退格（删除前一个字符）

（六）\r：回车（回到行开头）

四、转义序列的常见使用场景

（一）让输出更整齐（用 \t）

（二）处理带引号的字符串（用 \' 或 \"）

（三）控制换行（用 \n）

五、总结

ASCII 码教程（适合中小学生）

一、ASCII 码是什么？

二、ASCII 码表快速认识

三、在 C++ 中使用 ASCII 码

（一）查看字符的 ASCII 码

（二）用 ASCII 码生成字符

（三）示例：输出字母表的 ASCII 码

四、ASCII 码的简单应用

（一）大小写字母转换

（二）判断字符类型

五、总结

C++ 字符串及相关操作学习笔记

一、字符串基础

（一）字符串定义与初始化

（二）字符串输入输出

1. 简单输入输出（cin、cout）

2. 读取一整行字符串（getline）

3. 输入输出示例 - 处理两个单词

4. 输入输出示例 - 数字选择句子

二、字符串长度相关操作

（一）size() 方法（推荐）和 length() 方法

（二）求字符串长度示例

三、字符串元素访问

（一）下标运算符 [] 和 at() 方法

四、类型转换（数字转字符串）

五、sizeof 运算符补充（拓展知识，和字符串相关场景结合 ）

状态

开发

支持

还没有账户？

登录

（一）简单输入输出（`cin` 和 `cout`）

（二）读取一整行（`getline`）

（一）`size()` 和 `length()` 方法

（一）`[]` 和 `at()` 方法

六、数字转字符串（`to_string`）

七、拓展：`sizeof` 运算符（了解）

（一）`\n`：换行符

（二）`\t`：制表符（空几格）

（三）`\\`：显示反斜杠

（四）`\'` 和 `\"`：在字符串里用引号

（五）`\b`：退格（删除前一个字符）

（六）`\r`：回车（回到行开头）

（一）让输出更整齐（用 `\t`）

（二）处理带引号的字符串（用 `\'` 或 `\"`）

（三）控制换行（用 `\n`）

1. 简单输入输出（`cin`、`cout`）

2. 读取一整行字符串（`getline`）

（一）`size()` 方法（推荐）和 `length()` 方法

（一）下标运算符 `[]` 和 `at()` 方法

五、`sizeof` 运算符补充（拓展知识，和字符串相关场景结合）

字符	ASCII 码（十进制）	字符	ASCII 码（十进制）
'A'	65	'a'	97
'B'	66	'b'	98
'C'	67	'c'	99
...
'Z'	90	'z'	122
'0'	48	' '	32
'1'	49	'!'	33
'2'	50	'?'	63
...