C语言-字符串+内存函数介绍与模拟实现（10）

最新推荐文章于 2024-07-25 22:24:14 发布
最新推荐文章于 2024-07-25 22:24:14 发布
阅读量472 收藏 16
点赞数 27
分类专栏： C语言学习 文章标签： c语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Locky136/article/details/128306730
版权

目录

思维导图：

字符串与内存函数

求字符串长度

strlen

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

strcpy

strcat

strcmp

长度受限制的字符串函数介绍

strncpy

strncat

strncmp

字符串查找

strstr

strtok

错误信息报告

strerror

perror

字符操作

内存操作函数

memcpy

memmove

memset

memcmp

写在最后：

思维导图：

字符串与内存函数

求字符串长度

strlen

size_t strlen ( const char * str )

其实我们对于strlen函数并不陌生，

他能通过字符串首地址求出字符串长度。

既然如此，我们来挑战一下，用三种不同的方法实现strlen函数：

第一种：循环

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

//size_t strlen(const char * str)
size_t my_strlen(const char* str)
{
	assert(str);
	int count = 0;//计数
	while (*str)//遍历数组
	{
		str++;
		count++;
	}
	return count;
}

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

输出：

输出：6

第二种：递归

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

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

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

输出：

输出：6

第三种：指针减指针

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

//size_t strlen(const char * str)
size_t my_strlen(const char* str)
{
	assert(str);
	const char* start = str;
	while (*str)
	{
		str++;
	}
	return str - start;//指针之间隔着一整个数组
	//数组在内存中是连续存储的，start与str之间相差6个字节
}

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

输出：

输出：6

怎么样，学会了吗？

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

strcpy

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

strcpy是字符串拷贝函数，可以拷贝字符串

例：

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

int main()
{
	char arr1[] = "welcome to my blog";
	char arr2[30] = { 0 };
	strcpy(arr2, arr1);
	printf("%s\n", arr2);
	return 0;
}

输出：

输出：welcome to my blog

注：

1.源字符串必须以 '\0' 结束，

2.该函数会将源字符串中的 '\0' 拷贝到目标空间，

3.目标空间必须足够大，以确保能存放源字符串。

接下来我们可以模拟实现一下strcpy函数：

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

//char* strcpy(char* destination, const char* source)
char* my_strcpy(char* dest, const char* src)
{
	assert(dest && src);
	char* ret = dest;
	while (*dest++ = *src++)
	{
		;
	}
	return ret;//返回的是目标字符串的首字符地址
}

int main()
{
	char arr1[] = "welcome to my blog";
	char arr2[30] = { 0 };
	my_strcpy(arr2, arr1);
	printf("%s\n", arr2);
	return 0;
}

输出：

输出：welcome to my blog

strcat

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

strcat是个字符串追加函数，可以追加字符串。

例：

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

int main()
{
	char arr1[30] = "welcome to";
	char arr2[] = " my ";
	strcat(arr1, arr2);
	strcat(arr1, "blog");
	printf("%s\n", arr1);
	return 0;
}

输出：

输出：welcome to my blog

注：

1.源字符串必须以 '\0' 结束，

2.目标空间必须有足够的大，能容纳下源字符串的内容，

3.目标空间必须可修改。

接下来我们可以模拟实现一下strcat函数：

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

//char* strcat(char* destination, const char* source)
char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);
	const char* ret = dest;
	while (*dest)//指针到'\0'停下
	{
		dest++;
	}
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

int main()
{
	char arr1[30] = "welcome to";
	char arr2[] = " my ";
	my_strcat(arr1, arr2);
	my_strcat(arr1, "blog");
	printf("%s\n", arr1);
	return 0;
}

输出：

输出：welcome to my blog

strcmp

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

strcmp是字符串比较函数，可以用来进行字符串之间的比较。

例：

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

int main()
{
	char arr1[] = "abcd";
	char arr2[] = "abcz";
	int ret = strcmp(arr1, arr2);//按照字典序来排
	if (ret > 0)
		printf("arr1>arr2\n");
	else if (ret == 0)
		printf("arr1=arr2\n");
	else
		printf("arr1<arr2\n");
	return 0;
}

输出：

输出：arr1<arr2

注：

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

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

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

接下来我们可以模拟实现一下strcmp函数：

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

