字符函数和字符串函数

求字符串长度：

strlen()

size_t strlen(const char * str);

功能：返回字符串长度
参数：C字符串
返回值：字符串的长度
注意：字符串的长度由终止空字符（\0）确定，只计算到这个终止字符串前面的字符数

模拟实现strlen()

<1> 模拟实现的几个关键点

• assert进行声明，确保不传入空字符串
• size_t为无符号整形
• 代码思想：同时让首元素地址传给两个指针，一个指针负责记录开头，另一个指针负责前进直至访问至’\0’，让两者相减得到差值即可

#include <stdio.h>
#include <assert.h>
size_t my_strlen(const char * str)
{
	assert(str);
	char* start = str;
	char* end = str;
	while(*end != '\0')
	{
		end++;
	}
	return end - start
}

代码思想的图片展示：

长度不受限制的字符串函数

strcpy()

char * strcpy(char * destination,const char * source);

功能：复制字符串
参数：源字符串（source），目标字符串（destination）
返回值：返回destination
注意：

• 为避免栈溢出，目标所指向的数组大小应该足够长，以包含与source相同的C字符串（包括NULL字符串），且不应该在内存中与之重叠
• 字符串必须要以\0结尾
• \0也会被拷贝过去

//例子
#include<stdio.h>
#include<string.h>
int main()
{/*
	char arr[10] = { 0 };*/
	char arr[10] = "xxxxxxxxxx";
	const char* p = "abcdef";
	char* ret = strcpy(arr, p);
	printf("%s", ret);//abcdef
	return 0;
}

模拟实现strcpy()

**关键点 **

• 用assert表示指针合法
• 前置++是先使用后++，根据运算符优先级，会先进行赋值，后面再++，直到\0时会停止
• 因为此时dest这个指针已经到了最后字符串最后一个字符的地址，此时返回该字符串无法返回完整的字符串，此时在循环前就将dest指针内存放的字符串首元素地址赋值给ret，到时即可用该指针返回打印

#include <assert.h>
char * my_strcpy(char * dest,const char * src)
{
	assert(dest);//确保指针合法
	assert(src);
	char * ret = dest;
	while(*dest++ == *src++);
	return ret;
}

strcat（）

char * strcat (char * destination,const char * source);

功能：连接字符串
参数：源字符串，目标自付串
返回值：返回目标字符串（被添加后的）
注意：目标中的终止字符串被源字符串的第一个字符覆盖，最终的终止字符串在连接后的字符串的末尾

//例子
int main()
{
	char arr1[20] = "bit";
	char arr2[] = "bit" ;
	printf("%s\n", strcat(arr1, arr2));//bitbit
	return 0;
}

模拟实现strcat

关键点：

• 先将dest指针的地址赋给字符指针变量control，然后进行向后移位到\0处位置，再进行赋值操作，将原本的\0覆盖掉,再将source中的值一一赋值给的control
• 到最后的时候，control的位置已经到了最后一个字符的地址（此时所有字符连接完毕），但此时如果将control返回打印只能打印最后一个字符，但control存放着dest的地址，实际上dest的内容借着control已经全部修改，且的dest此时存放着首元素的地址，所以可以返回dest，从而打印整个数组

char* my_strcat(const char* dest,const char * source)
{
	char* control = dest;
	while(control !='\0')
	{
		control++;
	}
	while(*control++ = *src++);
	return dest;
}

strcmp

int strcmp(const char *str1,const char *str2)

功能：比较两个字符串大小
参数：两个字符串
返回值：

• 大于返回>0的值
• 小于返回<0的值
• 两个字符串相等返回0

模拟实现strcmp

关键点：

• str1的值等于0就说明此时两个字符串比较到了最后，所以返回0
• 最后比较的大小值可以直接用减法（ASCLL码），得出大于或者小于0的值来判断两个字符串大小

int strcmp(const char * str1,const char * str2)
{
	assert(str1 && str2);
	while(*str1 == *str2)
	{
		if(*str1 == '\0')
		{
			return 0;
		}
		str1++;
		str2++;
	}
	return *str1-*str2;
}

长度受限制的字符串表示

strncpy

char * strncpy(char * destination,const char * source ,size_t num);

功能：复制字符
参数：两个字符串，destination：指向再其中复制内容的目标数组的指针。source：要复制的C字符串。size_t:无符号整数，规定要复制的字符数。
返回值：要被复制的那部分字符串

