【C语言】—— 字符串&内存函数（详解）

已于 2022-06-20 17:46:50 修改
阅读量665 收藏 4
点赞数 11
分类专栏： C语言系列 文章标签： c语言 c++
于 2022-02-13 19:25:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sjsjnsjnn/article/details/122895122
版权

 

目录

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

1.strlen函数

​2.strcpy函数

3.strcat函数 

4.strcmp函数 

二、 长度受限制的字符串函数

1.strncpy函数

2.strncat函数 

​3.strncmp函数

三、其他字符串函数

1.strstr函数

2.strtok函数

四、内存操作函数

1.memcpy函数 

2.memmove 函数

3.memcmp函数 

4.memset函数

​五、库函数的模拟实现

1.模拟实现strlen函数

①递归实现

②计数器实现

③指针 - 指针

2.模拟实现strcpy函数

3.模拟实现strcat函数

4.模拟实现strcmp函数

5.模拟实现strncpy函数

6.模拟实现strncat函数

7.模拟实现strncmp函数

8.模拟实现strstr函数

9.模拟实现memcpy函数

10.模拟实现memmove函数

11.模拟实现memcmp函数

12.模拟实现memset函数

六、总结

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

1.strlen函数

字符串以‘\0’作为结束标志，strlen函数返回的是字符串前面出现的字符个数

函数原型：size_t strlen( const char *string );

头 文 件 ：<string.h>

函数功能：计算字符串的长度；

注意事项：1.定义的字符串必须要包含'\0'

char arr1[] = "abcd";/*正确*/
char arr2[] = { 'a', 'b', 'c', 'd' };/*错误*/

举例：

#include <stdio.h>
#include <string.h>
int main()
{
	char str1[] = "ABCD";//里面包含\0
	char str2[] = { 'A','B','C','D' };//里面不包含\0
	printf("%d\n", strlen(str1));
	printf("%d\n", strlen(str2));
	return 0;
}

2.strcpy函数

函数原型：char *strcpy( char *strDestination, const char *strSource );

头 文 件 ：<string.h>

函数功能：字符串拷贝；它是连同'\0'一起拷贝过去；

参数解读：

                  1.char *strDestination --- 目标字符串

                  2.const char *strSource  --- 源字符串（不可被修改）

                  3.返回类型：char* --- 返回的是拷贝后源字符串的地址

注意事项:

                1.拷贝时源字符串中一定要包含\0;

                2.拷贝时目标空间要足够大，保证放的下要拷贝过去的字符串;

                3.拷贝时目标空间必须可修改（不能被const修饰）;

 举例：

#include <stdio.h>
#include <string.h>
int main()
{
	char str1[20] = "xxxxxxx";//目标空间要足够大
	char str2[] = "Hello World";
	printf("拷贝前为：%s\n", str1);
	strcpy(str1, str2);
	printf("拷贝后为：%s\n", str1);
	return 0;
}

3.strcat函数 

函数原型：char *strcat( char *strDestination, const char *strSource );

头 文 件 ：<string.h>

函数功能：字符串连接（追加）：它是连同'\0'一起追加过去；

参数解读：

                  1.char *strDestination --- 目标字符串

                  2.const char *strSource  --- 源字符串（不可被修改）

                  3.返回类型：char* --- 返回的是拷贝后源字符串的地址

注意事项：

                 1.追加时源字符串中一定要包含\0

                 2.追加时目标空间要足够大，保证放的下要追加过去的字符串

                 3.追加时目标空间必须可修改（不能被const修饰）

                 4.自己不能给自己追加（需要使用strncat）

举例：

#include <stdio.h>
#include <string.h>
int main()
{
	char str1[20] = "Hello ";//目标空间要足够大
	char str2[] = "World";
	printf("追加前为：%s\n", str1);
	strcat(str1, str2);
	printf("追加后为：%s\n", str1);
	return 0;
}

4.strcmp函数 

函数原型：int strcmp( const char *string1, const char *string2 );

头 文 件 ：<string.h>

函数功能：字符串比较：比较的是ASSIC码值;比较的是内容而不是长度；

