目录
介绍处理字符和字符串的库函数的使用和注意事项：
求字符串长度
strlen
长度不受限制的字符串函数
strcpy
strcat
strcmp
长度受限制的字符串函数介绍
strncpy
strncat
strncmp
字符串查找
strstr
strtok
错误信息报告
strerror
字符操作
内存操作函数
memcpy
memmove
memset
memcmp
注：C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串 中或者字符数组中。字符串常量适用于那些对它不做修改的字符串函数
1.函数介绍
1.1strlen：求字符串长度
size_t strlen ( const char * str );//声明 //注：const放在*左边无法解引用，放在*右边无法改变指针指向
说明：字符串已'\0'作为结束标志，strlen函数返回的是在字符串中'\0'前面出现的字符个数（不包含 '\0' ) ，参数指向的字符串必须要以'\0'结束。
为什么返回值类型设置出size_t类型？
strlen是求字符串长度的，求出的长度是不可能为负数的所以返回类型设置为size_t，size_t本质上是无符号整型unsigned int所以接收返回值的时候我们可以使用size_t类型来接收。
模拟实现strlen
第一种方法
第二种方法
第三种方法
//指针减指针
//第一种方法
size_t my_strlen(const char* str)
{
const char* count = str;
while (*count++);
return count - str - 1;
}
//第二种方法
//定义一个变量来统计
size_t my_strlen(const char* str)
{
int count = 0;
while (*str++)
{
count++;
}
return count;
}
//第三种方法
//递归
size_t my_strlen(const char* str)
{
if (*str != '\0')
return 1 + my_strlen(str + 1);//递归参数不能使用++，由于用的递归，而递归的每一个状态都需要的是该时期的状态
else
return 0;
}
int main()
{
char ch[] = "hello world";
size_t len = my_strlen(ch);
printf("%u\n", len);
return 0;
}1.2strcpy：拷贝字符串
char* strcpy(char * destination, const char * source );
说明：源字符串必须以'\0'结束，会将源字符串中的'\0'拷贝到目标空间。目标空间必须足够大，以确保能存放源字符串，目标空间必须可变，并且不应在内存中与源重叠。
第一个参数：目标空间
第二个参数：源字符串
返回值：返回目标起始空间地址。
将源字符串拷贝到目标空间，返回他起始地址
模拟实现strcpy
char* my_strcpy(char* dest, const char* src)
{
char* start = dest;
while (*dest++ = *src++);
return start;
}
int main()
{
char ch1[20] = { 0 };
char ch2[] = "hello world";
my_strcpy(ch1, ch2);
printf("%s\n",ch1);
return 0;
}1.3strcat：追加字符串
char * strcat ( char * destination, const char * source );
说明：将源字符串的副本追加到目标字符串末尾。目标中的终止空字符('\0')被源字符串的第一个字符覆盖，并且在目标中由两者串联形成的新字符串的末尾包含一个空字符('\0')。源字符串必须以'\0'结束，目标空间必须有足够的大，能容纳下源字符串的内容，目标空间必须可修改。
第一个参数：目标空间
第二个参数：源字符串
返回值：返回目标起始空间地址。
将源字符串追加到目标空间\0处形成一个新的字符串末尾包含一个\0，返回他起始地址
模拟实现strcat
char* my_strcat(char* dest, const char* src)
{
char* start = dest;
//找目标空间的\0
while (*dest)
dest++;
//追加
while (*dest++ = *src++);
return start;
}
int main()
{
char ch1[20] = "hello ";
my_strcat(ch1, "world");
printf("%s\n",ch1);
return 0;
}1.4strcmp：比较字符串
int strcmp ( const char * str1, const char * str2 );
说明：从此函数开始比较两个字符串的第一个字符。如果它们彼此相等，则继续以下对，直到字符不同或达到终止空字符（\0）。此函数执行的是字符的二进制比较。
第一个参数：要比较的字符串str1
第二个参数：要比较的字符串str2
标准规定：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字
模拟实现strcmp
int my_strcmp(const char* str1, const char* str2)
{
while (*str1 == *str2)
{
if (*str1 == '\0')
return 0;
str1++;
str2++;
}
//第一种方法
/*if (*str1 > *str2)
return 1;
else
return -1;*/
//第二种方法
return *str1 - *str2;//使用ASCII值相减
}
int main()
{
char ch1[20] = "abcde";
char ch2[20] = "abc";
int ret = my_strcmp(ch1, ch2);
printf("%d\n",ret);
return 0;
}1.5strncpy：拷贝字符串个数
char * strncpy ( char * destination, const char * source, size_t num );
说明：拷贝num个字符从源字符串到目标空间。如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。 如果源字符串长度超过num则不会在目标空间末尾添加\0
第一个参数：目标空间
第二个参数：源字符串
点三个参数：拷贝的个数
返回值：返回目标起始空间地址。
将源字符串拷贝到目标空间，返回他起始地址
模拟实现strncpy
char* my_strncpy(char* dest, const char* src, size_t num)
{
char* start = dest;
while (*src && num)
{
*dest++ = *src++;
num--;
}
while (num--)
{
*dest++ = 0;
}
return start;
}
int main()
{
char ch1[20] = "xxxxxxxxxxx";
char ch2[20] = "abcdef";
my_strncpy(ch1, ch2, 6);
printf("%s\n",ch1);
return 0;
}1.6strncat：追加字符串个数
char * strncat ( char * destination, const char * source, size_t num );
说明：追加num个字符从源字符串到目标空间外加一个\0，如果源字符串的长度小于num，则仅复制终止\0之前的内容。
第一个参数：目标空间
第二个参数：源字符串
第三个参数：追加的个数
返回值：返回目标起始空间地址。
将源字符串追加到目标空间，返回他起始地址
模拟实现strncat
char* my_strncat(char* dest, const char* src, size_t num)
{
char* start = dest;
while (*dest)
dest++;
while (num--)
{
*dest = *src;
dest++;
src++;
}
*dest = 0;
return start;
}
int main()
{
char ch1[20] = "hello ";
char ch2[20] = "world";
my_strncat(ch1, ch2, 5);
printf("%s\n",ch1);
return 0;
}1.7strncmp：比较字符串个数
int strncmp ( const char * str1, const char * str2, size_t num );
说明：从此函数开始比较两个字符串的第一个字符。如果它们彼此相等，则继续以下对，直到字符不同或达到终止空字符\0或者直到两个字符串中的num字符匹配。此函数执行的是字符的二进制比较。
第一个参数：要比较的字符串str1
第二个参数：要比较的字符串str2
第三个参数：比较的个数
标准规定：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字
模拟实现strncmp
int my_strcmp(const char* str1, const char* str2, size_t num)
{
while (*str1 == *str2 && num)
{
if (*str1 == '\0')//相等的请况
return 0;
str1++;
str2++;
num--;
}
if (num == 0)
return 0;
return *str1 - *str2;//使用ASCII值相减
}
int main()
{
char ch1[20] = "abcde";
char ch2[20] = "abcdef";
int ret = my_strcmp(ch1, ch2,6);
printf("%d\n", ret);
return 0;
}1.8strstr：查找子字符串
char * strstr ( const char *str1, const char * str2);
说明：返回指向str1中第一次出现的str2的指针，如果str2不是str1的一部分，则返回一个空指针。匹配过程不包括\0，遇到\0停止。
模拟实现strstr
char* my_strstr(const char* str1, const char* str2)
{
if (*str2 == '\0')
return (char*)str1;
const char* pos = str1;
const char* s1 = NULL;
const char* s2 = NULL;
while (*pos)
{
s1 = pos;
s2 = str2;
while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2)
{
s1++;
s2++;
}
if (*s2 == '\0')
return (char*)pos;
pos++;
}
return NULL;
}
int main()
{
char ch1[10] = "abbbcde";
char ch2[10] = "bc";
char* ret = my_strstr(ch1, ch2);
if (ret == NULL)
{
printf("找不到\n");
}
else
{
printf("%s\n", ret);
}
return 0;
}1.9strtok：拆分字符串
char * strtok ( char * str, const char * sep );
sep参数是个字符串，定义了用作分隔符的字符集合
第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：
strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
如果字符串中不存在更多的标记，则返回 NULL 指针。
模拟实现strtok
char* my_strtok(char* src, const char* sep)
{
char* head = NULL;//标记返回的头
char* tail = NULL;//找到的标记替换成'\0'
static char* pos = NULL;//记录下一次起始位置
if (src == NULL)
src = pos;
//找返回目标起始空间的地址
while (*src)
{
const char* sp = sep;
while (*src != '\0' && * sp != '\0' && *src != *sp)
{
sp++;
}
if (*sp == '\0')
{
head = src;
break;
}
src++;
}
//找下一个标记
while (*src)
{
const char* sp = sep;
while (*src != '\0' && *sp != '\0' && *src != *sp)
{
sp++;
}
if (*src == *sp)
{
*src = '\0';
tail = src;
pos = src + 1;//记录'\0'之后的位置地址
return head;
}
src++;
}
return NULL;
}
int main()
{
char ch1[30] = "- This, a sample string.";
char ch2[10] = " ,.-";
char* ret = NULL;
for (ret = my_strtok(ch1, ch2); ret != NULL; ret = my_strtok(NULL, ch2))
{
printf("%s\n", ret);
}
return 0;
}1.10strerror：获取指向错误消息字符串的指针
char * strerror ( int errnum );
获取指向错误消息字符串的指针
解释errnum的值，生成一个字符串，其中包含描述错误条件的消息，就像由库的函数设置为errno一样。
返回的指针指向静态分配的字符串，程序不应修改该字符串。对此函数的进一步调用可能会覆盖其内容
C语言的库函数在运行的时候，如果发生错误，就会将错误码存在一个变量中，这个变量是：errno
错误是一些数字，我们需要将错误码翻译成错误信息 。
使用方法：
当我们在该文件目录底下创建这个文件的时候就不会报错。
至于这个文件操作后面在介绍。
还有一个类似的库函数和strerror差不多的函数顺便介绍一下：
perror的使用：
这个函数会自动将错误码转换成错误信息打印在屏幕上，根据自身情况来使用这两个函数perror和strerror，如果不想将错误码转成错误信息打印信息在屏幕上可以使用strerror。
字符分类函数：
| 函数 | 如果他的参数符合下列条件就返回真 |
| iscntrl | 任何控制字符 |
| isspace | 空白字符：空格' '，换页'\f'，换行'\n'，回车'\r'，制表符'\t'或者垂直制表符'\v' |
| isdigit | 十进制数字 0~9 |
| isxdigit | 十六进制数字，包括所有十进制数字，小写字母a~f，大写字母A~F |
| islower | 小写字母a~z |
| isupper | 大写字母A~Z |
| isalpha | 字母a~z或A~Z |
| isalnum | 字母或者数字，a~z,A~Z,0~9 |
| ispunct | 标点符号，任何不属于数字或者字母的图形字符（可打印） |
| isgraph | 任何图形字符 |
| isprint | 任何可打印字符，包括图形字符和空白字符 |
这些函数的使用方法可以直接去这个网站查找使用方法
网站链接：cplusplus.com - The C++ Resources Network只用输入函数名搜索即可，以及其他函数。
内存函数
内存函数针对内存相关的函数分别介绍这几个内存函数：
memcpy
memmove
memcmp
memset
之前介绍的函数都是针对字符串类型的函数，如果我们要拷贝整型、浮点型、结构体类型等等的时候，这时候就用到了内存函数，它们都是通过内存一个一个字节来处理的。
1.1memcpy：内存拷贝函数
void * memcpy ( void * destination, const void * source, size_t num );
它的返回类型和接收参数都是void*类型，因为void*可以接收任意指针类型也可以赋值给任意类型指针，这使得这个函数能拷贝任意类型数据。最后一个参数代表你要拷贝几个字节。
函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
这个函数在遇到 '\0' 的时候并不会停下来。如果source和destination有任何的重叠，复制的结果都是未定义 。
memcpy的使用：
就算是17个字节他一样可以拷贝，因为数据是按小端形式来存放的07 00 00 00，他会把第一个字节07给拷贝过来
memcpy模拟实现：
void* my_memcpy(void* dest, const void* src, size_t num)
{
void* start = dest;
while (num--)
{
//以下几种写法
//1.
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
2.
//((char*)dest)++;
//((char*)src)++;
3.
//++(char*)dest;
//++(char*)src;
}
return start;
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = { 0 };
my_memcpy(arr2, arr1, 20);
for (int i = 0; i < 10; i++)
{
printf("%d ", arr2[i]);
}
return 0;
}1.2内存函数memmove：
void * memmove ( void * destination, const void * source, size_t num );
和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。如果源空间和目标空间出现重叠，就得使用memmove函数处 。
注：库函数里面memcpy也能实现重叠拷贝。
模拟实现memmove
void* my_memmove(void* dest, const void* src, size_t num)
{
void* start = dest;
if ((char*)dest > (char*)src && (char*)dest < ((char*)src + num))//从后向前拷贝
{
while (num--)
{
*((char*)dest + num) = *((char*)src + num);
}
}
else//从前向后拷贝
{
while (num--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
}
return start;
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
my_memmove(arr1, arr1 + 2, 20);
for (int i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
1.3内存函数memcmp：
int memcmp ( const void * ptr1, const void * ptr2, size_t num );
从此函数开始比较两个字符串的第一个字符。如果它们彼此相等，则继续以下对，直到数据值不同或者直到比较完num对字符串。
标准规定：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字
模拟实现memcmp
int my_memcmp(const void* ptr1, const void* ptr2, size_t num)
{
while (num-- && (*(char*)ptr1 == *(char*)ptr2))
{
ptr1 = (char*)ptr1 + 1;
ptr2 = (char*)ptr2 + 1;
}
return *(char*)ptr1 - *(char*)ptr2;
}
int main()
{
int arr1[10] = { 1,2,3,4,5 };
int arr2[10] = { 1,2,3,4,10 };
int ret = my_memcmp(arr1, arr2, 20);
printf("%d", ret);
return 0;
}1.4内存函数memset：内存设置函数
void * memset ( void * ptr, int value, size_t num );
将ptr指向的内存块的num个字节，一个字节一个字节的设置成指定的value值。
使用方法以及注意事项：
因为是一个一个字节设置的他会把每一个比特位设置成1，一般使用来初始化设置为0。
560
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
