一、字符和字符串

结合之前学过的数据类型以及 ASCII 码，我们知道字符是用单引号包裹（''），本质是 ASCII 码值的整数，并且只能有一个字符，数据类型用 char 表示。（包括转义字符，如 ‘\n’ 表示换行）。

#include <iostream>
using namespace std;
int main()
{
    char n1;     // 定义了数据类型为字符类型的变量n1
    n1 = 'A';
    cout << n1-0 << endl;    // -0会直接把该字符的 ASCII 码输出
    cout << "今天是2025年！！！Happy@@@";    // 字符串
    return 0;
}

运行结果如下：

而字符串不一样，是以双引号包裹（""），是包含多个字符（中文、英文、符号等）。在 C++ 中，字符串有专门的数据类型，即 string（需要包含头文件 < string >）。

二、字符串数组

（一）字符串数组定义

如下代码，定义一个能存储 10 个字符的字符数组（C风格字符串），要注意最多能存储 9 个有效字符，因为固定大小为 10 个字符（需包括字符串结束符 \0 ）：

char a[10];

同时，还定义了 C++ 标准库的 string 对象 string b，该方法是动态大小，不需要预先指定长度。

#include <iostream>
using namespace std;

int main() 
{
    char a[10];  // char 字符类型
    string b;
    cin >> a >> b;
    cout << a << endl << b;
    return 0;
}  

运行结果如下：

（二）strlen() 和 sizeof()

有两种获取字符串数组长度的两种方法，strlen() 从数组开头开始计算，直到遇到 ‘\0’ 停止，其返回的是有效字符的个数，不包括 ‘\0’，而 sizeof() 包括 ‘\0’。如下代码：

#include <iostream>
#include <cstring>    // 必须包含头文件
using namespace std;

int main() 
{
    char str[] = "Hello World";    // 字符数组
    cout << strlen(str) << endl;   // 不包括'\0'
    cout << sizeof(str);   // 包括11个字符 + 1个'\0'，所以12
    return 0;
}

运行结果如下：

（三）cin.getline()

cin >> 会从输入缓冲区中读取数据，但它有一个特点：遇到空白符（空格、制表符\t、换行符\n）就会停止读取，并将空白符留在缓冲区中。所以，cin 最适合读取单个、没有空格的单词或数字。

想读取一个词（数字或单词） → 用 cin >>
想读取一行话（带空格） → 用 cin.getline()

cin.getline() 会读取一整行输入，包括空格，直到遇到换行符（按下回车键）为止。

cin.getline(数组名, 最大长度)

此时会读取并丢弃换行符，不会把它留在缓冲区里。【使用该方法需指定缓冲区大小，即最大长度】

#include <iostream>
using namespace std;

int main() 
{
    char a[10],b[10];  // 定义两个字符数组，每个最多存储9个有效字符（含结束符'\0'）
    cin.getline(a,10);   // 读取一行字符串到a，最多读取9个字符（第10个位置留给'\0'）
    cin.getline(b,10);
    cout << a << endl << b;
    return 0;
} 

以上是 C 风格字符串的用法，如果对于 string 类，应该用以下方法，而不是 cin.getline(字符串变量, 长度)：

getline(cin, 字符串变量)

例如，下面代码：

#include <iostream>
#include <string>  // 确保string类型正常使用
using namespace std;

int main() 
{
    string a;
    getline(cin, a);  // getline 传入流对象和字符串
    cout << a;
    return 0;
}

运行结果如下：

三、字符串相关操作

（一）空字符串&清空字符串

当声明字符串变量时如果不初始化，会自动创建一个空字符串（内部长度为 0，不包含任何字符），因为标准库会自动处理默认初始化。另外，如果我们想表示一个空字符串，直接定义就可以，不需要初始化：

#include <iostream>
#include <string>      // 需要导入该头文件
using namespace std;
int main()
{
    string n1;     // 直接定义就可以初始化
    string n2 = "";   // 这种也可以，不过没前面的简洁
    return 0;
}

要注意字符串的索引范围是 0 到 a.size() - 1。当 i 等于 a.size() 时，a[i] 会访问超出字符串范围的内存，这是未定义行为，可能导致程序崩溃或异常结果。所以，一般循环如下：