参数解读：

                  1.string1 --- 被比较的字符串；

                  2.string2 --- 待比较的字符串；

比较方法：

                  1.当 str1 < str2  返回负数

                  2.当 str1 = str2  返回0

                  3.当 str1 > str2  返回正数 

举例：

#include <stdio.h>
#include <string.h>
int main()
{
	char str1[] = "ABCD";
	char str2[] = "ABCE";
	int ret = strcmp(str1, str2);
	if (ret > 0)
	{
		printf("ret=%d：str1>str2\n", ret);
	}
	else if (ret < 0)
	{
		printf("ret=%d：str1<str2\n", ret);
	}
	else
	{
		printf("ret=%d：str1=str2\n", ret);
	}
	return 0;
}

 

二、 长度受限制的字符串函数

1.strncpy函数

函数原型：char *strncpy( char *strDest, const char *strSource, size_t count );

头 文 件 ：<string.h>

函数功能：字符串拷贝：可以指定拷贝字符的个数；

参数解读：

                  1.char *strDest --- 目标字符串

                  2.const char *strSource  --- 源字符串（不可被修改）

                  3.size_t count --- 指定拷贝多少个字符

                  4.返回类型：char* --- 返回的是拷贝后源字符串的地址

注意事项:

                  1.拷贝时：当拷贝的个数大于源字符串长度时（比如源字符串“abcd”，拷贝6个），不够的用\0补（设置个数时要合理）

                  2.拷贝时目标空间要足够大，保证放的下要拷贝过去的字符串

                  3.拷贝时目标空间必须可修改（不能被const修饰）

举例：

#include <stdio.h>
#include <string.h>
int main()
{
	char dest[20] = "xxxxxxx";
	char src[] = "Hello World";
	printf("拷贝前为：%s\n", dest);
	strncpy(dest, src,5);
	printf("拷贝后为：%s\n", dest);
	return 0;
}

#include <stdio.h>
#include <string.h>
int main()
{
	char dest[20] = "xxxxxxxxxx";
	char src[] = "abcd";
	printf("拷贝前为：%s\n", dest);
	strncpy(dest, src, 6);
	printf("拷贝后为：%s\n", dest);
	return 0;
}

 

2.strncat函数 

函数原型：char *strncat( char *strDest, const char *strSource, size_t count );

头 文 件 ：<string.h>

函数功能：字符串追加：可以指定追加字符的个数；

参数解读：

                  1.char *strDest --- 目标字符串

                  2.const char *strSource  --- 源字符串（不可被修改）

                  3.size_t count --- 指定追加多少个字符

                  4.返回类型：char* --- 返回的是拷贝后源字符串的地址

注意事项：

                  1.追加时：当追加的个数小于源字符串的个数时，会主动追加'\0'

                  2.追加时：当追加的个数大于源字符串的个数时，库函数的定义是只追加到'\0'位置，所以个数就算很大并不影响

                  3.追加时目标空间必须可修改（不能被const修饰）

 举例：

#include <stdio.h>
#include <string.h>
int main()
{
	char dest[20] = "Hello ";
	char src[] = "World";
	printf("追加前为：%s\n", dest);
	strncat(dest, src, 4);
	printf("追加后为：%s\n", dest);
	return 0;
}

3.strncmp函数

函数原型：int strncmp( const char *string1, const char *string2, size_t count );

头 文 件 ：<string.h>

函数功能：字符串比较：可以指定比较字符的个数；

参数解读：

                  1.string1 --- 被比较的字符串；

                  2.string2 --- 待比较的字符串；

                  3.size_t count --- 指定 比较多少个字符 （从前向后比较）

比较方法：

                  1.当 str1 < str2  返回负数

                  2.当 str1 = str2  返回0

                  3.当 str1 > str2  返回正数 

举例：

#include <stdio.h>
#include <string.h>
int main()
{
	char str1[] = "ABCD";
	char str2[] = "ABCE";
	int ret = strncmp(str1, str2,3);
	if (ret > 0)
	{
		printf("ret=%d：str1>str2\n", ret);
	}
	else if (ret < 0)
	{
		printf("ret=%d：str1<str2\n", ret);
	}
	else
	{
		printf("ret=%d：str1=str2\n", ret);
	}
	return 0;
}

 

