宝子，你不点个赞吗？不评个论吗？不收个藏吗？

最后的最后，关注我，关注我，关注我，你会看到更多有趣的博客哦！！！

喵喵喵，你对我真的很重要。

前言

知识导图

字符串的使用

strlen

const

strlen的应用

strlen的模拟实现

assert

strcpy

strcpy的应用

strcpy的模拟实现

strcat

strcat的应用及模拟实现

strcmp

strcmp的应用及模拟实现

strncpy

strncpy的应用

strncat

strncat的应用

strncmp

strncmp的应用

strstr

strstr的应用及模拟实现

strtok

strtok的应用及模拟实现

strerror

字符分类函数

字符分类函数的应用：

字符转换：

memcpy

memcpy的模拟实现

memmove

memmove的应用及模拟实现

memcmp

memcmp的模拟实现（VS下进行）

memset

memset的应用

总结

前言

啊哒，想小喵没？喵喵喵~，小喵想死你啦。

这一次我们学习字符函数和字符串的函数，及其模拟实现，了解一个库函数的前世今生。额，一共有14个库函数，多吧，乱吧，小喵画个知识导图吧！学习每个库函数时，我们大体的思路是它是什么，有什么作用，注意事项，函数模拟实现。

啊，当然啦，为什么跳过三轮的第二章呢？来上图

瞧见没，准备搞一键透彻，内容不出意外，会非常多，小喵倒时会分一分，一次搞定，还是多轮食用，全看宝子自己。一定要看啊。不要像小喵一样，摆烂，白天的债，晚上还。呜呜，小喵想呼死自己，不争气的玩意。

那么，宝子，我们开始吧！

知识导图

字符串的使用

C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中。

字符串常量适用于那些对它不做修改的字符串函数.

有点晕哈，宝子，你细品，品不出来就往下看，看完回头，会明朗许多。

strlen

const

它在这个代码中的作用是保证str不变，定死了的。

const是一个C语言（ANSI C）的关键字，具有着举足轻重的地位。它限定一个变量不允许被改变，产生静态作用。使用const在一定程度上可以提高程序的安全性和可靠性。另外，在观看别人代码的时候，清晰理解const所起的作用，对理解对方的程序也有一定帮助。

strlen的作用和sizeof很像，C语言中strlen 函数用来求字符串的长度（包含多少个字符）。

注意事项：

字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包含 '\0' )。
参数指向的字符串必须要以 '\0' 结束。
注意函数的返回值为size_t，是无符号的（易错）

strlen的应用

#include <stdio.h>
int main()
{
 const char*str1 = "abcdef";
 const char*str2 = "bbb";
 if(strlen(str2)-strlen(str1)>0)
 {
 printf("str2>str1\n");
 } 
 else
 {
 printf("srt1>str2\n");
 }
 return 0;
}

strlen的模拟实现

assert

它在这个代码中的作用是保证str不能等于零。

编写代码时，我们总是会做出一些假设，断言就是用于在代码中捕捉这些假设，可以将断言看作是异常处理的一种高级形式。断言表示为一些布尔表达式，程序员相信在程序中的某个特定点该表达式值为真。可以在任何时候启用和禁用断言验证，因此可以在测试时启用断言，而在部署时禁用断言。同样，程序投入运行后，最终用户在遇到问题时可以重新启用断言。使用断言可以创建更稳定，品质更好且不易于出错的代码。

strcpy

char* strcpy(char * destination, const char * source )
//destination是一个英语单词，名词，作名词时意为“目的地，终点”。（结果）
//source是一个英语单词，解释是（河的）源头；水源，引申意思为出处等意思。（输入值）

strcpy，即string copy（字符串复制）的缩写。

strcpy是C++语言的一个标准函数，strcpy把含有'\0'结束符的字符串复制到另一个地址空间，返回值的类型为char*。

在C语言函数中：

原型声明：char *strcpy(char* dest, const char *src);

头文件：#include <string.h> 和 #include <stdio.h>

功能：把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间

说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。

返回指向dest的指针。

注意事项：

将源指向的 C 字符串复制到目标指向的数组中，包括终止空字符（并在该点停止）
源字符串必须以 '\0' 结束。
会将源字符串中的 '\0' 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可变。

strcpy的应用

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <string.h>


