C语言进阶---字符串+内存函数

已于 2023-07-01 20:37:57 修改
阅读量774 收藏 1
点赞数
分类专栏： C语言 文章标签： c语言
于 2023-07-01 20:37:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57776598/article/details/131494375
版权

本章重点

重点介绍处理字符和字符串的库函数的使用和注意事项。

  • 求字符串长度
    • strlen()
  • 长度不受限制的的字符串函数
    • strcpy()
    • strcat()
    • strcmp()
  • 长度受限制的的字符串函数
    • strncpy()
    • strncat()
    • strncmp()
  • 字符串查找
    • strstr()
    • strtok()
  • 错误信息报告
    • strerror()
  • 字符操作
  • 内存操作函数
    • memcpy()
    • memmove()
    • memset()
    • memcmp()

前言

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

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

1、字符串函数

1.1、strlen()—统计字符串长度

//头文件<string.h>

size_t strlen(const char* str);
  • 首先传的参数需要是个指针类型的。
  • 字符串以'\0'作为结束标志，strlen()函数返回的是在字符串中'\0'前面出现的字符个数（不包含'\0'）。
  • 参数指向的字符串必须要以'\0'结束。
  • 注意函数的返回值为size_t，是无符号整型的
  • 学会strlen()函数的模拟实现。

1.2、strcpy()—字符串拷贝

//头文件<string.h>

char* strcpy(char* destination, const char* source)
  • 源字符串必须以'\0'结束。
  • 会将源字符串中的'\0'拷贝到目标空间。
  • 返回值为目标字符串的首字符地址。
  • 目标空间必须足够大，以确保能存放源字符串。
  • 目标空间必须可变。
  • 学会模拟实现。

简单使用介绍：

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

int main()
{
	char name[20] = { 0 };
	strcpy(name, "zhangsan");
	printf("%s\n", name);
	return 0;
}

输出：

在这里插入图片描述

1.3、strcat()—字符串追加

//头文件<string.h>
char* strcat(char* destination, const char* source)
  • 源字符串必须以'\0'结束。
  • 源字符串在目标字符串有\0的地方开始追加。并不是说只会在目标字符串末尾处开始追加，只要目标字符串中间某个位置有\0，那就直接从这个位置开始追加。
  • 目标空间必须有足够的大，能容纳下源字符串的内容。
  • 目标空间必须可修改

1、简单使用介绍：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

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

输出：

在这里插入图片描述

2、这里说明一下：源字符串在目标字符串有\0的地方开始追加。并不是说只会在目标字符串末尾处开始追加，只要目标字符串中间某个位置有\0，那就直接从这个位置开始追加。

如下代码：“hel\0lo”，中间位置有个\0，所以在追加"world"是，就直接从"hel"初开始追加了。最后输出结果就是:

“helworld”。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	char arr2[20] = "hel\0lo ";
	strcat(arr2, "world");
	printf("%s\n", arr2);
	return 0;
}

输出：

在这里插入图片描述

2、模拟实现：

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

char* my_strcat(char* dest, const char* source)
{
	char* ret = dest;
	assert(dest && source);
	//1、找到目标字符串的\0。
	while (*dest != '\0')
	{
		dest++;
	}
    //2、拷贝
	while (*dest++ = *source++)
	{
		;
	}
	return ret;
}

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

那能不能实现字符串自己给自己追加？如下：

答案：是不能的。

int main()
{
	char arr1[20] = "hello ";
	my_strcat(arr1, arr1);             //如何实现这样的效果呢？
	printf("%s\n", arr1);
	return 0;
}

1.4、strcmp()—比较字符串大小

//头文件<string.h>
int strcmp(const char* str1, const char* str2);
  • 返回值：
    • 第一个字符串<第二个字符串，就返回小于0的数字
    • 第一个字符串=第二个字符串，就返回0
    • 第一个字符串>第二个字符串，就返回大于0的数字

那具体是怎么比较的呢？是依次比较各个字符串中字符的ASCII值。

比如：首先arr1中的字符’a’和arr2中的字符’a’进行比较，发现ASCII一样，然后再比较字符’b’…

之后当比较到arr1中的字符’d’和arr2中的字符’f’是，发现arr2中的’f’的ASCII值比arr1中的’d’的ASCII值大。

