C语言字符串函数和内存函数

最新推荐文章于 2024-07-24 10:46:51 发布
最新推荐文章于 2024-07-24 10:46:51 发布
阅读量82 收藏 1
点赞数 1
分类专栏： 笔记 文章标签： c语言 青少年编程 c++ 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66300412/article/details/124079594
版权

C语言字符串函数和内存函数

一、求字符串长度

在使用字符串函数时都需要引头文件 <string.h>。

1.strlen

strlen是打印字符串中含有字符的个数。
使用示例：

int main()
{
	char str[] = "abc";
	int ret = strlen(str);
	//strlen是计算'\0'之前字符的个数，不包括'\0'。
	printf("%d", ret);//结果为3
	return 0;
}

strlen的模拟实现:

//计数器方式
int my_strlen(const char* str)
{
	int count = 0;
	while (*str++)
	{
		count++;
	}
	return count;
}

//不创建临时变量计数器的方法
int my_strlen(char* str)
{
	if (*str == '\0')
	{
		return 0;
	}
	else
	{
		return 1 + my_strlen(str + 1);
	}
}

//指针-指针的方式
int my_strlen(char* s)
{
  char* p = s;
	while (*p != '\0')
		p++;
	return p - s;
}

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

注意：strlen返回的是无符号数。

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

1.strcpy

strcpy是将一个字符串中的字符拷贝到另一个空间。
1.源字符串必须以’\0’结束。
2.会将源字符串中的’\0’拷贝到目标空间。
3.目标空间必须足够大，以确保能存放源字符串。
4.目标空间必须可变。
使用示例：

int main()
{
	char str1[] = "XXXXXXXXXX";
	char str2[] = "Juice";
	printf(strcpy(str1, str2));//strcpy会返回目标空间的首字符地址，打印结果为Juice。
	return 0;
}

模拟实现：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <assert.h>
char* my_strcpy(char* dest, const char* sorc)
{
	char* ret = dest;
	assert(dest && sorc);
	while (*dest++ = *sorc++)
	{
		;
	}
	return ret;
}

int main()
{
	char str1[] = "abcdefg";
	char str2[] = "efg";
	printf("%s\n", my_strcpy(str1, str2));//结果为efg。
	return 0;

}

2.strcat

strcat函数是将源字符串追加到目标字符串的后面。
1.目标字符串必须包含’\0’，因为是从目标字符串的’\0’开始追加。
2.源字符串必须以’\0’结束。
3.会将源字符串中的’\0’拷贝到目标空间。
4.目标空间必须足够大，以确保能存放源字符串。
5.目标空间必须可变。

int main()
{
	char str1[50] = "Hello!";
	char str2[] = "World";
	printf("%s", strcat(str1, str2));//str1是目标字符串，str2是源字符串
	                                 //将str2追加到str1的后面，打印结果为 Hello！World
}

strcat的模拟实现：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
char* my_strcat(char* str1, const char* str2)
{
	assert(str1 && str2);
	char* ret = str1;
	while (*str1)
	{
		str1++;
	}
	while (*str2)
	{
		*str1++ = *str2++;
	}
	*str1 = *str2;
	return ret;
}

int main()
{
	char str1[50] = "hello ";
	char str2[] = "bit!";
	printf("%s\n", my_strcat(str1, str2));//打印结果为 hello bit！
	return 0;
}

3.strcmp

strcmp比较的不是字符串的长度，而是按照ASCII码比较两个字符串中对应位置上的字符的大小，如果相同，就比较下一对，直到不同或者都遇到’\0’。

规定：1.第一个字符串大于第二个字符串，则返回大于0的数字。
2.第一个字符串小于第二个字符串，则返回小于0的数字。
3.第一个字符串等于第二个字符串，则返回0。
使用示例：

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abq";
	int ret = strcmp(arr1, arr2);//c的ASCII码值小于q的ASCII码值，所以strcmp返回一个小于0的数。
	printf("%d", ret);//打印结果为-1
}

strcmp的模拟实现：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int my_strcmp(const char* str1, const char* str2)
{
	while (*str1++ && *str2++)
	{
		if (*str1 > *str2)
		{
			return 1;
		}
		else if (*str1 < *str2)
		{
			return -1;
		}
		else
		{
			return 0;
		}
	}
}