三、其他字符串函数

1.strstr函数

函数原型：char *strstr( const char *string, const char *strCharSet );

头  文  件：<string.h>

函数功能：字符串查找：在string中查找strCharSet是否存在；

参数解读：

                  1.string --- 被搜索的以空结尾的字符串；

                  2.strCharSet --- 要搜索的以空结尾的字符串；

注意事项：

                  1.当找到时：返回一个指针 strCharSet 在string中第一次出现的那个位置；

                  2.未找到时：返回一个空指针（NULL）；

举例：

#include <stdio.h>
#include <string.h>
int main()
{
	char str1[] = "ABCD";
	char str2[] = "BC";
	char str3[] = "HaHa";
	if (strstr(str1, str2) != NULL)
	{
		printf("找到了\n");
	}
	else
	{
		printf("找不到\n");
	}
	return 0;
}

2.strtok函数

函数原型：char *strtok( char *strToken, const char *strDelimit ); 

头  文  件：<string.h>

函数功能：字符串切分

功能：

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

        2.第一个参数指定一个字符，它包含0个或多个由sep字符串中一个或多个分隔符分割的标记

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

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

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

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

 举例：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[] = "zhangsan@school.student";
	char arr2[100] = { 0 };
	char sep[] = "@.";
	strcpy(arr2, arr1);
	char* ret = NULL;
	for (ret = strtok(arr2, sep); ret != NULL;ret=strtok(NULL,sep))
	{
		printf("%s\n", ret);
	}
	return 0;
}

 

四、内存操作函数

1.memcpy函数 

函数原型：void *memcpy( void *dest, const void *src, size_t count ); 

头  文  件：<memory.h>or<string.h>

函数功能：内存拷贝：（适用于内存不重叠的场景）

功能：

        1.函数memcpy从src的位置开始向后复制count个字节的数据到dest的内存位置；

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

        3.如果source和destination有任何重叠，复制的结果都是未定义的；

 举例：

#include <stdio.h>
#include <string.h>
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	memcpy(arr1, arr1 + 4, 16);
	//arr1+2是指向5的，从这个位置向后16个字节的数据存到arr1向后16个字节
	//也就是把5 6 7 8 拷贝到1 2 3 4 上去
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	printf("\n");
	return 0;
}

2.memmove 函数

函数原型：void *memmove( void *dest, const void *src, size_t count ); 

头  文  件：<string.h>

函数功能：内存拷贝：（适用于内存重叠或不重叠的场景）

注意事项：

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

举例：

#include <stdio.h>
#include <string.h>
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr1, arr1 + 2, 16);
	//arr1+2是指向3的，从这个位置向后16个字节的数据存到arr1向后16个字节
	//也就是把3 4 5 6 拷贝到1 2 3 4 上去（这里就是内存重叠了，重叠的位置是3 4）
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	printf("\n");
	return 0;
}

3.memcmp函数 

函数原型：int memcmp( const void *buf1, const void *buf2, size_t count );

头  文  件：<memory.h>or<string.h>

函数功能：内存比较：（比较buf1和buf2指针开始的num个字节）

比较方法：

                1.当buf1<buf2时 返回<0

                2.当buf1=buf2时 返回=0

                3.当buf1>buf2时 返回>0

举例：

#include <stdio.h>
#include <string.h>
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 1,2,3,6,6 };
	int ret = memcmp(arr1, arr2, 12);
	//这里向后比较12个字节，就是比较1 2 3
	if (ret > 0)
	{
		printf("ret=%d arr1>arr2\n", ret);
	}
	else if (ret < 0)
	{
		printf("ret=%d arr1<arr2\n", ret);
	}
	else
	{
		printf("ret=%d arr1=arr2\n", ret);
	}
	return 0;
}

 

4.memset函数

函数原型：void *memset( void *dest, int c, size_t count );

 头  文  件：<memory.h>or<string.h>

函数功能：内存设置（memset函数将dest的第一个count个字节设置为字符c）

举例：

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

