目录

• 一：strlen
• • 模拟实现：
• 二：strcpy
• • 模拟实现：
• 三：strcat
• • 模拟实现：
• 四：strcmp
• • 模拟实现：
• 五：strncpy
• • 模拟实现：
• 六：strncat
• • 模拟实现：
• 七：strncmp
• • 模拟实现：
• 八：strstr
• • 模拟实现：
• 九：strtok
• • 代码实现：
• 九：strerror
• 十：perror
• 十一：一些字符函数
• • 字符分类函数：
  • 字符转换函数：
• 十二：memcpy
• • 模拟实现：
• 十三：memmove
• • 模拟实现：
• 十四：memcmp
• 十四：memset

成都创新互联公司是专业的鼓楼网站建设公司，鼓楼接单;提供成都做网站、网站制作、成都外贸网站建设,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行鼓楼网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!一：strlen

strlen：计算字符串长度函数
size_t strlen ( const char * str );

注意事项：

• 字符串以'\0'作为结束标志，strlen函数返回值是在字符串中'\0'前面出现的字符个数（不包含'\0'）
• 参数是一个字符指针变量
• 参数指向的字符串必须要以'\0'结束，否则计算出的长度是随机值
• 注意函数的返回值为size_t，是无符号的

 因为返回值是size_t，所以就要避免出现下面这样的代码：strlen("abc") - strlen("abcde")，strlen("abc")算出的结果是3，strlen("abcde")算出的结果是5，可能想着3-5得到-2，实际上并不是这样的，这里算出的3和5都是无符号整型，算出的-2也是一个无符号整型，-2在内存中以补码的形式存储，从无符号整型的视角看去，这串补码就表示一个很大的正数。

模拟实现：

//常规实现
int my_strlen1(const char* arr)
{assert(arr != NULL);
	int count = 0;
	while (*arr)
	{count++;
		arr++;
	}
	return count;
}

//递归实现
int my_strlen2(const char* arr)
{assert(arr!=NULL);
	if (*arr == '\0')
	{return 0;
	}
	else
	{return 1 + my_strlen2(arr + 1);
	}
}

//指针减指针实现
int my_strlen3(const char* arr)
{assert(arr != NULL);
	const char* start = arr;
	while (*arr)
	{arr++;
	}
	return arr - start;
}

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

二：strcpy

strcpy：字符串拷贝函数，把源字符串拷贝到目标空间
char * strcpy ( char * destination, const char * source );

注意事项：

• 函数有两个参数，其中source指向待拷贝的字符串，也叫做源字符串，destination是目标空间的地址
• 源字符串必须以’\0’结束
• 会把源字符串中的 ‘\0’ 也拷贝到目标空间
• 目标空间必须足够大，以确保能存放源字符串，否则会出现非法访问
• 目标空间必须可变，例如把源字符串拷贝到一个字符串常量里面是不可取的

模拟实现：

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

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

三：strcat

strcat：字符串追加函数，将源字符串追加到目标字符串后面，目标中的终止字符’\0’会被源字符串的第一个字符覆盖
char * strcat ( char * destination, const char * source );

注意事项：

• 函数有两个参数，其中source指向要追加的字符串，也叫做源字符串，destination是目标空间的地址
• 目标空间中必须要有'\0'，作为追加的起始地址
• 源字符串中也必须要有'\0'作为追加的结束标志
• 目标空间必须足够大，能容纳下源字符串的内容
• 目标空间必须可修改
• 自己给自己追加会陷入死循环

模拟实现：

char* my_strcat(char* dest, const char* src)
{assert(dest && src);
	char* ret = dest;
	//找目标空间的'\0'
	while (*dest != '\0')
	{dest++;
	}
	//追加
	while (*dest++ = *src++)
	{;
	}
	return ret;
}

