【让你从0到1学会c语言】字符串函数详解及模拟实现
作者：喜欢猫咪的的程序员
专栏：《C语言》
喜欢的话：世间因为少年的挺身而出，而更加瑰丽。 ——《人民日报》
目录
前言：什么是字符串函数？
字符串函数：
strlen函数：
strlen介绍：
strlen的注意点：
strlen的使用：
例子代码：
运行结果：
strlen与sizeof的区别：
相同点：
不同点：
sizeof和strlen在计算字符串时的不同计算方式：
strlen的模拟实现：
原理：
模拟实现：
运行结果：
strcpy函数：
strcpy介绍：
strcpy函数的注意点：
strcpy函数的使用：
例子代码：
运行结果：
strcpy的模拟实现：
原理：
模拟实现：
运行结果：
strcat函数：
strcat函数介绍：
strcat函数注意点：
strcat函数的使用：
例子代码：
运行结果：
strcat函数模拟实现：
原理：
模拟实现：
运行结果：
strcmp函数：
strcmp函数介绍：
strcmp函数注意点（返回值）：
我们如何两个字符串如何比较：
strcmp函数的使用：
例子代码：
运行结果：
strcmp函数模拟实现：
原理：
模拟实现：
运行结果：
strncpy函数：
strncpy函数介绍：
strncpy函数注意点：
strncpy函数的使用：
例子代码：
运行结果：
strncpy函数的模拟实现：
原理：
模拟实现：
运行结果：
strncat函数：
strncat函数介绍：
strncat函数的使用：
例子代码：
运行结果：
strncat函数模拟实现：
原理：
模拟实现：
运行结果：
strncmp函数：
strncmp函数介绍：
strncmp函数注意点：
strncmp函数的使用：
例子代码：
运行结果：
strncmp函数的模拟实现：
原理：
模拟实现：
运行结果：
前言：什么是字符串函数？
字符串函数（String processing function）也叫字符串处理函数，指的是编程语言中用来进行字符串处理的函数，如C，pascal，Visual以及LotusScript中进行字符串拷贝，计算长度，字符查找等的函数。
字符串函数：
- 求字符串长度
strlen
- 长度不受限制的字符串函数
strcpy
strcat
strcmp
- 长度受限制的字符串函数介绍
strncpy
strncat
strncmp
- 字符串查找
strstr
strtok
- 错误信息报告
strerror
- 字符操作
- 内存操作函数
memcpy
memmove
memset
memcmp
- atoi函数
strlen函数：
strlen介绍：
用处：计算字符串长度。
参数：str为char*的指针（地址），为字符串的起始地址。
返回值：为size_t，为 字符串的长度。
头文件为：#include
strlen的注意点：
- 注意函数的返回值为size_t，是无符号的（ 易错 ）
- 参数指向的字符串必须要以 '\0' 结束。
strlen的使用：
例子代码：
int main()
{
char p[20] = "asasf";
int q = strlen(p);
printf("%d", q);
return 0;
}运行结果：
strlen与sizeof的区别：
我们知道strlen和sizeof都是计算数据大小的。
我们来说一下：strlen和sizeof异同点。
相同点：
sizeof和strlen的返回值都是size_t（ize_t的全称应该是size type，就是说一种用来记录大小的数据类型‘）。
不同点：
- strlen是一个库函数，而sizeof是一个操作符。
sizeof是计算数据占用内存的大小，单位是字节。strlen是字符串长度，只能运用于字符串。
sizeof和strlen在计算字符串时的不同计算方式：
- strlen是只能用来计算字符串的长度的，计算\0前面有几个数（不包括\0），\0前面有几个数strlen的结果就是几。
- sizeof不止可以用来计算字符串的长度，计算int类型的占用的字节大小也可以。sizeof计算的是字符串在内存中占用几个字节。会包括/0
详细部分以及示例可看我的例外一篇博客：(4条消息) C语言语言：探究sizeof和strlen的区别_一个喜欢猫咪的程序员的博客-CSDN博客
https://blog.csdn.net/m0_69061857/article/details/126288232?spm=1001.2014.3001.5501
strlen的模拟实现：
原理：
我们只要定义一个个数，每遇到一个字符，个数++就好，'\0'不要个数++就好。
模拟实现：
#include
size_t my_strlen(const char* str)
{
int count = 0;
while (*str)
{
count++;
str++;
}
return count;
}
int main()
{
char* ch="abcdefgh";//需要计算的字符串
int sz = my_strlen(ch);
printf("%d\n", sz);
return 0;
} 运行结果：
strcpy函数：
strcpy介绍：
用处：用于字符串复制，将一个字符串复制给例外一个字符串，
参数 ：两个参数，第一个参数是目标字符串的指针（地址），第二个是要复制的字符串的指针（地址），都为char*类型。
返回值：为char*类型，为目标字符串的首字符的指针（地址）。
头文件：#include
strcpy函数的注意点：
- 会将要复制的字符串中的 '\0' 拷贝到目标字符串。
- 目标空间必须足够大，以确保能存放源字符串。
- 目标空间必须可变。不能是常量字符串
strcpy函数的使用：
例子代码：
int main()
{//strcpy的使用
char p1[20] ;//目标字符串
char p2[10] = "qqqqq";//要复制的字符串
strcpy(p1, p2);
printf("%s", p1);
return 0;
}运行结果：
strcpy的模拟实现：
原理：
我们要将要复制的字符串中的字符一个个赋值给目标字符串，记得'\0'也要赋过去哦。
模拟实现：
#include
void my_strcpy(char a1[], char a2[])
{
for (int i = 0; i < strlen(a1); i++)
{
a1[i] = a2[i];
}
}
int main()
{//strcpy的模拟实现
char a1[] = "xxxxxxxxxx";//目标字符串
char a2[] = "abcdef";//要复制的字符串
printf("%s\n", a1);
my_strcpy(a1,a2);
printf("%s\n", a1);
return 0;
} 运行结果：
strcat函数：
strcat函数介绍：
用处：向一个字符串，追加另外一个字符串。
参数：第一个为原字符串，第二个为要追加的字符串。
返回值：为char*，为原字符串的首字符的地址（指针）。
头文件：#include
strcat函数注意点：
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。
strcat函数的使用：
例子代码：
int main()
{
char p1[20] = "dfaw";
char p2[20] = "sqqqq";
strcat(p1, p2);
printf("%s", p1);
return 0;
}运行结果：
strcat函数模拟实现：
原理：
先找原字符串的‘\0’的位置，从这个位置开始将要追加的字符串的字符一个个追加，注意：最后还是要有‘\0’的。
模拟实现：
#include
#include
char* my_strcat(char* dest, const char* src)
{
char* start = dest;
assert(dest != NULL && src != NULL);
while (*dest != '\0')
dest++;
while (*src != '\0')
{
*dest = *src;
dest++;
src++;
}
*dest = '\0';
return start;
}
int main()
{//模拟实现strcat函数
char a[20] = "hellow";
char b[10] = " word !";
char* c;
c = my_strcat(a, b);
printf("%s\n", a);
system("pause");
return 0;
} 运行结果：
strcmp函数：
strcmp函数介绍：
用处：比较两个字符串的大小。
参数：两个字符串指针。
返回值：为int类型，有三种可能，一种为0，一种为大于0的数，一种为小于0的数。
头文件：#include
strcmp函数注意点（返回值）：
strcmp函数要注意的是就它的返回值。
我们在上面说过，strcmp的返回值有三种可能。
标准规定：
- 第一个字符串大于第二个字符串，则返回大于0的数字
- 第一个字符串等于第二个字符串，则返回0
- 第一个字符串小于第二个字符串，则返回小于0的数字
我们如何两个字符串如何比较：
两个字符串如何比较呢？
- 第一个字符串的第一个字符与另外一个字符串的第一个字符比较ASCII码值，如果第一个大于第二个，就返回大于0，反之，就返回小于0.
- 如果第一个字符串的第一个和另外一个字符串的第一个字符相等，就比较两者的第二个字符，以此类推，只有每一个字符都相等才返回0.
strcmp函数的使用：
例子代码：
int main()
{
char p1[20] = "asjkd";
char p2[20] = "ksd";
int n=strcmp(p1, p2);
if (n == 0)
printf("两个相等\n");
if (n > 0)
printf("p1大\n");
if(n<0)
printf("p2大\n");
return 0;
}运行结果：
strcmp函数模拟实现：
原理：
将两者的字符串的每一个字符进行比较，如果不同，就返回结果，如果相同，就进行两者下一个字符的比较。当每一个字符都相等，才判断为两个字符串相等。
模拟实现：
int my_strcmp(char* ch1, char* ch2)
{
if (ch1 != ch2)
{
if (ch1 > ch2)
return 1;
else
return 2;
}
ch1++;
ch2++;
}
int main()
{//strcmp函数的模拟实现
char* ch1 = "abcdefg";
char* ch2 = 'acdw';
int a=my_strcmp(ch1, ch2);
if (a == 1)
printf("ch1大");
if (a == 2)
printf("ch2大");
return 0;
}运行结果：
strncpy函数：
strncpy函数介绍：
用处：这个就是strcpy函数的加强版，我们可以控制要复制的字符个数。还是为字符串复制函数。
参数：第一个为目标字符串的地址（指针），第二个为要复制的字符串的首字符的地址（指针），第三个为我们需要复制字符的个数。
返回值：返回值为目标字符串的地址。
头文件：#include
strncpy函数注意点：
strncpy函数是拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。
strncpy函数的使用：
例子代码：
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
char p[10]="sdafwa";
char a[12] = "sdghj";
int num = 3;
strncpy(p, a, num);
printf("%s", p);
return 0;
} 运行结果：
strncpy函数的模拟实现：
原理：
利用循环，然后将限制条件设为num，让它只复制num个字符就好。
模拟实现：
char* my_strncpy(char* goal, char* copy, int num)
{
assert(goal);
assert(copy);
int i = 0;
for (int i = 0; i < num; i++)
{
*(goal + i) = *(copy + i);
}
return goal;
}
int main()
{//模拟实现strncpy函数
char* goal[20];//目标字符串
scanf("%s", goal);
printf("\n");
char* copy[20];//要复制的字符串
scanf("%s", copy);
printf("\n");
int num;
scanf("%d", &num);
char*p=my_strncpy(goal, copy, num);
printf("%s", p);
return 0;
}运行结果：
strncat函数：
strncat函数介绍：
用处：这个也是strcat函数的加强版，可以控制想要的个数来追加字符串。
参数：第一个为目标字符串的地址（指针），第二个为要追加的字符串，第三个为你想要追加字符的个数。
返回值：为char*类型，是目标字符串的地址。
头文件：#include
strncat函数的使用：
例子代码：
int main()
{//strncat函数的使用
char p1[20]="dawff";
char p2[10] = "siiiii";
int num = 5;
strncat(p1, p2, num);
printf("%s", p1);
return 0;
}运行结果：
strncat函数模拟实现：
原理：
找到'\0'的位置，然后利用循环将追加的字符个数设为循环的判断条件，让它只追加num个字符。
模拟实现：
#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include
#include
#define Tot 20
#define NUM 10
char* my_strncat(char* address, char* add, int num)
{
assert(address);//断言防止错误
assert(add);
int len = (int)strlen(address);
int remaining = Tot - len;//剩余空间
char* p;
int sz = (int)strlen(add);//追加函数大小
if (sz >=num)
{
if (num < remaining)
{
p = address + len;
int i;
for (int i = 0; i < num; i++)
{
*(p + i) = *(add+i);
}
*(p + num) = '\0';
return address;
}
else
return NULL;
}
else
return NULL;
}
int main()
{//模拟实现strncat,追加n个字符的函数
char arr[Tot];//原字符串
printf("原字符串：");
scanf("%s", arr);
char add_char[Tot];//追加字符串
printf("\n追加的字符串：");
scanf("%s", add_char);
int num;//追加的字符个数
printf("\n追加的字符个数:");
scanf("%d", &num);
char* arr2=my_strncat(arr,add_char,num);
if (arr2 == NULL)
{
printf("追加的字符串过大，无法追加\n");
}
else
printf("追加后的字符串：%s", arr2);
return 0;
} 运行结果：
strncmp函数：
strncmp函数介绍：
用处：这个也是strcmp函数的加强版。不过它是控制最多比较几个字符。
参数：第一个参数是第一个字符串，第二个参数是第二个字符串，第三个参数是我们想要的最多比较几个字符的个数。
返回值： 为int类型，有三种可能，一种为0，一种为大于0的数，一种为小于0的数。
头文件：#include
strncmp函数注意点：
strncmp的注意点与strcmp函数一样都是为返回值，并且一样的。
我们在上面说过，strncmp的返回值有三种可能。
标准规定：
- 第一个字符串大于第二个字符串，则返回大于0的数字
- 第一个字符串等于第二个字符串，则返回0
- 第一个字符串小于第二个字符串，则返回小于0的数字
strncmp函数的使用：
例子代码：
int main()
{
char p1[10] = "afasa";
char p2[10] = "afcqqqqq";
int num = 2;
int a=strncmp(p1, p2, num);
if (a == 0)
{
printf("两者相等");
}
if (a > 0)
{
printf("p1大");
}
if (a < 0)
{
printf("p2大");
}
return 0;
}运行结果：
strncmp函数的模拟实现：
原理：
每次循环判断一次大小，如果判断出来就返回，当num次后还没有比出大小，就返回0.
模拟实现：
#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#define NUM1 20
#define NUM2 10
int my_strncmp(char* str1, char* str2, int num)
{
assert(str1);
assert(str2);
int i;
int flag = 0;
for (int i = 0; i < num; i++)
{
if (*str1 != *str2)
{
if (*str1 > *str2)
{
flag++;
return flag;
}
else
{
flag--;
return flag;
}
}
}
return flag;
}
int main()
{
char str1[NUM1];//第一个字符串
printf("str1=");
scanf("%s", str1);
printf("\n");
char str2[NUM2];//第二个字符串
printf("str2=");
scanf("%s", str2);
printf("\n");
int num;//需要比较的字符个数
printf("要比较的字符个数num=");
scanf("%d", &num);
int p;//用来判断返回值
p=my_strncmp(str1, str2, num);
if(p == 0)
{
printf("两者相等");
}
if (p > 0)
{
printf("str1大");
}
if (p < 0)
{
printf("str2大");
}
return 0;
} 运行结果：