int main()
{
	char str[] = "almost every programmer should know memset!";
	memset(str, '-', 6);//从起始位置开始向后6个字节的内容改为 '-'
	puts(str);
	return 0;
}

五、库函数的模拟实现

1.模拟实现strlen函数

①递归实现

#include <stdio.h>
int my_strlen(const char* pa)
{
	if (*pa != '\0')
	{
		return 1 + my_strlen(pa + 1);//1+1+1+1+1+1+0
	}
	else
	{
		return 0;
	}

}
int main()
{
	char arr[] = "abcdef";
	int ret = my_strlen(arr);
	printf("arr的长度为：%d\n", ret);
	return 0;
}

②计数器实现

#include <stdio.h>
int my_strlen(const char* pa)
{
	int count = 0;
	for (int i = 0; pa[i] != '\0'; i++)
	{
		count++;//只要不等于 \0 就加一
	}
	return count;
}
int main()
{
	char arr[] = "abcdef";
	int ret = my_strlen(arr);
	printf("arr的长度为：%d\n", ret);
	return 0;
}

③指针 - 指针

#include <stdio.h>
int my_strlen(const char* pa)
{
	char* pa1 = pa;//先保存首元素的地址
	while (*pa1)
	{
		pa1++;//去找 \0 的地址
	}
	return pa1 - pa;//pa1是 \0 的地址，pa是首元素的地址；相减就得到元素个数
}
int main()
{
	char arr[] = "abcdef";
	int ret = my_strlen(arr);
	printf("arr的长度为：%d\n", ret);
	return 0;
}

2.模拟实现strcpy函数

#include <stdio.h>
#include <assert.h>
char* my_strcpy(char* dest, const char* src)
{
	assert(dest && src);//断言 --- 判断这两个指针是否为空
    char* ret = dest;
	while (*dest++ = *src++)//直接赋值，直到遇到'\0'就停下
	{
		;
	}
    return ret;
}

int main()
{
	char arr1[20] = "xxxxxx";
	char arr2[] = "Hello";
	printf("拷贝前为：%s\n", arr1);
	char* ret = my_strcpy(arr1, arr2);
	printf("拷贝后为：%s\n", ret);
	return 0;
}
#include <stdio.h>
#include <assert.h>
char* my_strcpy(char* dest, const char* src)
{
	assert(dest && src);//断言 --- 判断这两个指针是否为空
	int i = 0;
	for (i = 0; src[i] != '\0'; i++)
	{
		dest[i] = src[i];//赋值，但是没有'\0'结束标志
	}
	dest[i] = '\0';//末尾添加一个'\0'

}

int main()
{
	char arr1[20] = "xxxxxx";
	char arr2[] = "Hello";
	printf("拷贝前为：%s\n", arr1);
	my_strcpy(arr1, arr2);
	printf("拷贝后为：%s\n", arr1);
	return 0;
}

3.模拟实现strcat函数

#include <stdio.h>
#include <assert.h>
char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);//断言 --- 判断这两个指针是否为空
	while (*dest)
	{
		//先找到dest所指向的数组中'\0'的位置
		dest++;
	}
	while (*src)
	{
		*dest++ = *src++;//进行追加
	}
}
int main()
{
	char arr1[20] = "Hello ";
	char arr2[] = "World";
	printf("追加前为：%s\n", arr1);
	my_strcat(arr1, arr2);
	printf("追加后为：%s\n", arr1);
	return 0;
}

4.模拟实现strcmp函数

#include <stdio.h>
#include <assert.h>
int my_strcmp(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[] = "ABCDEF";
	char arr2[] = "ABCDE";
	int ret = my_strcmp(arr1, arr2);
	if (ret > 0)
	{
		printf("ret = %d：arr1>arr2", ret);
	}
	else if (ret < 0)
	{
		printf("ret = %d：arr1<arr2", ret);
	}
	else
	{
		printf("ret = %d：arr1=arr2", ret);
	}
	return 0;
}

5.模拟实现strncpy函数