int my_strcmp(const char* src, const char* dest)
{
    int ret = 0;
    assert(src &&dest);
	while (!(ret = *(unsigned char*)src++ - *(unsigned char*)dest++) && *dest && *src)
	{     //!ret如果ret!=0则跳出循环，ret=0则继续,*dest=0和*src=0也跳出循环
		;
	}
	if (ret < 0)
		ret = -1;
	else if (ret > 0)
        ret = 1;
    return ret;
}

int main()
{
	char arr1[] = "abcd";
	char arr2[] = "abcz";
	int ret = my_strcmp(arr1, arr2);//按照字典序来排
	if (ret > 0)
		printf("arr1>arr2\n");
	else if (ret == 0)
		printf("arr1=arr2\n");
	else
		printf("arr1<arr2\n");
	return 0;
}

输出：

输出：arr1<arr2

以上就是长度不受限制的字符串函数。

长度受限制的字符串函数介绍

strncpy

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

strncpy可以控制拷贝过去的字符串的字符个数。

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

int main()
{
	char arr1[20] = "xxxxxxxxxxxxx";
	char arr2[] = "hello";
	strncpy(arr1, arr2, 3);
	printf("%s\n", arr1);
	strncpy(arr1, arr2, 6);//\0也会被拷贝过去
	printf("%s\n", arr1);
	return 0;
}

输出：

输出：
helxxxxxxxxxx
hello

他的实现方式与strcpy自然也是大同小异。

例：

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

//char* strncpy(char* destination, const char* source, size_t num)
char* my_strncpy(char* dest, const char* src, size_t num)
{
	assert(dest && src);
	char* ret = dest;
	for (int i = 0; i < num; i++)
	{
		*dest++ = *src++;
	}
	return ret;//返回的是目标字符串的首字符地址
}

int main()
{
	char arr1[20] = "xxxxxxxxxxxxx";
	char arr2[] = "hello";
	my_strncpy(arr1, arr2, 3);
	printf("%s\n", arr1);
	my_strncpy(arr1, arr2, 6);//\0也会被拷贝过去
	printf("%s\n", arr1);
	return 0;
}

输出：

输出：
helxxxxxxxxxx
hello

strncat

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

strncat可以控制追加字符的数量。

例：

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

int main()
{
	char arr1[30] = "welcome to";
	char arr2[] = " my ";
	strncat(arr1, arr2, 2);
	strncat(arr1, "blog", 2);
	printf("%s\n", arr1);
	return 0;
}

输出:

输出：welcome to mbl

我们也能将它模拟实现一下：

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

//char* strncat(char* destination, const char* source, size_t num)
char* my_strncat(char* dest, const char* src, size_t num)
{
	assert(dest && src);
	const char* ret = dest;
	while (*dest)//指针到'\0'停下
	{
		dest++;
	}
	for (int i = 0; i < num; i++)
	{
		*dest++ = *src++;
	}
	return ret;
}

int main()
{
	char arr1[30] = "welcome to";
	char arr2[] = " my ";
	my_strncat(arr1, arr2, 2);
	my_strncat(arr1, "blog", 2);
	printf("%s\n", arr1);
	return 0;
}

输出：

输出：welcome to mbl

strncmp

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

strncmp可以控制比较的字符串的字符数。

例：

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

void print(int ret)
{
	if (ret > 0)
		printf("arr1>arr2\n");
	else if (ret == 0)
		printf("arr1=arr2\n");
	else
		printf("arr1<arr2\n");
}

int main()
{
	char arr1[] = "abcd";
	char arr2[] = "abcz";
	int ret = strncmp(arr1, arr2, 3);
	print(ret);
	ret = strncmp(arr1, arr2, 4);
	print(ret);
	return 0;
}

输出：

输出：
arr1=arr2
arr1<arr2

字符串查找

strstr

strstr函数可以查找字符串中的字符，并返回他们的地址。

如果找不到对应字符或字符串，就返回空指针。

例：

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

int main()
{
	char arr[] = "welcome to my blog";
	char* p = strstr(arr, "my");
	printf("%s\n", p);
	return 0;
}

输出：

输出：my blog

例2：

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

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

输出：

输出：找不到

接下来我们可以模拟实现一下strstr函数：


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

//char* strstr(const char* str1, const char* str2)
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;//cp指针的作用是作为遍历字符串str1的起始地址

	while (*cp)//如果*cp已经等于'\0'了就证明查找失败了，不再进入循环
	{
		s1 = cp;//如果没找到，s1指针返回cp地址，也就是遍历开始的地址
		s2 = str2;//而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;
}

输出：