for(int i=0;i<a.size();i++)     //正序
for(int i=s.size()-1;i>= 0;i--)     //倒序

另外，clear() 是字符串的一个成员函数，用于清空字符串中的所有内容，使其变为空字符串（长度为 0）。例如，下面代码是通过输入一个字符串，然后进行加法运算，其中now.clear() 的作用是当解析完一个数字（遇到 + 号时），清空当前存储数字字符的字符串 now，以便重新存储下一个数字的字符：

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

int main() 
{
    int sum=0;      // 用于存储总和的变量，初始化为0
    string s,now;   // s存储输入的完整字符串，now存储当前正在解析的数字字符串
    getline(cin,s);
    for(int i=0;i<s.size();i++)  // 遍历输入字符串的每个字符
    {
        if(s[i]=='+')            // 遇到加号时，表示一个数字结束
        {
            if(!now.empty())    // 如果当前正在解析的数字不为空
            {
                sum+=stoi(now); // 将当前数字转换为整数并累加到总和
                now.clear();    // 清空当前数字字符串，准备解析下一个数字
            }
        }
        else                   // 遇到数字字符时
            now+=s[i];         // 将字符添加到当前数字字符串中
    }
    if(!now.empty())          // 循环结束后，处理字符串末尾的最后一个数字
        sum+=stoi(now);      // 将最后一个数字累加到总和
    cout<<sum;
    return 0;
}

运行结果如下：

（二）获取长度

首先，我们要知道字符串也是由很多个字符组成的。
这里我们通过 成员函数 size() 来返回 string 对象中存储的 “字符元素数量”（每个元素是 char 类型，占 1 个字节）。

在 C++ 中，字符串的编码取决于你的编译器 / 运行环境（Windows 下默认是 GBK 编码，Linux/macOS 下默认是
UTF-8 编码），不同编码下中文占的字节数不同：
➡️GBK 编码（Windows 常见）：1 个中文汉字 / 中文符号占 2 个字节（即 2 个 char 元素）。
➡️UTF-8编码（Linux/macOS 常见）：1 个中文汉字 / 中文符号占 3 个字节（即 3 个 char 元素）。
➡️英文、数字、英文符号（如2025、@、#）：无论哪种编码，都占 1 个字节（1 个 char 元素）。

例如，下面代码中该字符串包含中文、英文、符号等：

#include <iostream>
#include <string>      // 需要导入该头文件
using namespace std;
int main()
{
    string n1; 
    string n2 = "今天是2025年,happy@#￥!";
    cout << n1.size() << endl;
    cout << n2.size() << endl;
    return 0;
}

运行结果如下：

n1 是空字符串，所以第一个输出显示为 0。n2 字符串中， 正常的 Windows 电脑中，使用 GBK 编码（中文 / 中文符号占 2 字节），这里的￥是中文符号，所以：

总字节数 = 中文 (4×2) + 中文符号 (1×2) + 数字 (4×1) + 英文符号 (4×1) + 英文字母 (5×1)
= 8 + 2 + 4 + 4 + 5 = 23。

另外，strlen() 函数用于计算 C 风格字符串（以 \0 结尾的字符数组）的长度。

#include <iostream>
#include <cstring>
using namespace std;
int main()
{
    string a;
    cin >> a;
    char b[20]="Hello world!";
    cout << a.size() << endl <<strlen(b);
    return 0;
}

运行结果如下，输入“abc”，最终结果是 3 和 12：

（三）访问索引

访问字符串索引可以通过[]或者at()来实现，区别就是后者
会做越界检查。

越界则会抛出 out_of_range 异常。

例如，下面代码通过for循环依次访问字符串索引，s.size() 获取字符串长度，s[i] 通过索引访问每个字符，同时循环变量 i 从0开始，每次递增1，直到字符串末尾：

#include <iostream>
#include <string>
using namespace std;
int main() 
{
    string s = "12345";
    for (int i = 0; i < s.size(); i++) 
        cout << s[i] << endl;
    return 0;
}