所以最终结果为arr2大。

char arr1[] = "abcd";
char arr2[] = "abcf";

1、简单使用：

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

int main()
{
	char arr1[] = "abcd";
	char arr2[] = "abcf";
	int ret = strcmp(arr1, arr2);    //arr1小于arr2
	if (ret < 0)
		printf("<\n");
	else if (ret == 0)
		printf("=\n");
	else
		printf(">\n");
	return 0;
}

输出：

在这里插入图片描述

2、模拟实现：

#define _CRT_SECURE_NO_WARNINGS
#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[] = "abcd";
	char arr2[] = "abcf";
	int ret = my_strcmp(arr1, arr2);
	if (ret < 0)
		printf("<\n");
	else if (ret == 0)
		printf("=\n");
	else
		printf(">\n");
	return 0;
}


//判断>或者<的返回值还可以在优化：
//将下面一段代码替换为最后一行优化的代码
if (*str1 > *str2)
		return 1;
	else
		return -1;

//替换这个优化的代码
return *str1 - *str2;

关于以上库函数不安全的说明

上面所说到了库函数，其实是相对不安全的，比如：

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

int main()
{
	char arr1[] = "abcd";
	char arr2[] = "abcdfr";
	//arr2的字符长度比arr1的字符长度长，当让arr2拷贝到arr1时，arr1数组会放不下，
	//放不下编译器也会放，那就呆滞了越界访问，以至于改变了其它内存中的数据，这是相当危险的。
	strcpy(arr1, arr2);   
	return 0;
}

那这个时候，就应用诞生了相对来说安全一点的库函数：长度受限制的的字符串函数。

长度受限制的字符串函数是什么意思呢？下面介绍：

1.5、strncpy()–长度受限制拷贝

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

多个参数：num。这个参数就是限制长度的参数，比如说让arr2的字符串拷贝到arr1中去，但是只允许拷贝3个字节的字符:

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

int main()
{
	char arr1[] = "aaaaa";
	char arr2[] = "bbbbb";
	//让arr2的数据拷贝到arr1中去，但是只拷贝3个字节。
	strncpy(arr1, arr2,3);   
	printf("%s\n", arr1);
	return 0;
}

输出：

在这里插入图片描述

可以看到输出结果：只会将arr2中的前3个字符拷贝到arr1中，arr1前3个也字符会改变，并且后面的字符不会改变。

1.6、strncat()—长度受限制追加

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

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

输出：这里有个点要注意以下：在使用strncat()时，在追加完毕后，会自动在目标字符串末尾添加一个\0表示一个字符的结束。

这里采用调试查看：

在这里插入图片描述

1.7、strncmp()—长度受限制比较

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

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abc";
	strncmp(arr1, arr2, 3);   //只比较3个字符，结果应该为相等。
	return 0;
}

1.8、strstr()—查找子串

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

参数说明：

  • str1是母字符串的地址
  • str2是子串的地址

比如现在有两个字符串：

char arr1[] = "abcdef";
char arr2[] = "cde"
strstr(arr1,arr2);

需要在arr1（母字符串）中寻找有没有arr2（子串）的内容。首先arr2中的字符串内容为：“cde”，而arr1中的字符串：“abcdef”，正好全部包含"cde"。那么此时strstr()函数会返回arr1中包含子串的首字符地址。也就是会返回arr1中字符c的地址。那如果我们在以%s打印时，就会将arr1的"cdef"的值全部打印出来，因为从起始位置’c’到’\0’结束，就是"cdef"。

所以strstr()函数的返回值是个char*类型的。

如果没有查找到字串，就会返回一个NULL指针。

1、使用演示：

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

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "cde";
	char* ret = strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("没有找到\n");
	}
	else
	{
		printf("%s\n", ret);
	}
	return 0;
}

输出：

在这里插入图片描述