输出：bbcdbbcef

strtok

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

strtok函数可以通过分隔符sep分割字符串，并标记

如果之后传空指针，也能通过标记继续分割字符串。

例：

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

int main()
{
	char arr[] = "asdf@hjkl.qwer";
	char* p = "@.";
	char buf[20] = { 0 };
	strcpy(buf, arr);

	char* pa = strtok(buf, p);
	printf("%s\n", pa);

	pa = strtok(NULL, p);//传空指针
	printf("%s\n", pa);

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

	return 0;
}

输出：

输出：
asdf
hjkl
qwer

但是，我们发现，想上面那样写的话，

代码有一点冗余了，该怎么解决呢？

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

int main()
{
	char arr[] = "asdf@hjkl.qwer";
	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;
}

输出：

输出：
asdf
hjkl
qwer

写成循环的形式就好多啦。

错误信息报告

strerror

C语言的库函数在运行的时候，如果发生错误，

就会将错误码存在一个变量中，这个变量是：errno。

而strerror 函数能将错误码翻译成错误信息。

例：

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

int main()
{
	//错误码是一些数字：1 2 3 4 5 ，他们都有不同的含义
	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


perror

但在平时，perror用的也很多，

举个例子：

#include <stdio.h>
#include <string.h>
#include <errno.h>//这个是errno的头文件

int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));//实际上我们并没有这个文件，就能通过strerror报错
		return 1;
	}
	//读文件
	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

输出：

输出：No such file or directory

但是使用perror 函数会更方便和灵活。

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

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

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

例：

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

int main()
{
	int ret = isdigit('Q');//参数是十进制数字 0~9返回真，否则返回假
	printf("%d\n", ret);

	return 0;
}

输出：

输出：0

还有一些字符操作函数：

例:

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

int main()
{
	printf("%c\n", toupper('a'));//转成大写
	printf("%c\n", tolower('A'));//转成小写

	return 0;
}

输出：

输出：
A
a

内存操作函数

memcpy

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

memcpy是内存拷贝函数：

1.函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。

2.这个函数在遇到 '\0' 的时候并不会停下来。

3.如果source和destination有任何的重叠，复制的结果都是未定义的（会出问题）。

例：

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

void print(int* arr, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0 };
	memcpy(arr2, arr1 + 2, 17);//17个字节
	int sz = sizeof(arr2) / sizeof(arr2[0]);
	print(arr2, sz);
}

输出：

输出；3 4 5 6 7 0 0 0 0 0

接下来我们可以模拟实现一下memcpy函数：

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

void print(int* arr, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

//void* memcpy(void* destination, const void* source, size_t num)
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;
	}
	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, 17);//17个字节
	int sz = sizeof(arr2) / sizeof(arr2[0]);
	print(arr2, sz);
}

输出：

输出：3 4 5 6 7 0 0 0 0 0

memmove

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

memmove函数的功能与memcpy的功能类似，但也有差别：

1.和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。

2.如果源空间和目标空间出现重叠，就得使用memmove函数处理

例：

如果使用memcpy,拷贝的结果就会出问题：

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

void print(int* arr, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

//void* memcpy(void* destination, const void* source, size_t num)
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;
	}
	return ret;
}

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memcpy(arr1 + 2, arr1, 17);//17个字节
	int sz = sizeof(arr1) / sizeof(arr1[0]);
	print(arr1, sz);
}

输出：

输出：1 2 1 2 1 2 1 8 9 10

我们想要的结果是：1 2 1 2 3 4 5 8 9 10

（注：在VS2019的环境下，memcpy的库函数实现已经和memmove一样了）

那就得使用memmove函数：

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

void print(int* arr, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr1 + 2, arr1, 17);//17个字节
	int sz = sizeof(arr1) / sizeof(arr1[0]);
	print(arr1, sz);
}

输出：

输出：1 2 1 2 3 4 5 8 9 10

这样就成功得到我们想要的值了。

接下来我们可以模拟实现一下memmove函数：

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

void print(int* arr, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

//void* memmove(void* destination, const void* source, size_t num)
void* my_memmove(void* dest, const void* src, size_t 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--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
}

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr1 + 2, arr1, 17);//17个字节
	int sz = sizeof(arr1) / sizeof(arr1[0]);
	print(arr1, sz);
}

输出：

输出：1 2 1 2 3 4 5 8 9 10

memset

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

memset是内存定义函数，我们一般用它来进行初始化操作。

例：

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

