字符串的使用

字符串的三种表达形式：

char *ptr = "abcdfef" ;  //字符串常量，存放在常量区
char ptr[] = "abcd";//    strlen(ptr)-->5
char ptr[] = {'a','b','c','d','\n'};    //和第二个是一个意思
char ptr[] = {'a','b','c','d'};      strlen(ptr)------>随机值，因为没有\n; 

• size_t strlen ( const char * str );
  字符串已经 ‘\0’ 作为结束标志，strlen是指字符串\0之前有多少个字符

int mystrlen(const char* src)   //方式1
{
	if (NULL == src)
		return 0;
	int cout = 0;
	while (*src)
	{
		cout++;
		src++;
	}
	return cout;

}
int mystrlen(const char* src)   //方式2
{
	const char* cur = src;
	if (src == NULL)
		return 0;
	while (*src)
	{
		src++;
	}
	return src - cur; 
}

• char* strcat(char* des,const char* src)

将两个char类型连接。
char d[20]=“GoldenGlobal”; char *s=“View”; strcat(d,s);
结果放在d中
printf（"%s",d）；
输出 d 为 GoldenGlobalView （中间无空格）

char *my_strcat( char* dest,char*src)
{
	assert(dest);
	assert(src);
	char *ret = dest;
	while (*dest)
	{
		dest++;
	}
	while (*dest++=*src++)
	{
		;
	}

	return ret;


}

• int strcmp ( const char * str1, const char * str2 );
  标准规定：
  第⼀个字符串⼤于第⼆个字符串，则返回⼤于0的数字
  第⼀个字符串等于第⼆个字符串，则返回0
  第⼀个字符串⼩于第⼆个字符串，则返回⼩于0的数字

int  mystrcmp(const char* str1,const char* str2)
{
	if (str1 != NULL &&str2 != NULL)
	{
		while (*str1 && *str2)
		{
			if (*str1 > *str2)

			{
				return 1;
			}
			else if (*str1 < *str2)

			{
				return -1;
			}
			else
			{
				str1++;
				str2++;
			}
			  
		}
		if (*str1 == '\0' && *str2 == '\0')   //易错点，是判断谁先遇到\0，而不是谁先为空
			return 0;
		else if (*str1 == '\0'&& *str2 != '\0')
			return -1;
		else
			return 1;

		

	}
}

• char* strcpy(char* des,const char* src)

char arr[100] = "abc";
   char* arr1 = "ab"
   strcpy(arr,arr1);  //拷贝完，arr是ab;以第二个字符串的\0为截止

char* mystrcpy(char* str1, const char* str2)    //停在原串的\n
{
	if (str1 != NULL && str2 != NULL)
	{
		char *pcur = str1;
		while (*str2)   
		{
			*pcur = *str2;
			pcur++;
			str2++;
		}
		return pcur;
	}
}

内存操作函数

strcpy和memcpy都是标准C库函数，它们有下面的特点。
strcpy提供了字符串的复制。即strcpy只用于字符串复制，并且它不仅复制字符串内容之外，还会复制字符串的结束符。

已知strcpy函数的原型是：char* strcpy(char* dest, const char* src);
memcpy提供了一般内存的复制。即memcpy对于需要复制的内容没有限制，因此用途更广。

void * memcpy ( void * destination, const void * source, size_t num );
函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
这个函数在遇到 '\0' 的时候并不会停下来。
但是处理不了源地址和目标地址的重叠部分

-void* memcpy(char* des,const char* src,size_t num)

void * memcpy(void* des,const void* src,size_t num)
{
	char *ret =(char*) des;
	char *p = (char *)des;
	char *q = (char *)src;   //给定指针，按字节来一个一个拷贝
	while (num--)
	{
		*p = *q;
		p++, q++;
	}
	return ret;

}

• void* memove(void* des,const void* src,size_t num) //处理内存重叠的问题

void* my_memove(void *dest, const void *src, int size) //解决内存重叠问题，即两块内存独立时可以任意拷贝，但两块内存重叠时就要分类拷贝

{
	char *ret = dest;
	char *p =(char*) dest;
	char *q = (char*)src;
	if ((q<p) && (q + size>p))  //从右向左拷
	{ 

		p = p + size - 1;
		q = q + size - 1;
		while (size--)
		{
			*p = *q;
			p--, q--;
		}

	}
	else                //其余情况都是从左向右拷
	{
		while (size--)
		{
			*p = *q;
			p++, q++;
		}
	}
	return  ret;
}