int main()
{char arr1[20] = "hello ";
	char arr2[] = "world";
	my_strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

四：strcmp

strcmp：字符串比较函数
int strcmp ( const char * str1, const char * str2 );

注意事项：

• 这里比较的不是两个字符串的长度，而是对应位置上的ASCII值
• 第一个字符串大于第二个字符串，则返回大于0的数字
• 第一个字符串等于第二个字符串，则返回0
• 第一个字符串小于第二个字符串，则返回小于0的数字

模拟实现：

int my_strcmp(const char* str1, const char* str2)
{assert(str1 && str2);
	while (*str1 == *str2)//如果相等就进去，两个指针加加，但是可能会出现两个字符串相等的情况，两个指针都指向'\0'，此时比较就结束了
	{if (*str1 == '\0')
		{	return 0;
		}
		str1++;
		str2++;
	}
	if (*str1 >*str2)
	{return 1;
	}
	else
	{return -1;
	}
}

int main()
{char arr1[] = "abq";
	char arr2[] = "abq";
	int ret=my_strcmp(arr1, arr2);
	printf("%d\n", ret);
	return 0;
}

五：strncpy

strncpy：长度受限的字符串拷贝函数
char * strncpy ( char * destination, const char * source, size_t num );

注意事项：

• 拷贝num个字符从源字符串到目标空间。
• 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

模拟实现：

char* my_strncpy(char* dest, const char* src, int num)
{assert(dest && src);
	char* ret = dest;
	while (num)
	{if (*src == '\0')//此时说明src指针已经指向了待拷贝字符串的结束标志'\0'处，src指针就不用再++了
		{	*dest = '\0';
			dest++;
		}
		else
		{	*dest = *src;
			dest++;
			src++;
		}
		num--;
	}
	return ret;
}

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

六：strncat

strncat：长度受限的字符串追加函数
char * strncat ( char * destination, const char * source, size_t num );

注意事项：

• 从源字符串的第一个字符开始往后数num个字符追加到目标空间的后面，外加一个终止字符。
• 如果源字符串的长度小于 num，则仅复制终止字符之前的内容。

模拟实现：

char* my_strncat(char* dest, const char* src, int sz)
{assert(dest && src);
	char* ret = dest;
	//找目标空间的\0
	while (*dest != '\0')
	{dest++;
	}
	//追加
	while (sz)
	{*dest++ = *src++;
		sz--;
	}
	*dest = '\0';
	return ret;
}

int main()
{char arr1[20] = "abc\0xxxxxxxxxxx";
	my_strncat(arr1, "defjhigk", 3);
	printf("%s\n", arr1);
	return 0;
}

七：strncmp

strncmp：长的受限的字符串比较函数
int strncmp ( const char * str1, const char * str2, size_t num );

注意事项：

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

模拟实现：

int my_strncmp(const char* str1, const char* str2, int sz)
{assert(str1 && str2);
	while (sz)
	{if (*str1< *str2)
		{	return -1;
		}
		else if (*str1 >*str2)
		{	return 1;
		}
		else if(*str1 == '\0'||*str2 =='\0')//当有一个为'\0'，说明比较就可以结束了
		{	if (*str1 == '\0' && *str2 == '\0')//如果二者都是'\0'，说明两个字符串相等
			{		return 0;
			}
			else if(*str1 =='\0')//如果str1为'\0'，说明str1小，str2大
			{		return -1;
			}
			else//如果src为'\0'，说明str1大，str2小
			{		return 1;
			}
		}
		sz--;
		str1++;
		str2++;
	}
}

int main()
{int ret = my_strncmp("abcdef", "abcd", 5);
	printf("%d\n", ret);
	return 0;
}

八：strstr

strstr：字符串查找函数
const char * strstr ( const char * str1, const char * str2 );

注意事项：

• 在str1指向的字符串中查找str2指向的字符串
• 返回一个指向str1中第一次出现的str2的指针
• 如果 str2 不是 str1 的一部分，则返回一个空指针
• 匹配过程不包括终止空字符，但它到此为止

模拟实现：

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

int main()
{char arr1[] = "abbvcbcbbdbbvbnui";
	char arr2[] = "bbvb";
	char* ret = my_strstr(arr1, arr2);
	if (ret == NULL)
	{printf("找不到\n");
	}
	else
	{printf("%s\n", ret);
	}
	
	return 0;
}

九：strtok

strtok：字符串拆分函数
char * strtok ( char * str, const char * sep );

注意事项：

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

代码实现：

int main()
{char arr[] = "konglong@qq.com";
	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);
	}
	return 0;
}

九：strerror

strerror：把错误码转换成错误信息的函数
char * strerror ( int errnum );

