c语言进阶-第3节-字符函数和字符串函数

已于 2022-02-21 09:17:53 修改
阅读量559 收藏 1
点赞数 1
分类专栏： c语言进阶 文章标签： c语言 开发语言 后端
于 2022-01-24 12:02:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45113223/article/details/122664171
版权

目录

1.strlen函数

1.1.strlen函数介绍

1.2.strlen函数模拟实现

2.strcpy函数

2.1.strcpy函数介绍​

2.2.strcpy函数模拟实现

3.strcat函数

3.1.strcat函数介绍

3.2.strcat函数模拟实现

4.strcmp函数

4.1.strcmp函数介绍

4.2.strcmp函数模拟实现

5.strncpy函数

6.strncat函数

7.strncmp函数

8.strstr函数 

8.1.strstr函数介绍

8.2.strstr函数模拟实现

9.strtok函数

10.strerror函数

11.字符分类函数

12.字符转换函数

13.memcpy函数

13.1.memcpy函数介绍

13.2.memcpy函数模拟实现

14.memmove函数

14.1.memmove函数介绍

14.2.memmove函数模拟实现

15.memcmp函数

16.memset函数

1.strlen函数

1.1.strlen函数介绍

size_t  strlen  ( const char * str );
1. 字符串以  '\0' 作为结束标志， strlen 函数返回的是在字符串中 '\0' 前面出现的字符个数（不包
含 '\0' )
2. 参数指向的字符串必须要以 '\0' 结束。
3.注意函数的返回值为 size_t ，是无符号的（ 易错 ） 
#include<stdio.h>
#include<string.h>

int main()
{
    int len=strlen("abcdef");
    printf("%d\n",len);

    return 0;
}

1.2.strlen函数模拟实现

模拟实现方法：
1.计数器的方法
2.递归方法
3.指针-指针
模拟实现1：（计数器的方法） 
#include<stdio.h>

int my_strlen(const char* str) 
{
    assert(str);
	int count = 0;
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}

int main()
{
	int len = my_strlen("abcdef");
	printf("%d\n", len);

	return 0;
}

注：

1.操作符sizeof的返回类型其实是size_t类型的，size_t类型本质上是unsigned_int类型
2.用size_t来接收strlen函数的返回值有好处也有不好的地方，好处是长度一定是一个正数，用无符号整型接收更合理，坏处如下图所示，用无符号返回值进行计算，使用时不顺手，易引入bug。

模拟实现2：（递归方法）

#include<stdio.h>

int my_strlen(const char* str) 
{
    assert(str);
	if (*str == '\0')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}

int main()
{
	int len = my_strlen("abcdef");
	printf("%d\n", len);

	return 0;
}

模拟实现3：（指针-指针）

#include<stdio.h>

int my_strlen(char* s) 
{
    assert(str);
	char* p = s;
	while (*p != '\0')
		p++;
	return p - s;
}

int main()
{
	int len = my_strlen("abcdef");
	printf("%d\n", len);

	return 0;
}

2.strcpy函数

2.1.strcpy函数介绍

char*   strcpy ( char * destination , const char * source )
源字符串必须以 '\0' 结束
会将源字符串中的 '\0' 拷贝到目标空间
目标空间必须足够大，以确保能存放源字符串
目标空间必须可变(只读数据区的内容不可更改) 
#include<stdio.h>
#include<string.h>

int main()
{
    char arr1[]="abcdef";
    char arr2[20]={0};
    strcpy(arr2,arr1);
    printf("%s\n",arr2);

    return 0;
}

2.2.strcpy函数模拟实现

模拟实现1： 
#include<stdio.h>
#include <string.h>
#include <assert.h>

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

int main()
{
	char arr1[] = {'a', 'b', 'c', 'd', 'e', 'f', '\0'};
	char arr2[20] = "xxxxxxxxxxxx";

	my_strcpy(arr2, arr1);
	
	printf("%s\n", arr2);


	return 0;
}

模拟实现2：(改进版)

#include<stdio.h>
#include <string.h>
#include <assert.h>

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