int main()
{
	char arr1[20] = "";
	//char* p = "abcdefghiqwer";
	char arr2[] = "hello bit";
	my_strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

strcpy的模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <string.h>

char* my_strcpy(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest && src);
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

int main()
{
	char arr1[20] = "";
	//char* p = "abcdefghiqwer";
	char arr2[] = "hello bit";
	my_strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

strcat

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

strcat

原型

extern char *strcat(char *dest, const char *src);

用法

#include <string.h>

头文件

在C中，函数原型存在 <string.h>头文件中。

在C++中，则存在于<cstring>头文件中。

功能

把src所指向的字符串（包括“\0”）复制到dest所指向的字符串后面（删除*dest原来末尾的“\0”）。要保证*dest足够长，以容纳被复制进来的*src。*src中原有的字符不变。返回指向dest的指针。

举个栗子

将两个char类型连接。

例如：

char d[20]="Golden";

char s[20]="View";

strcat(d,s);

//打印d

printf("%s",d);

输出 d 为 GoldenView （中间无空格）

d和s所指内存区域不可以重叠且d必须有足够的空间来容纳s的字符串。

返回指向d的指针。

Appends a copy of the source string to the destination string. The terminating null character in destination is overwritten by the first character of source, and a null-character is included at the end of the new string formed by the concatenation of both in destination.（翻译：将源字符串的副本追加到目标字符串。目标中的终止空字符被源的第一个字符覆盖，并且在目标中由两者串联形成的新字符串的末尾包含一个空字符。)
源字符串必须以 '\0' 结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。字符串自己给自己追加，如何？会出现错误，重复，达不到预期效果

strcat的应用及模拟实现

char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);
	char* ret = dest;

	//1. 找目标空间的\0
	while (*dest)
	{
		dest++;
	}
	//2. 追加
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

int main()
{
	char arr[20] = "hello ";
	//char arr2[] = "world";
	char* p = "world";
	my_strcat(arr, p);

	printf("%s\n", arr);

	return 0;
}

strcmp

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

strcmp函数是string compare(字符串比较)的缩写，用于比较两个字符串并根据比较结果返回整数。基本形式为strcmp(str1,str2)，若str1=str2，则返回零；若str1<str2，则返回负数；若str1>str2，则返回正数。

当s1<s2时，返回为负数；

当s1=s2时，返回值= 0；

当s1>s2时，返回正数。

即：两个字符串自左向右逐个字符相比（按ASCII值大小相比较），直到出现不同的字符或遇'\0'为止。

注意事项：

This function starts comparing the first character of each string. If they are equal to each other, it continues with the following pairs until the characters differ or until a terminating null-character is reached.（翻译：此函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续以下对，直到字符不同或达到终止空字符。）
标准规定：

第一个字符串大于第二个字符串，则返回大于0的数字

第一个字符串等于第二个字符串，则返回0

第一个字符串小于第二个字符串，则返回小于0的数字

strcmp的应用及模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <string.h>

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
			return 0;
		str1++;
		str2++;
	}
	/*if (*str1 > *str2)
		return 1;
	else
		return -1;*/
	return *str1 - *str2;
}


int main()
{
	char arr1[] = "abq";
	char arr2[] = "abcdef";
	//VS环境下：
	//> 1 
	//= 0 
	//< -1
	int ret = my_strcmp(arr1, arr2);

	if (ret > 0)
		printf("arr1>arr2\n");

	printf("%d\n", ret);

	return 0;
}

接下来三个多“n”的库函数，用法是和前面几个函数一样的，唯独区别就是使用参数上，可以规定作用到具体的字符

strncpy

注意事项：

Copies the first num characters of source to destination. If the end of the source C string (which is signaled by a null-character) is found before num characters have been copied, destination is padded with zeros until a total of num characters have been written to it.（翻译：将源的第一个字符数复制到目标。如果在复制 num 个字符之前找到源 C 字符串的末尾（由 null 字符表示），则目标将填充零，直到总共写入 num 个字符为止。）
拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

strncpy的应用

建议调试，用监视窗口看更明显

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <string.h>

 int main()
{
	char arr1[20] = "xxxxxxxxxxxxxx";
	strncpy(arr1, "abcdef", 10);
	printf("%s\n", arr1);
	return 0;
}

strncat

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

Appends the first num characters of source to destination, plus a terminating null-character. If the length of the C string in source is less than num, only the content up to the terminating null-character is copied（翻译：将源的第一个数字字符追加到目标，外加一个终止空字符。如果源中 C 字符串的长度小于 num，则仅复制终止空字符之前的内容）

strncat的应用

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
//#include <assert.h>
#include <string.h>
int main()
{
	char arr1[20] = "abc\0xxxxxxxx";
	strncat(arr1, "defqwer", 4);
	printf("%s\n", arr1);

	return 0;
}

