【C语言进阶】动态内存管理

最新推荐文章于 2024-06-15 09:59:21 发布
最新推荐文章于 2024-06-15 09:59:21 发布
阅读量738 收藏 11
点赞数 27
分类专栏： C语言进阶学习 文章标签： c语言 开发语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43108974/article/details/139501046
版权

【C语言进阶】动态内存管理

文章目录

本章目标：

学会使用动态内存函数，了解常见的动态内存错误，了解什么是柔性数组。

本章重点：

  • 为什么存在动态内存分配？
  • 动态内存函数的介绍
    • malloc()
    • calloc()
    • realloc()
    • free()
  • 常见的动态内存错误
  • 经典笔试题
  • 柔性数组



正文：

一、为什么存在动态内存分配？

已经了解的开辟内存的方式有：

//变量
int val = 10;//在栈空间上开辟4个字节的大小
//数组
char arr[10] = {0};//在栈上开辟10个字节的连续空间

上述开辟空间的方式有两个特点：( 静态数组 )

  1. 空间开辟的大小是固定的。
  2. 数组在声明的时候，必须指定数组的长度，数组所需要的内存空间在编译时分配。

对于空间大小的需求是不同的，在某些情况下，只有当程序运行的时候才能知道所需确切的空间大小，那么像数组这类在编译时开辟空间的方式就不能满足我们的需求了。

此时，就会利用到动态开辟内存了。


二、动态内存函数的介绍

1 malloc()

C语言提供了可以动态开辟内存的函数：malloc()

1.1 介绍

函数原型：

//#include<stdlib.h>
void* malloc(size_t size);

说明：

1 该函数申请的是堆区的内存空间。

2 该函数向内存申请一块连续可用的空间，并返回指向这块空间的空类型指针。

  如果开辟成功，则返回一个指向开辟好的空间的指针。

  如果开辟失败，则返回一个 NULL 指针，因此要对 malloc 的返回值做检查。

int* p = (int)malloc(40);
if (p == NULL)//对malloc的返回值做检查
{
	perror("malloc");
	return;
}

  返回值的类型是 void* ，所以 malloc 函数是不清楚开辟的空间的类型的，具体在使用的时候由使用者决定。

  如果参数 size_t 为0，这种情况下 malloc 的行为是标准未定义的 ，具体情况会取决于编译器。

3 malloc 在申请到空间后，会直接返回这块空间的起始地址，并不会初始化空间的内容。

4 通过 malloc 开辟的空间不会主动释放，除非整个程序结束或者通过 free 函数来释放这块空间。


1.2 示例

代码示例：

#include<stdio.h>

#include<stdlib.h>
int main()
{
	//malloc()

	int arr[10];
	int* p = (int*)malloc(40);
	//malloc返回值的检查
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//开辟成功
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", *(p + i));
	}

	free(p);//释放动态开辟的内存
	p = NULL;//主动置空指针，防止出现野指针

	return 0;
}

解释说明：

1 malloc 动态开辟内存有可能会失败，失败会返回空指针，所以在使用前要对 malloc 的返回值做检查。

2 malloc 在申请到空间后，会直接返回这块空间的起始地址，不会初始化空间的内容。

malloc不会初始化空间内容


2 free()

C语言提供了另外一个函数 free ，专门用来做动态内存的回收和释放的。

2.1 介绍

函数原型：

//#include<stdlib.h>
void free(void* ptr);

说明：

1.free 函数用来释放动态开辟的内存。

  如果参数 ptr 指向的空间不是动态开辟的，那此时 free 函数的行为是未定义的。

  如果参数 ptr 是 NULL 指针，则函数什么也不做。


2.2 示例

代码示例：

#include<stdio.h>