int main()
{
	char arr1[] = {'a', 'b', 'c', 'd', 'e', 'f', '\0'};
	char arr2[20] = "xxxxxxxxxxxx";

	my_strcpy(arr2, arr1);
	
	printf("%s\n", arr2);

	return 0;
}

3.strcat函数

3.1.strcat函数介绍

char * strcat ( char * destination , const char * source );
功能：将源字符串的内容追加到目标字符串的后面
源字符串和目标字符串都必须以 '\0' 结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。 
#include<stdio.h>
#include<string.h>

int main()
{
    char arr1[30]="hello";
    char arr2[]="word";
    strcat(arr1,arr2);
    printf("%s\n",arr1);

    return 0;
}

3.2.strcat函数模拟实现

模拟实现： 
#include<stdio.h>
#include<string.h>
#include<assert.h>

char* my_strcat(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest && src);
	//1. 目标空间中的\0
	while (*dest)
	{
		dest++;
	}
	//2. 追加内容到目标空间
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[30] = "hello";
	char arr2[] = "world";

    my_strcat(arr1, arr2);
	printf("%s\n", arr1);

	return 0;
}

注：

1.若想知道编译器函数库中某函数是怎样实现的，通过以下步骤可观察（以strcat函数为例）

步骤一：打开everything，搜索该函数名，找到.c文件

 步骤二：单机鼠标右键，点击打开路径

 步骤三：找到.c文件所在文件夹，将该文件拖入vs编译器窗口

 步骤四：这里就是函数库中要找函数的实现代码

2.通过上面方法找到的.c源文件其实是vs编译器给出的参考代码（有些函数可能编译器没有给出参考代码，因此找不到.c文件），代码中真正使用函数时通过头文件包含进行调用，其实是从静态库中进行调用的（从msdn等地方可以查到对应函数静态库名字，如下图）

4.strcmp函数

4.1.strcmp函数介绍

int strcmp ( const char * str1 , const char * str2 );
返回：
从起始地址开始比较：
第一个字符串大于第二个字符串，则返回大于 0 的数字
第一个字符串等于第二个字符串，则返回 0
第一个字符串小于第二个字符串，则返回小于 0 的数字
功能：
比较对应位置上的字符大小 
#include<stdio.h>
#include<string.h>

int main()
{
    char arr1[30]="abcdef";
    char arr2[]="abq";

    int ret=strcmp(arr1,arr2);
    printf("%d\n",ret);

    return 0;
}

4.2.strcmp函数模拟实现

模拟实现1： 
#include<stdio.h>
#include<string.h>
#include<assert.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;
}

int main()
{
	char arr1[] = "abc";
	char arr2[] = "abc";

	int ret = my_strcmp(arr1, arr2);

	if (ret<0)
	{
		printf("arr1<arr2");
	}
	else if (ret >0)
	{
		printf("arr1>arr2");
	}
	else
	{
		printf("arr1==arr2");
	}

	return 0;
}

注：

此处，在主函数打印时，一定不能用-1、1、0进行判断，因为标准规定返回值是一个>0、<0、=0的值（其他编译器就不一定是只返回-1、1、0三个了数字），下面就是错误的例子。

 模拟实现2：

#include<stdio.h>
#include<string.h>
#include<assert.h>

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

	return *str1 - *str2;

}

int main()
{
	char arr1[] = "abc";
	char arr2[] = "abc";

	int ret = my_strcmp(arr1, arr2);

	if (ret<0)
	{
		printf("arr1<arr2");
	}
	else if (ret >0)
	{
		printf("arr1>arr2");
	}
	else
	{
		printf("arr1==arr2");
	}

	return 0;
}

5.strncpy函数

char * strncpy ( char * destination , const char * source , size_t num );
拷贝 num 个字符从源字符串到目标空间
如果源字符串的长度小于 num ，则拷贝完源字符串之后，在目标的后边追加\ 0 ，直到 num 个

代码1：

#include<stdio.h>
#include<string.h>

int main()
{
    char arr1="xxxxxxxxxxxxxxxx";
    char arr2[]="hello word";

    strncpy(arr1,arr2,5);
    printf("%s\n",arr1);

    return 0;
}

运行结果1：

代码2：

#include<stdio.h>
#include<string.h>

