文章目录
本章重点
重点介绍处理字符和字符串的库函数的使用和注意事项
- 求字符串长度 —— strlen
- 长度不受限制的字符串函数 —— strcpy strcat strcmp
- 长度受限制的字符串函数介绍 —— strncpy strncat strncmp
- 字符串查找 —— strstr strtok
- 错误信息报告 —— strerror
- 字符操作
- 内存操作函数 —— memcpy memmove memset memcmp
0.前言
在我们学习C语言的时候,对字符和字符串的处理很是频繁,所以,我们经常需要借用一下字符串函数来帮助我们简化代码难度。接下来,我就带着大家来了解一下常用的一下函数。
1.函数介绍
1.1 strlen
字符串长度函数,通常用来计算字符串的长度
size_t strlen (const char* str);
- 字符串已经 ‘\0’ 作为结束标志,strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数(不包括 ‘\0’ )
- 参数指向的字符串必须要以 ‘\0’ 结束。
- 注意函数的返回值为 size_t ,是无符号的(易错)
- 学会strlen函数的模拟实现
#include <stdio.h>
#include <string.h>
int main()
{
char arr[] = "abcd";
int len = strlen(arr);
printf("%d\n", len);
return 0;
}
1.2 strcpy
字符串拷贝函数,通常用来进行字符串间的拷贝
char* strcpy(char *destination, const char * source)
- 源字符串必须以 ‘\0’ 结束
- 会将源字符串中的 ‘\0’ 拷贝到目标空间
- 目标空间必须足够大,以确保能存放源字符串。
- 目标空间必须可变
- 学会模拟实现
#include <stdio.h>
#include <string.h>
int main()
{
char arr1[] = "aaaaa";
char arr2[] = "bb bb";
strcpy(arr1, arr2);
printf("arr1 = %s\narr2 = %s", arr1, arr2);
return 0;
}
1.3 strcat
字符串追加函数,通常用来字符串1后加上字符串2
char * strcat (char * destination, const char* source)
- 源字符串必须以 ‘\0’ 结束
- 目标空间必须有足够大,能容纳下源字符串的内容
- 目标空间必须可修改
- 字符串也可以给自己追加,但会有前提条件,后面我们会将,本函数不行。
#include <stdio.h>
#include <string.h>
int main()
{
char arr1[20] = "hello ";
char arr2[] = "world";
strcat(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
1.4 strcmp
字符串比较函数,通常用来比较两个字符串的大小。
是通过每一个字符的ascii码进行比较的。
int strcmp ( const char * str1, const char * str2)
- 第一个字符串大于第二个字符串,返回大于0的数字
- 第一个字符串等于第二个字符串,返回0
- 第一个字符串小于第二个字符串,返回小于0的数字
#include <stdio.h>
#include <string.h>
int main()
{
char arr1[] = "abcc";
char arr2[] = "abcd";
int len = strcmp(arr1, arr2);
printf("%d\n", len);
if (len > 0)
{
printf(">\n");
}
else if (len == 0)
{
printf("=\n");
}
else
{
printf("<\n");
}
return 0;
}
1.5 strncpy
字符串拷贝函数,主要与上面strcpy函数不同就是,能控制拷贝的字符长度
char* strncpy (char * destination, const char * source, size_t num)
- 拷贝num个字符从源字符串到目标空间
- 如果源字符串的长度小于num,则拷贝完源字符串之后,在目标的后边追加0,直到num个。
- 注意:num的单位是字节。
#include <stdio.h>
#include <string.h>
int main()
{
char arr1[] = "abcde";
char arr2[] = "ooooo";
strncpy(arr1, arr2, 3);
printf("%s\n", arr1);
return 0;
}
1.6 strncat
字符串追加函数,主要与上面strncat函数不同就是,能控制追加字符长度
char* strncat (char* destination, const char* source, size_t num)
- 注意:num的单位是字节。
#include <stdio.h>
#include <string.h>
int main()
{
char arr1[20] = "hello ";
char arr2[] = "world";
strncat(arr1, arr2,3);
printf("%s\n", arr1);
return 0;
}
1.7 strncmp
字符串比较函数,主要与上面strncmp函数不同就是,能控制比较字符长度
int strncmp (const char* str1, const char* str2, size_t num)
- 比较到出现另一个字符不一样或者一个字符串结束或者num个字符全部比较完结束。
- 注意:num的单位是字节。
#include <stdio.h>
#include <string.h>
int main()
{
char arr1[] = "abcc";
char arr2[] = "abcd";
int len = strncmp(arr1, arr2,3);
printf("%d\n", len);
if (len > 0)
{
printf(">\n");
}
else if (len == 0)
{
printf("=\n");
}
else
{
printf("<\n");
}
return 0;
}
1.8 strstr
字符串查找函数,就是在字符串1中查找字符串2.
char* strstr( const char* str1, const char* str2)
- 如果找到了,函数会返回查找到的字符串中第一个字符的地址
- 如果没有找到,则返回NULL.
#include <stdio.h>
#include <string.h>
int main()
{
char arr[] = "this is a simple string";
char* ps;
ps = strstr(arr, "simple");
printf("%s", ps);
return 0;
}
1.9 strtok
字符串分割函数,通常用于分割地址,网址的信息
char* strtok( char* str, const char* sep)
- sep参数是个字符串,定义了用作分隔符的字符集合
- 第一个参数指定一个字符串,它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记
- strtok函数找到str中的下一个标记,并将其用 ‘\0’ 结尾,返回一个指向这个标记的指针。(strtok函数会改变操作的字符串,所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改)
- strtok函数的第一个参数不为NULL,函数将找到str中第一个标记,strtok函数将保存他在字符串中的位置
- strtok函数的第一个参数为NULL,函数将在用一个字符串中被保存的位置开始,查找下一个标记
- 如果字符串中不存在更多的标记,则返回NULL指针。
#include <stdio.h>
#include <string.h>
int main()
{
char arr[20] = "329.321.33.2";
char* p = "."; // 存放所有的分隔符
char* ps;
for (ps = strtok(arr, p); ps != NULL; ps = strtok(NULL, p))
{
printf("%s\n", ps);
}
return 0;
}
1.10 strerror
返回错误码,搜对应的错误信息
char* strerror(int errnum)
- 在程序中errno变量是共用的,在出现下一个错误值是,会将原有的错误信息覆盖
- 所以要及时打印每一个错误信息。
#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
//打开文件
//打开文件的时候,如果文件的打开方式是"r"
//文件存在则打开成功,文件不存在打开失败
//打开文件失败的话,会返回NULL
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
printf("%s\n", strerror(errno));
perror("打开文件失败");
//perror == strerror + printf;
return 1;
}
fclose(pf);
pf = NULL;
return 0;
}
1.11 字符分类函数
此类函数使用次数不多,但偶尔也需要,所以,我们子需要记住他们在 #include <ctype.h> 这个头文件中即可,用的时候也可以去现找。
- 符合返回真,即大于0的数;不符合返回假,即小于0的数。
#include <stdio.h>
#include <ctype.h>
int main() //大写转小写
{
char arr[20] = "This Is A Boy";
int i = 0;
for (i = 0; i < 20; i++)
{
if (toupper(arr[i]) > 0)
{
arr[i] = tolower(arr[i]);
}
}
printf("%s\n", arr);
return 0;
}
在C语言的学习中,我们不仅仅只对字符串进行处理,还有整型,浮点型等等,这时,我们就不能使用字符串函数进行处理了。所以,为了方便使用,C语言又整出了内存函数。
1.12 memcpy
内存拷贝函数,因为不知道拷贝的数据是什么类型,所以必须规定拷贝的大小。
void* memcpy (void* destination, const void* source, size_t num)
- 函数memcpy从source的位置开始想后复制num个字节的数据到destination的内存位置。
- 这个函数在遇到 ‘\0’ 的时候并不会停下来
- 如果source和destination有任何的重叠,复制的结果都是未定义的。
#include <stdio.h>
#include <string.h>
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[20] = { 0 };
memcpy(arr2, arr, 20); // 20/4 = 5
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%d ", arr2[i]);
}
return 0;
}
1.13 memmove
内存移动函数,因为不知道移动的数据是什么类型,所以必须规定移动的大小。
void* memmove ( void* destination, const void* source, size_t num)
- 和memcpy的差别就是memmove函数处理的原内存块和目标内存块是可以重叠的。
- 如果原空间和目标空间出现重叠,就得使用memmove函数处理。
#include <stdio.h>
#include <string.h>
int main()
{
int arr[20] = { 1,2,3,4,5,6,7,8,9,10 };
memmove(arr, arr + 3, 20);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
1.14 memcmp
内存比较函数,因为不知道比较的数据是什么类型,所以只能一个字节一个字节比较。
int memcmp (const void* ptr1, const void* ptr2, size_t num)
- 比较从ptr1和ptr2指针开始的num个字节
#include <stdio.h>
#include <string.h>
int main()
{
char arr1[] = "qqqwwwweeee";
char arr2[] = "qqqwwweeeee";
int len = 0;
len = memcmp(arr1, arr2, sizeof(arr1));
printf("%d\n", len);
return 0;
}
2.库函数的模拟实现
了解了函数的用法,还是明白其中的原理才好。
以下都是小编自己想的代码,并非源码。
如有错误,欢迎指正。
2.1模拟实现strlen
#include <stdio.h>
#include <assert.h>
int my_strlen1(char* arr)
{
assert(arr != NULL);
int num = 0;
while (*arr)
{
num++;
arr++;
}
return num;
}
int my_strlen2(char* arr)
{
assert(arr != NULL);
if (*arr == '\0')
return 0;
else
{
return 1 + my_strlen2(arr + 1);
}
}
int my_strlen3(char* arr)
{
assert(arr != NULL);
char* p = arr;
while (*p != '\0')
{
p++;
}
return p - arr;
}
int main()
{
char arr[] = "abcd";
int len = 0;
//len = my_strlen1(arr);
//len = my_strlen2(arr);
len = my_strlen3(arr);
printf("%d\n", len);
return 0;
}
2.2模拟实现strcpy
#include <stdio.h>
#include <assert.h>
void my_strcmp(char* dest, const char* src)
{
assert(dest != NULL);
assert(src != NULL);
while (*src)
{
*dest = *src;
dest++;
src++;
}
}
int main()
{
char arr[20] = "abcd";
char arr2[20] = "0";
my_strcmp(arr2, arr);
printf("%s\n", arr2);
return 0;
}
2.3模拟实现strcat
#include <stdio.h>
#include <assert.h>
void my_strcat(char* dest, const char* src)
{
assert(dest != NULL);
assert(src != NULL);
while (*dest)
{
dest++; // 找到arr1数组中的最后一个元素的后一位
}
while (*src)
{
*dest = *src;
dest++;
src++;
}
}
int main()
{
char arr1[20] = "hello ";
char arr2[20] = "world";
my_strcat(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
2.4模拟实现strstr
#include <stdio.h>
#include <assert.h>
void* my_strstr(char* dest, const char* src)
{
assert(dest != NULL);
assert(src != NULL);
char* s1 = NULL;
char* s2 = NULL;
char* ps = dest;
while (*src)
{
s1 = ps;
s2 = src;
while (*s1 == *s2 && *s1 && *s2)
{
s1++;
s2++;
if (*s2 == '\0')
{
return ps;
}
}
ps++;
}
return NULL;
}
int main()
{
char arr1[20] = "abababababcedf";
char arr2[20] = "abc";
char* ps = NULL;
ps = my_strstr(arr1, arr2);
printf("%s\n", ps);
return 0;
}
2.5模拟实现strcmp
#include <stdio.h>
#include <assert.h>
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()
{
char arr1[] = "abzqw";
char arr2[] = "abq";
if (strcmp(arr1, arr2) > 0)
printf(">\n");
else if (strcmp(arr1, arr2) == 0)
printf("=\n");
else
printf("<\n");
return 0;
}
2.6模拟实现memcpy
#include <stdio.h>
#include <assert.h>
void* my_memcpy(void* dest, const void* src, size_t num)
{
assert(dest != NULL);
assert(src != NULL);
char* ret = dest;
while (num--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9 };
int ar[8] = { 0 };
my_memcpy(ar, arr, 20);
for (int i = 0; i < 5; i++)
{
printf("%d ", ar[i]);
}
return 0;
}
2.7模拟实现memmove
#include <stdio.h>
#include <assert.h>
void* my_memmove(void* dest, const void* src, size_t num)
{
assert(dest != NULL);
assert(src != NULL);
char* ret = dest;
if (dest < src)
{
while (num--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
}
else
{
while (num--)
{
*((char*)dest + num) = *((char*)src + num);
}
}
return ret;
}
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int ar[10] = { 0 };
my_memmove(arr, arr + 2, 20);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr[i]);
}
}