#include <stdio.h>
#include <assert.h>
char* my_strncpy(char *dest, const char *src,size_t count)
{
	assert(dest && src);
	char *ret = dest;
	//1.拷贝字符串的个数
	while (count && (*dest++ = *src++))
	{
		count--;
	}
	//2.不够的用\0补
	if (count)
	{
		while (--count)
		{
			*dest++ = '\0';
		}
	}
	return ret;
}
int main()
{
	char arr1[20] = "xxxxxxxx";
	char arr2[] = "Hello World";
	printf("拷贝前为：%s\n", arr1);
	char* ret = my_strncpy(arr1, arr2, 5);
	printf("拷贝后为：%s\n", ret);
	return 0;
}

6.模拟实现strncat函数

#include <stdio.h>
#include <assert.h>
char* my_strncat(char *dest, const char *src, int count)
{
	assert(dest && src);
	char *ret = dest;
	//1.先找到\0的位置
	while (*dest++)
	{
		;
	}
	dest--;
	//2.将源字符串追加进去（根据指定的个数）
	while (count--)
	{
		//3.只要不是\0就一直追加，追加到\0为止
		if (!(*dest++ = *src++))
		{
			return ret;
		}
	}
	*dest = '\0';
	return ret;
}
int main()
{
	char arr1[20] = "Hello ";
	char arr2[] = "World";
	printf("追加前的字符串为：%s\n", arr1);
	char *ret = my_strncat(arr1, arr2, 8);
	printf("追加后的字符串为：%s\n", ret);
	return 0;
}

7.模拟实现strncmp函数

#include <stdio.h>
#include <assert.h>
int my_strncmp(char *str1, const char *str2, int count)
{
	assert(str1 && str2);
	while(count&&(*str1 == *str2))
	{
		if (*str1 == '\0')
			return 0;
		str1++;
		str2++;
		count--;
	}
	return *str1 - *str2;
}
int main()
{
	char arr1[] = "Hello";
	char arr2[] = "Helld";
	int ret = my_strncmp(arr1, arr2, 5);
	if (ret > 0)
	{
		printf("ret = %d：arr1>arr2", ret);
	}
	else if (ret < 0)
	{
		printf("ret = %d：arr1<arr2", ret);
	}
	else
	{
		printf("ret = %d：arr1=arr2", ret);
	}
	return 0;
}

8.模拟实现strstr函数

#include <stdio.h>
#include <assert.h>
char* my_strstr(char* str1, const char* str2)
{
	assert(str1 && str2);
	char* s1;
	char* s2;
	char* cp = str1;
    //如果传过来的是 \0
	if (*str2 == '\0')
	{
		return str1;
	}
    //两种情况：
    //		    arr1-- abcdef   arr1-- abbbcdef
    //	查找	arr2-- bcd      arr2-- bbc
	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[] = "abbbcdef";
	char arr2[] = "bcd";
	char* ret = my_strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("找不到\n");
	}
	else
	{
		printf("找到了，是：%s\n", ret);
	}
	return 0;
}

9.模拟实现memcpy函数

#include <stdio.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;//强制转换为char*，是为了让其一次访问一个字节的内容
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memcpy(arr, arr + 4, 4 * sizeof(int));
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

10.模拟实现memmove函数