int main()
{
    char arr1[] = "xxxxxxxxxxxxxx";
    char arr2[] = "he";

    strncpy(arr1, arr2, 5);
    printf("%s\n", arr1);

    return 0;
}

运行结果2：

运行调试2：

6.strncat函数

char * strncat ( char * destination , const char * source , size_t num );
strncat函数对目标字符串进行追加，有两种情况
1. 若源字符串的长度小于等于 num： 遇到源字符串的\0停止，只将源字符串进行追加完即可（与strncpy函数不同）
2. 若源字符串的长度大于 num：追加源字符串的num个字符，然后在追加的最后一个字符后面补一个\0
代码1： 
#include<stdio.h>
#include<string.h>

int main()
{
    char arr1[20]="hello";
    char arr2[]="word";

    strncat(arr1,arr2,5);
    printf("%s\n",arr1);

    return 0;
}

运行结果1：

 代码2：

#include<stdio.h>
#include<string.h>

int main()
{
    char arr1[20] = "hello";
    char arr2[] = "word";

    strncat(arr1, arr2, 2);
    printf("%s\n", arr1);

    return 0;
}

运行结果2：

代码3：

#include<stdio.h>
#include<string.h>

int main()
{
    char arr1[20] = "hello\0xxxxxxxxx";
    char arr2[] = "word";

    strncat(arr1, arr2, 3);
    printf("%s\n", arr1);

    return 0;
}

运行结果3：

运行调试3：

 代码4：

#include<stdio.h>
#include<string.h>

int main()
{
    char arr1[20] = "hello\0xxxxxxxxx";
    char arr2[] = "word";

    strncat(arr1, arr2, 7);
    printf("%s\n", arr1);

    return 0;
}

运行结果4：

运行调试4：

7.strncmp函数

int strncmp ( const char * str1 , const char * str2 , size_t num );
标准规定：
第一个字符串大于第二个字符串，则返回大于 0 的数字
第一个字符串等于第二个字符串，则返回 0
第一个字符串小于第二个字符串，则返回小于 0 的数字
代码1： 
#include<stdio.h>
#include<string.h>

int main()
{
    char arr1[]="abcdef";
    char arr2[]="abcqqqqqq";

    int ret=strncmp(arr1,arr2,3);
    printf("%d\n",ret);

    return 0;
}

运行结果1：

代码2：

#include<stdio.h>
#include<string.h>

int main()
{
    char arr1[]="abcdef";
    char arr2[]="abcqqqqqq";

    int ret=strncmp(arr1,arr2,4);
    printf("%d\n",ret);

    return 0;
}

运行结果2：

 代码3：

#include<stdio.h>
#include<string.h>

int main()
{
    char arr1[] = "abcwef";
    char arr2[] = "abcqqqqqq";

    int ret = strncmp(arr1, arr2, 4);
    printf("%d\n", ret);

    return 0;
}

运行结果3：

8.strstr函数 

8.1.strstr函数介绍

char * strstr ( const char * str1 , const char * str2 );
功能：在str1字符串中找str2字符串。若找到str2了，返回str2第一次出现的起始地址；若找不到str2，返回一个空指针。
代码1： 
#include<stdio.h>
#include<string.h>

int main()
{
    char arr1[]="abcdefabcdef";
    char arr2[]="bcd";

    char* ret=strstr(arr1,arr2);

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

    return 0;
}

运行结果1：

 代码2：

#include<stdio.h>
#include<string.h>

int main()
{
    char arr1[] = "abcdefabcdef";
    char arr2[] = "bcdq";

    char* ret = strstr(arr1, arr2);

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

    return 0;
}

运行结果2：

8.2.strstr函数模拟实现

模拟实现：

#include<stdio.h>
#include<string.h>
#include<assert.h>