#include<stdlib.h>
int main()
{
	//free()

	int num = 0;
	scanf("%d", &num);

	int* ptr = NULL;
	ptr = (int*)malloc(num * sizeof(int));
	if (ptr != NULL)
	{
		int i = 0;
		for (i = 0; i < num; i++)
		{
			*(ptr + i) = i + 1;
		}
		for (i = 0; i < num; i++)
		{
			printf("%d ", ptr[i]);
		}
		printf("\n");
	}
	free(ptr);//释放ptr所指向的动态内存
	ptr = NULL;//主动置空，防止出现野指针


	//不能用free释放非动态开辟的内存
	int a = 10;
	int* pa = &a;
	//free(pa);//error

	return 0;
}

解释说明：

1 不能用 free 来释放非动态开辟的内存。


3 calloc()

C语言还提供了一函数 calloc ，该函数也可以用来动态内存分配。

3.1 介绍

函数原型：

void* calloc(size_t num, size_t size);

说明：

1.calloc 函数的功能是开辟 num 个大小为 size 类型的空间，并且把每个空间初始化为0。

  如果开辟成功，则返回一个指向开辟好的空间的指针。

  如果开辟失败，则返回一个 NULL 指针，因此要对 calloc 的返回值做检查。

2.与 malloc 的区别是 calloc 会初始化开辟的空间。


3.2 示例

代码示例：

#include<stdio.h>

#include<stdlib.h>
int main()
{
	//calloc()

	int* p = (int*)calloc(10, sizeof(int));
	if (p != NULL)//判断是否开辟成功
	{
		//具体操作
		printf("calloc()开辟成功！");
	}
	free(p);//释放动态内存
	p = NULL;//指针置空，防止出现野指针

	return 0;
}

解释说明：

calloc 会把成功开辟的空间中每个字节都初始化为0。

calloc会初始化空间内容


4 realloc()

realloc 函数可以调整动态开辟的空间。

4.1 介绍

函数原型：

void* realloc(void* ptr, size_t size);

说明：

1.ptr 是要调整空间的内存地址（必须是动态开辟的内存空间的地址）。

2.size 是调整后空间的新大小。

3.如果传入的是空指针，那么功能就和 malloc 一样。

4.该函数在调整原内存空间大小的基础上，可能还会将原来内存中的数据移动到新的空间（如果原空间后面没有足够大的空间开辟新的）。


4.2 realloc() 开辟新空间

relloc 函数在调整内存空间的时候分为两种情况：

  情况1：原有空间之后有足够大的空间。

  情况2：原有空间之后没有足够大的空间。

realloc开辟空间


4.2.1 情况1

  要扩展的内存直接在原有内存之后追加空间即可，原空间不发生改变（数据不变）。

4.2.2 情况2

  原空间后没有足够多的空间用来扩展。此时扩展的方法是：在堆空间上另外寻找一块合适大小的连续空间来使用，然后返回新空间的地址。

  • 新空间开辟的步骤：

​ 1.开辟新的空间

​ 2.将旧空间中的数据拷贝到新的空间中

​ 3.释放旧的空间

​ 4.返回新空间的起始地址


4.3 示例

代码示例：

#include<stdio.h>

#include<stdlib.h>
int main()
{
	//realloc()

	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}

	//内存的初始化
	int i = 0;
	for (i = 0; i < 10; i++) 
	{
		p[i] = i + 1;
	}

	//p = (int*)realloc(p, 1000);//不建议这样写
	//“realloc”可能返回null指针: 将null指针赋给“p”将导致原始内存块泄漏。

	//增加一些空间
	int* ptr = (int*)realloc(p, 80);
	if (ptr != NULL)
	{
		p = ptr;
		ptr = NULL;
	}
	else
	{
		perror("realloc");
		return 1;
	}

	//打印数据
	for (i = 0; i < 20; i++)
	{
		printf("%d\n", p[i]);
	}

	//释放动态内存
	free(p);
	p = NULL;

	return 0;
}

解释说明：

1 realloc 开辟新空间有可能不是在原始空间之后增加新的空间，而是重新开辟新的内存空间，所以最好不要直接将新空间的地址赋值给原指针，而是通过中间临时指针判断非空后赋值给原指针。

2 对于减少空间，直接在原空间上减少就行，仍然会返回原空间的起始地址。