void print(int* arr, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	memset(arr1, 0, sizeof(arr1));//设置成0
	char arr2[20] = "hello world";
	memset(arr2, 'x', 5);//把五个字节的内容设置成‘x’
	int sz = sizeof(arr1) / sizeof(arr1[0]);
	print(arr1, sz);
	printf("%s\n", arr2);
}

输出：

输出：
0 0 0 0 0 0 0 0 0 0
xxxxx world

memcmp

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

memcmp函数能比较从ptr1和ptr2指针开始的num个字节，

ptr1 > ptr2 返回 >0 的数，

ptr1 < ptr2 返回 <0 的数，

ptr1 = ptr2 返回 =0 的数。

例：

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

int main()
{
	char arr1[] = "abcd";
	char arr2[] = "abcz";
	int ret = memcmp(arr1, arr2, 4);//比较四个字节的内容
	if (ret > 0)
		printf("arr1>arr2\n");
	else if (ret == 0)
		printf("arr1=arr2\n");
	else
		printf("arr1<arr2\n");
	return 0;
}

输出：

输出：arr1<arr2

写在最后：

以上就是本篇文章的内容了，感谢你的阅读。

如果喜欢本文的话，欢迎点赞和评论，写下你的见解。

如果想和我一起学习编程，不妨点个关注，我们一起学习，一同成长。

之后我还会输出更多高质量内容，欢迎收看。

戊子仲秋
关注
  • 27
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 36
    评论