注意事项：

• C语言的库函数在运行的时候，如果发生错误，就会把错误码存在一个变量中，这个变量是：errno
• 返回的指针指向静态分配的字符串（错误信息字符串）

一些错误码对应的错误信息：

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;
}
//结果：
No error
Operation not permitted
No such file or directory
No such process
Interrupted function call
Input/output error

strerror函数的一般用法：

int main()
{//打开文件
	FILE* pf = fopen("test.c", "r");
	if (pf == NULL)
	{printf("%s\n", strerror(errno));//需要包含头文件#includereturn 1;
	}
	//读文件
	//关闭文件
	fclose(pf);
	return 0;
}
//打开失败时屏幕显示：
No such file or directory

 fopen是一个打开文件的函数，第一参数是文件名，第二个参数是打开方式，如果打开成功会返回一个有限的指针，打开失败会返回一个空指针，此时我们就可以通过strerror函数去查看为什么打开失败

十：perror

perror：直接打印错误信息的函数
void perror ( const char * str );

注意事项：

• str指向一个字符串，这个字符串包含要在错误消息本身之前打印的自定义消息。如果是空指针，则不会打印前面的自定义消息，但仍会打印错误消息
• 如果参数str不是空指针，则打印str后跟冒号 （:)和一个空间。然后，无论str是否为空指针，都会打印生成的错误描述，后跟换行符 （'\n'）

perror函数的一般用法：

int main()
{//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{perror("fopen");
		return 1;
	}
	//读文件
	//关闭文件
	fclose(pf);
	return 0;
}
//打开失败时显示：
fopen: No such file or directory

十一：一些字符函数字符分类函数：

函数	如果它的参数复合下列条件就返回真（一个非零数字）
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	任何可打印字符，包括图形字符和空白字符

字符转换函数：

tolower：将大写字母转换为小写字母
int tolower ( int c );

注意事项：

• 如果 c 是大写字母并且具有小写等效字母，则将 c 转换为其小写等效项。如果无法进行此类转换，则返回的值为 c 不变。
• 大写字母是以下任意字母：A B C D E F G H I J K L M N O P Q R S T U V W X Y Z，分别翻译为：a b c d e f g h i j k l m n o p q r s t u v w x y z
• 这里是值传递，不会改变实参

toupper：将小写字母转换成大写字母
int toupper ( int c );

注意事项：

• 如果 c 是小写字母并且具有大写等效字母，则将 c 转换为其大写等效字母。如果无法进行此类转换，则返回的值为 c 不变
• 这里是值传递，不会改变实参

应用：

int main()
{char arr[] = "I Have An Apple";
	int i = 0;
	while (arr[i])
	{if (isupper(arr[i]))
		{	printf("%c", tolower(arr[i]));//把转换的小写字母直接打印出来
		}
		else
		{	printf("%c", arr[i]);
		}
		i++;
	}
	return 0;
}
//结果：
i have an apple

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;
}

 以上介绍的这些函数都是针对字符串或者字符的，那如果我们要拷贝其他类型的数据呢？用上面这些函数自然就行不通了，此时就要用到即将介绍的内存函数了。

十二：memcpy

memcpy：内存拷贝函数
void * memcpy ( void * destination, const void * source, size_t num );

注意事项：
 这里的destination指向要在其中赋值内容的目标数组，source指向要复制的数据源，num是要复制的字节数，注意这里前两个指针的的类型还有函数返回值都是void*，这是因为，memcpy这个函数是内存拷贝函数，它有可能拷贝整型，浮点型，结构体等等各种类型的数据……虽然返回类型是void*，但他也是必不可少的，void*也表示一个地址，用户可以把它强制转换成自己需要的类型去使用。

应用：