1.9、strtok()—切割字符串

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

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

    比如现在有一个字符串：“zhengbo@helloworld.com”，假如字符@和字符.就是我们分隔符，通过这两个符号，可以将字符串切割为一段一段的。那我们就可以这样定义这个sep参数：

    const char* sep = "@.";

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

    这里的第一个参数就是要切割的字符串：

    char arr[] = "zhengbo@helloworld.com";

  • strtok函数找到了str中的下一个标记，并将其用\0结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容没那个，并且可修改。）

    strtok函数找到了str中的下一个标记这句话的意思就是说，strtok找到了@分隔符，就会把@分隔符变为'\0'，那arr数组就会变成如下的样子：

    char arr[] = "zhengbo\0helloworld.com";

    然后返回一个指向这个标记的指针，就是把分隔好的字符串：“zhengbo\0”，通过返回字符'z'的地址，作为指针返回过去。

    但是这样我们会发现一个问题：就是会把arr数组里面的内容给修改。那如果下面程序还需要使用arr数组呢？那情况就不对。所以说我们先应该使用strcmp()函数把arr数组给临时拷贝一份给另外一个数组，然后把临时拷贝的数组交给strtok来进行操作，那这样既能提取出来分隔的字符串，又能不对原数组arr进行修改。具体实现如下代码：

    #include <stdio.h>
#include <string.h>
int mian()
{
	const char* sep = "@.";
	char arr[] = "zhengbo@helloworld.com";
	char cp[30] = { 0 };
	strcmp(cp,arr);     //临时拷贝一份
	strtok(cp, sep);    //对临时拷贝的数组进行分隔
	return 0;
}

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

    这个是说，我们在首次使用strtok函数时，需要传第一个参数，因为第一个参数里面保存了分隔符的地址，有了一个参数后，函数将找到str中第一个标记，也就是说找到了@标记（分隔符），然后返回首字符z的地址，作为函数返回值，然后保存下来。

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

    到这一步，再次调用strtok函数，需要找第二个，第三个，第四个分割符的时候就不需要传第一个参数了，所以到这个地方我们就能明白，只有在找第一个分隔符的时候才传第一个参数。好，那问题又来了：那不传第一个参数，如何找到，下一个需要分割为字符串的首字符地址呢？原因是这样的：其实在找到第一个分隔符之后，NULL指针表示一种状态，NULL指针会记录着上一个分割后的起始位置，也就已经记着了第一个分隔符后面的字符地址了。然后在根据sep中记录的分隔符，分割出一段字符串。

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

    到这一步，是说，在真个arr数组里面没找到分隔符，那就直接strtok函数返回NULL指针。

1、效果演示：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
int main()
{
    //创建分隔符集合
	const char* sep = "@.";
    //待分割的字符串
	char arr[] = "zhengbo@helloworld.com";
    //创建一个临时数组
	char cp[30] = { 0 };
	//拷贝一份临时数据
	strcpy(cp,arr);
	//切割出zhengbo@，并把@换为\0了，且把z字符的地址，返回给了ret。
	char* ret = strtok(cp, sep);    
	//打印出：zhengbo
	printf("%s\n", ret);
	
    //打印helloworld，这里的NULL指针表示一种状态，NULL指针记录了'h'的地址
	ret = strtok(NULL, sep);
	printf("%s\n", ret);
	
    //打印com，这里NULL指针记录了'c'的地址
	ret = strtok(NULL, sep);
	printf("%s\n", ret);
	return 0;
}

输出：

在这里插入图片描述

2、优化：上面的代码分割一个字符串就需要打印一次，其实这里可以写个for循环，来优化下代码：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
int main()
{
	const char* sep = "@.";
	char arr[] = "zhengbo@helloworld.com";
	char cp[30] = { 0 };
	//拷贝一份临时数据
	strcpy(cp,arr);
	//切割出zhengbo@，并把@换为\0了，且把z字符的地址，返回给了ret。
	char* ret = NULL;
    //优化部分
	for (ret = strtok(cp, sep); ret != NULL; ret = strtok(NULL, sep))
	{
		printf("%s\n", ret);
	}
	return 0;
}

1.10、strerror()

返回错误码，所对应的错误信息。

//头文件：<errno.h>
char* strerror (int errnum);

在C语言中，库函数在执行失败的时候，都会设置错误码。

虽说设置的都有错误码，但是我们怎么样才能知道错误码所对应的错误信息呢？

这个时候strerror()函数就起作用了。只需要把错误码传参进去，这个函数就会返回错误码所对应错误信息字符串的首字符地址。

1、代码演示：

//在X86平台上运行

#include <stdio.h>
#include <errno.h>

