#define _CRT_SECURE_NO_WARNINGS 1
#include<assert.h>
#include<stdio.h>
//strlen模拟实现


size_t my_strlen(const char* str)
{
	int count = 0;
	assert(str != NULL);
	while (*str !='\0')
	{
		count++;
		str++;
	}
	return count;
}


int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

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

（1）strcpy

strcpy（）字符串拷贝

声明 char *strcpy(char *dest, const char *src)

头文件 #include<string.h>

返回值该函数返回一个指向最终的目标字符串 dest 的指针

注意如果目标数组 dest 不够大，而源字符串的长度又太长，可能会造成缓冲溢出的情况。

下面模拟实现库函数strcpy

//strcpy模拟实现
#include<stdio.h>
#include<assert.h>
char* my_strcpy( char* dest,const char* str)
{
	assert(dest != NULL);
	assert(str != NULL);
	//assert(dest&&str);
	char* ret = dest;
	while (*dest++ = *str++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[20] = {0};
	char* arr2 = "abcdef";
	my_strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

(2) strcat

strcat() 字符串追加

声明 char *strcat(char *dest, const char *src)

头文件 #include<stdio.h>

把 src 所指向的字符串追加到 dest 所指向的字符串的结尾。

下面模拟实现库函数strcat

//strcat模拟实现 连接
#include<stdio.h>
#include<assert.h>
char* my_strcat(char* dest, char* str)
{
	assert(dest && str);
	char* len = dest;//找到目标空间的'\0'
	while (*dest)
	{
		dest++;
	}
	while (*dest++ = *str++)//拷贝
	{
		;
	}
	return len;
}
int main()
{
	char arr1[20] = "hello";
	char arr2[] = " bit";
	printf("%s\n",my_strcat(arr1, arr2));


	return 0;
}

(3) strcmp

strcmp() 字符串比较

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

头文件 #include<stdio.h>

把 str1 所指向的字符串和 str2 所指向的字符串进行比较。

如果返回值小于 0，则表示 str1 小于 str2。

如果返回值大于 0，则表示 str1 大于 str2。

如果返回值等于 0，则表示 str1 等于 str2。

下面模拟实现库函数strcmp

//strcmp模拟实现 比较
#include<stdio.h>
#include<assert.h>
int my_strcmp(const char* dest,const char* str)
{
	assert(dest && str);
	while (*dest == *str)
	{
		//相等
		if (*dest == '\0')
		{
			return 0;
		}
		dest++;
		str++;
	}
	return *dest - *str;
}
int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abq";
	int len=my_strcmp(arr1, arr2);


	if (len > 0)
	{
		printf(">\n");
	}
	else if (len == 0)
	{
		printf("==\n");
	}
	else
	{
		printf("<\n");
	}
	return 0;
}

3. 长度受限制的字符串函数

(1) strncpy

strncpy() 拷贝字符串中有限个字符

声明 char *strncpy(char *dest, const char *src, size_t n)

头文件 #include<string.h>

把 src 所指向的字符串复制到 dest，最多复制 n 个字符。当 src 的长度小于 n 时，dest 的剩余部分将用空字节填充。

(2) strncat

strncat() 追加字符串中有限个字符

声明 char *strncat(char *dest, const char *src, size_t n)

头文件 #include<string,h>

把 src 所指向的字符串追加到 dest 所指向的字符串的结尾，直到 n 字符长度为止。

(3)strncmp

strncmp() 比较字符串的前几个字节

声明 int strncmp(const char *str1, const char *str2, size_t n)

头文件 #include<string.h>

把 str1 和 str2 进行比较，最多比较前 n个字节

如果返回值 < 0，则表示 str1 小于 str2。

如果返回值 > 0，则表示 str1 大于 str2。

如果返回值 = 0，则表示 str1 等于 str2。

4. 字符串查找

(1) strstr

strstr() 在一个字符串中找另一个字符串的子串

声明 char *strstr(const char *haystack, const char *needle)

头文件 #incldue<string.h>

在字符串 haystack 中查找第一次出现字符串 needle 的位置，不包含终止符 ‘\0’。

该函数返回在 haystack 中第一次出现 needle 字符串的位置，如果未找到则返回 null。

下面模拟实现库函数 strstr

//strstr模拟实现 找子字符串
#include<stdio.h>
#include<assert.h>
char* my_strstr(const char* dest, const char* src)
{
	assert(dest && src);
	const char* s1 = dest;
	const char* s2 = src;
	const char* cur = dest;
	while (*cur)
	{
		s1 = cur;
		s2 = src;
		while (*s1 && *s2 && (*s1 == *s2))
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return (char*)cur;
		}
		cur++;
	}
	return NULL;


}
int main()
{
	char str1[] = "abcdef";
	char str2[] = "cde";
	char* len=my_strstr(str1, str2);
	if (NULL == len)
	{
		printf("找不到子串\n");
	}
	else
	{
		printf("%s\n", len);
	}
	return 0;
}

