字符串函数以及模拟实现

• 一.字符串函数
• • 1.1 strlen
  • 1.2 strcpy
  • 1.3 strcat
  • 1.4 strcmp
  • 1.5 strncpy
  • 1.6 strncat
  • 1.7 strncmp
  • 1.8 strstr
  • 1.9 strtok
  • 1.10 strerror
  • 1.11 memcpy
  • 1.12 memmove
  • 1.13 memcmp

size_t strlen(const char* str)

注意：
1.字符串必须以''结尾
2.strlen返回类型为size_t，即unsigned int
3.strlen函数计算的是第一个''前的字符个数（不包括''）

//模拟实现
size_t my_strlen(const char* arr)
{
	assert(arr);            //断言，不为空指针
	size_t count = 0;       //类型为size_t
	while (*arr++ != '')  //先判断，后++
		count++;
	return count;
}

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

注意：
1.源字符串必须以''结尾
2.会将''拷贝进目标字符串
3.目标空间必须足够大，保证能正常复制
4.目标空间必须可变（？）

//模拟实现
char* my_strcpy(char* dest, const char* source)
{
	assert(dest && source);
	char* ret = dest;               //创建一个变量记录目标字符串的起始位置
	while (*dest++ = *source++)     //将''复制过去后while判断为0，结束循环
		;
	return ret;
}

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

注意：
1.该函数为字符串追加函数，如在"hello"后面追加"world"
2.返回值为目标字符串的首字符地址
3.目标空间必须足够大，且可以改变
4.源字符串必须以''结尾

重点：
字符串追加不能自己加自己
因为在追加时会破坏自己本来的数据，即’’被破坏，无法停下

//模拟实现
char* my_strcat(char* dest, const char* source)
{
	assert(dest && source);
	char* ret = dest;
	//while (*dest++ != '')
	//	;
	//如果用上面那个，则当*dest==''时dest又加了一次
	while (*dest != '')
	{
		dest++;
	}
	while (*dest++ = *source++)
		;
	return ret;
}

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

strcmp()函数的功能是比较两个字符串，从两个字符串的第一个字符开始比较，比较ASCII值大小，
如果相同则比较下一对字符，知道比出结果或者碰到字符串末尾

注意：
1.第一个字符串大于第二个字符串，则返回大于0的数字
2.如果相同，则返回0
3.第一个字符串小于第二个字符串，则返回小于0的数字

//模拟实现
int my_strcmp(const char* arr1, const char* arr2)
{
	assert(arr1 && arr2);
	while (*arr1 == *arr2)
	{
		if (*arr1 == '')
			return 0;
		arr1++;
		arr2++;
	}
	return *arr1 - *arr2;
}

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

注意:
1.拷贝num个字符从源字符串到目标空间
 （与strcpy类似，但可以控制拷贝的字符个数）
2.如果源字符串的长度小于num，则拷贝完字符串之后，在目标的后面追加0，直到num

//模拟实现
char* my_strncpy(char* destination, const char* source,size_t num)
{
	assert(destination && source);
	char* cmp = destination;
	while (num)
	{
		if (*source != '')
			*destination++ = *source++;
		else
			*destination++ = '';
		num--;
	}
	return cmp;
}

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

与strcat函数类似，但可以控制追加字符的个数，如果源字符串长度小于num，则在后面补0，直到num

//模拟实现
char* my_strncat(char* destination, char* source, size_t num)
{
	assert(destination && source);
	char* tmp = destination;
	while (*destination)
		destination++;
	while (num)
	{
		if (*source != '')
			*destination++ = *source++;
		else
			*destination++ = '';
		num--;
	}
	*destination = '';
	return tmp;
}

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

比较到出现字符不一样或者一个字符串结束或者num个字符全部比较完

//模拟实现
int my_strncmp(const char* str1, const char* str2, size_t num)
{(c
	while (*str1==*str2 && num)
	{
		if (*str1 == '')
			return 0;
		str1++;
		str2++;
		num--;
	}
	if (num == 0)
		return 0;
	return *str1 - *str2;
}

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

注意：
1.该函数是在一个字符串中找到子字符串的起始位置
2.如果没有找到，则返回NULL

//模拟实现
char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	const char* arr1 = str1;
	const char* arr2 = str2;
	const char* p = str1;
	while (*p)
	{
		p = arr1;
		while (*arr1!='' && *arr1 == *arr2 && *arr2!='')
		{
			arr1++;
			arr2++;
		}
		if (*arr2 == '')
			return (char*)p;
		arr1 = p + 1;
		arr2 = str2;
	}
	return NULL;
}

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

注意:
1.sep参数是个字符串，定义了用作分隔符的字符集合
2.strtok函数找到str中的下一个标记，并将其用  结尾，返回一个指向这个标记的指针。      
  (strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
3.strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
4.strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
5.如果字符串中不存在更多的标记，则返回 NULL 指针。

//运行案例
int main ()
{
    char str[] ="- This, a sample string.";
    char * pch;
    printf ("Splitting string "%s" into tokens:n",str);
    pch = strtok (str," ,.-");
    while (pch != NULL)
    {
        printf ("%sn",pch);
        pch = strtok (NULL, " ,.-");
    }
    return 0;
}

char* strerror(int errnum)
作用：返回错误码所对应的错误信息

注意：
1.头文件为 #include
2.errno-> c语言设置的一个全局的错误码存放的变量
  当出现错误时，会将错误码自动存在errno中

//使用案例
FILE* pf=fopen("test.txt","r");
if(pf==NULL)
{
      printf("%sn",strerror(errno));
}

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

注意：
1.函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
2.这个函数在遇到 '' 的时候并不会停下来。
3.如果source和destination有任何的重叠，复制的结果都是未定义的。

//模拟实现
void* my_memcpy(void* dest, const void* soc, size_t sz)
{
	assert(dest && soc);
	void* ret = dest;
	while (sz--)
	{
		*((char*)dest) = *((char*)soc);
		(char*)dest = (char*)dest + 1;
		(char*)soc = (char*)soc + 1;
	}
	return ret;
}

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

注意：
1.和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
2.如果源空间和目标空间出现重叠，就得使用memmove函数处理。

//模拟实现
//处理有重叠的两个字符串时，想法就是考虑在区域还没被复制时就已经操作完成
//所以这时候考虑从前往后复制还是从后往前复制

void* my_memmove(void* dest, const void* sorc, size_t sz)
{
	assert(dest && sorc);
	void* ret = dest;
	if (sorc >= dest)
	{
		while (sz--)
		{
			*((char*)dest) = *((char*)sorc);
			(char*)dest = (char*)dest + 1;
			(char*)sorc = (char*)sorc + 1;
		}
	}
	else
	{
		while (sz--)
			*((char*)dest + sz) = *((char*)sorc + sz);
	}
	return ret;
}

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

作用：比较从ptr1和ptr2指针开始的num个字节
注意：
1.memcmp不会碰到''停下
2.num不能超过两个比较对象的字节大小