【C语言】字符函数和字符串函数
目录
1.求字符串长度strlen
2.长度不受限制的字符串函数
字符串拷贝strcpy
字符串追加strcat
字符串比较strcmp
3.长度受限制的字符串函数介绍strncpy
strncat
编辑strncmp
4.字符串查找strstr
5.字符串分割strtok
6.错误信息报告
strerror
perror
7.字符分类函数
8.字符转换函数
9.内存操作函数
memcpy
memmove
memset
memcmp编辑
1.求字符串长度strlen
函数介绍
- 字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包含 '\0' )。
- 参数指向的字符串必须要以 '\0' 结束。
- 注意函数的返回值为size_t，是无符号的（ 易错 ）
使用示例
int main()
{
size_t sz = strlen("abcd");
printf("%u", sz);
return 0;
}因为函数的返回值为无符号类型，所以对于下面这种代码，我们很容易就看错：
#include
#include
int main()
{
if (strlen("abc") - strlen("abcdef") > 0)
{
printf("大于\n");
}
else
{
printf("小于\n");
}
return 0;
} 输出结果：
正确的比较方法：
if (strlen("abc") > strlen("abcdef"))strlen的模拟实现
size_t my_strlen(const char* str)
{
int count = 0;
while (*str!='\0')
{
count++;
str++;
}
return count;
}
2.长度不受限制的字符串函数
字符串拷贝strcpy
- Copies the C string pointed by source into the array pointed by destination, including the terminating null character (and stopping at that point).
- 源字符串必须以 '\0' 结束。
- 会将源字符串中的 '\0' 拷贝到目标空间。
- 目标空间必须足够大，以确保能存放源字符串。
- 目标空间必须可变
使用示例
int main()
{
char arr1[20] = { 0 };
char arr2[] = "hello world";
strcpy(arr1, arr2);
printf("%s", arr1);
return 0;
}输出结果： 
strcpy的模拟实现
char* my_strcpy(char* dest, const char* src)
{
assert(dest && src);
char* ret = dest;
while (*dest++ = *src++)
{
}
return ret;
}字符串追加strcat
- Appends a copy of the source string to the destination string. The terminating null character in destination is overwritten by the first character of source, and a null-character is included at the end of the new string formed by the concatenation of both in destination.
- 源字符串必须以 '\0' 结束。
- 目标空间必须有足够的大，能容纳下源字符串的内容。
- 目标空间必须可修改。
- 字符串自己给自己追加，如何？
使用示例
int main()
{
char arr1[20] = "hello ";
char arr2[] = "world";
strcat(arr1, arr2);
printf("%s", arr1);
return 0;
}输出结果：
strcat的模拟实现
char* my_strcat(char* dest, const char* src)
{
assert(dest && src);
char* ret = dest;
while (*dest != '\0')//找到目标空间的\0
{
dest++;
}
while (*dest++ = *src++)
{
}
return ret;
}注意：字符串不能自己给自己追加
当字符串自己给自己追加时，字符串中的'\0'将会被覆盖，导致程序陷入死循环。
字符串比较strcmp
- This function starts comparing the first character of each string. If they are equal to each other, it continues with the following pairs until the characters differ or until a terminating null-character is reached.
- 标准规定：
- 第一个字符串大于第二个字符串，则返回大于0的数字
- 第一个字符串等于第二个字符串，则返回0
- 第一个字符串小于第二个字符串，则返回小于0的数字
使用示例
int main()
{
int ret1 = strcmp("abcdef", "abq");
int ret2 = strcmp("abc", "abc");
printf("%d\n", ret1);
printf("%d\n", ret2);
return 0;
}输出结果：
strcmp的模拟实现
int my_strcmp(const char* str1, const char* str2)
{
assert(str1 && str2);
while (*str1++ == *str2++)
{
if (*str1 == '\0')
{
return 0;
}
}
return *str1 - *str2;
}
3.长度受限制的字符串函数介绍
strncpy
- Copies the first num characters of source to destination. If the end of the source C string (which is signaled by a null-character) is found before num characters have been copied, destination is padded with zeros until a total of num characters have been written to it.
- 拷贝num个字符从源字符串到目标空间。
- 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。
使用示例
int main()
{
char arr1[20] = "abcdef";
char arr2[20] = "xxxxxxxxxxxxxx";
strncpy(arr1, arr2, 3);
printf("%s\n", arr1);
return 0;
}输出结果：
strncat
- Appends the first num characters of source to destination, plus a terminating null-character.
- If the length of the C string in source is less than num, only the content up to the terminating null-character is copied.
使用示例
int main()
{
char arr1[20] = "hello ";
char arr2[20] = "worldxxx";
strncat(arr1, arr2, 5);
printf("%s\n", arr1);
return 0;
}输出结果：
strncmp
比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。
使用示例
int main()
{
char arr1[20] = "abc";
char arr2[20] = "abcdef";
char arr3[20] = "aba";
printf("%d\n", strncmp(arr1, arr2, 3));
printf("%d\n", strncmp(arr1, arr2, 4));
printf("%d\n", strncmp(arr1, arr3, 5));
return 0;
}输出结果：
4.字符串查找strstr
strstr函数是在字符串str1中查找是否含有字符串str2，如果存在，返回str2在str1中第一次出现的地址；否则返回NULL。
使用示例
int main()
{
char arr1[] = "abcdefabcdef";
char arr2[] = "def";
char* ret = strstr(arr1, arr2);
if(ret!=NULL)
{
printf("%s\n", ret);
}
return 0;
}输出结果：
strstr的模拟实现
这里使用的是BF算法来实现：
char* my_strstr(char* str1, char* str2)
{
char* cp = str1;
char* s1 = cp;
char* s2 = str2;
while (*cp)
{
s1 = cp;
s2 = str2;
while (*s1 && *s2 && *s1 == *s2)
{
s1++;
s2++;
}
if (*s2 == '\0')
return cp;
cp++;
}
return NULL;
}
5.字符串分割strtok
- sep参数是个字符串，定义了用作分隔符的字符集合
- 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标 记。
- strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注： strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
- strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
- strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
- 如果字符串中不存在更多的标记，则返回 NULL 指针。
使用示例1
int main()
{
char arr[] = "[email protected]";
char sep[] = "@.";
char copy[20];
strcpy(copy, arr);
char* pc = strtok(copy, sep);
while (pc)
{
puts(pc);
pc = strtok(NULL, sep);
}
return 0;
}使用示例2
int main()
{
char arr[] = "[email protected]";
char sep[] = "@.";
char copy[20];
strcpy(copy, arr);
char* ret = NULL;
for (ret = strtok(copy, sep); ret != NULL; ret = strtok(NULL, sep))
{
printf("%s\n", ret);
}
return 0;
}输出结果：
6.错误信息报告
strerror
返回错误码，所对应的错误信息。
库函数在执行的时候，发生了错误会将错误码存放在errno这个全局变量中。errno是C语言提供的一个全局变量。
下面代码是将错误码0~9所对应的错误信息给打印出来：
int main()
{
int i = 0;
for (int i = 0; i < 10; i++)
{
printf("%d:%s\n", i, strerror(i));
}
return 0;
}
当然，这里展示的仅仅是一小部分。
下面演示一下当我们进行文件操作是，打开文件失败后查找打开失败的原因：
int main()
{
FILE* pf = fopen("data.txt", "r");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
}
return 0;
}
程序输出了“ No such file or directory ”的错误提示，意思是没有要打开的文件。
perror
perror(str) 用来将上一个函数发生错误的原因输出到标准设备(stderr)。参数 str 所指的字符串会先打印出，后面再加上错误原因字符串。此错误原因依照全局变量errno的值来决定要输出的字符串。
使用示例
int main()
{
FILE* pf = fopen("data.txt", "r");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
perror("fopen");
}
return 0;
} 输出结果：
7.字符分类函数
8.字符转换函数
下面代码的功能是输入一串字符，将字符串中的小写字母转成大写，大写字母转成小写
int main()
{
char arr[30] = { 0 };
gets(arr);
char* p = arr;
while (*p)
{
if (isupper(*p))
{
*p = tolower(*p);
}
else if (islower(*p))
{
*p = toupper(*p);
}
*p++;
}
puts(arr);
}
9.内存操作函数
memcpy
- 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
- 这个函数在遇到 '\0' 的时候并不会停下来。
- 如果source和destination有任何的重叠，复制的结果都是未定义的。
可以拷贝任意类型的数据：字符串，整形数组，结构体数据类型……
使用示例
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[20] = { 0 };
//将arr1的内容拷贝到arr2中
memcpy(arr2, arr1, 40);
for (int i = 0; i < 20; i++)
{
printf("%d ", arr2[i]);
}
return 0;
}输出结果：
memcpy的模拟实现
void* my_memcpy(void* dest, void* src, size_t num)
{
assert(dest && src);
void* ret = dest;
while (num--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}注意下面这种写法编译器会报错：
在代码中，使用了(char*)dest++和(char*)src++来更新指针的位置。然而，这种写法是不正确的，因为后缀递增操作符++的优先级高于类型转换操作符(char*)，所以实际上你只是在转换指针类型后递增了一个临时变量，而没有更新指针本身的值。
注意：mencpy 函数是用来处理不会重叠的内存拷贝，当我们拷贝两个相同的字符串是，可以结果与预期的会不相同：
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
my_memcpy(arr1+2, arr1, 32);
for (int i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
printf("\n");
return 0;
}对于上面的代码，我们的预期结果是这样的：
实际输出的结果却是如下：
如果要拷贝重叠的内存，我们就要使用下面这个函数了
memmove
- 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
- 如果源空间和目标空间出现重叠，就得使用memmove函数处理。
使用示例
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
memmove(arr1+2, arr1, 32);
for (int i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
printf("\n");
return 0;
}输出结果：
memmove的模拟实现
不同于memcpy,mommove的拷贝需要分情况：
void* my_memmove(void* dest, const void* src, size_t num)
{
assert(dest && src);
void* ret = dest;
if (dest < src)
{
//从前向后拷贝
while (num--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
}
else
{
printf("从后向前拷贝\n");
//从后向前拷贝
while (num--)
{
*((char*)dest + num) = *((char*)src + num);
}
}
return ret;
}
memset
memset是一个初始化函数，作用是将某一块内存中的全部设置为指定的值。
- prr 指向要填充的内存块。
- value 是要被设置的值。
- num 是要被设置该值的字符数。
- 返回类型是一个指向存储区s的指针。
使用示例1
int main()
{
char arr[] = "hello world";
memset(arr + 1, 'x', 4);
printf("%s\n", arr);
return 0;
}上面代码的作用是将的arr数组的第2个元素到第5个元素的值设置成‘x',输出结果：
使用示例2
int main()
{
int arr[10] = { 0 };
memset(arr, 1, 10);
return 0;
}
memcmp
比较从ptr1和ptr2指针开始的num个字节
返回值如下：
使用示例
int main()
{
int arr1[] = { 1,2,1,4,5,6 };
int arr2[] = { 1,2,257 };
int ret = memcmp(arr1, arr2, 9);
printf("%d\n", ret);
return 0;
}对于上面的代码，可以借助编译器的调试来查看 arr1 和 arr2 的内存：
可以看出，arr1和arr2的前9个字节是相同的，而我们比较的是前9个字节，因此输出结果应该是0。 
