前言
C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在 常量字符串 中或者 字符数组 中。 字符串常量 适用于那些对它不做修改的字符串函数.
1.库函数介绍
求字符串长度
- strlen
长度不受限制的字符串函数 - strcpy
- strcmp
- strcat
长度受限制的字符串函数 - strncpy
- strncmp
- strncat
字符串查找 - strstr
- strtok
错误信息报告 - sterror
- perror
字符分类函数
内存操作函数
- memcpy
- memcmp
- memmove
- memset
strlen
size_t strlen ( const char * str );
定义：求字符串长度
头文件 ： <string.h>
注：
- 字符串以 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
- 参数指向的字符串必须要以 ‘\0’ 结束。
- 函数的返回值为size_t（无符号的）
例：
#include<stdio.h>
#include<string.h>
int main()
{
char arr[] = "hello world";
printf("%d\n", strlen(arr));
return 0;
}
strcpy
char* strcpy(char * destination, const char * source );
定义：拷贝字符串
头文件：<string.h>
注：
- strcpy函数的作用是将strSource(包括结束空字符)复制到strDestination指定的位置。复制或追加字符串时不执行溢出检查（需要自己判断strDestination空间>=strSource空间）。
- strSource：源头字符串 strDestination 目标字符串
- 源字符串必须以 ‘\0’ 结束。
- 目标空间必须足够大，以确保能存放源字符串。
- 目标空间必须可变
- 简单理解为是把原指针指向的内容拷贝到目标指针的空间上去
- Char*在这里的作用是：当把源头数据拷贝过去的时候，我们期望目标空间发生变化，可能会使用目标空间的内容，所以需要返回的是目标空间的起始地址
- const：变量和文件本身都有读写的权限，由const修饰时缩小变量的权限，让变量只能读不能写。也是为了提高代码的安全性。
例：
#include<string.h>
#include<stdio.h>
int main()
{
char arr1[] = "abcdef";
char arr2[] = "xxxxxx";
strcpy(arr2, arr1);
printf("%s\n", arr2);
return 0;
}
strcmp
int strcmp ( const char * str1, const char * str2 );
定义：比较字符串
头文件：<string.h>
注：
-
标准规定：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字 -
比较的不是字符串的长度
比较字符串对应位置上的字符的大小/asscii码值
如果相同就比较下一对，直到不同或遇到\0
例：
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[] = "abcdef";
char arr2[] = "abcdfg";
printf("%d\n", strcmp(arr1, arr2));
return 0;
}
strcat
char * strcat ( char * destination, const char * source );
定义：追加字符串
头文件：<string.h>
注：
- 参数：strDestination：以\0结尾的目标字符串
strSource：以\0结尾的源字符串 - 源字符串必须以 ‘\0’ 结束。
- 目标空间必须有足够的大，能容纳下源字符串的内容。
- 目标空间必须可修改。
- strcat函数将strSource附加到strDestination后，并以空字符结束字符串。strSource的初始字符覆盖strDestination的终止NULL字符。复制或追加字符串时不执行溢出检查。如果源字符串和目标字符串重叠，则strcat的行为未定义。
例：
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[20] = "abc";
char arr2[] = "def";
printf("%s\n", strcat(arr1, arr2));
return 0;
}
strncpy
char * strncpy ( char * destination, const char * source, size_t count );
定义：拷贝字符串
头文件：<string.h>
注：
- count：要复制的字符数
- 拷贝num个字符从源字符串到目标空间。
- 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。
例：
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[] = "abcdef";
char arr2[] = "xxxxxx";
printf("%s\n", strncpy(arr2, arr1, 3));
return 0;
}
strncmp
int strncmp ( const char * str1, const char * str2, size_t count );
定义：比较两个字符串
头文件：<string.h>
注：
- 比较到出现另个字符不一样或者一个字符串结束或者count个字符全部比较完
例：
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[20] = "ab";
char arr2[] = "abcdef";
printf("%d\n", strncmp(arr1, arr2, 3));
return 0;
}
strncat
char * strncat ( char * destination, const char * source, size_t num );
定义：追加字符串
头文件：<string.h>
注：
- strncat函数最多将strSource的第一个count字符追加到strDest。strSource的初始字符覆盖strDest的终止null字符。如果strSource中在添加count字符之前出现空字符，strncat将追加strSource中的所有字符，直到空字符。如果count大于strSource的长度，则使用strSource的长度代替count。结果字符串以空字符结束。如果复制发生在重叠的字符串之间，则行为未定义。
例：
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[20] = "abc";
char arr2[] = "def";
printf("%s\n", strncat(arr1, arr2,1));
return 0;
}
综上所述，可以小小的总结一下就是：
strstr
char *strstr( const char *string, const char *strCharSet );
定义：查找子字符串。
头文件：<string.h>
注：
- 函数中的每一个都返回一个指向strCharSet在string中第一次出现的指针，如果strCharSet没有出现在string中，则返回NULL。如果strCharSet指向一个长度为零的字符串，则返回string。
例：
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[] = "abcdef";
char arr2[] = "cdef";
printf("%s\n", strstr(arr1, arr2));
return 0;
}
strtok
char * strtok ( char * str, const char * sep );
定义：查找字符串中的下一个标记 / 通过字符串中的特殊符号分割字符串
头文件：<string.h>
注：
- sep参数是个字符串，定义了用作分隔符的字符集合
- 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
- strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
- strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
- strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
- 如果字符串中不存在更多的标记，则返回 NULL 指针。
例：
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[] = "hello@world.com";
char buf[20] = { 0 };
strcpy(buf, arr1);
const char* sep = "@.";
//写法①
printf("%s\n", strtok(buf, sep));
printf("%s\n", strtok(NULL, sep));
printf("%s\n", strtok(NULL, sep));
//写法②
char* str = NULL;
for (str = strtok(buf, sep); str != NULL; str = strtok(NULL, sep))
{
printf("%s\n", str);
}
//strtok会从字符串首字符开始寻找，找到分隔符后，会把分隔符置成\0（NULL),并取出首字符到\0之前的元素
//下次访问的时候会从NULL的位置继续向后访问，直至再次访问到分割符，置成NULL，取出
//其中，strtok的实现应该是有一个静态变量的指针保存着NULL的位置
return 0;
}
strerror
char * strerror ( int errnum );
定义：返回错误码，所对应的错误信息
头文件：<string.h>
注：
- strerro返回指向错误消息字符串的指针。
- strerror不会打印消息，需要调用输出函数，例如printf。
例：
#include<stdio.h>
#include<string.h>
#include<errno.h>
int main()
{
strerror(errno);//errno(错误码）:全局变量 ，需要头文件<errno.h>
//补：
// 0 :No error 无错误信息
// 1 :Operation not permitted 操作被拒绝
// 2 :No such file or directory 无文件
// 3 :No such process 无进程
// 4 :Interrupted function call 函数调用中断
//...
return 0;
}
perror
void perror( const char *string );
定义：打印错误信息
头文件：<stdio.h> or <stdlib.h>
例：
#include<stdio.h>
#include<string.h>
int main()
{
perror("自定义提示信息");
return 0;
}
可以简单看一下 perror vs strerror 二者的对比：
- memcpy
void *memcpy( void *dest, const void *src, size_t count );
定义：在缓冲区之间复制字符
头文件：<string.h>
注：
- 函数memcpy从src的位置开始向后复制 count 个字节的数据到dest的内存位置。
- 这个函数在遇到 ‘\0’ 的时候并不会停下来。
- 如果src和dest有任何的重叠，复制的结果都是未定义的
例：
#include<stdio.h>
#include<string.h>
int main()
{
int arr1[] = { 1,2,3,4,5,6,7 };
int arr2[20] = { 0 };
memcpy(arr2, arr1, 20);//单位是字节
return 0;
}
- memcmp
int memcmp ( const void * ptr1,
const void * ptr2,
size_t num );
定义：比较两个缓冲区中的字符
头文件：<string.h>
注：
- 比较从ptr1和ptr2指针开始的num个字节
例：
#include<stdio.h>
#include<string.h>
int main()
{
int arr1[] = { 1,2,3,4,5,6,7 };
int arr2[20] = { 1，2，3，4，5，6，0x00000007 };
memcmp(arr2, arr1, 20);//单位是字节
return 0;
}
- memmove
void * memmove ( void * destination, const void * source, size_t num );
定义：将一个缓冲区移动到另一个缓冲
头文件：<string.h>
注：
- 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
- 如果源空间和目标空间出现重叠，就得使用memmove函数处理。
例：
#include<stdio.h>
#include<string.h>
int main()
{
int arr1[] = { 1,2,3,4,5,6,7 };
memmove(arr1+3, arr1, 20);//可以实现重叠内存的拷贝
return 0;
}
- memset
定义：将缓冲区设置为指定字符/初始化
头文件：<string.h>
注：
- memset函数将dest的第一个计数字节设置为字符c。
例：
#include<stdio.h>
#include<string.h>
int main()
{
int arr[] = { 0x11111111,0x22222222,3,4,5 };
memset(arr, 0, 20);//将arr前20个字节初始化成0
return 0;
}
2.函数模拟实现
- strlen
#include<assert.h>
#include<stdio.h>
#include<string.h>
int my_strlen(char* str)
{
assert(str);
int count = 0;
while (*str)
{
count++;
str++;
}
return count;
}
int main()
{
char arr[] = "abcdef";
printf("%d\n", my_strlen(arr));
return 0;
}
- strcpy
#include<assert.h>
#include<stdio.h>
#include<string.h>
char* my_strcpy(char* dest, const char* sour)
{
assert(dest && sour);
char* str = dest;
while (*dest++ = *sour++)
{
;
}
return str;
}
int main()
{
char arr1[] = "xxxxxxxxxxx";
char arr2[] = "abcdef";
printf("%s\n", my_strcpy(arr1, arr2));
return 0;
}
- strcmp
#include<assert.h>
#include<stdio.h>
#include<string.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[] = "abcdef";
char arr2[] = "bcdefg";
printf("%d\n", my_strcmp(arr1, arr2));
return 0;
}
- strcat
#include<assert.h>
#include<stdio.h>
#include<string.h>
char* my_strcat(char* dest, char* sour)
{
assert(dest && sour);
char* str = dest;
while (*dest)
{
dest++;
}
while (*dest++ = *sour++)
{
;
}
return dest;
}
int main()
{
char arr1[10] = "abc";
char arr2[] = "def";
my_strcat(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
- strstr
#include<assert.h>
#include<stdio.h>
#include<string.h>
char* my_strstr(const char* str1, const char* str2)
{
assert(str1 && str2);
const char* s1 = str1;
const char* s2 = str2;
const char* cur = str1;
while (*cur)
{
s1 = cur;
s2 = str2;
while (*s1 && *s2 && (*s1 == *s2))
{
s1++;
s2++;
}
if (*s2 == '\0')
{
return (char*)cur;
}
cur++;
}
return NULL;
}
int main()
{
char arr1[] = "abcdef";
char arr2[] = "cde";
char* str = my_strstr(arr1, arr2);
if (str == NULL)
{
printf("NO\n");
}
else
{
printf("YES\n");
}
return 0;
}
- memcpy
#include<assert.h>
#include<stdio.h>
#include<string.h>
void* my_memcpy(void* dest, const void* sour, size_t count)
{
assert(dest && sour);
void* ret = dest;
while (count--)
{
*(char*)dest = *(char*)sour;
dest = (char*)dest + 1;
sour = (char*)sour + 1;
}
return dest;
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[12] = { 0 };
int sz = sizeof(arr2) / sizeof(arr2[0]);
my_memcpy(arr2, arr1, 20);//size_t 单位是字节
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr2[i]);
}
return 0;
}
- memove
思路：
void* my_memove(void* dest, const void* sour, size_t count)
{
assert(dest && sour);
void* ret = dest;
if (dest < sour)
{
//前->后
while (count--)
{
*(char*)dest = *(char*)sour;
dest = (char*)dest + 1;
sour = (char*)sour + 1;
}
}
else
{
//后->前
while (count--) //这里 count==20 为真 进入循环，又因为是后置-- ，所以count == 19
{
*((char*)dest + count) = *((char*)sour + count); //这里每次进来count都会 --
}
}
return ret;
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//1 2 1 2 3 4 5 8 9 10
my_memove(arr + 2, arr, 20);//可以实现重叠内存的拷贝
int sz = sizeof(arr) / sizeof(arr[0]);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