char* my_strstr(const char* str, const char* substr)
{
	const char* s1 = str;
	const char* s2 = substr;
	const char* cur = str;

	assert(str && substr);
	if (*substr == '\0')
	{
		return (char*)str;
	}
	while (*cur)
	{
		s1 = cur;
		s2 = substr;
		while (*s1!='\0' && *s2!='\0' && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
			return (char*)cur;

		cur++;
	}
	return NULL;
}


int main()
{
	char arr1[] = "abbbcdef";
	char arr2[] = "bbc";

	char* ret = my_strstr(arr1, arr2);

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

	return 0;
}

9.strtok函数

char * strtok ( char * str , const char * sep );
参数：
第一个参数指定一个字符串，它包含了 0 个或者多个由 sep 字符串中一个或者多个分隔符分割的标记。
第二个参数sep 参数是个字符串，定义了用作分隔符的字符集合
返回：
返回一个指向这个标记所分割的字符串的地址（首元素地址）
功能：
strtok 函数找到 str 中的下一个标记，并将其用\0代替，返回一个指向这个标记所分割的字符串的地址（首元素地址）。（注：strtok函数会改变被操作的字符串，所以在使用 strtok 函数切分的字符串一般都是临时拷贝的内容并且可修改）
strtok 函数的第一个参数不为 NULL ，函数将找到 str 中第一个标记， strtok 函数将保存它在字符串中的位置。（strtok函数找第一个标记的时候，函数的第一个标记不是NULL）
strtok 函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。（strtok函数找非第一个标记的时候，函数的第一个标记是NULL）
如果字符串中不存在更多的标记，则返回 NULL 指针。
注：
strtok函数内部会有一个静态变量（static修饰的变量），来保存上一次标记的位置
代码1： 
#include <stdio.h>
#include <string.h>

int main()
{
	const char* p = "@.";
	char arr[] = "zpengwei@yeah.net";
	char buf[50] = { 0 };
	strcpy(buf, arr);
	char* str = NULL;

	str = strtok(buf, p);
	printf("%s\n", str);
	str = strtok(NULL, p);
	printf("%s\n", str);
	str = strtok(NULL, p);
	printf("%s\n", str);

	return 0;
}

运行结果1：

代码2：

#include <stdio.h>
#include <string.h>

int main()
{
	const char* p = "@.#";
	char arr[] = "zpengwei@yeah.net#hehe";
	char buf[50] = { 0 };
	strcpy(buf, arr);
	char* str = NULL;

	for (str = strtok(buf, p); str != NULL; str=strtok(NULL, p))
	{
		printf("%s\n", str);
	}

	return 0;
}

运行结果2：

10.strerror函数

char * strerror ( int errnum );
参数：
错误码
返回：
错误码所对错误信息的起始地址
功能：
strerror函数可以把错误码翻译成错误信息
代码1： 
#include <stdio.h>
#include <string.h>

int main() 
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%s\n", strerror(i));
	}
	return 0;
}
运行结果1：

注：错误码所对应的错误信息是常量字符串
代码2： 
#include <stdio.h>
#include <string.h>
#include <errno.h>

int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (NULL == pf)
	{
		//出错误的原因是什么
		printf("%s\n", strerror(errno));
		return 0;
	}


	//读文件
	//...
	

	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

运行结果2：

 注：

1.fopen函数

第一个参数：文件名（在工程路径下寻找）

第二个参数：打开文件的方式（具体方式msdn上有，下面给出一个方式）

返回：返回一个指针，指向找到的文件。如果遇到一个错误的话，返回一个空指针

2.当库函数使用的时候，发生错误会把errno这个全局的错误变量设置为本次执行库函数产生的错误码。errno是c语言提供的一个全局变量，可以直接使用，放在errno.h文件中

3.使用errno时，需要包含errno.h的头文件

4.fopen，fclose这些函数后期会专门进行讲解

11.字符分类函数

函数参数：一个字符

函数返回值：如果符合返回一个非零值（真），如果不符合返回0（假）

注：使用该系列函数，需要包含ctype.h头文件

函数
如果他的参数符合下列条件就返回真
iscntr
任何控制字符
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 <stdio.h>
#include <string.h>

int main()
{
	printf("%d\n", isspace(' '));
	printf("%d\n", isspace('!'));

	return 0;
}

运行结果：

 

12.字符转换函数

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

代码：

#include <stdio.h>
#include <string.h>