也可以对 for 循环进行简化：

for (char c : s) 
	cout << c << endl;

代码如下：

#include <iostream>
#include <string>
using namespace std;
int main() 
{
    string s = "12345";
    for (char c : s) 
        cout << c << endl;
    return 0;
}

运行结果：

另外，字符串的下标是从 0 开始 的

最开始的下标 固定为 0（第一个字符的位置）
最后的下标 为 a.size() - 1（最后一个字符的位置）

需要注意的是，只有当字符串不为空时（a.size() > 0），最后一个下标才有意义。如果字符串为空，a.size() - 1 会得到-1，

例如，我们输入字符串，然后输出其首字符和尾字符：

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

int main() 
{
    int last;
    string a;
    getline(cin,a);
    last = a.size()-1;
    cout << a[0] << " ";
    cout << a[last];
    return 0;
}

运行结果如下：

（四）判空&清空

empty() 是string 类的成员函数，其作用是判断字符串是否为空，会返回一个布尔值（true或false），由于输出时会被自动转换为整数：true 对应 1，false 对应 0。

empty() 结果	描述
1	字符串为空
0	字符串非空

#include <iostream>
#include <string>      // 需要导入该头文件
using namespace std;
int main()
{
    string n1;     // 直接定义就可以初始化
    string n2 = "";   // 这种也可以，不过没前面的简洁
    cout << n1.empty() << endl;
    cout << n2.empty() << endl;
    return 0;
}

运行结果如下，由于都是空的，所以都显示1：

empty( )是 string 类中的一个成员函数，这里 “.” 的意思是要对 n1 这个 string 类型的变量调用 empty()函数，即用 n1 这个字符串的 empty() 功能来检查它是否为空。

string s;
cin >> s;
// 检查字符串是否为空
if (s.empty()) {
    cout << "no" << endl;
    return 0;
}

另外，可以通过 s.clear() 来清空字符串，从而变成空串，此时 s.size() 变为 0。

（五）字符串拼接

1、加号拼接
直接用 + 连接多个字符串，会生成一个新的字符串，如下代码：

#include <iostream>
#include <string>      // 需要导入该头文件
using namespace std;
int main()
{
    string n1 = "今天是"; 
    string n2 = "2025年9月4日";
    cout << n1 + n2;
    return 0;
}

运行结果如下：

2、+= 直接拼接
也可以通过用 += 追加，给已有的字符串的末尾添加内容（直接修改原字符串），如下代码：

#include <iostream>
#include <string>      // 需要导入该头文件
using namespace std;
int main()
{
    string n1 = "今天是"; 
    n1 += "2025年9月4日";
    n1 += "！";
    cout << n1;
    return 0;
}

运行结果如下：

另外，C 语言提供了丰富的字符串处理函数，字符串连接函数 strcat() 可以把两个字符串拼接在一起，如下代码：

#include <iostream>
#include <cstring>
using namespace std;
int main()
{
    string a,b;
    cin >> a >> b;
    a+=b;
    cout << a << endl;
    char c[10]="Hello ";
    char d[10]="world!";
    cout << strcat(c,d);
    return 0;
}

运行结果如下：

同时，要注意strcat() 与 strcpy() 的区别：
strcpy(a, b)：用 b 覆盖 a（替换）
strcat(a, b)：将 b 追加到 a 后面（合并）

3、append() 末尾添加
append() 函数可以在一个字符串的末尾追加整个字符串或者精确添加部分字符串，如下代码：

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

int main()      
{
    string n1 = "今天是";
    n1.append("2025年9月4日");
    cout << n1;
    return 0;
}

运行结果如下：

也可以精确进行添加，如下代码，n1.append(n2, 0, 3) 表示从 n2 的第 0 个字符开始，截取 3 个字符，追加到 n1 后面：

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

int main()      
{
    string n1 = "I love ";
    string n2 = "C++ ！";
    n1.append(n2, 0, 3);   //将 n2 中从索引 0 开始的 3 个字符拼接到 n1 的末尾
    cout << n1 ; 
    return 0;
}