//例子
int main()
{
	/*char arr1[] = "helloworld";*/
	char arr1[20] = "abcde";
	char arr2[] = "xxxx";
	char* ret = strncpy(arr1, arr2, 5);///覆盖原本的\0然后添加对于元素后，补上\0
	/*strncat(arr1, arr1,5);*///覆盖原本的\0然后添加对于元素后，补上\0
	printf("%s", ret);//xxxx
	char* ret = strncpy(arr1, arr2,12);//arr2中只有4个字符，此时过度覆盖，多的那些部分自动补上\0
	return 0;
	
}

图片：第5个元素自动补位\0

strncat

char * strncat(char * destination,const char * source,size_t num)

功能：追加字符，连接字符（有限个）
参数： destination: 指向目标数组的指针，该数组一个包含字符串C，并且足够大以包含串联的结果字符串，包括附加的空字符，source：要追加的字符串，size_t:要追加的最大字符数，为无符号整数类型

返回值：连接后的字符串
注意：连接的时候会覆盖原本的\0然后添加对应元素，最后补上\0

int main()
{
	/*char arr1[] = "hello world";*/
	char arr1[20] = "abcde";
	char arr2[] = "xxxx";
	char* ret = strncat(arr1, arr1, 5);
	//覆盖原本的\0然后添加对应元素后，补上\0
	printf("%s", ret);//abcdeabced
	return 0;
}

strncmp

int strncmp(const char * str1,const char* str2,size_t num)

功能：从字符串中追加字符
参数：str1和str2为要比较的字符串，size_t num为要比较的字符数
返回值：小于0：str1<str2;大于0：str1>str2;等于0:str1=str2

int main()
{
	arr1[10]="abcde";
	arr2[10]="ab";
	int ret = strcmp(arr1,arr2,2);
	printf("%d",ret);//0
	int ret2 = strcmp(arr1,arr2,3):
	printf("%d",ret2);//1
}

字符串查找

strstr（）

char * strstr(const char * str1,const char * str2);

功能：定位字符串
参数：str1：要扫描的字符串，str2：要匹配的字符串
返回值：第一个字串的首地址

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abc";
	char* p = strstr(arr1, "bcd");
//一个字符串在另一个字符串中找是否有相同的字符串
	if (p == NULL)
	{
		printf("不存在");
	}
	else
	{
		printf("%s\n", p);//bcdef
	}
	return 0;
}

模拟实现strstr

关键点：

• p的强制类型转换，为了避免const的警告
• 设定指针p，假设第一位匹配成功，中途匹配字符不成功，不需要从头开始，只需要从匹配成功的第一位，往后移动一位继续进行匹配，p指针这里实行定位，让s1指针可以返回到这个位置，无需从头开始（造成死循环）
• 如若*s2已经为0，则说明匹配时，s1和s2匹配到了终止字符串，前面的字符都匹配成功，说明s2和s1已经匹配成功
• 此时返回的指针不能是s1或者s2，是因为这两者的地址在匹配成功元素的最后一位，打印时无法完全打印，而p指针正好保留着匹配时的第一个字符，所以返回p指针时，可以打印p对于元素包括以后的所有元素

char * my_strstr(const char * str1,const char * str2)
{
	 const char * s1 = str1;
	 const char * s2 = str2;
	 const char * p = str1;
	 while(*p)
	 {
	 	s1 = p;
	 	s2 = str2;
	 	while(s1!='\0' && s2!='\0'&&(s1==s2))
	 	{
	 		s1++;
	 		s2++;
		}
		if(*s2 = '\0')
		{
			return (char*)p;
		}
			 p++;
	 }
	return NULL;
}

strtok()

char * strtok(char * str,const char * delimiters)

功能：分割字符串
参数：str:要分割的字符串;delimiters:分割字符串的分隔符
返回值：返回分隔的那部分字符第一个元素的地址
注意：切分的字符串一般都是临时拷贝的内容，且切分的时候会改变被操作i的字符串

int main()
{
	char arr[] = "zpengwei@bitedu.com";
	char buf[200] = { 0 };
	strcpy(buf, arr);
	const char* p = "@.";//两个分隔符："@","."
	char* str = NULL;
	for (str = strtok(buf, p);str!=NULL;str = strtok(NULL,p))
	{
		printf("%s\n", str);
	}
	//zpengwei bitedu com
	return 0;
} 