变化有点小，要仔细看哦，最好从监视窗口看，会很不错。

strncmp

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

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

strncmp的应用

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
//#include <assert.h>
#include <string.h>
int main()
{
	char* p1 = "abcdef";
	char* p2 = "abcqwer";
	int ret = strncmp(p1, p2, 4);
	printf("%d\n", ret);
	return 0;
}

strstr

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

strstr

strstr(str1,str2) 函数用于判断字符串str2是否是str1的子串。如果是，则该函数返回 str1字符串从 str2第一次出现的位置开始到 str1结尾的字符串；否则，返回NULL。

函数原型：string strstr( string1，string2)

功能：strstr返回一个指针，指向string2在string1中首次出现的位置。

返回类型：字符串类型

Returns a pointer to the first occurrence of str2 in str1, or a null pointer if str2 is not part of str1.（翻译：返回指向 str1 中第一次出现的 str2 的指针，如果 str2 不是str1.）

有点乱哈，它的作用就是str2是否在str1里重复

strstr的应用及模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <string.h>
char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	if (*str2 == '\0')
	{
		return (char*)str1;
	}
	const char* s1 = NULL;
	const char* s2 = NULL;
	const char* cp = str1;

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

	return NULL;
}

int main()
{
	char arr1[] = "abbbcdbbcef";
	char arr2[] = "bbc";
	char* ret = my_strstr(arr1, arr2);

	if (ret == NULL)
	{
		printf("找不到\n");
	}
	else
	{
		printf("%s\n", ret);
	}

	return 0;
}

strtok

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

原型：

char *strtok(char s[], const char *delim);

功能：

strtok()用来将字符串分割成一个个片段。参数s指向欲分割的字符串，参数delim则为分割字符串中包含的所有字符。

例如：strtok("abc,def,ghi",",")，最后可以分割成为abc def ghi.尤其在点分十进制的IP中提取应用较多。

strtok的函数原型为char *strtok(char *s, char *delim)，功能为“Parse S into tokens separated by characters in DELIM.If S is NULL, the saved pointer in SAVE_PTR is used as the next starting point. ” 翻译成汉语就是：作用于字符串s，以包含在delim中的字符为分界符，将s切分成一个个子串；如果，s为空值NULL，则函数保存的指针SAVE_PTR在下一次调用中将作为起始位置。

说明

strtok()用来将字符串分割成一个个片段。参数s指向欲分割的字符串，参数delim则为分割字符串中包含的所有字符。当strtok()在参数s的字符串中发现参数delim中包含的分割字符时,则会将该字符改为\0 字符。在第一次调用时，strtok()必需给予参数s字符串，往后的调用则将参数s设置成NULL。每次调用成功则返回指向被分割出片段的指针。

返回值：

从s开头开始的一个个被分割的串。当s中的字符查找到末尾时，返回NULL。

如果查找不到delim中的字符时，返回当前strtok的字符串的指针。

所有delim中包含的字符都会被滤掉，并将被滤掉的地方设为一处分割的节点。

注意事项：

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

strtok的应用及模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <string.h>
 int main()
{
	char arr[] = "miaomiao@yeah.net";//"@."
	char arr[] = "192#168.120.85";
	char* p = "#.";
	char buf[20] = { 0 };
	strcpy(buf, arr);
	char* ret = NULL;
	for (ret = strtok(buf, p); ret != NULL; ret=strtok(NULL, p))
	{
		printf("%s\n", ret);
	}
	
	/*char* ret = strtok(buf, p);
	printf("%s\n", ret);
	ret = strtok(NULL, p);
	printf("%s\n", ret);
	ret = strtok(NULL, p);
	printf("%s\n", ret);*/
	return 0;
}

strerror

char * strerror ( int errnum )

strerror

通过标准错误的标号，获得错误的描述字符串，将单纯的错误标号转为字符串描述，方便用户查找错误。

函数名：

strerror, _strerror, _wcserror, __wcserror

函数作用：

Get a system error message (strerror, _wcserror) or prints a user-supplied error message (_strerror, __wcserror).

获取系统错误信息或打印用户程序错误信息。

头文件：

#include <errno.h>

#include <string.h>