//把arr1中的1、2、3、4、5拷贝到arr2数组中
int main()
{int arr1[] = {1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = {0 };
	memcpy(arr2, arr1, 20);//拷贝5个整型，就是20个字节
	return 0;
}

//把arr1中的3、4、5、6拷贝到arr2数组中
int main()
{int arr1[] = {1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = {0 };
	memcpy(arr2, arr1+2, 16);//此时只要改变参数中数据源的地址就可以，把3的地址传过去就行，复制4个整型就是1个字节
	return 0;
}

模拟实现：

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

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

 上面代码中模拟出来的my_memcpy函数已经可以实现把arr1数组中的元素拷贝到arr2数组里面去。但当我们想把arr1数组中的1、2、3、4、5拷贝到arr1数组中的3、4、5、6、7上去时，就会发生错误，如下图：

 原因是：当1拷贝到3上时，原来的3已经被1替换，当2拷贝到4上的时候，原来的4已将被2替换。所以当拷贝arr[2]到arr[4]上的时候，原本arr[2]里面存放的3已将被1替换了，同理，所以才得出了不符合我们预期的结果。那如何解决这个问题呢？先来分析这个问题产生的原因，这是因为源空间与目标空间之间有重叠，这里的arr[2]、arr[3]、arr[4]既是源空间也是目标空间，当拷贝1和2的时候把源空间中开没有拷贝的3和4就给覆盖了，此时源空间arr[2]和arr[3]里面存的就不再是3和4了，而是1和2，所以此时拷贝arr[2]和arr[3]里面的数据，其实拷贝的就是1和2。为了解决这个问题，我们可以从后往前拷贝，此时就不会出现这样的问题

 解决的思路就是：先拷贝重叠区域的元素，避免其还没拷贝就被覆盖掉。但并不是一遇到源空间和目标空间重叠就从后王前拷贝，比如下面这样，此时要把3、4、5、6、7拷贝到1、2、3、4、5里面

 此时就不能用上面的方法从后往前拷贝了，但是可以根据上面提到的解决思路：先拷贝重叠区域的元素，所以此时就应该从前往后拷贝，即按照3、4、5、6、7的顺序去拷贝
 因此在拷贝的时候，是按照从前往后的顺序还是从后往前的顺序得看具体的情况。当目标空间的起始位置在源空间的前面时，就得从前往后进行拷贝。当目标空间的起始位置在源空间的后面的时候，就要从后往前拷贝。当源空间和目标空间没有任何重叠的时候，不管是从前往后拷贝还是从后往前拷贝效果都一样。
 接下来介绍的memmove函数就可以完成重叠空间的元素拷贝。

十三：memmove

memmove：内存拷贝函数
void * memmove ( void * destination, const void * source, size_t num );
 它的参数、返回值与memcpy函数一模一样。这里就不过多介绍。对于这两个函数来说，目标空间必须足够大，不然就会发生越界访问。

模拟实现：

void* my_memmove(void* dest, const void* src, int num)
{assert(dest && src);
	void* ret = dest;
	if (dest< src)
	{//从前向后
		while (num--)
		{	*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{//从后往前
		while (num--)//num为1的时候，下面的num就是0
		{	*((char*)dest + num) = *((char*)src + num);//通过num的减减就可以实现对每一个字节的访问
		}
	}
	return ret;
}

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

十四：memcmp

memcmp：内存比较函数
int memcmp ( const void * ptr1, const void * ptr2, size_t num );

注意事项：

• 比较从ptr1和ptr2指针开始的num个字节
• 两个内存块中不匹配的第一个字节在 ptr1 中的值低于 ptr2 中的值返回一个小于零的数子，相等返回零，两个内存块中不匹配的第一个字节在 ptr1 中的值大于在 ptr2 中的值返回一个大于零的数子

应用

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;
}//结果：
1

十四：memset

memset：内存设置函数
void * memset ( void * ptr, int value, size_t num );

注意事项：

• 以字节为单位来设置内存中的数据，把从ptr开始往后的num个字节设置成value
• 形参value也可以是字符，字符其实也是整型，因为字符在内存中存的是其ASCII
• value如果是整数的话，需要注意它的取值范围，因为一个字节大可以存储255，超过255就会发生截断

应用：

int main()
{char arr[] = "hello word";
	memset(arr, 'x', 5);//先把"hello"改成"xxxxx"
	printf("%s\n", arr);
	memset(arr + 6, 'y', 4);//再把"word"改成"yyyy"
	printf("%s\n", arr);
	return 0;
}
//

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧

文章标题：【C语言进阶】一篇带你掌握字符串和内存函数-创新互联
路径分享：http://ybzwz.com/article/hhssh.html