int main()
{
	
	char ch = 0;
	ch = getchar();
	if (islower(ch))
	{
		ch = toupper(ch);
	}
	else
	{
		ch = tolower(ch);
	}
	printf("%c\n", ch);

	return 0;
}

运行结果：

13.memcpy函数

13.1.memcpy函数介绍

void * memcpy ( void * destination , const void * source , size_t num );
参数：
void * destination：要拷贝的目标内存地址
const void * source：要拷贝的源内存地址
size_t num：拷贝字节个数，单位是字节
返回：
要拷贝的目标内存地址
功能：
内存拷贝函数，以字节为单位进行拷贝（拷贝的源和目标不可以重叠）
c语言的memcpy函数的功能规定是拷贝不重叠的内存空间（vs编译器中的库函数memcpy超纲完成任务，其可以拷贝重叠的内存空间）
注：
函数 memcpy 从 source 的位置开始向后复制 num 个字节的数据到 destination 的内存位置。
这个函数在遇到 '\0' 的时候并不会停下来。
如果 source 和 destination 有任何的重叠，复制的结果都是未定义的。
代码： 
#include <stdio.h>
#include <string.h>

int main()
{

	int arr3[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr4[5] = { 0 };

	memcpy(arr4, arr3, 5*sizeof(arr3[0]));

	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d\n", arr4[i]);
	}

	return 0;
}

运行结果：

13.2.memcpy函数模拟实现

模拟实现：（只模拟c语言memcpy函数本身规定的功能，不去模拟内存重叠拷贝功能，与vs库中的memcpy有一定区别）

#include <stdio.h>
#include <string.h>
#include<assert.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 arr3[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr4[5] = { 0 };

	my_memcpy(arr4, arr3, 5*sizeof(arr3[0]));

	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", arr4[i]);
	}

	return 0;
}

注：

1.该模拟代码有一定问题，比如要想将上面代码arr3数组的1 2 3 4 5拷贝到3 4 5 6 7位置处，预期是1 2 1 2 3 4 5 8 9 10，但上面代码的拷贝结果如下图所示。（出现问题的原因是：拷贝的源字符串和目标字符串有重叠的部分）

2.如果拷贝的源字符串和目标字符串有重叠的部分，我们就不能再用memcpy函数了，应该使用下面的memmove函数

14.memmove函数

14.1.memmove函数介绍

void * memmove ( void * destination , const void * source , size_t num );
参数：
void * destination：要拷贝的目标内存地址
const void * source：要拷贝的源内存地址
size_t num：拷贝字节个数，单位是字节
返回：
要拷贝的目标内存地址
功能：
内存拷贝函数，以字节为单位进行拷贝（拷贝的源和目标可以重叠可以不重叠）
c语言的memmove函数的功能是拷贝重叠或不重叠的内存空间
注：
和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。
memmove函数的功能包含了memcpy函数
代码： 
#include <stdio.h>
#include <string.h>

int main()
{
	int arr3[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr4[5] = { 0 };

	memmove(arr3+2, arr3, 5*sizeof(arr3[0]));

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr3[i]);
	}

	return 0;
}

运行结果：

14.2.memmove函数模拟实现

模拟实现： 
#include <stdio.h>
#include <string.h>
#include <assert.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;
}

int main()
{
	int arr3[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr4[5] = { 0 };

	memmove(arr3+2, arr3, 5*sizeof(arr3[0]));

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr3[i]);
	}

	return 0;
}

模拟实现的运行结果：

注：
当目标地址dest>源地址src：源地址内容 从后往前拷贝进目标地址dest
当目标地址dest<源地址src：源地址内容 从前往后拷贝进目标地址dest

15.memcmp函数

int memcmp ( const void * ptr1 , const void * ptr2 , size_t num );
参数：
const void * ptr1：想比较的第一个内存块的起始地址
const void * ptr2：想比较的第二个内存块的起始地址
size_t num：从起始位置开始想比较的字节数
返回：
从起始地址开始比较：
第一个内存块大于第二个内存块，则返回大于0 的数字
第一个内存块等于第二个内存块，则返回0
第一个内存块小于第二个内存块，则返回小于0的数字
功能：
比较从 ptr1 和 ptr2 指针开始的 num 个字节
代码1： 
#include <stdio.h>
#include <string.h>