专栏目录
【C语言】字符串和内存函数介绍及模拟实现
杨同学的博客
07-07 3267
本文内容：strlen，strcpy，strncpy，strcat，strncat，strcmp，strncmp，strstr，strtok，strerror，memcpy，memmove，memcmp
C语言--字符串操作函数、内存操作函数介绍及模拟实现
羟基与苯的博客
03-29 1036
文章目录前言一、函数介绍1.1 strlen1.2 strcpy1.3 strcat1.4 strcmp1.5 长度受限制的字符串函数strncpy、strncat、strncmp1.5.1 strncpy1.5.2 strncat1.5.3 strncmp1.6 strstr1.7 strtok1.8 strerror1.9 perror1.10 字符分类函数1.11 memcpy1.12 memmove1.13 memcmp1.14 memset二、库函数模拟实现2.1 模拟实现strlen2.2 模拟
C语言----详解字符串相关的库函数（建议收藏）
baiyang2001的博客
09-19 9759
文章目录 系列文章目录 前言 一、C语言相关字符串库函数一览表 二、strlen函数 三、strcpy函数 四、 前言 C语言的库函数，是我们经常在编写程序所用到的函数，我们可以借用库函数去实现各种各样的功能，在本篇文章，我们介绍的是C语言中字符串和字符的相关库函数，以及他们的模拟实现，通过模拟实现我们可以深入了解到库函数的工作原理，以便今后更好的使用 一、C语言相关字符串库函数一览表 求字符串长度 strlen 长度不受限制的字符串函数 strcpy s..
C语言进阶-字符串函数与内存函数
~
09-21 1844
前言 本章主要讲解： 字符和字符串的库函数的使用和注意事项 求字符串长度 strlen 长度不受限制的字符串函数 strcpy strcat strcmp 长度受限制的字符串函数 strncpy strncat strncmp 字符串查找 strstr strtok 错误信息报告 strerror 字符操作 内存操作函数 memcpy memmove memset memcmp 写在前面的话： C语言本身是没有字符串类型的 字符串通常放在常量字符串（不做修改）中或者字符数
C语言-字符串函数+内存函数
weixin_58165485的博客
03-24 1227
1. 字符串函数 1.1 strlen ✨ 函数定义 size_t strlen ( const char * str ); ✨ 函数作用：计算一个字符串的长度 ✨ 函数使用 int main() { char s[] = "qwerty" size_t len = strlen(s); //但其实这里的类型应该是size_t(无符号) printf("%zu", len); // 结果是6 return 0; } ✨ 注意事项 字符串已经 '\0' 作为结束.
C语言之字符串+内存函数
weixin_63451038的博客
03-24 2132
C语言之字符串+内存函数一箩筐
C语言-常用字符函数详解+模拟实现
chuxinchangcun的博客
09-21 2462
今天是2021年9月21日，首先祝大家中秋节快乐啦！但愿人长久，千里共婵娟。又是一年月圆，祝大家在中秋节都能和你爱的人和爱你的人团圆~ 接下来进入整体啦~ 目录 1.字符函数 strlen() strcpy() strcat() strncpy() strcmp() strncat() strncmp() strstr() strtok() 2.总结 下列函数都是包含在#include<string.h>的库函数，若要使用，要现在最开始包含这个库 strlen().
C语言——字符串 + 内存函数详解整理
m0_74171054的博客
02-22 2130
小编精心整理分类了C常用的字符串函数和内存函数，除了函数的正常使用和注意事项，还有模拟实现，锻炼你的编程思维能力，相信这篇文章会成为你收藏夹里的一张查询表单！！！
C语言字符串与内存库函数的介绍与模拟实现
未见花闻的博客
09-19 848
⭐️前面的话⭐️ ???? 大家好！C语言库中为我们开发者提供了很多实用的函数，我相信不少小伙伴都用过有关字符串和内存的库函数，本文将围绕这两方面介绍有关的库函数并试着模拟实现部分的库函数！读完这篇文章你能学到： ????常见字符串与内存库函数的使用； ????掌握重要库函数的模拟实现。
C语言: 详解常用的字符串函数（使用+模拟实现）
须知少日拏云志，曾许人间第一流。
05-01 3295
前言: C语言中,字符串函数和字符函数的使用是很频繁的,如果我们能够熟练使用,能够帮助我们解决很多的字符问题。
C语言中字符串的内存地址操作的相关函数简介
09-03
在C语言中，处理字符串和内存地址的操作是非常常见的任务，特别是在系统编程和底层开发中。本文主要介绍三个非标准但常在某些环境中使用的函数：bcopy()、bzero()和bcmp()，它们分别用于内存复制、清零和比较。 1. ...
c语言中字符串分割函数及实现方法
01-01
自己在写一个linux下的模拟执行指令的时候，遇到了输入”cat a.c”，要将该字符串分解成cat和a.c两个单独的字符串，虽然知道有strtok的存在，但是想自己尝试写一下，于是就自己写了一个，不过总是遇到这样或那样的...
C语言字符串函数strcmp的详解使用和模拟
12-23
在C语言中，`strcmp`函数是用于比较两个字符串的关键函数。它位于`<string.h>`库中，是处理字符串时不可或缺的一部分。本篇将深入探讨`strcmp`函数的使用方法、工作原理以及如何实现一个简单的模拟版本。 `strcmp`...
C语言模拟实现atoi函数的实例详解
08-29
8. atoi函数的实现步骤：atoi函数的实现步骤主要包括检查指针是否为NULL、检查字符串是否为空字符串、跳过空白字符、检查正号与负号、判断是否溢出、处理异常字符等。 9. atoi函数的返回值：atoi函数的返回值可以是...
Windows图形界面(GUI)-DLG-C/C++ - 日期时间控件(DateTimePicker)
0xCC说逆向
07-21 397
【代码】Windows图形界面(GUI)-DLG-C/C++ - 日期时间控件(DateTimePicker)
AvaloniaUI的学习
最新发布
lishuangquan1987的博客
07-25 505
官方中文文档：https://docs.avaloniaui.net/zh-Hans/docs/welcome。
编程学习之路：从零到一的成长指南
KsuferNotes
07-22 445
在当今数字化时代，编程技能已经成为许多人职业发展的重要组成部分。不论你是已经在IT业从业多年的老手，还是刚刚起步的编程新手，这篇博客将带你走过编程学习的每一个重要阶段，从而顺利完成从零到一的华丽转变。
纯前端小游戏，4096小游戏，有音效，Html5，可学习使用
m0_62996549的博客
07-18 628
【代码】纯前端小游戏，4096小游戏，有音效，Html5，可学习使用。
从0开始的STM32HAL库学习6
hwq_1229_0525的博客
07-21 362
配置红色框图中的各种配置时钟源选择外部时钟 21.预分频器Prescaler，下面填0，不分频2.计数模式，计数模式选择为向上计数3.自动重装寄存器，自动重装计数器填为10，计数到10后清空并出发中断4.滤波器的频率分频：不使用影子寄存器。
c语言字符串替换函数模拟实现
07-25
C语言字符串替换函数模拟实现的方法有很多，以下是一种可能的实现方式： ```c #include #include void str_replace(char *str, const char *find, const char *replace) { int find_len = strlen(find); int ...
评论 36
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

戊子仲秋

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

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

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

打赏作者

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

抵扣说明：

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

余额充值