要注意 n2 中的字符依次是：‘C’、‘+’、‘+’、’ ‘（空格）、’！'（中文感叹号），运行结果如下：

4、insert() 插入
通过使用insert()函数在字符串的指定位置插入另一个字符串（如果插入到末尾，就相当于拼接）:

#include <iostream> 
#include <string>
using namespace std;
int main()      
{
    string n1 = "2025年9月4日";
    n1.insert(0, "今天是");    // 在位置0（字符串开头）插入"今天是"
    cout << n1;  // 输出：今天是2025年9月4日
    return 0;
}

运行结果如下：

总结一下字符串拼接几种方法适合的地方：

名称	特点
+=	简便末尾拼接，能直接追加整串
append()	可追加部分字符串
insert()	可任意位置插入（含末尾）

（六）查找

可以通过find()来查找相应的字符在字符串中的索引位置（默认从0开始），例如下面代码中，就是查找字符串变量 s 中字母o的出现位置以及特定从索引6开始搜索：

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

int main() 
{
    string s = "Hello World!";
    cout << s.find('o') << endl;         // 查找"World"中字母o的索引，默认从 0 开始 
    cout << s.find('o',6);               // 查找"World"中字母o的索引，从索引位置 6 开始 
    return 0;
}

运行结果如下：

➡️find()还有几种类似的用法：
rfind()：从字符串末尾开始查找（最后一次出现的位置）。
find_first_of()：查找任何一个匹配字符的第一个位置。
find_last_of()：查找任何一个匹配字符的最后一个位置。

例如，我们要查找最后一个特定字符位置：

// 在[0, end]范围内查找最后一个目标字符的位置
int findLastCharPosition(const string& s, char target, int end) {
    int lastPos = -1;
    for (int i = 0; i <= end; i++) {
        if (s[i] == target)
        {
            lastPos = i;
        }
    }
    return lastPos;
}

例如，我们要计算字符串中最后一个单词的长度：

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

int main() 
{
    int last=-1;  //表示初始状态下还没有找到任何空格（因为字符串的索引从 0 开始，-1 是一个不可能的索引值）
    string a;
    getline(cin, a);
    int end =a.size()-1;   //初始化变量end，让它指向字符串的最后一个字符（字符串索引从 0 开始，所以最后一个字符位置是长度减 1）
    while (end >= 0 && a[end] == ' ')
        end--;   //从字符串末尾向前遍历，跳过所有空格。当遇到非空格字符或遍历到字符串开头时停止。
    for(int i=0;i<=end;i++)  //从字符串开头遍历到end（经过第一步处理后的有效结尾）
    {
        if(a[i] == ' ')
            last = i;   //从字符串开头遍历到end（经过第一步处理后的有效结尾），确保只在有意义的范围内查找。
    }
    cout << end-last;
    return 0;
}

（七）插入

通过 insert() 插入方法可以插入字符或字符串，pos 代表下标，n 代表数量。

s.insert(pos, n ,'字符')
s.insert(pos, "字符串")

如下代码：

#include <bits/stdc++.h> 
using namespace std;

int main()
{
    string s = "ello";
    s.insert(0, 1, 'H');
    cout << s << endl;
    s.insert(5, " world!");
    cout << s;
    return 0;
}

（八）截取

substr()用于提取子字符串，可提取指定位置和长度的子字符串。

s.substr(pos);        // 截取下标pos之后
s.substr(pos, len);   // 截取下标pos，长度为len

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

int main() 
{
    string s = "Hello World!";
    cout << s.substr(6) << endl;      // 从索引6开始提取到末尾 → 得到"World!"
    cout << s.substr(0, 5);   // 从索引0开始提取5个字符 → 得到"Hello"
    return 0;
}

运行结果如下：

（九）替换

replace()可以替换字符串中指定位置或范围的字符。

s.replace(pos,n, t) ;  / / 从 pos 开始，替换 n 个字符为字符串 t

例如，s.replace(0, 1, 2, ‘H’) 的意思是从索引 0 开始，替换 1 个字符（即 ‘e’），用 2 个 ‘H’ 替换被删除的部分：

string s = "ello";
cout << s.replace(0, 1, 2, 'H');   // 输出 HHllo

