前言
C语言中对字符和字符串的处理很频繁，但是C语言本身没有字符串类型，字符串通常放在常量字符串中或者字符数组中。字符串常量适用于那些对它不做修改的字符串函数。
一、求字符串长度
1.1 求字符串长度 strlen
size_t strlen( const char* str );
* 字符串以 '\0' 作为结束标志，strlen 函数返回的是在字符串中 '\0' 前面出现的字符个数（不包含 '\0' ）。
* 参数指向的字符串必须有 '\0' 结束，不然会输出随机值。
* 注意函数的返回值为 size_t，是无符号的。
简单用用
char arr1[] = "abc";
char arr2[] = { 'a','b','c' };
int len1 = strlen(arr1);
int len2 = strlen(arr2);
printf("%d\n", len1);
printf("%d\n", len2);
模拟实现strlen函数
#define _CRT_SECURE_NO_WARNINGS 1
//三种方式模拟实现strlen
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
//1.使用计数器实现求字符串长度
int my_strlen1(const char*str) {
assert(str != NULL);
int count = 0;
while (*str != '\0') {
count++;
str++;
}
return count;
}
//2.使用递归实现求字符串长度
int my_strlen2(const char* str) {
assert(str != NULL);
if (*str != '\0') {
return 1 + my_strlen2(str+1);
}
return 0;
}
//3.通过指针-指针得到中间元素个数，求得字符串长度
int my_strlen3(const char* str) {
assert(str != NULL);
const char* tmp = str;
while (*str != '\0') {
str++;
}
return str - tmp;
}
int main() {
char arr[] = "abcdefg";
printf("%d\n", my_strlen1(arr));
printf("%d\n", my_strlen2(arr));
printf("%d\n", my_strlen3(arr));
return 0;
}
二、长度不受限制的字符串函数
2.1 字符串拷贝函数 strcpy
char* strcpy( char* destination, const char* source);
* 源字符串必须以 '\0' 结束
* 会将源字符串中的 '\0' 拷贝到目标空间
* 目标框架必须足够大，以确保能存放源字符串
* 目标空间必须可变
简单用用
//4、常量字符串目标空间不可变 - 不能拷贝
char* str = "xxxxxxxxxxxxxxxxxx";
char* p = "hello world";
strcpy(str, p);
printf("%s\n", p);
//3、目标空间不够源字符串拷贝 - 拷贝过去后报错
char arr[5] = "###";
char* p = "hello world";
strcpy(arr, p);
printf("%s\n", arr);
//2、拷贝没有结束标志的字符串 - 报错
char arr[20] = "#########";
//char arr1[] = { 'a','b','c' }; //err
strcpy(arr, "hello");
printf("%s\n", arr);
//1、正常使用
char arr[20] = { 0 };
strcpy(arr, "hello");
printf("%s\n", arr);
模拟实现strcpy函数
方式一：
//拷贝每一位上的字符，然后目标位置和源字符串的指针后移，直到遇到源字符串的结束标志
//注意，最后要补上源字符串的结束标志
void my_strcpy(char* dest, const char* src) {
assert(dest);
assert(src);
while (*src != '\0') {
*dest = *src;
dest++;
src++;
}
*dest = *src;
}
方式二：
//先使用一个指针tmp指向dest目标字符串
//然后在while条件中，赋值，后移指针...直到遇到'\0'，赋值后死循环结束
//最后返回一开始的指针tmp，因为dest指针被死循环移动到后面，不好找回起点
void my_strcpy2(char* dest, const char* src) {
assert(dest);
assert(src);
char* tmp = dest;
while (*dest++ = *src++) {
;
}
return tmp;
}
2.2 字符串追加函数 strcat
char* strcat( char* destination, const char* source);
* 源字符串必须以 '\0' 结束
* 目标空间必须够容纳下源字符串内容
* 目标空间必须可修改，不是常量
简单用用
//2、
//遇到\0就会开始拷贝字符串
//拷贝上的字符串会带上\0，所以后面####不输出
char arr1[20] = "hello \0######";
char arr2[] = "world";
strcat(arr1, arr2);
printf("%s\n", arr1);
//1、正常使用
char arr1[20] = "hello ";
char arr2[] = "world";
strcat(arr1, arr2);
printf("%s\n", arr1);
模拟实现 strcat
//先找目标字符串dest的结束标志前一位地址
//开始拷贝，把源字符串src一个一个拷贝覆盖，指针后移
//最后遇到源字符串src的结束标志\0，结束死循环
void my_strcat(char* dest, const char* src) {
assert(dest && src);
while (*dest != '\0') {
dest++;
}
while (*dest++ = *src++) {
;
}
}
ps. 库函数 strcat 不能自己给自己追加字符串，
因为 \0 会被第一个字符覆盖，找不到 \0，就不能结束函数。
2.3 字符串字符对比函数 strcmp
int strcmp( const char* str1, const char* str2 );
str1 和 str2 是一个字符一个字符的对比。
* 标准规定：
第一个字符串str1 大于 第二个字符串str2，则返回大于 0 的数字
第一个字符串 等于 第二个字符串，则返回 0
第一个字符串 小于 第二个字符串，则返回小于 0 的数字
简单用用
//1、正常使用
int ret = strcmp("abcd", "abq"); //-1
printf("%d\n", ret);
printf("%d\n", strcmp("aaa", "aaa")); //0
printf("%d\n", strcmp("bbb", "aaa")); //1
模拟实现 strcmp
int my_strcmp(const char* str1, const char* str2) {
//先判断目前位置上的字符是否相等
while (*str1 == *str2) {
//等于 \0 表示对比结束了，没有找到不同，输出 0
if (*str1 == '\0') {
return 0;
}
//不等于 \0 就后移指针
str1++;
str2++;
}
//如果目前位置的字符，str1大于str2，输出1
if (*str1 > *str2) {
return 1;
}
//str1小于str2，输出-1
else {
return -1;
}
}
优化
int my_strcmp2(const char* str1, const char* str2) {
//加上断言
assert(str1 && str2);
while (*str1 == *str2) {
if (*str1 == '\0') {
return 0;
}
str1++;
str2++;
}
//直接相减，正数表示str1大，负数str2小
return *str1 - *str2;
}
三、长度受限制的字符串函数介绍
3.1 有限制的拷贝字符串函数 strncpy
char* strncpy( char* destination, const char* source, size_t num );
拷贝 num 个字符从源字符串到目标空间。
如果源字符串的长度小于 num，则拷贝完源字符串之后，在目标的后边追加 0，直到 num 个。
如果拷贝的字符长度大于source容量，则会破坏dest字符串后面的\0，要避免这种情况发生。
简单使用
//2、拷贝字符6大于源字符串，则拷贝完后其余补\0
char arr1[20] = "abcdefghi";
char arr2[] = "qwer";
strncpy(arr1, arr2, 6);
printf("%s\n", arr1); //qwer
//1、正常使用
char arr1[20] = "abcdef";
char arr2[] = "qwer";
strncpy(arr1, arr2, 2);
printf("%s\n", arr1); //qwcdef
模拟实现 strncpy
//方式一：
//先断言传递过来的指针是否有问题，然后创建指针tmp记录dest开始位置
//第一个while，当拷贝n大于0，并且src源字符串有数据可以拷贝
//第二个while，当src源字符串没有数据拷贝，n还大于0，那给dest赋值n个\0
char* my_strncpy1(char* dest, const char* src, int n) {
assert(dest && src);
char* tmp = dest;
while ((n > 0) && (*src != '\0')) {
*dest = *src;
dest++;
src++;
n--;
}
while (n > 0) {
*dest = '\0';
dest++;
n--;
}
return tmp;
}
//方式二：
//思路同上，优化了代码
char* my_strncpy2(char* dest, const char* src, int count) {
assert(dest && src);
char* tmp = dest;
while (count && (*dest++ = *src++) != '\0') {
count--;
}
while (count--) {
*dest = '\0';
dest++;
}
return tmp;
}
3.2 有限制的字符串追加函数 strncat
char* strncat( char* destination, const char* source, size_t num );
从source字符串中，取num个字符，追加到destination字符串中。
如果目标字符串中有\0，那么从\0位置开始追加字符串。
如果追加的字符长度大于目标空间剩余容量，会越界访问。
简单使用
//2、如果目标字符串中有\0，那么从\0位置开始追加字符串。
char arr1[15] = "1234\0xxxxxxxxx";
char arr2[] = "abcd";
strncat(arr1, arr2, 1);
printf("%s\n", arr1); //1234a
//1、正常使用
char arr1[20] = "hello ";
char arr2[] = "world";
strncat(arr1, arr2, 3);
printf("%s\n", arr1);
char str1[20];
char str2[20];
strcpy(str1, "To be ");
strcpy(str2, "or not to be");
strncat(str1, str2, 6);
puts(str1);
模拟实现
//记录dest起始位置
//然后一直找到dest字符串的末尾
//循环num次，src追加到dest，中途src遇到\0表示src到末尾
//退出循环记得给dest末尾补上\0
char* my_strncat1(char* dest, const char* src, int num) {
assert(dest && src);
char* tmp = dest;
while (*dest != '\0') {
dest++;
}
while (num) {
*dest = *src;
dest++;
src++;
if (*src == '\0') {
break;
}
num--;
}
*dest = '\0';
return tmp;
}
3.3 有限制的字符串比较函数 strncmp
int strncmp( const char* str1, const char* str2, size_t num );
比较字符串 str1 和 str2，比较的字符由 num 决定。
str1比str2小，则函数返回结果小于0
str1等于str2，函数返回结果等于0
str1大于str2，函数返回结果大于0
简单使用
char arr1[] = "abcdef";
char arr2[] = "abcd12";
int ret = 0;
ret = strncmp(arr1, arr2, 6);
if (ret == 0) {
printf("arr1 = arr2\n");
}
else if (ret < 0) {
printf("arr1 < arr2\n");
}
else {
printf("arr1 > arr2\n");
}
char str[][5] = { "R2D2","C3PO","R2A6" };
int n;
puts("Looking for R2 astromech droids...");
for (n = 0; n < 3; n++) {
//和R2XX比较2个字符，相等则输出
if (strncmp(str[n], "R2XX", 2) == 0) {
printf("found %s\n", str[n]);
}
}
模拟实现
int my_strncmp(const char* str1, const char* str2, int num) {
assert(str1 && str2);
//要多个判断num个字符
while (num && (*str1 == *str2)) {
//提前结束
if (*str1 == '\0') {
return 0;
}
//进入while，num要减一，str1和str2才能后移
if (--num) {
str1++;
str2++;
}
}
if (*str1 > *str2) {
return 1;
}
else if(*str1 < *str2){
return -1;
}
else {
return 0;
}
}
四、字符串查找
4.1 字符串查找函数 strstr
char* strstr( const char* str1, const char * str2);
从str1字符串中，查找子串str2
如果在 str1 中查到子串 str2，则返回 str1 中子串 str2 的起始位置。
如果查不到，返回空指针NULL。
如果 str1 中含有多个 str2 子串，返回第一个被查到的 str2 起始地址。
简单使用
char arr1[] = "abbbcdefbcd";
char arr2[] = "bcd";
char* ret = strstr(arr1, arr2);
if (ret == NULL) {
printf("not find!\n");
}
else {
printf("%s\n", ret);
}
模拟实现
char* my_strstr(const char* str1, const char* str2) {
assert(str1 && str2);
char* tmp = str1;
char* p1 = NULL;
char* p2 = NULL;
//子串不存在，直接返回str1字符串。
if (*str2 == '\0') {
return str1;
}
//tmp也就是str1没到末尾，while不结束
while (*tmp != '\0') {
p1 = tmp;
p2 = str2;
//一直找p1和p2相等
while ((*p1 == *p2) && (*p1 != '\0') && (*p2 != '\0')) {
p1++;
p2++;
}
if (*p2 == '\0') {
return tmp;
}
tmp++;
}
return NULL;
}
4.2 字符串分割函数 strtok
char* strtok( char* str, const char* sep );
参数一str，要被分割的字符串起始位置
参数二sep，被用于分割的字符集合起始位置
strtok函数找到str中的下一个标记，并且将其用 \0 结尾，返回一个指向这个标记的指针。
strtok函数会改变被操作的字符串，所以使用strtok函数切分的字符串一般都是临时拷贝的内容而且可修改。
strtok函数的第一个参数不为NULL，函数将找到str中第一个标记，strtok函数将保持它在字符串中的位置。
strtok函数的第一个参数为NULL，函数将在同一个字符串中被保持的位置开始，查找下一个标记。
如果字符串中不存在更多标记，则返回NULL指针。
简单使用
char arr1[] = "www.baidu.com";
char* p = ".";
char buf[100] = { 0 };
//用于标记分割后指针的位置
char* ret = 0;
//拷贝一份数据来分割
strcpy(buf, arr1);
//第一次参数需要源数据和分割符号
//指针一直后移，遇到分割符号停止，最后输出指针前面内容
ret = strtok(buf, p);
printf("%s\n", ret);
//NULL表示从内存中指针的位置开始
//继续后移找分割符号
ret = strtok(NULL, p);
printf("%s\n", ret);
//NULL表示从内存中指针的位置开始
//继续后移找分割符号
ret = strtok(NULL, p);
printf("%s\n", ret);
//一次性打印
char arr1[] = "www.baidu.com";
char* p = ".";
char buf[100] = { 0 };
//用于标记分割后指针的位置
char* ret = 0;
//拷贝一份数据来分割
strcpy(buf, arr1);
//一次性打印
//第一次参数输入源字符串
//只要ret不返回NULL，表示没有分割结束
//后续strtok参数继续NULL，继续向后分割字符串即可
for (ret = strtok(buf, p); ret != NULL; ret = strtok(NULL, p)) {
printf("%s\n", ret);
}
//切个复杂的
char str[] = "- this, a sample string.";
char buf[100] = { 0 };
strcpy(buf, str); //拷贝副本
char* pch;
pch = strtok(buf, " ,.-");
//先切割一次
//后续只需要传递NULL和切割符号
while (pch != NULL) {
printf("%s\n", pch);
pch = strtok(NULL, " ,.-");
}
五、错误信息报告
5.1 错误信息函数 strerror
char* strerror( int errnum );
返回错误码，所对应的错误信息
头文件：errno.h
简单使用
int i = 0;
for (i = 0; i < 10; i++) {
printf("%d --- %s\n", i, strerror(i));
}
使用举例: 文件打开失败
FILE* pf = fopen("test.txt", "r");
if (pf == NULL) {
printf("%s\n", strerror(errno));
//errno是一个全局的错误码变量，需要引用头文件 errno.h
//当c语言库函数执行过程中发生了错误，就会把对应的错误码赋值到errno中
return 1;
}
fclose(pf);
pf = NULL;
5.2 打印错误信息函数 perror
perror：直接打印错误信息
头文件：stdio.h
1. 把错误码转换成错误信息。
2. 打印错误信息（包含自定义消息）。
FILE* pf = fopen("test.txt", "r");
if (pf == NULL) {
perror("fopen");
return 1;
}
fclose(pf);
pf = NULL;
1550
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