#include <stdio.h>
#include <assert.h>
void* my_memmove(void* dest, const void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	if (dest < src)
	{
		//从前向后拷贝
		while (count--)
		{
             //强制转换为char*，是为了让其一次访问一个字节的内容
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		//从后向前拷贝
		while (count--)
		{
			*((char*)dest + count) = *((char*)src + count);
		}
	}
	return ret;
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr, arr + 2, 4 * sizeof(int));
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

11.模拟实现memcmp函数

#include <stdio.h>
#include <assert.h>
int my_memcmp(const void* ptr1, const void* ptr2, size_t num)
{
	assert(ptr1 && ptr2);
    //void* --- 无具体类型指针
    //1.可以接受任意类型的指针
    //2.但不能进行运算
    //这里进行强制转换后就能够执行了
	while (num&&(*(char*)ptr1== *(char*)ptr2))
	{
		if (*(char*)ptr1 == '\0')
		{
			return 0;
		}
		ptr1 = (char*)ptr1+1;
		ptr2 = (char*)ptr2+1;
		num--;
	}
	return *(char*)ptr1 - *(char*)ptr2;
}
int main()
{
	char buf1[] = "ABCDEF";
	char buf2[] = "ABCDGS";
	int ret = my_memcmp(buf1, buf2, 4 * sizeof(char));
	if (ret > 0)
	{
		printf("buf1>buf2\n");
	}
	else if (ret < 0)
	{
		printf("buf1\<buf2\n");
	}
	else
	{
		printf("buf1=buf2\n");
	}
	return 0;
}

12.模拟实现memset函数

#include <stdio.h>
#include <assert.h>
void* my_memset(void* ptr, int val, size_t num)
{
	assert(ptr);
	for (int i = 0; i < num; i++)
	{
		*((char*)ptr + i) = val;
	}
    return ptr;
}
int main()
{
	char str[] = "almost every programmer should know memset!";
	char ch = '-';
	my_memset(str, ch, 6);
	puts(str);
	return 0;
}

六、总结

         以上的这些库函数大部分使用较多，深入了解并牢牢掌握其功能，对于这方面的解题会得心应手，笔者可能在模拟实现上不一定是最优解，但是可以帮助大家从了解到掌握。

霄沫凡
关注
  • 11
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 19
    评论
专栏目录
C语言——字符串 + 内存函数详解整理
m0_74171054的博客
02-22 1845
小编精心整理分类了C常用的字符串函数和内存函数，除了函数的正常使用和注意事项，还有模拟实现，锻炼你的编程思维能力，相信这篇文章会成为你收藏夹里的一张查询表单！！！
C语言——字符串函数（必收藏）
weixin_59174190的博客
04-16 1万+
超细超用心的字符串函数详解（必收藏噢！入股不亏！）
【C语言进阶】⑦字符串函数详解
森林里的白杨
05-16 1765
一、字符串函数 1.求字符串长度 - strlen()： 函数介绍： 字符串以 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包 含 ‘\0’ )； 传递的实参所指向的字符串必须要以 ‘\0’ 结束，否则得到的是一个错误值； 函数strlen()的返回值为size_t，是无符号的整数； 2.自己模拟实现strlen()函数的功能 2.1计数器版本 int my_strlen(const char*str){ int count = 0; asser
【C语言】字符串和内存函数详解
qq_68661624的博客
10-09 3382
字符串函数 strlen、strcpy、strcat、strcmp、strncpy、strncat、strncmp、strstr、strtok、strerror 内存函数memcpy、memmove、memcmp、memset 等函数详解
C语言——字符串函数（七千字详解）
2202_75625589的博客
01-14 6521
自从学会了字符串函数，做题有速度了，头发也长起来了。
C语言—— 字符串与指针
m0_73246954的博客
09-01 3140
⭐️1 字符串的表示形式 在C程序中，可以用两种方法访问一个字符串 (1)用字符数组存放一个字符串，然后输出该字符串。 (2)用字符指针指向一个字符串 ⭐️2 字符指针作函数参数 将一个字符串从一个函数传递到另一个函数，可以用地址传递的方法，即用字符数组名作参数，也可以用指向字符的指针变量作参数。在被调用的函数中可以改变字符串的内容，在主调函数中可以得到改变了的字符串。 (1)用字符数组作参数 (2)形参用字符指针变量 ⭐️3 对使用字符指针变量和字符数组的讨论 虽然用字符数组
C语言常用字符串函数详解
weixin_43164548的博客
08-30 1901
对C语言标准库里面的string.h常用的函数进行解释说明，并模拟实现，有助于更好的运用和理解C语言里面的字符串库函数
C语言——字符串基础详解
热门推荐
qq_40918707的博客
03-31 2万+
字符数组 char word[] = {'H', 'e', 'l', 'l', 'o', '!'}; word[0] H word[1] e word[2] l word[3] l word[4] o word[5] ! 字符串 char word[] = {'H', 'e', 'l', 'l', 'o', '!', '\0'}; word[0] H...
c语言——字符串右移
qq_62136607的博客
01-20 3083
例题详解： 将一个字符串循环右移n位 输入样例： abcdefghijklmn 10 输出样例： efghijklmnabcd #include<stdio.h> #include<string.h> int move(char b[],int n,int m); int main() { int n,m,i; char a[50]; printf("请输入字符串：") ; scanf("%s",a); n=strlen(a); printf("请输入.
C语言中字符串实现正序与逆序实例详解
12-31
C语言中字符串实现逆序实例详解 字符串逆序和正序的实现代码： #include #include #include #include #include /*定义*/ typedef struct node { char c; struct node *llink,*rlink; }stud; /*建立链表*/ ...
C语言字符串函数strcmp的详解使用和模拟
12-23
在C语言中，`strcmp`函数是用于比较两个字符串的关键函数。它位于`<string.h>`库中，是处理字符串时不可或缺的一部分。本篇将深入探讨`strcmp`函数的使用方法、工作原理以及如何实现一个简单的模拟版本。 `strcmp`...
C语言-字符串函数大全和详解
08-16
C语言-字符串函数大全和详解，基本上包含了所有的C语言的字符串处理函数，而且讲解很详细
C语言字符串(string)函数详解.pdf
11-23
C语言字符串(string)函数详解.pdf
[C/C++入门][循环]14、计算2的幂(2的n次方）
qq_14840819的专栏
07-15 914
计算2的幂（即2的n次方）非常经典。你懂几种方法呢？很多人只会一种，我们来分析一下。
[C/C++入门][ifelse]15、判断奇偶数
qq_14840819的专栏
07-16 342
在数学中，判断一个整数是否为奇数或偶数的依据是基于数的模运算。对于任意整数 n，当 n除以2的余数等于0 时，n 是偶数；当 余数为1 时，n 是奇数。计算机中% 表示模运算，即求余数。尝试运行以下这段代码，看看它如何工作。如果有疑问，随时留在评论区，我们一起讨论吧。
PD协议芯片ECP5701+充电管理芯片+升压芯片搭配应用TYPE-C口充电及升压供电系统
IC_Aihui的博客
07-18 704
能芯科技ECP5701是一颗PD取电芯片，支持PD和QC取电，兼容USB PD3.0规范，并向下支持USB PD2.0，支持QC3.0和QC2.0，支持PD取电5、9、12、15、20V电压，QC取电9V和12V，芯片采用SOP8封装，外围简单。然而，TYPE-C接口，全称USB Type-C，迅速取代了传统的USB接口，不仅如此，TYPE-C接口的普及和PD（Power Delivery）取电协议芯片的出现，这一切便有了转机，这在快节奏的现代生活中，为我们的设备充电带来了极大的便利。
TYPE-C接口PD取电快充协议芯片ECP5701：支持PD 2.0和PD 3.0(5V,9V,12V,15V,20V)
最新发布
IC_Aihui的博客
07-18 434
PD取电快充协议芯片接收到请求信号后，会根据电池的容量、充电器的功率以及当前电池的状态等因素，计算出合适的电压和电流，然后向充电器发送反馈信号。总的来说，TYPE-C接口和PD取电快充协议的结合，是现代电子设备充电技术的一大进步，它们的普及和应用，无疑让我们的生活更加便捷，更加智能。比如可以配置适配器输出需要的电压，给。而TYPE-C接口作为新一代的USB接口，具有正反插、传输速度快、充电体验好等优点，已经成为了快充技术的主要接口形式。◇ 可自动匹配 PD 输出 5V，9V，12V，15V，20V电压。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 游乐园门票 (200分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
07-14 617
- 一日票: 仅限当日有效 - 三日票: 从购买当日起,连续3天内有效 - 周票: 从购买当日起,连续7天内有效 - 月票: 从购买当日起,连续30天内有效 现在给定每种门票的价格,以及LYA计划在未来一年内的游玩日期,请帮助LYA计算出她需要支付的最低门票费用。
"C语言字符串操作函数详解及应用实例
本章主要介绍了C语言中的字符串操作函数，并讨论了一些常见的字符串处理技巧。C语言提供了许多标准库函数来处理字符串，通过学习这些函数的使用方法，可以帮助程序员更高效地编写程序。 在本章中，首先介绍了字符串...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

霄沫凡

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

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

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

打赏作者

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

抵扣说明：

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

余额充值