void print_strcmp(int(*cmp)(const char* str1, const char* str2),const char*str1,const char*str2)
{
	if (cmp(str1, str2) > 0)
	{
		printf("str1大于str2");
	}
	else if (cmp(str1, str2) < 0)
	{
		printf("str1小于str2");
	}
	else
	{
		printf("str1等于str2");
	}
}

int main()
{
	char str1[] = "abcd";
	char str2[] = "accd";
	char str3[] = "ab";
	print_strcmp(my_strcmp,str1,str2);//结果为str1小于str2
	return 0;
}

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

1.strncpy

strncpy的使用方法与strcpy一样，只不过可以规定要拷贝字符串的个数。
1.拷贝n个字符从源字符串到目标空间。
2.如果源字符串的长度小于n，则拷贝完字符串之后，在目标的后面追加0，直到n个。

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



int main()
{
	char str1[50] = "XXXXXX";
	char str2[] = "Juice";
	//strncpy的第三个参数是要操作的字符串个数
	printf("%s", strncpy(str1, str2, 5));//打印结果为 JuiceX。
	printf("%s", strncpy(str1, str2, 6));//打印结果为 Juice，因为把'\0'也拷贝进去了。
}

strncpy的模拟实现：

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

char* my_strncpy(char* dest, const char* src, int num)
{
	char* ret = dest;
	while (num-- && *src)
	{
		*dest++ = *src++;
	}
	if (num != -1)
	{
		*dest = 0;
	}
	return ret;
}

int main()
{
	char str1[50] = "hello";
	char str2[] = "bit";
	my_strncpy(str1, str2, 2);//打印结果为billo
	printf("%s", str1);
	return 0;
}

2.strncat

strncat的使用方法和strcat一样，只不过可以规定追加的字符个数。
1.strncat在将源字符串追加到目标空间时，如果追加的字符不包括’\0’，那么除了将所追加的n个字符追加到目标字符串后面，还会自动再追加一个’\0’在后面。
2.如果n大于源字符串的字符个数，那么也只会将源字符串中的字符追加到目标字符串后面。
使用示例：

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

int main()
{
	char arr1[20] = "abcdef\0XXXXXXXX";
	char arr2[] = "qwe";
	strncat(arr1, arr2, 3);//将arr2中的三个字符追加到arr1中字符'\0'。
	printf("%s", arr1);//打印结果为abcdefqwe。
	return 0;
}

strncat的模拟实现：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

char* my_strncat(char* dest, const char* src, int num)
{
	char* tmp = dest + strlen(dest);
	while (num-- && *src)
	{
		*tmp++ = *src++;
	}
	*tmp = 0;
	return dest;
}

int main()
{
	char str1[20] = "Hello!";
	char str2[] = "bit";
	printf("%s\n", my_strncat(str1, str2, 3));//打印结果为Hello!bit
	return 0;
}

3.strncmp

strncmp的用法与strcmp一样，只不过可以规定要比较字符串的前n个。

1.比较到出现一个不一样的字符，或者一个字符串结束，或者n个字符全部比较完。

使用示例：

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

int main()
{
	char str1[] = "abcdef";
	char str2[] = "abcdtyuiop";
	int ret = strncmp(str1, str2, 4);//比较前四个字符。
	printf("%d", ret);//打印结果为0
	return 0;
}

strncmp的模拟实现

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

int my_strncmp(char* str1, const char* str2, int n)
{
	assert(str1 && str2);
	while (n--)
	{
		if (*str1 > *str2)
		{
			return 1;
		}
		else if (*str1 < *str2)
		{
			return -1;
		}
		else
		{
			str1++;
			str2++;
		}
		if (*str1 == '\0' || *str2 == '\0')
		{
			return 0;
		}
	}
	return 0;
}

int main()
{
	char str1[] = "abcdef";
	char str2[] = "abcdtyuiop";
	int ret = my_strncmp(str1, str2, 4);//比较前四个字符。
	printf("%d", ret);//打印结果为0
	return 0;
}

四、字符串查找

1.strstr

在一个字符串中找另一个字符串，看一个字符串是不是另一个字符串的子串。

strstr(str1,str2)//str2字符串是str1的子串，就返回str2在str1中第一次出现的首字符的地址。
//str2不是str1的子串，就返回 NULL(空指针)。

使用示例:

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