三、常见的动态内存错误

1 对 NULL 指针的解引用操作

代码示例：

#include<stdio.h>

#include<stdlib.h>
void test()
{
	int* p = (int*)malloc(INT_MAX / 4);
	//malloc可能创建失败并返回空指针，所以需要对返回值做检查
	
	*p = 20;//p可能为空指针
	free(p);
}
int main()
{
	//对NULL指针的解引用操作

	return 0;
}

解释说明：

1 需要对动态内存函数的返回值进行检查。


2 对动态开辟空间的越界访问

代码示例：

#include<stdio.h>

#include<stdlib.h>
int main()
{
	//对动态开辟空间的越界访问

	int* p = (int*)malloc(40);//10个int
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;

	for (i = 0; i < 20; i++)
	{
		p[i] = i;//越界访问
	}

	free(p);
	p = NULL;

	return 0;
}

解释说明：

1 不能越界访问动态开辟的内存。


3 对非动态开辟内存使用 free 进行释放

代码示例：

#include<stdio.h>

int main()
{
	//对非动态开辟的内存使用free进行释放

	int a = 10;//a在栈区
	int* p = &a;//p在栈区
	printf("%d\n", *p);

	//free(p);//该行为标准未定义
	p = NULL;

	return 0;
}

解释说明：

1 不能对非动态开辟的内存使用 free 进行释放。


4 使用 free 释放动态内存的一部分

代码示例：

#include<stdio.h>

#include<stdlib.h>
int main()
{
	//使用free释放动态内存的一部分
	//如果需要处理，可以使用另一指向动态内存起始位置的指针，而初始的起始指针不动

	int* p = (int*)malloc(40);//10个int
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}

	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*p = i;
		p++;
	}
	//循环结束后，p不再指向动态内存的起始位置

	//free(p);//error；要释放动态内存，必须一次性释放完
	p = NULL;

	return 0;
}

解释说明：

1 动态内存必须一次性释放而不能分次释放，即传入 free 的参数必须是动态内存的起始地址。


5 对同一块动态内存多次释放

代码示例：

#include<stdio.h>

#include<stdlib.h>
int main()
{
	//对同一块动态内存多次进行释放

	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 1;
	}

	free(p);
	p = NULL;
	
	//free(p);//error；重复释放动态内存

	return 0;
}

解释说明：

1 不能重复释放同一块动态内存。


6 动态开辟的内存忘记释放（内存泄漏）

代码示例：

#include<stdio.h>

#include<stdlib.h>
void test()
{
	int* p = (int*)malloc(100);
	if (p != NULL)//如果是非空指针
	{
		*p = 20;
	}
	//p为局部变量，出了test函数即被销毁释放
	//但是动态内存并不会主动释放，如果没有主动释放，会导致内存泄漏
}
int main()
{
	//动态开辟的内存忘记释放--会导致内存泄漏

	test();
	//while (1);
	//如果程序需要24小时持续运行，每次动态开辟的内存都忘记释放，那么就会消耗内存资源，直到耗尽内存资源

	return;
}

解释说明：

1 动态开辟的空间一定要释放，并且要正确释放。


四、经典笔试题

1 题目1

代码示例：

#include<stdio.h>

#include<stdlib.h>
#include<string.h>
void GetMemory(char* pc)
{
	pc = (char*)malloc(100);
	//1.未主动释放动态开辟的内存，会导致内存泄漏
}
void test()
{
	char* str = NULL;
	GetMemory(str);//2.传入的是str的值，而非&str
	strcpy(str, "Hello World");
	//3.str可能是空指针，strcpy中对空指针(NULL)进行解引用，程序会崩溃
	printf(str);
}
int main()
{
	//题目1

	test();

	return 0;
}

解释说明：

1 解决方法

//1.实参传递指针的地址
GetMemory(&str);
//2.形参用二级指针接收
void GetMemory(char** p)
{
	*p = (char*)malloc(100);
}
//3.动态内存可能开辟失败，使用前先判断指针是否为空
if(str != NULL)
{
	strcpy(str, "Hello World");
}
//4.动态内存主动释放，主动置空
print(str);
free(str);
str = NULL;