int main()
{
	int arr1[]={1,2,7,4,5};
    int arr2[]={1,2,3,4,5};
    int ret=memcmp(arr1,arr2,9);
    printf("%d\n",ret);

	return 0;
}

运行结果1：

代码2：

#include <stdio.h>
#include <string.h>

int main()
{
    int arr1[] = { 1,2,3,4,5 };
    int arr2[] = { 1,2,3,4,5 };
    int ret = memcmp(arr1, arr2, 9);
    printf("%d\n", ret);

    return 0;
}

运行结果2： 

16.memset函数

void* memset ( void * dest , int c , size_t count)
参数：
void * dest：要设置的目的地起始地址
int c：要设置的内容，以字节为单位
size_t count：要设置的字节的个数
返回：
目的地地址
功能：
对一段内存块以字节为单位置入内容
代码1： 
#include <stdio.h>
#include <string.h>

int main()
{
    char arr[20]={0};
    memset(arr,'x',10);

    return 0;
}
调试结果1：

 代码2：

#include <stdio.h>
#include <string.h>

int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    memset(arr, 0, 10);

    return 0;
}

调试结果2：

随风张幔
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【C基础】字符函数和字符串函数
awenduxing的博客
09-18 250
字符串在程序中会经常使用到，所以字符串函数也非常重要，主要是能理解字符串在内存中的存储、字符的比较、字符串的结束标志'\0'等。
C语言中的字符串函数和字符函数
l_shadow_m的博客
06-12 1470
C语言中的字符串函数和字符函数
字符串&内存函数
weixin_64114056的博客
03-28 369
1.strcpy 2.strncpy 3.strcat 4.strncat 5.strlen 6.strstr 7.strcmp 8.strtok 内存函数 字符串函数 1.strcpy 函数名: strcpy 功 能: 将src字符串拷贝至dest所指的地址 用 法: char *strcpy(char *dest, const char *src); 返回值: 返回参数dest的字符串起始地址 strcpy将src字符串结尾'\0'一同复制到de...
【C 程序设计】数组基本知识大全
小白_xm
06-30 664
1. 数组 （1）特点：同一数组中的所有元素都属于同一种数据类型，比如 int 型、float 型、double 型和 char 型。 （2）方法：一个数组元素其实就是一个变量，也可以称带下标的变量。 （3）数组分类：一维数组、二位数组或字符数组等。 2. 一维数组 （1）定义格式：类型名 数组名[常量表达式]; // 一维数组，注意，中括号内的常量表达式必须是整数 int num[10] ; //一维整型数组 float stu[10] ; //一维单精度浮点型 double t
字符串函数以及内存函数的模拟实现（超详细，全面理解字符串函数）
m0_72161237的博客
09-18 570
一、strlen 1.参数指向的字符串必须要以 '\0' 结束。 2.注意strlen函数的返回值为size_t，是无符号的 3.模拟实现strlen 二、strcpy 1.源字符串中的 '\0' 拷贝到目标空间 2.源字符串必须以 '\0' 结束 3.目标空间必须足够大，以确保能存放源字符串 4.模拟实现strcpy 三、strcat 1.源字符串必须以 '\0' 结束 2.模拟实现strcat
11.字符串+内存函数
m0_62513305的博客
02-27 179
函数介绍 库函数的模拟实现
c语言字符函数和字符串函数介绍
weixin_59371851的博客
06-13 937
目录前言一、strlen函数1.简介2、模拟实现2.1计数器方式2.2递归方式2.3指针的方式二、strcpy函数1.简介2.模拟实现三、strcat函数1.简介2、模拟实现四、strcamp函数1、简介2、模拟实现五、strncpy函数六、strncat函数七、strncmp函数八、strstr函数1、简介2.模拟实现9、strtok函数 1、简介2、举例10、strerror函数11、memcpy函数1、简介2、模拟实现12、memmove函数1、简介2、模拟实现 13、memcmp函数c语言中对字符和
C语言进阶－第4讲存储器与指针共17页.pdf.zip
10-29
5. **常量区**：存放程序中的常量，如字符串字面量，其值在程序运行期间不能改变。 指针在C语言中扮演着关键角色，它是一个变量，其值为另一个变量的地址。通过指针，我们可以直接访问和修改存储在其他位置的变量，...
嵌入式C语言培训-编程进阶-2字符串
12-19
3. **字符串函数**： - `strlen()`：计算字符串的长度，不包括结束的'\0'。 - `strcpy()`：复制一个字符串到另一个字符串。 - `strncpy()`：安全地复制指定数量的字符。 - `strcat()`：连接两个字符串。 - `...
C语言进阶源码---文本编辑系统
01-04
3. **字符串处理**：`strcpy`、`strcat`、`strcmp`等函数用于处理字符串，而`strlen`可以计算字符串长度。 4. **错误处理**：使用`errno`和`perror`来识别和报告错误，确保程序在遇到问题时能够优雅地处理。 5. **...
C语言进阶－第三讲编译汇编调试.pdf
07-16
### C语言进阶——第三讲：编译、汇编与调试 #### 一、面向嵌入式系统的软件开发环境 面向嵌入式系统的软件开发环境通常包括以下几部分： 1. **编译器**：负责将高级语言如C/C++等源代码翻译成汇编语言。 2. **...
大学计算机C语言课程-第十一章-指针进阶.ppt
05-24
这使得我们可以方便地处理和操作多个字符串。例如，可以遍历数组来输出字符串的内容或者交换它们的值。 2. **指向指针的指针**：11.1.3节中介绍了指向指针的指针，这是一种更复杂的指针类型。例如，如果有一个指针...
C语言进阶-字符串函数与内存函数
~
09-21 1844
前言 本章主要讲解： 字符和字符串的库函数的使用和注意事项 求字符串长度 strlen 长度不受限制的字符串函数 strcpy strcat strcmp 长度受限制的字符串函数 strncpy strncat strncmp 字符串查找 strstr strtok 错误信息报告 strerror 字符操作 内存操作函数 memcpy memmove memset memcmp 写在前面的话： C语言本身是没有字符串类型的 字符串通常放在常量字符串（不做修改）中或者字符数
字符串和内存函数小记
普通大学生的博客
01-25 360
@sda 欢迎使用Markdown编 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示； 增加了
字符函数和字符串函数
travel_dream的博客
03-10 103
字符函数和字符串函数 前言： C语言中对字符和字符串的处理很频繁，但C语言本身是没有字符串类型的，字符串通常放在常量字符串和字符数组中。 常量字符串适用于那些不做修改的字符串函数 函数介绍： 1.1strlen size_t strlen ( const char* ptr ); 专门用来计算字符串的长度的 size_t是sizeof的返回类型，本质上是unsignedint类型，返回值类型为int和unsignedint各有各的的作用 例如计算strlen("abc")-...
strtok函数与函数用法实例
m0_65310080的博客
03-24 2656
strtok函数简介及运用实例（利用strtok函数分割字符串及单词逆序）
C语言字符串函数及如何实现这些函数
HeartFireY的博客
07-27 766
C语言字符串函数及如何实现这些函数 ​ 近期在复习C语言字符串相关的知识，在观看了 翁恺 老师的 C语言程序设计 课程后，打算对C语言标准库以及 string.h 内的函数进行整理，并写出自己的实现方式（部分函数涉及系统底层和复杂操作，只给出简单的C语言表示形式，数组同样可以做出相应的函数，但本文以指针角度进行阐释）。有不足之处还请大神指正。 1.putchar函数(属于stdio.h库函数) 函数原型： int putchar( int c ) 函数作用：向标准输出输出一个字符 函数的返回值： 1：
CCF GESP Python编程 五级认证真题 2024年6月
最新发布
No0d1es的博客
07-25 949
hlmFile = open("红楼梦.txt", "r", encoding = "utf-8") sSet = set(shzFile.read())第 1 题 在Python中，print((c for c in "GESP"))的输出是（ ）。C. 执行 print(count_if(range(-100,10),key = lambda x:x > 5)) 将输出 4。第 7 题 在下面的Python代码中，最后一行用于输出小于0的list，横线处不能填入的代码是( )。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

随风张幔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值