字符串常用函数 1.0
strcpy_s
errno_t strcpy_s(char * restrict dest, rsize_t destsz, const char * restrict src);
参数解释
dest：指向目标字符数组的指针，用于存储复制后的字符串。destsz：目标字符数组的大小，即dest所指向的缓冲区的最大容量，包括字符串结束符'\0'。src：指向源字符串的指针，该字符串将被复制到目标数组中。
返回值
- 如果复制操作成功，函数返回
0。 - 如果发生错误，函数返回一个非零的错误码。常见的错误情况包括：
EINVAL：如果dest或src为空指针，或者destsz为 0 或小于源字符串的长度（包括'\0'）。ERANGE：如果目标缓冲区太小，无法容纳源字符串及其结束符'\0'。
#include
#include
int main() {
char dest[20];
const char *src = "Hello, World!";
// 使用 strcpy_s 进行字符串复制
errno_t err = strcpy_s(dest, sizeof(dest), src);
if (err == 0) {
printf("复制成功: %s\n", dest);
} else {
printf("复制失败，错误码: %d\n", err);
}
return 0;
} 捕获异常函数
#include
#include
#include
// 自定义的无效参数处理函数
void my_invalid_parm_handler(const wchar_t* expression, const wchar_t* function, const wchar_t* file, unsigned int line, uintptr_t p_reserved) {
wprintf(L"Invalid parameter detected in function %s. File: %s Line %d\n", function, file, line);
wprintf(L"Expression: %s\n", expression);
}
int main() {
// 设置自定义的无效参数处理函数
_set_invalid_parameter_handler(my_invalid_parm_handler);
// 这里模拟一个可能触发无效参数的操作，比如除以0
int a = 10;
int b = 0;
int result = a / b;
return 0;
} 需要引用stdlib.h和crtdab.h
同时在代码前面加上 _set_invalid_parameter_handler(my_invalid_parm_handler);这一行
（具体为什么没看懂）
strcat_s
errno_t strcat_s(char *dest, rsize_t destsz, const char *src);参数
-
dest: 目标字符串缓冲区，连接后的字符串将存储在这里。
-
destsz: 目标缓冲区的大小（包括空字符
\0）。 -
src: 要追加到目标字符串的源字符串。
返回值
-
成功时返回
0。 -
失败时返回非零错误码（如
EINVAL或ERANGE）。
使用示例
#include
#include
int main() {
char dest[20] = "Hello, ";
const char *src = "World!";
// 使用 strcat_s 连接字符串
errno_t result = strcat_s(dest, sizeof(dest), src);
if (result == 0) {
printf("连接后的字符串: %s\n", dest);
} else {
printf("错误: 无法连接字符串\n");
}
return 0;
} 注意事项
-
缓冲区大小检查：
strcat_s会检查目标缓冲区是否有足够的空间容纳源字符串，避免溢出。 -
空指针检查：如果
dest或src是空指针，函数会返回错误。 -
目标缓冲区大小：
destsz必须大于目标字符串的当前长度加上源字符串的长度再加 1（用于空字符）。
sprintf_s
errno_t sprintf_s(char *restrict buffer, rsize_t sizeOfBuffer, const char *restrict format, ...);
参数解释
buffer：指向用于存储格式化结果的字符数组的指针。sizeOfBuffer：目标字符数组buffer的大小，包含字符串结束符'\0'。这个参数用于确保不会发生缓冲区溢出。format：格式化字符串，它指定了输出的格式。格式化字符串中可以包含普通字符和格式说明符（如%d用于整数，%s用于字符串等）。...：可变参数列表，根据format字符串中的格式说明符，提供相应的参数。
返回值
- 如果操作成功，返回写入到
buffer中的字符数（不包括字符串结束符'\0'）。 - 如果发生错误，返回一个非零的错误码。常见错误情况及对应错误码如下：
EINVAL：如果buffer或format为NULL指针，或者sizeOfBuffer为 0。ERANGE：如果格式化后的字符串长度（包括'\0'）超过了sizeOfBuffer。
示例代码
#include
#include
int main() {
char buffer[20];
int num = 42;
const char *str = "Hello";
errno_t err;
// 使用 sprintf_s 进行格式化输出
err = sprintf_s(buffer, sizeof(buffer), "Number: %d, String: %s", num, str);
if (err == 0) {
printf("格式化成功: %s\n", buffer);
} else {
printf("格式化失败，错误码: %d\n", err);
}
return 0;
} strncpy_s
errno_t strncpy_s(char *restrict dest, rsize_t destsz, const char *restrict src, rsize_t count);
参数解释
dest：指向目标字符数组的指针，用于存储复制过来的字符串。destsz：目标字符数组的大小，即dest所指向的缓冲区的最大容量，要包含字符串结束符'\0'。src：指向源字符串的指针，也就是要被复制的字符串。count：最多从src复制到dest的字符数量。
返回值
- 如果复制操作成功，函数返回
0。 - 如果出现错误，函数会返回一个非零的错误码，常见错误及对应错误码如下：
EINVAL：当dest或src为NULL指针，或者destsz为0或小于等于count时返回该错误码。ERANGE：如果src的长度大于等于count且destsz不足以容纳count个字符和字符串结束符'\0'时返回此错误码。
#include
#include
int main() {
char dest[10];
const char *src = "Hello, World!";
errno_t err;
// 使用 strncpy_s 复制字符串
err = strncpy_s(dest, sizeof(dest), src, 5);
if (err == 0) {
printf("复制成功: %s\n", dest);
} else {
printf("复制失败，错误码: %d\n", err);
}
return 0;
} strncat_s
errno_t strncat_s(char *restrict dest, rsize_t destsz, const char *restrict src, rsize_t count);
参数解释
dest：指向目标字符数组的指针，该数组需要预先包含一个以'\0'结尾的字符串，新追加的内容将从这个'\0'位置开始添加。destsz：目标字符数组的总大小，包含字符串结束符'\0'。此参数用于确保不会发生缓冲区溢出。src：指向源字符串的指针，该字符串以'\0'结尾，其中部分内容会被追加到目标字符串末尾。count：指定从源字符串src中最多追加到目标字符串dest的字符数量。
返回值
- 如果操作成功，函数返回
0。 - 如果出现错误，函数返回一个非零的错误码，常见的错误情况及对应错误码如下：
EINVAL：当dest或src为NULL指针，或者destsz为0时返回该错误码。ERANGE：若目标缓冲区没有足够的空间来容纳追加的字符和原有的内容（包括'\0'），会返回此错误码。
#include
#include
int main() {
char dest[20] = "Hello, ";
const char *src = "World!";
errno_t err;
// 使用 strncat_s 追加字符串
err = strncat_s(dest, sizeof(dest), src, 3);
if (err == 0) {
printf("追加成功: %s\n", dest);
} else {
printf("追加失败，错误码: %d\n", err);
}
return 0;
} gets_s
char *gets_s(char *str, rsize_t n);
参数解释
str：指向用于存储读取字符串的字符数组的指针。n：字符数组str的大小，也就是该数组能够容纳的最大字符数（包含字符串结束符'\0'）。
返回值
- 如果读取成功，函数返回
str指针。 - 如果遇到文件结束符（EOF）且没有读取到任何字符，函数返回
NULL并且str数组内容保持不变。 - 如果发生错误（例如读取的字符数超过了
n - 1个，或者输入过程中出现错误），函数会调用无效参数处理程序（如果已设置），并将str数组的第一个字符设置为'\0'，然后返回NULL。
#include
int main() {
char input[20];
char *result;
printf("请输入一行字符串：");
result = gets_s(input, sizeof(input));
if (result != NULL) {
printf("你输入的字符串是：%s\n", input);
} else {
printf("读取输入时发生错误或遇到文件结束符。\n");
}
return 0;
} strtok_s
strtok_s 是 C11 标准引入的一个安全版本的字符串分割函数，用于将一个字符串按照指定的分隔符分割成多个子字符串
char *strtok_s(char *restrict str, const char *restrict delimiters, char **restrict context);
参数解释
str：指向要分割的字符串的指针。在第一次调用strtok_s时，传入要分割的原始字符串；后续调用时，传入NULL以继续分割同一个字符串。delimiters：指向包含分隔符字符的字符串的指针。这些字符用于指定分割字符串的位置。context：指向一个char*类型的指针的指针，用于存储函数内部的上下文信息。这个上下文信息在后续调用strtok_s时会被使用，以记录分割的位置。
返回值
- 如果找到了一个有效的子字符串，函数返回指向该子字符串的指针。
- 如果没有更多的子字符串可供分割，函数返回
NULL。
#include
#include
int main() {
char str[] = "Hello,World,How,Are,You";
char *token;
char *context = NULL;
// 第一次调用 strtok_s 分割字符串
token = strtok_s(str, ",", &context);
while (token != NULL) {
printf("%s\n", token);
// 后续调用 strtok_s 继续分割字符串
token = strtok_s(NULL, ",", &context);
}
return 0;
} 运行结果
Hello
World
How
Are
Youstrcmp
strcmp 是 C 标准库 '\0'）
int strcmp(const char *s1, const char *s2);
参数解释
s1：指向要比较的第一个字符串的指针。s2：指向要比较的第二个字符串的指针。
返回值
- 如果
s1和s2相等（即两个字符串的内容完全相同），函数返回0。 - 如果
s1按字典序小于s2（即s1中第一个不同字符的 ASCII 值小于s2中对应字符的 ASCII 值），函数返回一个小于0的整数。 - 如果
s1按字典序大于s2（即s1中第一个不同字符的 ASCII 值大于s2中对应字符的 ASCII 值），函数返回一个大于0的整数。
示例代码
#include
#include
int main() {
const char *str1 = "apple";
const char *str2 = "banana";
const char *str3 = "apple";
int result1 = strcmp(str1, str2);
int result2 = strcmp(str1, str3);
if (result1 < 0) {
printf("'%s' 在字典序上小于 '%s'\n", str1, str2);
} else if (result1 > 0) {
printf("'%s' 在字典序上大于 '%s'\n", str1, str2);
} else {
printf("'%s' 等于 '%s'\n", str1, str2);
}
if (result2 < 0) {
printf("'%s' 在字典序上小于 '%s'\n", str1, str3);
} else if (result2 > 0) {
printf("'%s' 在字典序上大于 '%s'\n", str1, str3);
} else {
printf("'%s' 等于 '%s'\n", str1, str3);
}
return 0;
} strncmp
int strncmp(const char *s1, const char *s2, size_t n);
参数解释
s1：指向第一个要比较的字符串的指针。s2：指向第二个要比较的字符串的指针。n：指定要比较的最大字符数。函数会比较s1和s2的前n个字符。
返回值
- 如果
s1和s2的前n个字符完全相同，或者在比较到第n个字符之前就已经到达某个字符串的末尾（遇到'\0'）且之前的字符都相同，函数返回0。 - 如果
s1的前n个字符按字典序小于s2的前n个字符，函数返回一个小于0的整数。 - 如果
s1的前n个字符按字典序大于s2的前n个字符，函数返回一个大于0的整数。
示例代码
#include
#include
int main() {
const char *str1 = "apple";
const char *str2 = "applesauce";
const char *str3 = "banana";
// 比较前 3 个字符
int result1 = strncmp(str1, str2, 3);
int result2 = strncmp(str1, str3, 3);
if (result1 == 0) {
printf("'%s' 和 '%s' 的前 3 个字符相同\n", str1, str2);
} else {
printf("'%s' 和 '%s' 的前 3 个字符不同\n", str1, str2);
}
if (result2 < 0) {
printf("'%s' 的前 3 个字符在字典序上小于 '%s' 的前 3 个字符\n", str1, str3);
} else if (result2 > 0) {
printf("'%s' 的前 3 个字符在字典序上大于 '%s' 的前 3 个字符\n", str1, str3);
} else {
printf("'%s' 和 '%s' 的前 3 个字符相同\n", str1, str3);
}
return 0;
} strchr
strchr 是 C 标准库
char *strchr(const char *s, int c);
参数解释
s：指向要进行查找操作的字符串的指针，该字符串必须以'\0'结尾。c：要查找的字符，虽然参数类型是int，但实际上是将其作为char类型来处理的，这主要是为了兼容 EOF（文件结束符）的处理。
返回值
- 如果在字符串
s中找到了字符c，函数返回指向该字符首次出现位置的指针。 - 如果在字符串
s中没有找到字符c，函数返回NULL。
示例代码
#include
#include
int main() {
const char *str = "Hello, World!";
char target = 'o';
char *result = strchr(str, target);
if (result != NULL) {
printf("字符 '%c' 首次出现在字符串中的位置是: %ld\n", target, result - str);
} else {
printf("在字符串中未找到字符 '%c'\n", target);
}
return 0;
} strtchr
strrchr 是 C 标准库中的一个字符串处理函数，用于查找字符串中最后一个匹配指定字符的位置。
char *strrchr(const char *str, int c);参数解释
-
str: 要搜索的字符串。 -
c: 要查找的字符（以int形式传递，但会被转换为char）。
返回值
-
如果找到字符
c，返回指向字符串中最后一个匹配字符的指针。 -
如果未找到字符
c，返回NULL。
#include
#include
int main() {
const char *str = "Hello, World!";
char ch = 'o';
// 查找字符 'o' 最后一次出现的位置
char *result = strrchr(str, ch);
if (result != NULL) {
printf("找到字符 '%c'，位置在: %ld\n", ch, result - str);
printf("从该位置开始的子字符串: %s\n", result);
} else {
printf("未找到字符 '%c'\n", ch);
}
return 0;
} strstr
strstr 是 C 标准库
char *strstr(const char *haystack, const char *needle);参数解释
haystack：指向要进行查找操作的主字符串的指针，该字符串必须以'\0'结尾。needle：指向要查找的子字符串的指针，该字符串同样必须以'\0'结尾。
返回值
- 如果在主字符串
haystack中找到了子字符串needle，函数返回指向needle首次出现位置的指针。 - 如果在主字符串
haystack中没有找到子字符串needle，函数返回NULL。 - 如果
needle是一个空字符串（即只包含'\0'），函数返回haystack本身。
示例代码
#include
#include
int main() {
const char *haystack = "Hello, World! This is a test.";
const char *needle = "World";
char *result = strstr(haystack, needle);
if (result != NULL) {
printf("子字符串 '%s' 首次出现在主字符串中的位置是: %ld\n", needle, result - haystack);
} else {
printf("在主字符串中未找到子字符串 '%s'\n", needle);
}
return 0;
} strspn
strspn 是 C 标准库
size_t strspn(const char *s, const char *accept);
参数解释
s：指向要进行检查的字符串的指针，该字符串必须以'\0'结尾。accept：指向包含允许字符的字符串的指针，该字符串同样必须以'\0'结尾。
返回值
返回字符串 s 中从开头开始连续包含 accept 字符串中任意字符的字符数量。
工作原理
strspn 函数从字符串 s 的开头开始，逐个检查字符。只要当前字符存在于 accept 字符串中，就继续检查下一个字符，并计数。一旦遇到不在 accept 字符串中的字符，计数停止，函数返回之前统计的字符数量。
示例代码
#include
#include
int main() {
const char *s = "123abc456";
const char *accept = "1234567890";
size_t result = strspn(s, accept);
printf("字符串 '%s' 开头连续包含 '%s' 中字符的长度是: %zu\n", s, accept, result);
return 0;
} strcspn
strcspn 是 C 标准库 strspn 函数相对。strspn 用于计算字符串开头连续包含指定字符集合中字符的长度，而 strcspn 用于计算字符串开头连续不包含指定字符集合中字符的长度。
size_t strcspn(const char *s, const char *reject);参数解释
s：指向要进行检查的目标字符串的指针，该字符串必须以'\0'结尾。reject：指向包含要排除字符的字符串的指针，此字符串同样需以'\0'结尾。
返回值
返回字符串 s 中从开头开始连续不包含 reject 字符串中任意字符的字符数量。
工作原理
strcspn 函数从字符串 s 的起始位置开始，逐个检查字符。只要当前字符不在 reject 字符串中，就继续检查下一个字符，并对字符数量进行计数。一旦遇到 reject 字符串中包含的字符，计数停止，函数返回之前统计的字符数量。
示例代码
#include
#include
int main() {
const char *s = "abcdef123";
const char *reject = "1234567890";
size_t result = strcspn(s, reject);
printf("字符串 '%s' 开头连续不包含 '%s' 中字符的长度是: %zu\n", s, reject, result);
return 0;
} 用处：用来检验输入的字符串是否合法，判断有没有违规字符
int main(void)
{
char input[] = "filaname.txt";
char invaliChars[] = "/\\:*?\"<>|";
if (strscpn(input, invaliChars) < strlen(input)) {
printf("Input contains invalid characters.\n");
}
else {
printf("Input is valid.\n");
}
return 0;
}已完结