2 printf() 打印字符串

//方法一
printf("hello\n");
//方法二
char* p = "hello\n";
printf(p);
//方法二
printf("%s", "hello\n");


2 题目2

代码示例：

#include<stdio.h>

//返回栈空间地址的问题
char* GetMemory()
{
	char  p[] = "Hello World";
	return p;//error：返回局部变量的地址
}
void test()
{
	char* str = NULL;
	str = GetMemory();//返回的是野指针
	printf(str);//野指针，非法访问
}
int main()
{
	//题目2

	test();

	return 0;
}

解释说明：

1 不能返回局部变量的地址。


3 题目3

代码示例：

#include<stdio.h>

#include<stdlib.h>
#include<string.h>
void GetMemory(char** pc, int num)
{
	*pc = (char*)malloc(num);
}
void test()
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
	//没有释放动态内存：free(str);
}
int main()
{
	//题目3

	test();

	return 0;
}

解释说明：

1 没有释放动态内存。


4 题目4

代码示例：

#include<stdio.h>

#include<stdlib.h>
#include<string.h>
void test()
{
	char* str = (char*)malloc(100);
	//使用前应该检查是否开辟成功
	strcpy(str, "hello");
	free(str);
	//应该添加：str = NULL;（释放后应及时置空）
	if (str != NULL)
	{
		strcpy(str, " World");//非法访问被释放的动态内存
		printf(str);
	}
}
int main()
{
	//题目4

	test();

	return 0;
}

解释说明：

1 解决方法

void test()
{
	char* str = (char*)malloc(100);
	if(str != NULL)//使用前先检查动态内存是否开辟成功
	{
		strcpy(str, "hello");	
	}

	free(str);//主动释放动态内存
	str = NULL;//指针及时置空
	
	if (str != NULL)
	{
		strcpy(str, " World");//非法访问被释放的动态内存
		printf(str);
	}
}


五、C/C++程序的内存开辟

1 示例

请问运行 test 函数会有什么样的结果？

示例：

#include<stdio.h>

int GlobalVar = 10;//全局变量
static int StaticGlobalVar = 10;//静态全局

void test()
{
	static int StaticVar = 10;//静态局部变量

	int LocalVar = 10;//局部变量
	int num[10] = { 1,2,3,4 };
	char ch[] = "abcd";
	char* pch = "abcd";

	int* ptr1 = (int*)malloc(sizeof(int) * 4);
	int* ptr2 = (int*)calloc(4, sizeof(int));
	int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);

	free(ptr1);
	free(ptr3);
}
int main()
{
	test();

	return 0;
}

说明：

内存开辟


2 内存分区

C/C++程序内存分配的几个区域：

1.栈区（stack）：在函数执行时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元会被自动销毁和释放。栈内存分配运算内置于处理器等的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数时分配的局部变量、函数参数、返回数据、返回地址等。

2.堆区（heap）：一般由程序员手动分配和释放，若程序员不释放，程序结束时可由操作系统回收。分配方式类似于链表。

3.数据段（static）(静态区)：存放全局变量、静态数据。程序结束后由系统释放。

4.代码段：存放函数体（类成员函数和全局函数）的二进制代码。


3 自动变量与静态变量

自动变量与静态变量（自动存储期与静态存储期）：

普通局部变量存放在栈区，拥有自动存储期，出了作用域即被销毁。

静态变量和全局变量存放在数据区（静态区），拥有静态存储期，直到程序结束才被销毁。


六、柔性数组

C99中，结构体中的最后一个成员可以是未知大小的数组，该成员被称为柔性数组（flexible array）。

示例：

//写法一
typedef struct st_type
{
	int i;
	int arr[0];//柔性数组成员
}type_arr;

//写法二
typedef struct st_type
{
	int i;
	int arr[];//柔性数组成员
}type_arr;