int main()
{
	printf("%s\n", strerror(0));
	printf("%s\n", strerror(1));
	printf("%s\n", strerror(2));
	printf("%s\n", strerror(3));
	return 0;
}

输出：

在这里插入图片描述

2、情景演示

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <errno.h>

int main()
{
	//使用fopen()表示打开一个文件，并且r表示以只读的方式进行。
	//如果打开成功会返回一个指针，如果打开失败会返回NULL指针。
	//现在本地没有test.txt文件，所以会打开文件失败，返回NULL指针。
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		//errno是C语言中设置一个全局变量，用来专门存放错误码的。
		printf("%s\n", strerror(errno));
        return 1;
	}
	return 0;
}

输出：

在这里插入图片描述

2、字符分类函数

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

3、字符转换函数

字符转换：

1、tolower()-------------将大写字母转为小写

int tolower(int c);     //将大写字母转为小写，如果传参数表示大写字母，给什么值，输出什么值。

代码演示：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <ctype.h>

int main()
{
	printf("%c\n", tolower('A'));
	return 0;
}

输出：

在这里插入图片描述

2、toupper()----------------将小写字母转为大写

int toupper(int c);     //将小写字母转为大写，如果传参数表示小写字母，给什么值，输出什么值。

代码演示：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <ctype.h>

int main()
{
	printf("%c\n", toupper('g'));
	return 0;
}

输出：

在这里插入图片描述

4、内存操作函数

4.1、memcpy函数—内存拷贝（不能用来拷贝重叠内存）

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

上面讲到字符函数也有两个拷贝：strcpy、strncpy。

但是这两个库函数都是指针字符串进行拷贝的。

那现在有两个整型数组，如何拷贝呢？

比如：

  • int arr1[] = {1,2,3,4,5,6};
  • int arr2[10] = {0};

这个时候就需要使用memcpy()库函数了。

在介绍这个库函数前，先来思考一下这个库函数诞生的原因：如果需要拷贝字符类型的数据用到了strcpy、strncpy函数，那如果需要拷贝整型数据的呢？需要产生一个专用于整型拷贝的库函数吗？如果需要拷贝浮点型呢？如果需要拷贝结构体呢？不可能说都会产生一个对应的拷贝库函数。

而是说直接用一个memcpy()函数，这个函数是直接对内存进行操作的，它拷贝的是内存块里面的数据。而无论是字符还是整形，或者是浮点型，再或者是结构体。它们的数据都是存放在内存中的。所以说可以直接用memcpy()函数进行统一拷贝操作。

1、参数介绍：

//头文件   <string.h>
void * memcpy ( void * destination, const void * source, size_t num );
  • destination目标地址
  • source 源地址
  • 参数num的单位是字节。

2、代码演示：

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

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7 };
	int arr2[10] = { 0 };
	//因为一个整型是4个字节，arr1里面有7个整型数字，所以是28个字节，
	//memcpy的三个参数num的单位是字节，所以应传参28
    //将arr1的数据拷贝到arr2中
	memcpy(arr2, arr1, 28);
	return 0;
}

调试查看：

在这里插入图片描述

3、模拟实现memcpy()函数

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

void* my_memcpy(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	//用于返回目标地址。
	void* ret = dest;
	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 };
	int arr2[10] = { 0 };
	//因为一个整型是4个字节，arr1里面有7个整型数字，所以是28个字节，
	//memcpy的三个参数num的单位是字节，所以应传参28
	my_memcpy(arr2, arr1, 28);
	return 0;
}

4.2、memmove函数------内存拷贝（可以用来重叠内存之间的拷贝）

memcpy函数和memmove函数基本功能大致一样，但是memmove有个比memcpy强大的小功能：

1、memcpy函数是不能用来处理重叠的内存之间的数据拷贝。

2、memmove函数是可以处理重叠内存之间的数据拷贝的。

3、 memcpy只是memmove的一个子集。

memmove函数的参数和memmove函数的参数是一样的：

//头文件   <string.h>
void * memmove ( void * destination, const void * source, size_t num );

既然参数一样，那两个函数的用法也是一样的。

假如如下是数组arr1重叠部分：

在这里插入图片描述

下面来实现内存重叠的代码演示：

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

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

输出：

