memcpy：
从一个字符串复制一个字节到另外一个字符串（The memcpy() function copies n bytes from memory area src to memor area dest. ），并且两个字符串不能有重叠区域。
头文件包含：#include <string.h>
memcpy()函数原型：
void *memcpy(void *dest, const void *src, size_t n);
dest指向的字符串表示目标字符串，src指向的字符串表示原字符串，n表示要复制的字节数。
返回值：复制成功返回目标字符串（dest指向的字符串）的指针。
自己编写程序实现memcpy函数：
第一种方式利用assert宏:
#include <stdio.h>
#include <assert.h>
void *memcpy2(void *memTo, const void *memFrom, size_t size)
{
//ASSERT（）一般被称为断言，它是一个调试程序常用的宏。
//它定义在<assert.h>头文件中，通常用于判断程序中是否出现了非法的数据，
//在程序运行时它计算括号内的表达式的值，如果表达式的值是false（0），程序报告错误，终止运行。
assert((memTo != NULL) && (memFrom != NULL)); //memTo和memFrom必须有效
char *tempFrom = (char *)memFrom; //保存memFrom首地址
char *tempTo = (char *)memTo;
while(size -- > 0) //循环size次，复制memFrom的值到memTo中
*tempTo++ = *tempFrom++ ;
return memTo;
}
int main()
{
char strSrc[] = "rrrr"; //将被复制的字符数组
char strDest[20]; //目的字符数组
memcpy2(strDest, strSrc, 4); //复制strSrc的前4个字符到strDest中
strDest[4] = '\0'; //把strDest的第5个元素赋为结束符'\0'
printf("strDest: %s\n", strDest);
return 0;
}
第二种方式不用assert宏：
#include <stdio.h>
void *memcpy2(void *memTo, const void *memFrom, size_t size)
{
if((memTo != NULL) && (memFrom != NULL))
{
char *tempFrom = (char *)memFrom; //保存memFrom首地址
char *tempTo = (char *)memTo;
while(size!=0) //循环size次，复制memFrom的值到memTo中
{
*tempTo++ = *tempFrom++ ;
size--;
}
return memTo;
}
else
return NULL;
}
int main()
{
char strSrc[] = "rrrr"; //将被复制的字符数组
char strDest[20]; //目的字符数组
memcpy2(strDest, strSrc, 4); //复制strSrc的前4个字符到strDest中
strDest[4] = '\0'; //把strDest的第5个元素赋为结束符'\0'
printf("strDest: %s\n", strDest);
return 0;
}
注：与strcpy不同，memcpy用参数size决定复制多少个字符（strcpy遇到结束符"\0"结束）。由于在主程序中只复制了strSrc的前4个字符
memmove：
从一个字符串复制一个字节到另外一个字符串（The memcpy() function copies n bytes from memory area src to memor area dest. ），两个字符串可以有重叠区域。
头文件包含：#include <string.h>
memmove()函数原型：
void *memmove(void *dest, const void *src, size_t n);
des指向的字符串t表示目标字符串，src指向的字符串表示原字符串，n表示要复制的字节数。
返回值：复制成功返回目标字符串（dest指向的字符串）的指针。
memset：
将字符串s指向的字符串中的前n个字节用数字c来填充（The memset() function fills the first n bytes of the memory area pointed to by s with the constant byte c）
头文件包含：#include <string.h>
memset()函数原型：
void *memset(void *s, int c, size_t n);
s指向的字符串表示要被填充的字符串，c为填充的内容，n为填充多少个字节。
返回值：成功返回目标字符串（s指向的字符串）的指针。
memcmp：
分别比较s1指向的字符串字符串与s2指向的字符串字符串的前n个字符，且区分大小写，逐个按照它们的ASIIC大小来比较的（The memcmp() function compares the first n bytes of the memory areas s1 and s2.）
头文件包含：#include <string.h>
memcmp()函数原型：
int memcmp(const void *s1, const void *s2, size_t n);
s1指向的字符串表示字符串1，s2指向的字符串表示字符串2，n表示要对比的字节数。
返回值：
当s1指向的字符串小于s2指向的字符串，返回值小于0
当s1指向的字符串大于s2指向的字符串，返回值大于0
当s1指向的字符串等于s2指向的字符串，返回值等于0
代码示例：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main(int argc,char* argv[])
{
char *wakebuff[2]={"小爱同学你好","你好小爱同学"};
char *exitbuff[3]={"退出系统","退出程序","退出"};
char *result = "你好小爱同学";
printf("%s\n",wakebuff[1]);
int res = memcmp(wakebuff[1],result,strlen(result));
printf("res is = %d len= %d\n",res,strlen(result));
if(res == 0)
{
printf("compared sucessful\n\n");
}else
{
printf("compared fail\n\n");
}
return 0;
}
memchr：
从s所指内存区域的前n个字节查找字符c（The memchr() function scans the initial n bytes of the memory area pointed to by s for the first instance of c. ）
头文件包含：#include <string.h>
memchr()函数原型：
void *memchr(const void *s, int c, size_t n);
s指向的字符串表示要被查找的字符串，c表示要查找的字符，n表示查找的字节数。
返回值：成功，返回指向字符c的指针；否则返回NULL
strcpy：
用来复制字符串，包括结束符’\0’；不需要指定长度将src指向的字符串复制到dest指向的内存空间，遇到’\0’结束。（The strcpy() function copies the string pointed to by src, includin the terminating null byte (’\0’), to the buffer pointed to by dest.）
头文件包含：#include <string.h>
strcpy()函数原型：
char *strcpy(char *dest, const char *src);
sr表示源字符串，dest表示目标字符串。
返回值：成功复制返回一个指向目标字符串dest的指针。
strcpy与memcpy的区别：
字符串一般是用字符数组的方式存储，例如下面的str定义：
char str[] = “123456”;
strcpy和memcpy主要有以下3方面的区别：
1、复制的内容不同。strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符数组、整型、结构体、类等。
2、复制的方法不同。strcpy不需要指定长度，它遇到字符串结束符"\0"便结束。memcpy则是根据其第3个参数决定复制的长度。
3、用途不同。通常在复制字符串时用strcpy，而需要复制其他类型数据时则一般用memcpy。
不调用库函数实现strcpy函数：
#include <stdio.h>
char * strcpy(char * strDest, const char * strSrc) // 定义函数原型，实现strSrc到strDest的复制
{
if ((strDest == NULL) || (strSrc == NULL)) //判断参数strDest和strSrc的有效性，判断传入的参数strDest和strSrc是否为NULL，如果是则返回NULL。
{
return NULL;
}
char *strDestCopy = strDest; //保存目标字符串的首地址，把strDest的值保存到strDestCopy指针中
while ((*strDest++ = *strSrc++)!='\0'); //把strSrc字符串的内容复制到strDest目标字符串，对strSrc和strDest两个指针进行循环移动，并不断复制strSrc内存的值到strDest内存中
return strDestCopy; //由于已经保存了strDest指针的值，因此这里只需返回strDestCopy的值，而函数调用完后返回的就是strDest的值
};
int getStr_Len(const char *str) //获取字符串str的长度
{
int strlen = 0; //定义长度变量并初始化
while(*str++ != '\0') //循环直到遇见结束符'\0'为止
{
strlen++;
}
return strlen;
};
int main()
{
char strSrc[] = "Hello World!"; //定义要被复制的源字符串
char strDest[20]; //定义要复制到的目的字符数组
int len = 0; //定义并初始化保存目的字符数组中字符串的长度
len = getStr_Len(strcpy(strDest, strSrc)); //链式表达式，先复制后计算复制的长度
printf("strDest: %s\n", strDest);
printf("Length of strDest: %d\n", len);
return 0;
}
结果为：strDest: Hello World!
Length of strDest: 12
注：strcpy函数返回char *类型的原因是为了能使用链式表达式。
strncpy
用来复制字符串；可以利用n来指定长度将src指向的字符串复制到dest指向的内存空。如果scr的长度小于n，剩下的用null填充（The strncpy() function is similar, except that at most n bytes of sr are copied.）
头文件包含：#include <string.h>
strncpy()函数原型：
char *strncpy(char *dest, const char *src, size_t n);
sr表示源字符串，dest表示目标字符串，n表示要复制的字节数。
返回值：成功复制返回一个指向目标字符串dest的指针。
关键实现代码;
char *strncpy(char *dest, const char *src, size_t n)
{
size_t i;
for (i = 0; i < n && src[i] != '\0'; i++)
dest[i] = src[i];
for ( ; i < n; i++)
dest[i] = '\0';
return dest;
}
strcat
strcat（）函数将src字符串附加到dest字符串，覆盖dest末尾的终止空字节（’\ 0’），然后添加一个终止空字节。 如果dest不够大，则程序行为是不可预测的（ The strcat() function appends the src string to the dest string, over-writing the terminating null byte (’\0’) at the end of dest, and the adds a terminating null byte. The strings may not overlap, and th dest string must have enough space for the result. ）
头文件包含：#include <string.h>
strcat()函数原型：
char *strcat(char *dest, const char *src);
返回值：成功复制返回一个指向目标字符串dest的指针。
strncat：
strncat（）将n + 1个字节写入dest（来自src的n加终止空字节）。 因此，dest的大小必须至少为strlen（dest）+ n + 1（strncat() writes n+1 bytes to dest (n from src plus the terminating null byte). Therefore, the size of dest must be at least strlen(dest)+n+1.）。
头文件包含：#include <string.h>
strncat()函数原型：
char *strcat(char *dest, const char *src, size_t n);
返回值：成功复制返回一个指向目标字符串dest的指针。
关键实现代码：
char*strncat(char *dest, const char *src, size_t n)
{
size_t dest_len = strlen(dest);
size_t i;
for (i = 0 ; i < n && src[i] != '\0' ; i++)
dest[dest_len + i] = src[i];
dest[dest_len + i] = '\0';
return dest;
}
strcmp
两个字符串之间是逐个按照它们的ASIIC大小来比较的，一旦发现其中一个大于或小于另一个时，比较结束，返回一个值，不然就一直比较到’\0’为止（The strcmp() function compares the two strings s1 and s2. It returns an integer less than, equal to, or greater than zero if s1 is found, respectively, to be less than, to match, or be greater than s2.）
头文件包含：#include <string.h>
strcmp()函数原型：
int strcmp(const char *s1, const char *s2);
返回值：
s1大于s2，返回值大于零
s1等于s2，返回值等于零
s1小于s2，返回值小于零
strcmp与memcmp的区别和strcpy与memcpy的区别相似。
自己简单实现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;
str2++;
str1++;
}
return *str1-*str2;
}
int main()
{
char *p1 = "abde";
char *p2 = "aae";
int ret = my_strcmp(p1, p2);
printf("%d\n",ret);
return 0;
}
相同为0大于为1小于为-1（比较的是第一个不相同字符的ASIIC值的大小）。
strncmp
用法与strcmp相似，只是比较前n个字节。（The strncmp() function is similar, except it compares the only first (at most) n bytes of s1 and s2）。
头文件包含：#include <string.h>
strncmp()函数原型：
int strncmp(const char *s1, const char *s2, size_t n);
返回值：
s1大于s2，返回值大于零
s1等于s2，返回值等于零
s1小于s2，返回值小于零
strdup
将字符串拷贝到新建的位置处，strdup()函数主要是拷贝字符串s的一个副本，由函数返回值返回，这个副本有自己的内存空间，和s没有关联。（ The strdup() function returns a pointer to a new string which is a duplicate of the string s. ）
头文件包含：#include <string.h>
strdup()函数原型：
char *strdup(const char *s);
返回值：成功后，strdup（）函数将返回指向重复字符串的指针。
代码举例：
strdup函数实现：
char * __strdup(const char *s)
{
size_t len = strlen(s) +1;
void *new = malloc(len);
if (new == NULL)
return NULL;
return (char *)memecpy(new,s,len);
}
函数使用代码：
#include <stdio.h>
#include<string.h>
int main(void)
{
char *src ="This is the jibo";
char *dest;
dest = strdup(sfc);
printf("the dest %s\n",dest);
return 0;
}