int main()
{
	char arr1[] = "abcdJuicefghuJuice";
	char arr2[] = "Juice";
	printf("%s",strstr(arr1, arr2));//打印的结果是JuicefghuJuice
	
	return 0;
}

strstr的模拟实现：

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

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	char* p1 = str1;
	char* p2 = str2;
	while (*p1)
	{
		if (*p1 != *p2)
		{
			p1++;
		}
		char* ret = p1;
		while (*p1 == *p2)
		{
			p1++;
			p2++;
		}
		if (*p2 == '\0')
		{
			return ret;
		}
		else
		{
			p2 = str2;
		}
	}
	return NULL;
}

int main()
{
	char str1[] = "hello bit! hello World";
	char str2[] = "bit";
	char str3[] = "Hi";
	char str4[] = "helLo";
	char str5[] = "hello";
	if (my_strstr(str1, str2) == NULL)
	{
		printf("找不到子串");
	}
	else
	{
		printf("%s\n", my_strstr(str1, str2));//打印结果为bit! hello World
	}
	return 0;
}

2.strtok

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

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

使用示例：

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

int main()
{
	char str[] = "Juice@WRLD*999!999";
	char buf[30] = { 0 };
	strcpy(buf, str);
	const char* sep = "@*!";
	//strtok(buf, sep);只找第一个标记。
	//strtok(NULL, sep);从保存好的位置开始继续往后找，一次找一个sep中的字符。
	char* ptr = NULL;
	//注意：
	//char* ptr = strtok(buf, sep);  ×
	//错误的初始化方法，当在循环外初始化直接将strtok(buf,sep)赋值给ptr,会导致buf字符串中的'@'被替换为'\0'。
	//当for循环中再次调用strtok(buf,sep)函数时，实际上是对字符串"Juice"使用了strtok函数，而不是"Juice@WRLD*999!999"。
	//导致最后循环输出只能输出Juice
	for (ptr = strtok(buf, sep); ptr!= NULL; ptr = strtok(NULL, sep))
	{
		printf("%s\n", ptr);//打印结果为：
		                    //Juice
		                    //WRLD
		                    //999
		                    //999
	}
	//另外一种方法
    /*char* ptr = strtok(buf, sep);
    while (ptr != NULL)
    {
    	 printf("%s\n", ptr);
    	 ptr = strtok(NULL, sep);
    }*/

	return 0;
}

五、错误信息报告

1.strerror

返回错误码所对应的错误信息。
必须包含头文件<errno.h>与<string.h>。

使用示例：

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <limits.h>

int main()
{
	int* p = (int*)malloc(INT_MAX);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));//当malloc开辟空间失败时，会将错误码放到errno里面。
	}   //用strerror可以将错误码翻译。    //打印结果为Not enough space
	return 0;
}

六、字符操作

在这里插入图片描述字符转换

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

七、内存操作函数

1.memcpy

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

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

使用示例：

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


int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[5] = { 0 };
	memcpy(arr2, arr1, 20);//int类型占4个字节,拷贝20个字节,把1 2 3 4 5拷贝到arr2.
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", arr2[i]);//打印结果为1 2 3 4 5 
	}
	return 0;
}

memcpy的模拟实现：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
void* my_memcpy(void* dest, const void* src, int count)
{
	assert(dest && src);
	char* dest1 = dest;
	char* src1 = src;
	while (count--)
	{
		*dest1++ = *src1++;
	}
	return dest;
}

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[] = { 99,88,77,66,55 };
	my_memcpy(arr, arr2, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);//打印结果为99 88 77 66 55 6 7 8 9 10
	}
	return 0;
}

2.memmove

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

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

在这里插入图片描述

如图所示，当出现(1)对应的情况时，就需要先从src的头部开始复制;也就是memmove源码中的if分支，这部分源码和memcpy的实现是一致的;当出现(2)对应的情况时，就需要先从src的尾部开始复制，防止出现了覆盖现象。这就是memmove比memcpy多的一个考虑点，所以说，在实际使用时，使用memmove是比memcpy更安全的。

memmove的模拟实现：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

void* my_memmove(void* dest, const void* src, int count)
{
	char* buf1 = dest;
	char* buf2 = src;
	if (dest <= src|| (char*)dest >= ((char*)src + count))
	{
		while (count--)
		{
			*buf1++ = *buf2++;
		}
	}
	else
	{
		while (count--)
		{
			*(buf1 + count) = *(buf2 + count);
		}
	}
	return dest;
}

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[] = { 99,88,77 };
	my_memmove(arr1+2, arr1, 24);
	int sz = sizeof(arr1) / sizeof(arr1[0]);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr1[i]);//打印结果为1 2 1 2 3 4 5 6 9 10
	}
}