另外，要注意，当指定的替换长度超过字符串剩余长度时，replace() 会替换从起始位置到字符串末尾的所有内容。例如，字符串变量 s = “Hello World!”，其长度为 12（索引范围 0~11），从字符串 s 的索引 6 开始，替换长度为 11 的字符为 “C++”：

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

int main() 
{
    string s = "Hello World!";
    cout << s.replace(6,11,"C++") << endl;      // 从字符串 s 的索引 6 开始，替换长度为 11 的字符为 "C++"
    return 0;
}

运行结果如下：

（十）删除

可以通过erase()来删除子字符串，即删除字符串中指定位置或范围的字符。例如，字符串变量s = “Hello World!”，其长度为 12（索引范围 0~11）。

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

int main() 
{
    string s = "Hello World!";
    cout << s.erase(6,11) << endl;      // 从字符串 s 的索引 6 开始，删除长度为 11 的字符。
    return 0;
}

这里是从索引 6 开始删除，删除 11 个字符，但从索引 6 到字符串末尾实际只有 6 个字符（“World!”）。

（十一）字符串删除某字符

（1）方法一，结合 string 类，erase-remove 方法
（空格为例）使用remove(str.begin(), str.end(), ' ')需要导入< algorithm > 库，会把所有非空格字符挪到前面，然后返回一个 “标记”，这个标记指着最后一个非空格字符的下一个位置。然后，调用 string 的 erase() 方法，从 remove 返回的位置开始，删除到字符串末尾的所有字符。

#include <iostream>
#include <algorithm>  // 包含 remove 算法
#include <string>
using namespace std;

int main() 
{
    string str = "  Hello   World  C++  ";
    str.erase(remove(str.begin(), str.end(), ' '), str.end());    // 使用 erase 和 remove 算法一键去空格
    cout << str;
    return 0;
}

remove 算法的第三个参数可以是任何字符，不仅限于空格。只要把 ’ ’ 换成你想删除的目标字符，就能实现删除该字符的功能。

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

int main() 
{
    string str = ",,a,b,c,,d,,e,";
    // 删除所有逗号
    str.erase(remove(str.begin(), str.end(), ','), str.end());
    cout <<  str;  // 输出：删除逗号后: abcde
    return 0;
}

（2）方法二，创建新的字符串

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

int main() 
{
    string str = "  Hello   World  C++  ";
    string result; // 创建一个新字符串存放结果
    for(char c : str) 
    {
        if(c != ' ')
            result += c;
    }
    cout << result;
    return 0;
}

例如，我们要剔除字符串中某个字符，改成一般的 for 循环：

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

int main() 
{
    char t;
    string s,result;
    cin >> t;
    cin >> s;
    for(int i=0;i<s.size();i++)
    {
        if(s[i]!=t)
            result+=s[i];
    }
    cout<<result;
    return 0;
}

3、方法三，创建新的字符数组

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

int main() 
{
    char str[] = "  Hello   World  C++  ";
    int j = 0; 	// 新字符串的索引
    
    for(int i = 0; str[i]; i++) 
    {
        if(str[i] != ' ') 
        { 	// 如果不是空格
            str[j] = str[i]; 	// 复制到前面
            j++;
        }
    }
    str[j] = '\0'; 		// 添加字符串结束符
    
    cout << str ;
    return 0;
}

另外，例如我们要清除字符串末尾空格，可以通过以下实现：

// 清理字符串末尾的空格，返回最后一个非空格字符的位置
int trimTrailingSpaces(const string& s) {
    int end = s.size() - 1;
    while (end >= 0 && s[end] == ' ') {
        end--;
    }
    return end; // 若字符串全是空格或空串，返回-1
}

（十二）比较字符串

在 C++ 中，字符串可以直接使用关系运算符（如 <、>、<=、!=、== 等）。在进行比较时，比较的是字符串的字典序，类似字典中单词的排列顺序。

比较 "World" 和 "dream"：

第一个字符 'W'（ASCII 87）和 'd'（ASCII 100），
因为 87 < 100。

所以 "World" < "dream"。