在这里插入图片描述

4.3、memcmp—内存比较

//头文件   <string.h>
int memcmp ( const void * ptr1, const void * ptr2, size_t num );
  • num参数是字节。
  • 比较从ptr1和ptr2指针开始的num个__字节__。
  • 返回值如下：
    • ptr1内存块中存储的数据比ptr1内存块中存储的数据大，就返回>0的值
    • ptr1内存块中存储的数据比ptr1内存块中存储的数据小，就返回<0的值
    • 如果将所指定的num字节全部比较完毕后，还是一样的大小，会返回0.

1、代码演示：

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

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 1,3,2 };
	//这里num为12，表示比较12个字节的内容，一个int占用4个字节，所以一共比较3个数字。
	int ret = memcmp(arr1, arr2, 12);
	printf("%d\n", ret);
	return 0;
}

输出：

在这里插入图片描述

分析：是如何比较出来大小的呢？

首先arr1中的数字在内存中是这样存储的：
01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00

然后arr2中的数字在内存中是这样存储的：

01 00 00 00 03 00 00 00 02 00 00 00

因为我们指定了只比较12个字节的数据，所以两个数组开始从头比较，直到比较到第五个字节（如下图）：

arr1的数据是02，arr2的数据是03。这样一来比较大小就有了结果。是arr2大。所以返回-1<0的值。

在这里插入图片描述

4.4、memset—内存设置

void * memset ( void * ptr, int value, size_t num );

参数说明：

  • ptr：需要填充的内存块的地址。
  • value：要被填充的内容，（看着是int类型的，其实可以传char类型的数据，因为字符在内存中存储也是按照ASCII值存储的）。
  • num：要被填充多少个字节。

1、代码演示：

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

int main()
{
	char arr[] = "hello bbo";
	//表示，从整个字符数组首字符开始，一直填充5个'x'字符。
	memset(arr, 'x', 5);
	printf("%s\n", arr);
	return 0;
}

输出：

在这里插入图片描述