（2）strtok

strtok()

声明 char * strtok ( char * str, const char * sep );

头文件 #include<stdio.h>

sep
参数是个字符串，定义了用作分隔符的字符集合

第一个参数指定一个字符串，它包含了
0
个或者多个由
sep
字符串中一个或者多个分隔符分割的标记

strtok函数会改变被操作的字符串，所以在使用strtok
函数切分的字符串一般都是临时拷贝的内容

strtok
函数的第一个参数不为
NULL
，函数将找到
str
中第一个标记，
strtok
函数将保存它在字符串

中的位置。

strtok
函数的第一个参数为
NULL
，函数将在同一个字符串中被保存的位置开始，查找下一个标记

如果字符串中不存在更多的标记，则返回
NULL
指针。

5.内存操作函数

(1) memcpy

memcpy() 和strncpy特别像但是是实现内存上的拷贝

声明 void *memcpy(void *str1, const void *str2, size_t n)

头文件 #include<string.h>

从存储区 str2 复制 n 个字节到存储区 str1。

下面模拟实现库函数memcpy

//模拟实现memcpy
//实现内存上的拷贝
#include<stdio.h>
#include<assert.h>


void* my_memcpy(void* dest, const void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	while (count--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}


int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[5] = { 0 };
	my_memcpy(arr2, arr1, 20);


	int i = 0;
	int sz = sizeof(arr2) / sizeof(arr2[0]);
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr2[i]);
	}


	return 0;
}

(2) memmove

memmove() 可以实现重叠内存的拷贝

声明 void *memmove(void *str1, const void *str2, size_t n)

头文件 #include<string.h>

从 str2 复制 n 个字符到 str1，但是在重叠内存块这方面，memmove() 是比 memcpy() 更安全的方法。如果目标区域和源区域有重叠的话，memmove() 能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中，复制后源区域的内容会被更改。如果目标区域与源区域没有重叠，则和 memcpy() 函数功能相同。

下面模拟实现库函数memmove

#define _CRT_SECURE_NO_WARNINGS 1
#include<assert.h>
#include<stdio.h>
//模拟实现memmove
void* my_memmove(void* dest, const void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	if (dest < src)
	{
		//前——>后
		while (count--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		//后——>前
		while (count--)
		{
			*((char*)dest + count) = *((char*)src + count);
		}
	}
	return ret;
}
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr1 + 2, arr1, 20);
	//my_memmove(arr1, arr1 + 2, 20);


	int i = 0;
	int sz = sizeof(arr1) / sizeof(arr1[0]);
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr1[i]);
	}


	return 0;
}

(3)memcmp

momcmp() 比较从ptr1和ptr2指针开始的num个字节

声明 int memcmp(const void *str1, const void *str2, size_t n)

头文件 #include<string.h>

把存储区 str1 和存储区 str2 的前 n 个字节进行比较。

(4) memset

memset() 以字节为单位初始化内存单元

声明 void *memset(void *str, int c, size_t n)

头文件 #include<string.h>

参数

str — 指向要填充的内存块。

c — 要被设置的值。该值以 int 形式传递，但是函数在填充内存块时是使用该值的无符号字符形式。

n — 要被设置为该值的字符数。

还有一些字符分类函数

函数	如果他的参数符合下列条件就返回真
iscntrl	任何控制字符
isspace	空白字符：空格 ‘ ’ ，换页 ‘\f’ ，换行 ‘\n’ ，回车 ‘\r’ ，制表符 ‘\t’ 或者垂直制表符 ‘\v’
isdigit	十进制数字 0~9
isxdigit	十六进制数字，包括所有十进制数字，小写字母 a~f ，大写字母 A~F
islower	小写字母 a~z
isupper	大写字母 A~Z
isalpha	字母 a~z 或 A~Z
isalnum	字母或者数字， a~z,A~Z,0~9
ispunct	标点符号，任何不属于数字或者字母的图形字符（可打印）
isgraph	任何图形字符
isprint	任何可打印字符，包括图形字符和空白字符