遵循规则：
➡️ 从两个字符串的第一个字符开始，逐个字符进行比较，比较的是字符的 ASCII 码值；
➡️ 遇到第一个不相同的字符时，ASCII 码值小的字符所在的字符串被认为更小；
➡️ 一者是另一者前缀，则短的字符串更小；
➡️ 全同且等长才相等。（字符都相同且长度相等）

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

int main() 
{
    string a, b;
    getline(cin, a);
    getline(cin, b);
    if (a == b)  		// string类可直接用==比较内容
        cout << "YES";
    else
        cout << "NO";
    return 0;
}

另外，如果我们是对C 风格字符串（char 数组），直接用两个等于号比较的是地址，而非内容。如果要比较，可以用 strcmp() 函数比较内容。
要注意，对于字符串比较，不能直接使用 == ，因为该运算符比较的是数组地址，而非内容。

strcmp(a,b)     //a、b是两个C 风格字符串，即char 数组

strcmp() 可以进行两个字符串的比较，该函数以各个字符对应的 ASCII 码值进行比较。从两个字符串的第 1 个字符开始比较，如果它们相等，就继续比较下一个字符，直到遇见不同的字符，或者到字符串的末尾。

strcmp() 方法有一个返回值：若相同，则返回 0；若前者大于后者，则返回大于 0 的值；若前者小于后者，则返回小于 0 的值。这里就是，若不等，返回第一个不同字符的 ASCII 码差值（前减后）。

#include <iostream>
#include <cstring>
using namespace std;
int main()
{
    char a[10]="Hello";
    char b[10]="hello";
    cout << strcmp(a,b);
    return 0;
}

运行结果如下：

a 的第一个字符是大写 ‘H’，ASCII 码为 72；
b 的第一个字符是小写 ‘h’，ASCII 码为 104。
因此，strcmp(a, b) 的计算结果为 72 - 104 = -32。

也可以利用 C 语言的 strcasecmp 函数，用于忽略大小写比较字符串，直接返回所需的结果类型。 函数返回值规则：

若前一个字符串更小，返回负数 ；
若两个字符串相等，返回 0 ；
若前一个字符串更大，返回正数。

例如，下面代码比较两个输入的字符串是否完全相同：

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

int main() 
{
    char a[100], b[100];
    cin.getline(a, 100);  //读取一行
    cin.getline(b, 100);
    if (strcmp(a,b)==0)   // 使用strcmp()函数
        cout << "YES";
    else
        cout << "NO";
    return 0;
} 

运行结果如下：

（十三）字符串转换大小写

以下代码中，将两个字符数组（C 风格字符串）中的所有大写字母转换为小写字母，并输出转换后的结果。主要是通过 for 循环遍历字符串 a，将每个字符转换为小写，循环条件是当字符不是结束符 ‘\0’ 时继续（遍历到字符串末尾）：

#include <iostream>
#include <cctype>     // 包含字符处理函数（tolower）
using namespace std;

int main() 
{
    char a[10]="AAAadd";         // 数组大小10，实际使用6个字符+1个'\0'
    char b[10]="dfGERS";
    for (int i = 0; a[i] != '\0'; i++)    // 遇到 '\0'（字符串结束符）时停止循环,将字符串a中的所有字符转换为小写
        a[i] = tolower(a[i]);             // 将每个字符转换为小写
    for (int i = 0; b[i] != '\0'; i++)
        b[i] = tolower(b[i]);
    cout << a << endl << b;
    return 0; 
}   

运行结果如下：

如果使用 C++ 的 string 类，代码可以更简洁：

#include <iostream>
#include <cctype>     // 包含字符处理函数（tolower）
#include <string>
using namespace std;

int main() 
{
    string a = "AAAadd";
    string b = "dfGERS";
    
    for (int i = 0; i < a.size(); i++)
        a[i] = tolower(a[i]);
    for (int i = 0; i < b.size(); i++)
        b[i] = tolower(b[i]);
    
    cout << a << endl << b;
    return 0;
}

（十四）整型与字符串转换

可以使用 stoi 系列函数，将字符串类型转换为int整数类型，如下代码：

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