strerror的应用

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <string.h>
//C语言的库函数在运行的时候，如果发生错误，就会将错误码存在一个变量中，这个变量是：errno
//错误码是一些数字：1 2 3 4 5 
//我们需要讲错误码翻译成错误信息
//
int main()
{
	printf("%s\n", strerror(0));
	printf("%s\n", strerror(1));
	printf("%s\n", strerror(2));
	printf("%s\n", strerror(3));
	printf("%s\n", strerror(4));
	printf("%s\n", strerror(5));

	return 0;
}

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <string.h>
 #include <errno.h>

int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		//printf("%s\n", strerror(errno));
		perror("fopen");
		return 1;
	}
	//读文件
	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

字符分类函数

函数如果他的参数符合下列条件就返回真

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 任何可打印字符，包括图形字符和空白字符

这几个函数使用方法是一样的。

字符分类函数的应用：

#include <string.h>
 #include <errno.h>
#include <ctype.h>
int main()
{
	char arr[] = "I Have An Apple.";
	int i = 0;
	while (arr[i])
	{
		if (isupper(arr[i]))
		{
			arr[i] = tolower(arr[i]);
		}
		printf("%c", arr[i]);
		i++;
	}
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <string.h>
 #include <errno.h>
#include <ctype.h>

int main()
{
	int ret = isdigit('Q');
	printf("%d\n", ret);

	return 0;
}

字符转换：

int tolower ( int c )

int toupper ( int c )

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <string.h>
 #include <errno.h>
#include <ctype.h>
int main()
{
	printf("%c\n", toupper('a'));
	printf("%c\n", tolower('A'));

	return 0;
}

memcpy

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

memcpy

memcpy指的是C和C++使用的内存拷贝函数，函数原型为void *memcpy(void *destin, void *source, unsigned n)；函数的功能是从源内存地址的起始位置开始拷贝若干个字节到目标内存地址中，即从源source中拷贝n个字节到目标destin中。

参数：

destin-- 指向用于存储复制内容的目标数组，类型强制转换为 void* 指针。

source-- 指向要复制的数据源，类型强制转换为 void* 指针。

n-- 要被复制的字节数。

返回值：

该函数返回一个指向目标存储区destin的指针。

功能：

从源source所指的内存地址的起始位置开始拷贝n个字节到目标destin所指的内存地址的起始位置中。

头文件：

C语言：#include<string.h>

C++：#include<cstring>

注意事项：

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

memcpy的应用

/* memcpy example */
#include <stdio.h>
#include <string.h>
struct {
  char name[40];
  int age;
} person, person_copy;
int main ()
{
  char myname[] = "Pierre de Fermat";
  /* using memcpy to copy string: */
  memcpy ( person.name, myname, strlen(myname)+1 );
  person.age = 46;
  /* using memcpy to copy structure: */
  memcpy ( &person_copy, &person, sizeof(person) );
  printf ("person_copy: %s, %d \n", person_copy.name, person_copy.age );
  return 0;
}

memcpy的模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <string.h>
 #include <errno.h>
#include <ctype.h>

void* my_memcpy(void* dest, const 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;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0 };
	//内存拷贝-memcpy
	//    int*   int*
	my_memcpy(arr2, arr1 + 2, 17);
	//01 00 00 00 02 00 00 00 03 00 00 00
}

memmove

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

memmove

memmove用于拷贝字节，如果目标区域和源区域有重叠的话，memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中，但复制后源内容会被更改。但是当目标区域与源区域没有重叠则和memcpy函数功能相同。

头文件：<string.h>

功能：由src所指内存区域复制count个字节到dest所指内存区域。

注意事项：

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

memmove的应用及模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <string.h>
 #include <errno.h>
#include <ctype.h>
void* my_memmove(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(dest && src);
	if (dest < src)
	{
		//前-->后
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		//后->前
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}

	return ret;
}

void test3()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr1+2, arr1, 20);
}
int main()
{
	test3();
	return 0;
}

memcmp

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

memcmp：

memcmp函数的原型为 int memcmp(const void *str1, const void *str2, size_t n);其功能是把存储区 str1 和存储区 str2 的前 n 个字节进行比较。该函数是按字节比较的，位于string.h。

注意事项：

比较从ptr1和ptr2指针开始的num个字节
返回值如下：
如果返回值 < 0，则表示 str1 小于 str2。

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

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

memcmp的应用

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <string.h>
 #include <errno.h>
#include <ctype.h>
int main()
{
	int arr1[] = { 1,2,6 };//01 00 00 00 02 00 00 00 06 00 00 00
	int arr2[] = { 1,2,5 };//01 00 00 00 02 00 00 00 05 00 00 00
	int ret = memcmp(arr1, arr2, 9);
	printf("%d\n", ret);

	return 0;
}