⭐ 作者：小胡_不糊涂
🌱 作者主页：小胡_不糊涂的个人主页
💖 持续更文，谢谢大家支持 💖
文章目录
- 本文重点
- 1. strlen函数
- 1.1 模拟实现
- 2. strcpy函数
- 2.1 模拟实现
- 3. strcat函数
- 3.1 模拟实现
- 4. strcmp函数
- 4.1 模拟实现
- 5. strncpy函数
- 5.1 模拟实现
- 6. strncat函数
- 6.1 模拟实现
- 7. strncmp函数
- 7.1 模拟实现
- 8. strstr函数
- 8.1 模拟实现
- 9. strtok函数
- 10. strerror函数
- 11.memcpy函数
- 12. memmove函数
- 结束语
本文重点
| 函数作用 | 函数名 |
|---|---|
| 求字符串长度 | strlen |
| 长度不受限制的字符串函数 | strcpy strcat strcmp |
| 长度受限制的字符串函数 | strncpy strncat strncmp |
| 字符串查找 | strstr strtok |
| 错误信息报告 | strerror |
| 内存操作函数 | memcpy memmove memset memcmp |
| 字符操作 |
C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中。
字符串常量适用于那些对它不做修改的字符串函数。
1. strlen函数
功能： 获取字符串长度
size_t strlen ( const char * str );//返回字符串str的长度
//str--字符串
字符串的长度由终止空字符 '\0'确定：字符串的长度与字符串开头和终止空字符之间的字符数一样长（不包括终止空字符本身）。
🍤 例如：
char str[100]="string ";
定义了一个大小为 100 个字符的字符数组，但初始化 str 时使用的字符串的长度仅为 7 个字符。因此，当 sizeof(str) 的计算结果为 100 时，strlen(str) 返回 7。
通过 strlen函数 比较两个字符串大小
//有符号
#include<stdio.h>
#include<string.h>
int main()
{
const char* str1 = "abcdef";
const char* str2 = "bbb";
if ((int)strlen(str2) -(int) strlen(str1) > 0)
{
printf("str2>str1\n");
}
else
{
printf("srt1>str2\n");
}
return 0;
}
🍤 打印结果：
//无符号的
#include<stdio.h>
#include<string.h>
int main()
{
const char* str1 = "abcdef";
const char* str2 = "bbb";
if (strlen(str2) - strlen(str1) > 0)
{
printf("str2>str1\n");
}
else
{
printf("srt1>str2\n");
}
return 0;
}
🍤 打印结果：
因为函数返回值是无符号的
注：
🍥 字符串str以 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ ）。
🍥 参数指向的字符串必须要以 ‘\0’ 结束。
如果没有 ‘\0’ 结尾，长度会一直计算下去，直到遇到 ‘\0’ 。
🍥 注意函数的返回值为size_t，是无符号的。
1.1 模拟实现
#include<stdio.h>
size_t my_strlen(const char* str)
{
int count = 0;
while (*str != '\0')//终止条件
{
count++;//累计 计算字符串长度
str++;
}
return count;
}
int main()
{
size_t sz = my_strlen("abc");//无符号类型
printf("%u\n", sz);//打印无符号十进制整型
return 0;
}
2. strcpy函数
功能： 复制字符串
char * strcpy ( char * destination, const char * source );
//destination(目的地)--指向要在其中复制内容的目标数组的指针
//source(源)--要复制的字符串
将源指向的字符串复制到目标指向的数组中，包括终止的 ‘\0’ 字符（并在该点停止）。
为避免溢出，目标指向的数组的大小应足够长，以包含与源相同的字符串（包括终止空字符），并且不应在内存中与源重叠。
🍤 实例1：
#include <stdio.h>
#include<string.h>
int main()
{
char str1[] = "Sample string";
char str2[40];
char str3[40];
strcpy(str2, str1);//将str1拷贝到str2
strcpy(str3, "copy successful");
printf("str1: %s\nstr2: %s\nstr3: %s\n", str1, str2, str3);
return 0;
}
🍤 运行结果：
🍤 实例2：
#include <stdio.h>
#include<string.h>
int main()
{
char arr1[] = "xxxxxxxxxx";
char arr2[5] = { 'a', 'b', 'c', 'd', 'e' };
strcpy(arr1, arr2);//将 arr2 里的东西拷贝到 arr1 中
printf("%s\n", arr1);
return 0;
}
🍤 运行结果：
为什么结果不是 abcde 呢？
我们在调试时，打开监视窗口观察arr1的变化，虽然 abced 已拷贝给 arr1， 但没有发现结束标志，所以在创建 arr2 时，要在最后加上 ‘\0’
添加了结束标志的 arr2 ：
注：
🍥 源字符串必须以 ‘\0’ 结束。
🍥 会将源字符串中的 ‘\0’ 拷贝到目标空间。
🍥 目标空间必须足够大，以确保能存放源字符串。
🍥 目标空间必须可变。
2.1 模拟实现
#include<stdio.h>
#include<assert.h>
char* my_strcpy(char* dest, const char* src)
{
char* ret = dest;
assert(dest != NULL);//若字符串为空，就停止运行，并提示
assert(src != NULL);
while (*src != '\0')
{
*dest = *src;//实现拷贝
dest++;//后移一个字符
src++;
}
*dest = *src;// '\0'
return ret;
}
int main()
{
char arr1[20] = "hello world";
char arr2[] = "xxxxx";
my_strcpy(arr1 + 6, arr2);//从arr1的第六个字符之后开始拷贝arr2
printf("%s\n", arr1);
return 0;
}
🍤 运行结果：
🍩补充：
assert(表达式)--表达式为真时, 程序继续运行, 如果表达式为假, 那程序就会停止运行, 并提示错误信息
3. strcat函数
功能： 连接字符串
char * strcat ( char * destination, const char * source );
//destineion--指向目标数组的指针，该数组应包含字符串，并且足够大以包含串联的结果字符串
//source--要追加的字符串
将源字符串的副本追加到目标字符串。
目标中的终止空字符被源的第一个字符覆盖，并且在目标中由两者串联形成的新字符串的末尾包含一个空字符。
目的地和来源不得重叠。
🍤 实例：
#include <stdio.h>
#include <string.h>
int main()
{
char str1[100]="hello ";
char str2[] = "world";
printf("%s\n", strcat(str1, str2));
return 0;
}
🍤 运行结果：
注：
🍥 源字符串必须以 ‘\0’ 结束。
🍥 目标空间必须有足够的大，能容纳下源字符串的内容。
🍥 目标空间必须可修改。
3.1 模拟实现
#include<stdio.h>
char* my_strcat(char*dest, const char *src)
{
assert(dest && src);
char* ret = dest;
//1. 找目标空间中的\0
while (*dest)
{
dest++;
}
while (*dest++ = *src++)//实现拷贝
{
;
}
return ret;
}
int main()
{
char arr1[20] = "hello ";
char arr2[] = "world";
my_strcat(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
4. strcmp函数
功能： 比较两个字符串
int strcmp ( const char * str1, const char * str2 );
将字符串 str1 与字符串 str2 进行比较。
开始比较每个字符串的第一个字符。如果它们彼此相等，则继续以下对，直到字符不同或达到终止空字符。
此函数执行字符的二进制比较。
标准规定：
🍥 第一个字符串大于第二个字符串，则返回大于0的数字
🍥 第一个字符串等于第二个字符串，则返回0
🍥 第一个字符串小于第二个字符串，则返回小于0的数字
🍤 实例1：
#include<stdio.h>
#include<string.h>
int main()
{
printf("%d\n", strcmp("bbq","bcq"));
return 0;
}
🍤 运行结果：
-1
🍤 实例2：猜动物
#include<stdio.h>
#include<string.h>
int main()
{
char str1[] = "dog";
char str2[80];
do {
printf("Guess my favorite animal? ");
scanf("%s", str2);
} while (strcmp(str1, str2) != 0);
puts("Correct answer!");
return 0;
}
🍤 运行结果：
4.1 模拟实现
int my_strcmp(const char* str1, const char* str2)
{
assert(str1 && str2);
while (*str1 == *str2)
{
if (*str1 == '\0')
return 0;
str1++;//后移
str2++;
}
return (*str1 - *str2);
}
int main()
{
int ret = my_strcmp("bbq", "bcq");
if (ret>0)
printf(">\n");
printf("%d\n", ret);//-1
return 0;
}
5. strncpy函数
功能： 从字符串中复制字符
char * strncpy ( char * destination, const char * source, size_t num );
//destination--指向要在其中复制内容的目标数组的指针。
//source--要复制的 C 字符串。
//num--要从源复制的最大字符数。
//size_t 是无符号整数类型。
拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于 num，则拷贝完源字符串之后，在目标的后边追加0，直到 num个。
🍤 实例：
#include <stdio.h>
#include <string.h>
int main()
{
char str1[] = "To be or not to be";
char str2[40];
char str3[40];
strncpy(str2, str1, sizeof(str2));
strncpy(str3, str2, 5);
str3[5] = '\0';
puts(str1);//打印字符串
puts(str2);
puts(str3);
return 0;
}
🍤 运行结果：
5.1 模拟实现
#include<stdio.h>
#include<assert.h>
char* my_strncpy(char* dest, const char* sou, size_t num)
{
char* ret = dest;
assert(dest != NULL);
assert(sou != NULL);
for (int i = (int)num; i > 0; i--)
*dest++ = *sou++;
return ret;
}
int main()
{
char str1[20] = "abcdef";
char str2[] = "xxx";
my_strncpy(str1, str2, sizeof(str1));
puts(str1);
return 0;
}
🍤 运行结果：
xxx
6. strncat函数
功能： 从字符串追加字符
char * strncat ( char * destination, const char * source, size_t num );
//destination--指向目标数组的指针，该数组应包含一个字符串，并且足够大以包含串联的结果字符串，包括其他 null 字符。
//source--要追加的 C 字符串。
//num--要追加的最大字符数。
//size_t是无符号整数类型。
将源的第一个数字字符追加到目标，外加一个终止空字符。
如果源中 C 字符串的长度小于 num，则仅复制终止空字符之前的内容。
🍤 实例1：
#include <stdio.h>
#include <string.h>
int main ()
{
char str1[20];
char str2[20];
strcpy (str1,"To be ");
strcpy (str2,"or not to be");
strncat (str1, str2, 6);//将str2的前6个字符追加给str1后面
puts (str1);//To be or not
return 0;
}
🍤 运行结果：
🍤 实例2：
int main()
{
char arr1[20] = "abcdef\0yyyyyyyy";
char arr2[] = "xxxxxxxxx";
strncat(arr1, arr2, 3);
puts(arr1);//abcdefxxx
return 0;
}
🍩说明了，遇到了结束标志 '\0' 就开始复制源代码
6.1 模拟实现
#include <stdio.h>
#include<assert.h>
char* my_strncat(char* dest, const char* soc, size_t num)
{
char* ret = dest;
int i=0;
int count = 0;
assert(dest != NULL);
assert(soc != NULL);
while (*dest != '\0')
{
dest++;
}
while (num--)//终止条件：复制的个数num
*dest++ = *soc++;//追加
*dest = '\0';
return ret;
}
int main()
{
char arr1[20] = "abcdef\0yyyyyyyy";
char arr2[] = "xxxxxxxxx";
my_strncat(arr1, arr2, 3);
puts(arr1);//abcdefxxx
return 0;
}
🍤 运行结果：
7. strncmp函数
功能: 比较两个字符串的字符
int strncmp ( const char * str1, const char * str2, size_t num );
将字符串 str1 的字符数与字符串 str2 的字符数进行比较。
此函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续使用以下对，直到字符不同，直到达到终止的空字符，或者直到两个字符串中的 num 字符匹配，以先发生者为准。
标准规定：
🍥 第一个不匹配的字符在 str1 中的值大于在 str2 中的值，则返回大于0的数字
🍥 两个字符串的内容相等，则返回0
🍥 不匹配的第一个字符在 str1 中的值低于 str2 中的值，则返回小于0的数字
🍤 实例：
//代码1
#include <stdio.h>
#include<string.h>
int main()
{
char arr1[] = "abcioxjnjj";
char arr2[] = "abcdef";
printf("%d\n", strncmp(arr1, arr2, 4));//1
return 0;
}
//代码2：
int main()
{
char arr1[] = "abcdoxjnjj";
char arr2[] = "abcdef";
printf("%d\n", strncmp(arr1, arr2, 4));//0
return 0;
}
7.1 模拟实现
strncmp 函数与 strcmp 函数相似，不过它是比较两个字符串的前n个字符，它比较结束的标志是比较出来前n个字符的不同或者直到 ’\0’ 为止。
#include<stdio.h>
#include<assert.h>
int my_strncmp(const char* str1, const char* str2, size_t num)
{
assert(str1 != NULL);
assert(str2 != NULL);
while (num && *str1 && *str2)
{
if (*str1 > *str2)
{
return 1;
}
if (*str1 < *str2)
{
return -1;
}
else
{
return 0;
}
num--;
str1++;
str2++;
}
return 0;
}
int main()
{
char* str1 = "abcdoxjnjj";
char* str2 = "abcdef";
int ret = my_strncmp(str1, str2, 4);
printf("%d\n", ret);
return 0;
}
🍤 运行结果：
0
8. strstr函数
功能： 查找子字符串
const char * strstr ( const char * str1, const char * str2 );
//str1--要扫描的字符串。
//str2--包含要匹配的字符序列的字符串
返回指向 str2 中第一次出现的 str1 的指针，如果 str2 不是 str1 的一部分，则返回一个空指针。
匹配过程不包括终止空字符，但它到此为止。
🍤 实例：
#include <stdio.h>
#include <string.h>
int main()
{
char arr1[] = "abbbcdef";
char arr2[] = "bbc";
char* ret = strstr(arr1, arr2);
if (ret != NULL)
printf("%s\n", ret);
else
printf("找不到\n");
return 0;
}
🍤 运行结果：
8.1 模拟实现
#include <stdio.h>
char* my_strstr(char* str1, char* str2)
{
char* cp = str1;
char* s1 = cp;
char* s2 = str2;
if (*str2 == '\0')
return str1;
while (*cp)
{
//开始匹配
s1 = cp;
s2 = str2;
while (*s1 && *s2 && *s1 == *s2)
{
s1++;
s2++;
}
if (*s2 == '\0')
return cp;
cp++;
}
return NULL;
}
int main()
{
char arr1[] = "abbbcdef";
char arr2[] = "bbc";
char* ret = my_strstr(arr1, arr2);
if (ret != NULL)
printf("%s\n", ret);
else
printf("找不到\n");
return 0;
}
9. strtok函数
功能： 将字符串拆分为标记
char * strtok ( char * str, const char * delimiters );
- sep 参数是个字符串，定义了用作分隔符的字符集合。
- 第一个参数指定一个字符串，它包含了0个或者多个由 sep 字符串中一个或者多个分隔符分割的标记。
- strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。
（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改）
🍤 实例：
#include<string.h>
#include <stdio.h>
int main()
{
char* p = "woaiCyuyan.com/cn";
const char* sep = "./";
char arr[30];
char* str = NULL;
strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容
for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
{
printf("%s\n", str);
}
return 0;
}
🍤 运行结果：
10. strerror函数
功能： 返回错误码，所对应的错误信息
char * strerror ( int errnum );
🍤 实例：
#include <stdio.h>
#include<string.h>
#include <errno.h>//必须包含的头文件
int main()
{
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d: %s\n", i, strerror(i));
}
return 0;
}
🍤 运行结果：
11.memcpy函数
功能： 复制内存块
void * memcpy ( void * destination, const void * source, size_t num );
//destination--指向要在其中复制内容的目标数组的指针，类型转换为 void* 类型的指针。
//source--指向要复制的数据源的指针，类型转换为 const void* 类型的指针。
//num--要复制的字节数。
//size_t 是无符号整数类型。
🍥 函数 memcpy 从 source 的位置开始向后复制 num 个字节的数据到destination的内存位置。
🍥 这个函数在遇到 ‘\0’ 的时候并不会停下来。
🍥 如果 source 和 destination 有任何的重叠，复制的结果都是未定义的。
🍤 实例：
#include <stdio.h>
#include <string.h>
struct {
char name[40];
int age;
} person, person_copy;
int main()
{
char myname[] = "peter";
memcpy(person.name, myname, strlen(myname) + 1);
person.age = 46;
memcpy(&person_copy, &person, sizeof(person));
printf("person_copy: %s, %d \n", person_copy.name, person_copy.age);
return 0;
}
🍤 运行结果：
12. memmove函数
功能： 移动内存块，将字节数的值从源指向的位置复制到目标指向的内存块
void * memmove ( void * destination, const void * source, size_t num );
🍥 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
🍥 如果源空间和目标空间出现重叠，就得使用memmove函数处理。
🍤 实例：
#include <stdio.h>
#include <string.h>
int main ()
{
char str[] = "i love C";
memmove(str , str +2, 3);
//从l开始的三个字符(lov)移动到str中，且覆盖了str原来的前三个字符
puts (str);
return 0;
}
🍤 运行结果：
结束语
有关字符(串)的函数还有很多，我们还需要勤加练习，慢慢消化。
加油＾＿＾
我们下一篇文章再见。