int main()
{
	int num;
	string str;
	getline(cin, str);
	cout << typeid(stoi(str)).name();
	return 0;
}

运行结果如下：

整型转换为字符串类型，使用 to_string 函数，需要加上#include < string >，如下代码：

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

int main()
{
	int num;
	cin >> num;
	cout << typeid(to_string(num)).name();
	return 0;
}

运行结果如下：

（十五）字符分类函数

isalnum() 和 isalpha() 是 < cctype > 标准库中提供的字符分类函数，用于判断字符的属性，常用于字符串合法性校验。

1、 isalpha() 判断字母
isalpha() 函数用于判断一个字符是否为字母（大写字母和小写字母）。

2、isdigit() 判断数字
isdigit() 函数用于判断一个字符是否数字。

3、isalnum() 判断字母或者数字
isalnum() 函数用于判断一个字符是否为字母（大写字母和小写字母）或数字。

< cctype > 标准库中，还有其他常用的函数，如下：

例如，下面代码是判断输入的字符串是否是标准的变量名，规则如下：
1、首字符只能是字母和下划线
2、只包含字母、数字和下划线

#include <iostream>
#include <cctype>
#include <string>

using namespace std;

int main() 
{
    string s;
    cin >> s;
    if (s.empty()) 
    {
        cout << "no" << endl;
        return 0;
    }
    
    // 检查首字符：只能是字母或下划线
    char first = s[0];
    if (!isalpha(first) && first != '_') {
        cout << "no" << endl;
        return 0;
    }
    
    // 检查其余字符：只能是字母、数字或下划线
    for (int i = 1; i < s.size(); i++) {
        char c = s[i];
        if (!isalnum(c) && c != '_') {
            cout << "no" << endl;
            return 0;
        }
    }
    
    // 所有检查都通过
    cout << "yes" << endl;
    return 0;
}

（十六）字符串反转

reverse() 函数通过交换元素实现反转，从所给范围的首尾两端开始，交换第一个和最后一个元素，然后向中间移动，直到所有元素都被交换。使用前需要导入头文件 #include < algorithm >。

例如，我们反转字符串 str：

reverse(str.begin(), str.end());

例如，我们反转一个字符串 str，由数字组成：

// 处理负数
reverse(str.begin() + 1, str.end());

// 处理正数
reverse(str.begin(), str.end());

例如，下面代码是将输入的整数转换为字符串，然后再进行反转，正数和负数都可以处理：

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

int main() 
{
    int n;
    cin>>n;
    string str=to_string(n);  // 将整数转换为字符串
    if(str[0]=='-')     // 若是负数，从第二位开始反转（跳过负号）
        reverse(str.begin()+1,str.end());
    else               // 若是正数，反转整个字符串
        reverse(str.begin(),str.end());
    cout<<str;
    return 0;
}

运行结果如下：

或者可以通过传统的取余运算来实现逆序输出，还可以再加些代码，从而实现一个C++程序来判断输入数字的逆序数字是不是素数：

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

int main()
{
    int n,last,num=0;
    bool an=true;
    cin>>n;
    while(n!=0)    //只要原始数字n还未处理完（不为 0），就继续循环
    {
        last=n%10;          // 从原始数字n中获取最后一位
        num=num*10+last;    // *10是给新数字 "腾出位置"，将数字添加到逆序结果中
        n/=10;              // 移除n最后一位数字
    }
    if(num<2)    //所有小于 2 的数（如 0、1、负数）都不是素数
        an=false;
    else if(num==2)   //2是素数
        an=true;
    else if(num%2==0)  // 偶数不是素数（除了2）
        an=false;
    else          // 检查奇数因数
    {
        for(int i=3;i<=sqrt(num);i+=2)  //检查一个数是否能被除了 1 和自身以外的奇数整除
        {
            if(num%i==0)  //若num能被i整除（余数为 0），说明它不是素数
            {
                an=false;
                break;    //一旦找到一个能整除的数，就立即终止循环，无需继续检查其他数
            }
        }
    }
    if(an)
        cout<<"YES";
    else
        cout<<"NO";
    return 0;
}

运行结果如下：