文章目录
1.字符函数和字符串函数
(1).求字符串长度
? ? ? ? strlen
(2).长度不受限制的字符串函数
? ? ? ? strcpy? ? ? ? strcat? ? ? ? strcmp
(3).长度受限制的字符串函数
? ? ? ? ctrncpy? ? ? ? strncat? ? ? ? strncmp
(4).字符串查找
? ? ? ? strstr? ? ? ? strtoc
(5).错误信息报告
? ? ? ? strerror
(6)字符操作
2.内存函数
????????memcpy? ? ? ??
? ? ? ? memmove
? ? ? ? memset
? ? ? ? memcmp
3.自定义实现字符串函数+内存函数
1.字符函数和字符串函数
strlen
函数原型
size_t strlen ( const char * str );
strlen函数的作用是求字符串长度。
字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包含 '\0' )。
测试用例：
参数指向的字符串必须要以 '\0' 结束。
str数组里面包含abcdef这6个字符，当strlen函数在找’\0‘的时候没找到就会一直找，直到找’\0‘为止?
注意函数的返回值为size_t，是无符号的（ 易错 ），这该怎么理解呢？看下面这段代码：
#include<stdio.h >
#include<string.h>
int main()
{
char str1[] = "abc";
char str2[] = "abcd";
if (strlen(str1) - strlen(str2) < 0)
{
printf("有符号\n");
}
else
{
printf("无符号\n");
}
return 0;
}大家觉得输出的是无符号还是有符号呢，我们看答案：
哎，怎么输出的无符号呢？难道3-4不是小于0吗？所以要注意，strlen函数的返回值是一个无符号数，无符号数减去一个无符号数还是一个无符号数，所以程序运行输出的是无符号。?
strcpy
函数原型
char* strcpy(char * destination, const char * source );strcpy函数的作用是将源头里面的字符串拷贝到目的地里面去，并返回目的地地址。
测试用例：
?使用注意事项：
1.源字符串必须以 '\0' 结束。
strcpy拷贝的结束标志就是判断源字符串最后一个字符是否为'\0',若果没有'\0'，拷贝就会出错。
2.目标空间必须足够大，以确保能存放源字符串。
当我们所拷贝的字符串长度比目标空间大就会存在非法访问内存的问题。
strcat
函数原型
char * strcat ( char * destination, const char * source );
strcat函数的作用是将源头里面的字符串连接到目的地字符串后面，并返回目的地地址。
测试用例：
使用注意事项：
1.源字符串必须以 '\0' 结束。
2.目标空间必须有足够的大，能容纳下源字符串的内容。
3.目标空间必须可修改。?
4.自己给自己追加会出错。
strcmp
函数原型
int strcmp( const char *string1, const char *string2 );strcmp函数的作用是比较两个字符串大小。
????????若string1>stri2 返回一个大于0的数。
? ? ? ? 若string1<string2 返回一小于0的数。
? ? ? ? 若string1==string2 返回0.
测试用例：
?strcpy，strcat，strcmp都是长度不受限制的字符串函数是什么意思呢？，因为不管你定义的有多少字符，这些函数都会将全部字符进行复制、追加或者比较，那么有没有一些字符串函数是你想用多少字符就用多少字符呢?答案是当然有。
strncpy
函数原型
char *strncpy( char *strDest, const char *strSource, size_t count );
strncpy函数的作用是拷贝num个字符从源字符串到目标空间。
测试用例：
?如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。这是什么意思呢？看接下来这个代码：
#include<stdio.h>
#include<string.h>
int main()
{
char str1[10] = "abcdefg";
char str2[] = "12345";
strncpy(str1, str2, 7);
printf("%s\n", str1);
return 0;
}大家觉得答案输出的是什么呢？是12345fg吗？还是12345呢？
当源字符串长度小于num会直接在后面加0，而不会保留目的地之前的字符?。相信大家应该明白了吧！
strncat
函数原型
char *strncat( char *strDest, const char *strSource, size_t count );
strncat函数的作用是追加num个字符从源字符串到目标空间。
测试用例：
strncmp?
函数原型
int strncmp( const char *string1, const char *string2, size_t count );
strncmp函数的作用是分别从源字符串和目标空间比较num个字符。
测试用例：
接下来再来了解几个字符串函数吧！
strstr
函数原型
char *strstr( const char *string, const char *strCharSet );
strstr函数的功能是查找字符串
测试用例：
注意：strstr只会查找一次，不会查找多次，上面this里面包含is，而后面也有is，而只会找到this里面的is。
strtok?
函数原型
char *strtok( char *strToken, const char *strDelimit );
第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改 变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
如果字符串中不存在更多的标记，则返回 NULL 指针。
测试用例：
?strerror
函数原型
char *strerror( int errnum );
strerror的作用是错误码的错误信息打印出来。
测试用例：
?接下来就是字符函数：
字符函数一般不太常用，大家想用的话也可以去查一下它们的用法 。
我们刚刚介绍的这些字符函数都是用来操作字符或者字符串的，那么我们有没有一些函数也可以实现这些功能，但是可以操作其他类型的库函数呢？这就要介绍下内存函数了。
2.内存函数
memcpy
函数原型
void * memcpy ( void * destination, const void * source, size_t num );
memcpy函数的作用是用来拷贝任意类型的数据，从source的位置开始向后复制num个字节的数据到destination的内存位置。
这个函数在遇到 '\0' 的时候并不会停下来。
如果source和destination有任何的重叠，复制的结果都是未定义的。
头文件 引用：? ? ? ?
<memory.h> or <string.h>
测试用例
但是大家有没有想过这样一个问题，假若我们源头和目的地都是同一个数组呢？memcpy还会成功吗？其实在C语言标准规定memcpy处理内存不重叠，而接下来的函数就是处理内存重叠的：
memmove
函数原型
void * memmove ( void * destination, const void * source, size_t num );
测试用例
?
3.自定义实现字符串函数+内存函数
strlen
#include<stdio.h>
#include<string.h>
#include<assert.h>
int my_strlen(const char* p)
{
int count = 0;
assert(p != NULL);
while (*p != '\0')
{
count++;
p++;
}
return count;
}
int main()
{
char str[] = "abcdef";
int len = my_strlen(str);
printf("%d\n", len);
return 0;
}
strcpy
#include<stdio.h>
#include<assert.h>
char* my_strcpy( char* arr1, const char* arr2)
{
//断言arr1，arr2是不是空指针。
assert(arr1 != NULL);
assert(arr2 != NULL);
char* ret = arr1;
while (*arr1++ = *arr2++)
{
;
}
return ret;
}
int main()
{
char str1[256] = "fggfd";
char str2[] = "GGFGFD";
my_strcpy(str1, str2);
printf("%s\n", str1);
printf("%s", str2);
return 0;
}strcat
#include<stdio.h>
#include<assert.h>
char* my_strcat(char* str1,const char* str2)
{
char* ret = str1;
assert(str1&&str2);
while(*str1 != '\0')
{
str1++;
}
while (*str1++ = *str2++)
{
;
}
return ret;
}
int main()
{
char arr1[23] = "fdfdd";
char arr2[] = "gfgdf";
my_strcat(arr1, arr2);
printf("%s", arr1);
return 0;
}strcmp
#include<stdio.h>
#include<assert.h>
int my_strcmp( const char* str1, const char* str2)
{
assert(str1!=NULL)//断言
assert(str2!=NULL)
while (*str1==*str2)
{
if (*str1 =='\0')
{
return 0;
}
*str1++;
*str2++;
}
if (*str1 < *str2)
{
return -1;
}
else
{
return 1;
}
}
int main()
{
const char* arr1= "rfdfsfd";
const char* arr2 = "rfdfsfdf";
int ret = my_strcmp(arr1,arr2);
printf("%d", ret);
return 0;
}memcpy
#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* dest,const void* src, size_t num)
{
assert(dest&&src);
char* p1 =(char*) dest;
char* p2 = (char*)src;
while (num--)
{
*p1= *p2;
p1++;
p2++;
}
return dest;
}
int main()
{
int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int arr2[] = { 11, 22, 33, 44, 55, 66, 77, 88, 99, 1010 };
my_memcpy(arr1, arr2, sizeof(arr2));
for (int i = 0; i < 10; i++)
{
printf("%d\t", arr1[i]);
}
return 0;
}memmove
void * memmove ( void * dst, const void * src, size_t count)
{
void * ret = dst;
if (dst <= src || (char *)dst >= ((char *)src + count)) {
/*
* Non-Overlapping Buffers
* copy from lower addresses to higher addresses
*/
while (count--) {
*(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
}
}
else {
/*
* Overlapping Buffers
* copy from higher addresses to lower addresses
*/
dst = (char *)dst + count - 1;
src = (char *)src + count - 1;
while (count--) {
*(char *)dst = *(char *)src;
dst = (char *)dst - 1;
src = (char *)src - 1;
}
}
return(ret);
}