c语言字符串库函数详解&模拟实现（strlen、strcpy、strcat、strcmp）+字符操作函数+字符转换函数_林酽的博客-爱代码爱编程
字符串库函数详解
注：本文介绍函数都需包含指定头文件
一、无字符串长度限制的字符串函数
1. strlen 计算字符串长度函数
1.参数：
size_t strlen ( const char * str );
- strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
- strlen 的函数返回值是size_t，无符号整形
- strlen 的参数指向的字符串的结尾必须包含’\0’
- 注意： strlen(“abc”)-strlen(“abcde”) 结果是>0 （-2存到无符号数里 是很大的正数）因此最好用比较，不要相减
2.使用方法：
#include<string.h>
int main()
{
char arr[] = { "abcde" };
int n = strlen(arr);
int i = 0;
for (i = 0; i < n; i++)
{
printf("%c ", arr[i]);
}
return 0;
}
3.模拟实现：（此处为计数器办法，还可以用1.指针-指针 2.递归的方式）
size_t mysrtlen(const char* str)
{
size_t cnt = 0;
assert(str);
while (*str != '0')
{
cnt++;
str++;
}
}
int main()
{
char arr[] = "abcdef";
size_t n = my_strlen(arr);
printf("%u\n", n);
return 0;
}
2. strcpy 字符串拷贝函数
1.参数：
char* strcpy(char * destination, const char * source );
- strcpy 拷贝时保证原数据要有’\0’ 所以不能用arr[]={‘c’,‘a’,‘r’,‘o’,‘l’},同时防止数组放不下，越界访问
- strcpy 会将源字符串中的 ‘\0’ 拷贝到目标空间中
- 拷贝的目标空间必须足够大
- 不能拷贝到常量字符串里（char *p=“abc”)
2.使用方法：
strcpy 里的第一个参数是拷贝的目标空间，第二个参数是拷贝的内容
int main()
{
char arr[20] = { "xxxxxxxxxxxxxxxxxxxx" };
char x[] = { "hello china" };
strcpy(arr, x);
printf("%s", arr);
return 0;
}
3.模拟实现
void my_strcpy(char* dest, const char* src)
{
assert(dest && src);
char* ret = dest; //记录一下初始位置
while (*src)
*dest++ = *src++;
return ret;
}
int main(){
char arr1[] = "abcdef";
char arr2[20]={0};
my_strcpy(arr2,arr1);
return 0;
}
3. strcat 字符串追加函数
1.参数：
char * strcat ( char * destination, const char * source );
- strcat 的源字符串必须以 \0 为结束标志
- strcat 的被追加的空间必须能够存放的下追加的字符串
- strcat 的源字符串必须是可改变的，不能是常量字符串
- 注意：自己追加自己会怎样？–陷入死循环，因为会把\0覆盖掉，破坏原数据
2.使用方法：
int main()
{
char arr[20] = { "hello " };
char arr2[] = "china";
strcat(arr, arr2);
printf("%s\n", arr);
return 0;
}
strcat 函数追加会把 arr2 的所有字符串拷贝到arr1里，包括\0
3.模拟实现
char* my_strcat(char* dest, const char* src)
{
assert(dest && src);
char* ret = dest;
//1.找到目标空间的末尾\0
while (*dest != '\0')
{
dest++;
}
//2.拷贝
while (*dest++ = *src++)
;
return ret;
}
int main()
{
char arr1[] = "hello ";
my_strcat(arr1, "world");
return 0;
}
4. strcmp 字符串比较函数
1.参数：
int strcmp ( const char * str1, const char * str2 );
-
strcmp函数判定规则：
第一个大于第二个，返回大于0的数字
第一个等于第二个，则返回0
第一个小于第二个，则返回小于0的数字 -
strcmp 是比较每个字符串的第一个字符， 如果相等，
则继续比较下一对字符，直到字符不相等或遇到’\0’
2.使用方法：
int main()
{
char arr[] = { "abcdefg" };
char str[] = { "abg" };
int ret = strcmp(arr, str);
if (ret > 0)
printf("arr > str");
else if (ret < 0)
printf("arr < str");
else
printf("arr == str");
return 0;
}
3.模拟实现
int my_strcmp(const char* str1,const char* str2)
{
assert(str1 && str2);
while (*str1 == *str2) //相等就找下一个
{
if (*str1 == '\0') return 0; //相等
str1++;
str2++;
}
if (*str1 > *str2) return 1;
else return -1;
//上述if - else可简化为 return(*str1 - *str2);
}
二、 有字符串长度限制的字符串函数
1. strncpy 字符串拷贝函数
1.参数：
char * strncpy ( char * destination, const char * source, size_t num );
- strncpy 和 strcpy 函数的使用方法相似，只是多了一个参数 size_t num
- 多出来的参数是来限制字符串拷贝的长度，增加了安全性
- 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加\0，直到num个
2.使用方法：
int main()
{
char arr1[25] = { "hello world!" };
char arr2[] = { "For a better tomorrow!########" };
strncpy(arr1, arr2, 22);
printf("%s\n", arr);
return 0;
}
2. strncat 字符串追加函数
1.参数：
char * strncat ( char * destination, const char * source, size_t num );
- 和 strcat 函数使用的方法和规则类似，在arr1的后面追加arr2的内容，并会在末尾自动加上\0。只是多了一个参数 size_t num
- num 这个参数代表需要追加几个字符
2.使用方法：
int main()
{
char arr[20] = "hello ";
char* str = "world! For a better tomorrow!";
strncat(arr, str, 6);
printf("%s\n", arr);
return 0;
}
3. strncmp 字符串比较函数
1.参数：
int strncmp ( const char * str1, const char * str2, size_t num );
- 规则和 strcmp 一样
- 多出来的一个参数是用来要比较字符串的个数
2.使用方法：比较前3个字符大小
int main()
{
char arr[] = { "abgefg" };
char str[] = { "abgaaaa" };
int ret = strncmp(arr, str,3);
if (ret > 0)
printf("arr > str");
else if (ret < 0)
printf("arr < str");
else
printf("arr == str");
return 0;
}
4. strstr 在字符串中查找另一字符串
1.参数：
char * strstr ( const char *str1, const char * str2);
- 作用：在A 字符串中查找是否包含 B字符串
- 如果 A 中包含 B ，则返回 B 在 A 中首次出现的的地址。否则返回空指针。
因为返回的是地址，所以要用指针变量来接收
2.使用方法：
int main()
{
char arr[] = { "abcdefg" };
char str[] = { "cde" };
char* ret = strstr(arr, str);
if (ret == NULL)
printf("没有找到\n");
else
printf("%s\n", ret);
return 0;
}
5. strtok 切割字符串函数
1.参数：
char * strtok ( char * str, const char * sep );
- sep参数是个字符串，定义了用作分隔符的字符集合第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
- strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
- strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
- strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
- 如果字符串中不存在更多的标记（找不到），则返回 NULL 指针 （输出(null)）。
总结：第一次调用传第一个变量首地址，后面几次传NULL就行（怎么记录的？用static保存）
2.使用方法：
三、两个错误码函数
1. strerror 解析错误码函数
1.参数：
char * strerror ( int errnum );
注：需包含头文件<errno.h>
- 在使用库函数的时候，调用库函数失败时，都会设置错误码
- C语言中有一个全局变量叫 errno，只要调用库函数发生错误，就会把错误码放到errno里
- strerror函数会把错误码翻译成对应的错误信息
2.效果展示：
int main()
{
printf("%s\n", strerror(0));
printf("%s\n", strerror(1));
printf("%s\n", strerror(2));
printf("%s\n", strerror(3));
printf("%s\n", strerror(4));
printf("%s\n", strerror(5));
return 0;
}
3.使用方法：
一般是 strerror 里放 errno，errno 里存放的是错误码
int main()
{
FILE* pFile;
pFile = fopen("test.txt", "r");//打开test.txt,以读的形式打开文件
if (pFile == NULL) // 打开失败就是空指针
printf("%s\n", strerror(errno));
//错误码自动保存在 errno 变量当中
return 0;
}
2.perror 解析错误码，打印信息
1.参数：
void perror(const char* str);
注：需包含头文件<stdio.h>
- perror 和 strerror 作用都是一样的，不过strerror 没有打印的效果
- perror 是把错误码转换成错误信息，再打印
2.使用方法：
int main()
{
//1. 打开文件失败时，返回NULL
FILE* pd = fopen("test.txt", "r");
if (pd == NULL)
{
perror("错误信息");
return 1;
}
// 2. 读文件
// .....
//3. 关闭文件
fclose(pd);
pd = NULL;
return 0;
}
字符操作函数
注：以上函数需要头文件<ctype.h>
字符转换函数
1.tolower
使用：
#include<ctype.h>
int main()
{
char arr[20] = { 0 };
scanf("%s", &arr);
int i = 0;
while (arr[i] != '\0')
{
if (isupper(arr[i])) //判断是否是大写字母
{
arr[i] = tolower(arr[i]);
}
printf("%c ", arr[i]);
i++;
}
return 0;
}
2.toupper
使用：
int main()
{
char arr[20] = { 0 };
scanf("%s", &arr);
int i = 0;
while (arr[i] != '\0')
{
if (islower(arr[i])) //判断是否是小写字母
{
arr[i] = toupper(arr[i]); //转换成大写字符
}
printf("%c ", arr[i]);
i++;
}
return 0;
}
总结
注意头文件的使用，使用字符串相关函数都要有<string.h>，两个报错函数不同头文件，字符操作函数和转换函数需要<ctype.h>。
一般使用有字符串长度限制的字符串函数，防止越界报错，提高安全性。
注意思考这些字符串函数自己作用于自己时的情况，结合’\0’考虑。