3.memcmp

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

比较从ptr1和ptr2两个指针开始的num个字节
1.ptr1指向的内容大于ptr2时，函数返回大于0的数。
2.ptr1指向的内容等于ptr2时，函数返回0。
3.ptr1指向的内容小于ptr2时，函数返回小于0的数。

使用示例：

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

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 1,2,3,4,0x11223305 };
	printf("16字节比较结果:%d\n",memcmp(arr1, arr2, 16));
	//打印结果为0，因为前16个字节为前4个整形，相等返回0。
	
	printf("17字节比较结果:%d\n", memcmp(arr1, arr2, 17));
	//打印结果为0，因为前17个字节为前四个整形加上1个字节，两个数组第17个字节存的都是 05 所以相等返回0。
	
	printf("18字节比较结果:%d\n", memcmp(arr1, arr2, 18));
	//打印结果为-1，因为arr1的第18个字节存的是00，而arr2的第18个字节存的是33，所以比较结果为arr1<arr2 返回-1。
	return 0;
}

arr1的内存：
在这里插入图片描述
arr2的内存：
在这里插入图片描述

4.memset

void * memset(void * destination, int c, size_t count);

内存设置函数，将目标指针destination后面的count个字节设置为c。

使用示例：

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

int main()
{
	int dest[] = { 99,88,77,66,55 };
	memset(dest, 0x99, 20);//将20个字节全部设置为16进制的99
}

memset以前的dest数组内存：
在这里插入图片描述
memset以后的dest数组内存：
在这里插入图片描述