1 柔性数组的特点

  • 结构体中的柔性数组成员之前必须至少有一个其他成员。

  • sizeof 计算包含柔性数组的结构体的大小是不包含柔性数组的大小。

  • 包含柔性数组成员的结构用 malloc 函数进行动态内存分配，并且分配的内存应该大于结构体的大小，以适应柔性数组的预期大小。

代码示例：

#include<stdio.h>

#include<stdlib.h>
typedef struct st_type
{
	int i;
	int arr[0];
}type_arr;
int main()
{
	//柔性数组

	printf("%d\n", sizeof(type_arr));//4

	type_arr* p = (type_arr*)malloc(sizeof(type_arr) + 40);

	//sizeof(type_arr)  -->  其他成员
	//40  -->  柔性数组
	//

	if (p != NULL)
	{
		//业务处理
	}

	free(p);//释放动态内存
	p = NULL;//指针置空，防止出现野指针

	return 0;
}

解释说明：

1 printf("%d\n", sizeof(type_arr));//4

  在计算结构体的大小时，是不包含柔性数组的。


2 柔性数组的使用

代码示例：

//代码1
#include<stdio.h>

#include<stdlib.h>
typedef struct st_type
{
	int i;
	int arr[0];
}type_arr;
int main()
{
	//柔性数组的使用

	type_arr* p = (type_arr*)malloc(sizeof(type_arr) + 100 * sizeof(int));
	//100 * sizeof(int) -- 相当于 -- arr[100]
	if (p != NULL)
	{
		//业务处理

		int i = 0;
		for (i = 0; i < 100; i++)
		{
			p->arr[i] = i;
		}
	}

	free(p);//释放动态内存
	p = NULL;//指针置空，防止出现野指针

	return 0;
}

解释说明：

1 使用柔性数组成员 arr ，100 * sizeof(int) 相当于是创建了一个包含100个 int 类型元素的连续空间。


3 柔性数组的优势

上述结构体 type_arr 也可以这样设计：

代码示例：

//代码2
#include<stdio.h>

#include<stdlib.h>
typedef struct st_type
{
	int i;
	int* p_arr;
}type_arr;
int main()
{
	//柔性数组的优势

	type_arr* p = (type_arr*)malloc(sizeof(type_arr));
	if (p == NULL)
	{
		return;
	}

	p->i = 100;
	p->p_arr = (int*)malloc((p->i) * sizeof(int));
	if (p->p_arr == NULL)
	{
		return;
	}

	//业务处理
	int i = 0;
	for (i = 0; i < 100; i++)
	{
		p->p_arr[i] = i;
	}

	free(p->p_arr);//先释放内层动态内存
	p->p_arr = NULL;//指针置空，防止出现野指针

	free(p);//再释放外层动态内存
	p = NULL;//指针置空，防止出现野指针

	return 0;
}

解释说明：

1 柔性数组的优势：

柔性数组的优势


上述示例中，代码1和代码2可以实现相同的功能，但是代码1采用柔性数组的实现有两个好处：

好处一：方便内存释放

  代码2中成员指向的动态内存需要释放，动态开辟的结构体变量也要释放，总共需要释放两次，不能指望用户去干这些事情。

  所以，如果把结构体的内存以及其成员需要的内存一次性分配好，并返回给用户一个结构体指针，那么用户就能一次 free 就能把所有动态申请的内存给释放干净。

好处二：有助于提升访问速度

​  连续的内存有益于提升访问速度，也有益于减少内存碎片。


扩展阅读：

C语言结构体里的成员数组和指针 | 酷 壳 - CoolShell


总结：

  本节介绍了C语言的动态内存函数以及常见的动态内存错误；同时又讲解了什么是柔性数组以及使用柔性数组的优势。

感谢您的阅读！如有任何错误，欢迎您的批评指正！