让我三行代码
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
嵌入式C语言培训-编程进阶-2字符串
12-19
开发者应始终确保有足够的空间来存储和操作字符串，并使用安全的字符串函数，如`strncpy()`而不是`strcpy()`。 8. **实践应用**：在嵌入式系统中，字符串处理常见于日志记录、配置文件解析、网络通信和用户交互等...
C语言进阶－第4讲存储器与指针共17页.pdf.zip
10-29
5. **常量区**：存放程序中的常量，如字符串字面量，其值在程序运行期间不能改变。 指针在C语言中扮演着关键角色，它是一个变量，其值为另一个变量的地址。通过指针，我们可以直接访问和修改存储在其他位置的变量，...
C语言进阶-字符串函数与内存函数
~
09-21 1842
前言 本章主要讲解： 字符和字符串的库函数的使用和注意事项 求字符串长度 strlen 长度不受限制的字符串函数 strcpy strcat strcmp 长度受限制的字符串函数 strncpy strncat strncmp 字符串查找 strstr strtok 错误信息报告 strerror 字符操作 内存操作函数 memcpy memmove memset memcmp 写在前面的话： C语言本身是没有字符串类型的 字符串通常放在常量字符串（不做修改）中或者字符数
c语言进阶-字符串函数、内存函数
myz1016的博客
06-27 89
（存在各种各样的安全隐患，比如找不到“\0”，就无法停止） 自己给自己追加会修改掉本身的‘\0’停止字符比的是ASCII码值 错误的比较示范 函数的参数多了一个长度的参数。 此函数返回的是找到的字符串的首地址（指针）。如果未找到则返回空指针。
Linux C语言进阶-D2字符数组和字符串
zhaojiazb的博客
10-31 145
字符数组：元素的数据类型为字符类型的数组字符数组的初始化逐个字符赋值,无\0在下图中，剩余的会自动添加上\0，而在int中会自动添加0，和NULL其实是一个意思用字符串常量有\0字符数组长度计算下图中，if 0前面的第一个printf中%s是要打印字符串，字符串打印的话要遇到\0才会结束，所以会接着打印直到碰到\0。
手撕C语言进阶---字符串和内存函数(详解+实现+原码)
Edward_Asia的博客
09-22 608
字符函数和字符串函数 本章重点 重点介绍处理字符和字符串的库函数的使用和注意事项 求字符串长度 strlen 长度不受限制的字符串函数 strcpy strcat strcmp 长度受限制的字符串函数介绍 strncpy strncat strncmp 字符串查找 strstr strtok 错误信息报告 strerror 字符操作 内存操作函数 memcpy memmove memset memcmp 前言 C语言中.
C语言进阶----字符函数和字符串函数
weixin_62436283的博客
03-23 944
目录 前言 函数介绍 长度不受限的字符串函数 1.1 strlen 1.2 strcpy 1.3 strcat 1.4 strcmp 长度受限的字符串函数 1.5 strncpy 1.6 strncat 1.7 strncmp 1.8 strstr 1.9strtok 1.10sterror 内存操作函数： 1.11 memcpy 1.12 memmove 1.13 memcmp 1.14memset
C语言进阶--万字讲解带你学会字符串函数
微笑，来自内心坚不可摧的自信。
02-04 1107
万字讲解带你学会字符串函数
进阶C语言-字符函数和字符串函数
qq_73121173的博客
11-30 507
关于C语言字符串函数
【C语言进阶】--- 字符串函数与内存函数
weixin_59005084的博客
06-01 811
应用并模拟实现函数功能
C语言突破进阶-字符串与内存函数
Allen9012的博客
01-22 1285
C语言突破进阶-字符串与内存函数0. Intro1. strlen1.0 strlen注意事项1.1 证明返回值的无符号型1.2 计数器法模拟1.3 递归法1.4 指针-指针2. strcpy2.0 长度受限函数和长度不受限函数2.1 strcpy 注意事项2.1.1 目标空间足够大2.1.2 目标空间要可变2.2 strcpy 模拟实现3. strcat3.0 认识strcat3.1 strcat 注意事项3.1.1 源字符串必须以'\0' 结束3.1.2 目标空间必须有足够的大3.1.3 目标空间必须可
C语言进阶system函数.docx-综合文档
05-22
**C语言进阶system函数详解** 在C语言编程中，`system()`函数是一个非常实用的工具，它允许我们在程序中直接执行操作系统级别的命令。这个函数在Windows操作系统下尤其常见，其功能是向DOS（Disk Operating System...
C语言进阶system函数.rar-综合文档
05-11
`command`参数是一个字符串，包含了要执行的操作系统命令。`system`函数返回一个整数值，表示命令执行的结果。如果命令成功执行，通常返回0；若出错或命令被终止，返回非零值。 ### 使用示例 以下是一些使用`...
【C语言】深入解析插入排序
Easonmax的博客
07-15 731
插入排序（Insertion Sort）是一种基于比较的排序算法。它的基本思想是将元素逐个插入到已排序的部分中，使整个序列保持有序。插入排序在处理小数据集或几乎已经有序的数据集时，效率较高。
C/C++ 进阶（7）模拟实现map/set
敲代码嘞~的博客
07-12 367
map和set都是关联性容器，底层都是用红黑树写的。存的Key值都是唯一的，不重复。map存的是键值对（Key—Value）。set存的是键值（Key）。
C语言13 位域
weixin_46286415的博客
07-17 169
位域是在结构体中使用的。你可以指定每个成员占用的位数。// 定义一个结构体，包含位域struct {// 占3位// 占5位// 占6位} bitField;// 给位域成员赋值// 打印位域成员的值// 输出: a: 5// 输出: b: 10// 输出: c: 20return 0;类型：位域的类型通常是int或，但也可以是其他整数类型。位宽：冒号后面的数字表示该成员占用的位数。
Windows图形界面(GUI)-DLG-C/C++ - 进度条(ProgressBar)
最新发布
0xCC说逆向
07-18 251
【代码】Windows图形界面(GUI)-DLG-C/C++ - 进度条(ProgressBar)
C语言进阶教程-王桂林解析
"C语言综合提高-王桂林，这是...指针数组，特别是字符指针数组，常用于字符串处理。在返回堆上的空间时，一级指针和二级指针可以作为参数或返回值来传递动态分配的内存，这对于内存管理和复杂数据结构的处理至关重要。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

让我三行代码

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

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

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

打赏作者

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

抵扣说明：

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

余额充值