_Juice_
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c/c++内存释放知识总结
beiyuan19880219的专栏
08-21 2714
基础知识：五大内存分区 　　栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。 　　堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。（new char;  delete char;new c
C语言—内存的管理和释放
little_rookie__的博客
01-08 1万+
C语言—内存的管理和释放一、Linux下内存分配管理1.编译好的C程序文件分区2.C程序运行时内存分区3.为什么要进行内存分配4.内存分配方式二、详解堆和栈1.堆和栈的简介2.堆和栈的区别三、内存管理函数四、其它知识1.（嵌入式开发中）程序编译完成后的大小统计2.数据存储区域实例3.字符串与字符数组 一、Linux下内存分配管理 1.编译好的C程序文件分区 分析C语言下程序的内存分配，我们从一段简单C程序源码test.c开始。如下所示： #include <stdio.h> #include
c语言程序结束时字符数组释放,复习用总结：C语言程序设计(黄迪明) 未完待续...
weixin_31901801的博客
05-17 586
C语言程序设计(黄迪明)第一章 C语言程序设计基础知识例题及习题1.1 C语言具有哪些特点答：1.C语言是一种兼有高级语言和汇编语言优点的语言；2.C语言是一种结构化程序设计语言；3.语言数据类型丰富；4.C语言具有种类丰富的运算符；5.C语言具有预处理功能。、1.4 C语言开发步骤答：C程序的运行一般要经过四个步骤。即源程序的编辑、源程序的编译、目标程序的链接和可执行程序的运行。1.7 one_...
C语言 字符串函数
kjl167的博客
03-14 1万+
前言：字符串是一种重要的数据类型，但是C语言没有显式的字符串数据类型，字符串通过字符串常量或字符数组方式储存。C语言提供了许多与字符串相关函数，可以在头文件<string.h>中查看函数声明，本章将会自行编写相关字符串函数 一、字符串长度函数 strlen 功能：字符串以 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包 含 ‘\0’ ) 库函数strlen函数声明： size_t&emsp;strlen(char const *string
c语言中常用的字符串函数和内存函数
m0_61227789的博客
07-10 3981
字符串函数 qsort（）
c语言字符串函数超详解
weixin_62623251的博客
03-14 2279
文章目录一、字符串函数介绍二、函数介绍2.1 strlen2.2 长度不受限的字符串函数2.2.1 strcpy2.2.2 strcat2.2.3 strcmp2.3 长度受限的字符串函数2.3.1 strncpy2.3.2 strncat2.3.3 strncmp2.4字符串查找函数2.4.1 strstr2.4.2 strtok2.5 错误报告函数strerror2.6各种字符分类函数三、库函数模拟实现3.1 模拟实现strlen3.2 模拟实现strcpy3.3 模拟实现strcmp3.4 模拟实
C语言字符串常用函数总结（持续更新）
qq_43427424的博客
07-12 1万+
C语言字符串常见函数总结，函数包括：字符串输入、字符串输入、计算字符串长度、字符串赋值、字符串分割、字符串拼接、字符串与整型的转换等。后续持续更新。
C语言用函数字符串的查找,字符串查找函数，C语言字符串查找函数详解
weixin_35433448的博客
05-17 1万+
在对 C 语言的编程实践中，字符串查找是最频繁的字符串操作之一，本节就对常用的字符串查找函数做一个简单的总结。使用 strchr 与 strrchr 函数查找单个字符如果需要对字符串中的单个字符进行查找，那么应该使用 strchr 或 strrchr 函数。其中，strchr 函数原型的一般格式如下：char *strchr(const char *s, int c);查找任何一个不包含在strc...
C语言字符串操作函数.doc
12-02
C语言字符串操作函数是一组强大且实用的函数，用于处理和操作字符串。这些函数在C语言编程中非常常用，掌握这些函数可以提高编程效率和质量。本章将详细介绍C语言字符串操作函数的使用方法和应用场景。 1. 字符串...
基于C语言字符串函数的一些使用心得
09-05
本文将深入探讨C语言中的字符串函数，特别是`strcat()`函数的使用心得和注意事项。 `strcat()`函数用于将一个字符串连接到另一个字符串的末尾。其原型如下： ```c char *strcat(char *dest, const char *src); ```...
C语言字符串函数大全
11-29
以下是一些常见的C语言字符串函数及其详细说明： 1. **stpcpy()**: 此函数用于将一个字符串复制到另一个字符串中，并返回目标字符串的终止符位置。其函数原型为`char *stpcpy(char *destin, char *source)`。在提供...
浅谈C语言之字符串处理函数
09-01
本文将探讨8种基本的字符串处理函数，它们在处理和操作字符数组时非常有用。这些函数在大多数C语言编译系统中都内置提供，使得程序员能够方便地对字符串进行各种操作。 1. `puts` 函数： `puts` 用于输出字符串到...
（C语言）常见字符函数和字符串函数
热门推荐
芮萌萌的博客
07-23 7万+
我们都知道，在C语言里有string.h这个头文件，但是C语言里没有string这个类型。 字符串通常放在常量字符串中或者字符数组中，字符串常量适用于那些对她不做修改的字符串函数。 string.h这个头文件里声明的函数原型也全是针对char数组的种种操作。 直到C++中才出现了string这个类 这篇文章就简单整理一下C语言中处理字符、字符串的库函数。 strlen size...
c语言字符串输出函数是,C语言字符串输入与输出函数
weixin_30647489的博客
05-17 3936
字符串输入如果想把一个字符串读取到程序中，必须首先预留存储字符串的空间，然后使用输入函数来获取这个字符串，C库提供了三个读取字符串的函数：scanf()、gets()和fgets()。创建存储空间可以通过数组(char name[10])来分配存储空间，也可以通过C语言动态内存分配函数来动态分配存储空间。char *name;scanf("%s", name);如果通过上面的代码来创建存储空间，可...
x264 编码器 CAVLC 熵编码原理分析：cavlc_block_residual_internal函数
人生只有一次，不妨大胆一点～～
07-22 369
x264 编码器 CAVLC 熵编码原理分析：cavlc_block_residual_internal函数
C语言 之 理解指针（3）
fallzzzzz的博客
07-21 1088
本章主要内容是对数组名的理解、使⽤指针访问数组、⼀维数组传参的本质、⼆级指针、指针数组、指针数组模拟⼆维数组
C 观察者模式 Demo
最新发布
我要出家当道士
07-24 309
本文简单介绍了观察者模式，并提供了 C Demo
"C语言字符串操作函数详解及应用实例
在本章中，首先介绍了字符串拷贝函数strcpy和内存拷贝函数memcpy的区别及其适用场景。strcpy函数只能拷贝字符串，将源字符串的每个字节拷贝到目标字符串中，遇到字符串末尾的null字符时，会删除该字符并结束拷贝。而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值