榴花
关注
  • 27
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言进阶---动态内存管理.md
04-03
动态内存空间开辟的详细讲解
C语言进阶语法与编程技巧.md
08-12
内存管理 2.1 动态内存分配 2.2 内存释放 文件操作 3.1 打开与关闭文件 3.2 读写文件内容 字符串处理 4.1 字符串的基本操作 4.2 字符串库函数 预处理指令与宏 5.1 #include与#include_once 5.2 宏的定义与使用 多...
15 C语言进阶动态内存管理
Tian_baby的博客
02-15 791
动态内存管理 动态内存分配的意义 动态内存函数介绍 malloc free calloc realloc 常见的动态内存错误 几个经典的笔试题 柔性数组 动态内存分配的意义 我们已经指到的内存开辟的方式： //开辟四个字节的空间 int a = 5; //开辟连续的一个字节的十个空间 char arr[10] = {0}; 但是这两种方式开辟的空间有两个特点： 空间开辟的大小是固定的 数组在申明的时候，必须指定数组的长度，它需要的内存在编译时进行分配。 但是对空间的需求，
C语言进阶：动态内存管理
m0_62934529的博客
04-16 476
1. 为什么存在动态内存分配 首先先看内存的划分： 我们已经掌握的内存开辟方式有： int main() { //已经掌握的内存开辟方式: int a = 10; //在栈空间上开辟四个字节 char c = 'w'; char arr[200] = { 0 };//在栈空间上开辟200个字节的连续空间 int arr2[5] = { 0 }; return 0; } 但是上述的开辟空间的方式有两个特点： 1. 空间开辟大小是固定的。 2. 数组在申明的时候，必须指定数
C语言进阶——动态内存管理
xcxhzjl的博客
12-14 1028
笔记22-1（C语言进阶 动态内存管理）
w_pab的博客
05-31 372
为什么存在动态内存分配 动态内存函数的介绍 malloc和free calloc realloc 常见的动态内存错误 1.对NULL指针的解引用操作 2.对动态开辟空间的越界访问 3.使用free函数释放了非动态开辟的空间 4.使用free函数释放一块动态开辟的内存的一部分 5.对同一块动态开辟的空间，多次释放 6.动态开辟的内存忘记释放（内存泄漏 - 比较严重） 经典的笔试题（可供参考：《高质量C++/C 编程指南》） 题目1：运行Test函数的结果？（p = (char*)ma
C语言进阶-动态内存管理/柔性数组
~
10-01 1207
动态内存管理的使用即注意事项有关于动态内存管理的寄到笔试题讲解柔性数组的使用为什么存在动态内存分配一般的开辟空间方式：//在栈空间上开辟四个字节//在栈空间上开辟10个字节的连续空间特点：空间开辟大小是固定的（数组申明必须指定数组的长度，它所需要的内存在编译时分配）但有时候我们需要的空间大小在程序运行的时候才能知道， 那数组的编译时开辟空间的方式就不能满足了，由此动态内存开辟就来了动态内存函数的介绍。
C语言进阶-动态内存管理
m0_56900257的博客
03-08 873
这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。如果开辟成功，则返回一个指向开辟好空间的指针。如果开辟失败，则返回一个NULL指针,因此malloc的返回值一定要做检查。返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候来决定。如果参数 size 为0，malloc的行为标准是未定义的，取决于编译器。int main()//动态开辟return 1;//使用i < 10;i++)//即使没有free。
C语言进阶--动态内存管理
weixin_36194037的博客
06-29 665
C语言进阶--动态内存管理
c语言进阶-动态内存管理
myz1016的博客
07-07 286
返回值是无类型的指针，指向分配的内存的首地址。申请失败会返回空指针。Malloc 内存申请函数。
（c语言进阶）动态内存管理
2301_79580018的博客
01-16 863
【代码】（c语言进阶）动态内存管理。
Linux_C语言高级进阶就业阶教程
05-07
书中内容主要聚焦于Linux环境下的C语言高级应用，包括但不限于数组和指针的深入理解与运用，文件操作，内存管理，进程与线程控制，网络编程，系统调用等。这些主题都是在Linux环境中进行系统级开发和集成时不可或缺...
高级进阶c语言教程..doc
05-10
高级进阶c语言教程 目录 1. C 语言中的指针和内存泄漏 5 2. C语言难点分析整理 10 3. C语言难点 18 4. C/C++实现冒泡排序算法 32 5. C++中指针和引用的区别 35 6. const char*, char const*, char*const的区别 36 7....
实验一 可变分区存储管理1
08-03
在这个实验中，你需要使用C语言编写一个程序来模拟UNIX系统的可变分区内存管理，特别关注指针的使用和链表操作。 首先，你需要理解可变分区存储管理的基本原理。这种管理方式允许动态地分配和回收内存，每个进程...
Java的c/s架构如何同时访问多个数据源
codemami的博客
06-11 1159
在Java的客户端/服务器（C/S）架构中，当服务器需要同时访问多个数据源时，通常是在服务器端进行配置和实现的。可以通过继承这个类来自定义多数据源的连接。在Java的C/S（客户端/服务器）架构中，实现同时访问多个数据源通常涉及后端服务器的设计和实现。接下来，你需要实现一个动态数据源路由的功能，这通常是通过继承AbstractRoutingDataSource类来实现的。配置数据源：为每个数据源创建DataSource对象，并配置相应的数据库连接信息，如驱动类名、URL、用户名和密码等。
为什么选择Python作为AI开发语言
AI心易行者
06-09 2197
综上所述，Python因其简洁易读的语法、丰富的库和框架、广泛的社区支持、适合快速原型开发的特性以及良好的兼容性和集成性，成为AI开发的首选语言。而像PlugLink这样的工具，则进一步提升了Python在AI开发中的效率和便利性。对于任何希望在AI领域有所作为的开发者来说，掌握Python无疑是必不可少的技能。在未来，随着AI技术的不断发展和进步，Python必将继续扮演重要角色，推动这一领域的创新和变革。如果你还没有开始学习Python，那么现在就是最好的时机。
十大成长型思维：定位思维、商业思维、时间管理思维、学习成长思维、精力管理思维、逻辑表达思维、聚焦思维、金字塔原理、目标思维、反思思维
最新发布
limengshi138392的博客
06-15 1090
十大成长型思维：定位思维、商业思维、时间管理思维、学习成长思维、精力管理思维、逻辑表达思维、聚焦思维、金字塔原理、目标思维、反思思维
STM学习记录（四）———中断及NVIC
qq_63556165的博客
06-14 542
一个学习32单片机的小白~ 有问题评论或私信指出~提示：以下是本篇文章正文内容，下面案例可供参考在主程序运行过程中，出现了特定的中断触发条件（中断源），使得CPU暂停当前正在运行的程序，转去处理中断程序，处理完成后又返回被暂停的位置继续执行。1.中断就相当于我们人在处理事情时会先选择重要的事情去做处理完之后回到被打断的事情继续执行。
狄泰c语言进阶剖析教程
01-01
《狄泰C语言进阶剖析教程》是一本深入研究C语言的进阶教材。本书从C语言的基础知识出发，逐步引导读者深入了解C语言的高级特性和底层机制，帮助读者提升自己的编程水平。 首先，本书通过对C语言的数据类型、控制流、函数等基础知识的回顾，夯实读者的编程基础。然后，本书详细介绍C语言中的指针和内存管理，帮助读者掌握C语言底层的原理和机制，从而能够更好地进行内存管理和指针操作。 此外，本书还介绍了C语言的结构体和联合体，以及文件操作和预处理指令等高级特性。通过对这些特性的深入剖析，读者能够掌握C语言更丰富和复杂的功能，为解决实际问题提供更好的支持。 在内容安排上，本书采用了逐步深入的方式，从浅入深地引导读者理解C语言的高级特性。每一章节都配有大量的例子和练习题，帮助读者巩固所学内容，提升编程能力。 总而言之，《狄泰C语言进阶剖析教程》通过深入剖析C语言的高级特性和底层机制，帮助读者提升自己的编程水平。无论是想要深入学习C语言的初学者，还是已有一定C语言基础的程序员，本书都能够为其提供有价值的学习资源。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值