strerror()

char * strerror(int errnum)

功能：获取指向错误消息字符串的指针
参数：错误号
返回值：描述错误的错误字符串的指针

#include <errno.h>
int main()
{
	//把错误码转换成错误信息
	//printf("%s\n", strerror(0));
	错误码记录到错误码的变量之中 
	errno-C语言提供的全局错误变量
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	读文件
	fclose(pf);
	pf = NULL;
	return 0; 
}

字符操作

内存操作函数

<一> memcpy（）

void * memcpy(void * destination,const void * source,size_t num)

功能：复制内存块，可以拷贝任何类型数据
参数：destination:指向要在其中复制内容的目标数组，类型转换为void*的指针；source：指向要复制的数据源的指针；size_t num:要复制的字节数
返回值：空指针
注意：memcpy可以拷贝任意类型的数据，但不同的数据之间无法识别，不可跨数据拷贝

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0 };
	memcpy(arr2, arr, 20);//将arr里面的内容拷贝到arr2里面，拷贝5个元素（20个字节）
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;

模拟实现mercpy

关键点：

• void可以接受任意类型的指针，但void类型的指针不可以解引用，所以对于dest和char指针需要强制类型转换，以字节为单位
• 不能直接强制转换再++，这样的指针是不作用于++的
• num是拷贝的字节数，用来控制循环的次数
• dest在最后已经达到了拷贝的最后一个字符的地址，所以要用ret来存放dest首元素既首字符的地址，最后直接打印便可
• 定义指针为空，返回值可以接受也可以不接受

1.*(char*)dest++

void * my_mercpy(void*dest,void*src,size_t num)
{
	void* ret = dest;
	assert(dest&&src);
	while(num--)//决定拷贝次数
	{	
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}

<2>memmove()

void * memmove(void * destination,const void* source , size_t num)

功能: 拷贝重叠数据
参数:destination:要在其中复制内容的指针
source:要指向复制的数据源指针
size_t:要复制的字节数

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0 };//要标注好空间，不然会越界访问出去
	memmove(arr1, arr2, 20);
	int i = 0;
	for (i = 0; i <10; i++)
	{
		printf("%d ", arr1[i]);
		//0 0 0 0 0 6 7 8 9 10
	}
	return 0;
}

模拟实现memmove

void* my_memmove(void* dest, void* src, size_t num)//void接受任何类型的指针
{
	void* ret = dest;//保留首个元素地址
	assert(dest);
	assert(src);
	if (dest < src)
	{
		while (num--)
		{
			//*dest = *src//void*类型的指针不可以直接解引用
			*(char*)dest = *(char*)src;
			/*(char*)dest++;*///强制类型转换的指针是不作用于++的
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	return ret;
}

<3>memcmp()

int memcmp(const void* ptr1,const void * ptr2 ,size_t num);

功能:比较大小(可以比较各种类型数据的大小)
参数:ptr1,ptr2:指向内存块的指针,不限类型; size_t num:比较的字节个数.
返回值:和strcmp一样*

/*在这里插入代码片* memcmp example */
#include <stdio.h>
#include <string.h>

int main ()
{
  char buffer1[] = "DWgaOtP12df0";
  char buffer2[] = "DWGAOTP12DF0";

  int n;

  n=memcmp ( buffer1, buffer2, sizeof(buffer1) );

  if (n>0) printf ("'%s' is greater than '%s'.\n",buffer1,buffer2);
  else if (n<0) printf ("'%s' is less than '%s'.\n",buffer1,buffer2);
  else printf ("'%s' is the same as '%s'.\n",buffer1,buffer2);
//'DWgaOtP12df0' is greater than 'DWGAOTP12DF0'

  return 0;
}

<4>memset()

void * memset(void*ptr,int value,size_t num)

功能:填充内存块,将ptr所指向的内存块的前Num个字节设置为指定的值
参数:ptr:指向要填充的内存指针;value:要填充的值;size_t num:要填充的字节数
返回值:返回ptr

int main()
{
	int arr[] = { 1,2,3,4,5 };
	memset(arr, 0, 8);//将数组前8个字节（前两个元素）全都改为0，以字节为单位修改
	for (int i = 0; i < 5; i++)
	{
		printf("%d", arr[i]);
		//0 0 3 4 5
	}
}