字符函数与字符串函数模拟

---

前言

提示：在上一节中，我们已经介绍了一些字符函数并了解了其功能。接下来，我们便讨论剩余的字符串函数，便通过模拟实现函数加深印象。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、字符函数

strtok

char * strtok ( char * str, const char * sep );
strtok函数用来分隔由分隔符链接的字符串。如1122334455@qq.com
使用strtok函数可以依次分割成1122334455，qq，com。

1、sep参数是个字符串，定义了用作分隔符的字符集合
2、第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个
或者多个分隔符分割的标记。
3、strtok函数找到str中的一个分隔符，将其用 \0 替换，返回一个指向这个标记
的指针，下次分割时直接从上次的地址开始。（注：strtok函数会改变被操作的字
符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改）
4、strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，
strtok函数将保存它在字符串中的位置。
5、strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置
开始，查找下一个标记。
6、如果字符串中不存在更多的标记，则返回 NULL 指针。

代码如下（示例）：

#include <stdio.h>
int main()
{
   char *p = "11223334455@qq.com";
 const char* sep = ".@";
 char arr[30];
 char *str = NULL;
 strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容
 for(str=strtok(arr, sep); str != NULL; str=strtok(NULL, sep))
 {
 printf("%s\n", str);
 }
}

---

strerror

char * strerror ( int errnum );
返回错误码所对应的错误
#include <errno.h>//必须包含的头文件

代码如下（示例）：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <errno.h>
int main()
{
	char* str = strerror(0);
	//printf("%s\n", str);
	printf("%s\n", str);
		//错误码  错误信息
	//0 -     No error
	//1 -     Operation not permitted
	//2 -     No such file or directory
	//...
	//errno 是一个全局的错误码的变量
	//当C语言的库函数在执行过程中，发生了错误，就会把对应的错误码，赋值到errno中
	
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));
	}
	else
	{
		printf("open file success\n");
	}
	return 0;
}

字符分类函数

代码如下（示例）：

#include <ctype.h>

int main()
{
	//char ch = '2';
	int ret = islower(ch);//转小写
	//int ret = isdigit(ch);//转大写
	//printf("%d\n", ret);

	//char ch = tolower('q');
	//char ch = toupper('q');
	//putchar(ch);
	char arr[] = "I Am A Student";
	int i = 0;
	while (arr[i])
	{
		if (isupper(arr[i]))
		{
			arr[i] = tolower(arr[i]);
		}
		i++;
	}
	printf("%s\n", arr);
	return 0;
}

---

memcpy

memcpy可以拷贝任意类型的字符串给另一不同地址的字符串
void * memcpy ( void * destination, const void * source, size_t num ); 
函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
这个函数在遇到 '\0' 的时候并不会停下来。
如果source和destination有任何的重叠，复制的结果都是未定义的

代码如下（示例）：

struct S
{
	char name[20];
	int age;
};
void* my_memcpy(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(dest != NULL);
	assert(src != NULL);

	while (num--)
	{
		*(char*)dest = *(char*)src;
		++(char*)dest;
		++(char*)src;
	}
	return ret;
}

---

memmove

void * memmove ( void * destination, const void * source, size_t num ); 
和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove函数

代码如下（示例）：

/* memmove example */ 
#include <stdio.h> 
#include <string.h> 
int main () 
{ 
 char str[] = "memmove can be very useful......"; 
 memmove (str+20,str+15,11); 
 puts (str); 
 return 0; 
}

---

memcmp

 memcmp ( const void * ptr1,  const void * ptr2,  size_t num ); 
memcmp函数可以比较指定字节，由形参size_num决定

代码如下（示例）：

#include <string.h>
int main()
{
 	int arr1[] = { 1, 2, 3, 4, 5};
 	int arr2[] = { 1, 2, 5, 4, 3};
 	int ret = memcmp(arr1, arr2, 8)
 	printf("%d\n",ret);//0
 	return 0;
}

二、字符函数模拟

strlen模拟

//指针-指针的方式 
int my_strlen(char* str)
{
	char* p = str;
	while (*str != '\0')
	{
		p++;
	}
	return p - str;
}

//不能创建临时变量计数器
int my_strlen(const char* str)
{
	if (*str == '\0') return 0; else return 1 + my_strlen(str + 1);
}

//计数器方式 
int my_strlen(const char* str)
{
	int count = 0;
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}

strcpy模拟

#include <assert.h>
char* my_strcpy(char* dest, const char* src) {
	char* ret = dest; assert(dest != NULL); 比特科技
		assert(src != NULL);

	while ((*dest++ = *src++))
	{
		;
	}
	return ret;
}

strcat模拟

#include <assert.h>
char *my_strcat(char *dest, const char*src) 
{ 
 char *ret = dest; 
 assert(dest != NULL); 
 assert(src != NULL); 
 while(*dest) 
 { 
 dest++; 
 } 
 while((*dest++ = *src++)) 
 { 
 ; 
 } 
 return ret; 
}

strcmp模拟

//模拟实现strcmp
#include <assert.h>
int my_strcmp(const char* src, const char* dest)
{
	int ret = 0;
	assert(src != NULL);
	assert(dest != NULL);
	while (!(ret = *(unsigned char*)src - *(unsigned char*)dst) && *dst)
		++src, ++dst;
	if (ret < 0)
		ret = -1;
	else if (ret > 0)
		ret = 1;
	return(ret);
}

strstr模拟

#include <assert.h>
char* my_strstr(const char* str1, const char* str2)
{
	assert(str1);
	assert(str2);

	char* cp = (char*)str1;
	char* substr = (char*)str2;
	char* s1 = NULL;

	if (*str2 == '\0')
		return NULL;

	while (*cp)
	{
		s1 = cp;
		substr = str2;
		while (*s1 && *substr && (*s1 == *substr))
		{
			s1++;
			substr++;
		}
		if (*substr == '\0')
			return cp;
		cp++;
	}
}

memcpy模拟

#include <assert.h>
void* memcpy(void* dst, const void* src, size_t count)
{
	void* ret = dst;
	assert(dst);
	assert(src);
	/*
	* copy from lower addresses to higher addresses
	*/
	while (count--) {
		*(char*)dst = *(char*)src;
		dst = (char*)dst + 1;
		src = (char*)src + 1;
	}
	return(ret);
}

memmove函数模拟

#include <assert.h>
//模拟实现1，有堆栈错误
void my_memmove(void* dest,const void* src, size_t num)
{
	assert(dest != NULL);
	assert(src != NULL);
	int count = num;
	void* p = dest;
	while (num--)
	{
		if (dest > src)
		{
			*((char*)dest + count) = *((char*)src + count);
			--(char*)dest;
			--(char*)src;
		}
		else
		{
			*(char*)dest  = *(char*)src ;
			++(char*)dest;
			++(char*)src;
		}
	}
	return p;
}

//模拟实现2,成功模拟
void my_memmove(void* dest, const void* src, size_t num)
{
	assert(dest != NULL);
	assert(src != NULL);
	int count = num;
	void* p = dest;
		if (dest < src)
		{
			while (count--)
			{
				*((char*)dest ) = *((char*)src );
				++(char*)dest;
				++(char*)src;
			}
		}
		else
		{
			while (count--)
			{
				*((char*)dest + count) = *((char*)src + count);

			}
		}
	return p;
}

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10};
	my_memmove(arr+5,arr,20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}