【C语言】一节课拿捏---动态内存分配

最新推荐文章于 2024-07-18 11:11:00 发布
最新推荐文章于 2024-07-18 11:11:00 发布
阅读量1.9k 收藏 44
点赞数 31
分类专栏： C语言 文章标签： c语言 java 算法 visual studio code 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C4840/article/details/139462698
版权

谢谢观看！希望以下内容帮助到了你，对你起到作用的话，可以一键三连加关注！你们的支持是我更新地动力。
因作者水平有限，有错误还请指出，多多包涵，谢谢！

目录

一、 为什么要有动态内存分配

  我们已经掌握的内存开辟方式有：

int val = 20;//在栈空间上开辟四个字节
char arr[10] = {0};//在栈空间上开辟10个字节的连续空间

  但是上述的开辟空间的方式有两个特点：

  • 空间开辟大小是固定的。
  • 数组在申明的时候，必须指定数组的长度，数组空间一旦确定了大小不能调整但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小会根据实际情况发生变化，如果使用数组的话，可能开辟的空间太大，也可能开辟的空间不够，那数组的编译时开辟空间的方式就不能满足了。

  所以在C语言引入了动态内存开辟，让程序员自己可以申请和释放空间，就比较灵活了。这就需要使用到库函数来进行申请内存空间了。

  

二、malloc和free

2.1malloc

  C语言提供了一个动态内存开辟的函数：

void* malloc (size_t size);
//size表示需要申请的一块空间大小是多少，单位是字节
//void*表示返回那一块空间的起始位置的地址

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

  注意事项：

  • 如果开辟成功，则返回一个指向开辟好空间的指针。
  • 如果开辟失败，则返回一个 NULL 指针，因此malloc的返回值⼀定要做检查。
  • 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
  • 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器
  • 使用函数malloc之前需要加上头文件#include<stdlib.h>

  具体使用方式：

//代码一
int* p = (int*)malloc(10*sizeof(int));
char* p = (char*)malloc(10*sizeof(char));

//代码二
#include<stdio.h>
#include<stdlib.h>

int main()
{
	int* p = (int*)malloc(10*sizeof(int));
	if(p == NULL)
	{
		//空间开辟失败
		perror("malloc");//perror函数会打印出错误信息
		return 1;//1表示异常返回，在主函数main()中
	}
	//可以使用40个字节的空间了
	int i = 0;
	for(i = 0;i < 10;i++)
	{
		scanf("%d",(p+i));//scanf需要的参数是空间的地址
	}
	for(i = 0;i < 10;i++)
	{
		printf("%d ",*(p+i));
	}
	return 0;
}

  那么malloc申请的空间和数组的空间有什么区别呢？

  • 动态内存的大小是可以调整的
  • 开辟空间的位置不一样，malloc开辟的空间在堆区，数组arr开辟的空间在栈区。

在这里插入图片描述

  

2.2free

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

void free (void* ptr);
//ptr表示形参是指针，传递地址给它
//void *表示传递任何类型的指针都可以

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

  注意事项：

  • 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
  • 如果参数 ptr 是NULL指针，则函数什么事都不做。

  具体使用方式：

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int* p = (int*)malloc(10*sizeof(int));
	if(p == NULL)
	{
		//空间开辟失败
		perror("malloc");//perror函数会打印出错误信息
		return 1;//1表示异常返回，在主函数main()中
	}
	//可以使用40个字节的空间了
	int i = 0;
	for(i = 0;i < 10;i++)
	{
		scanf("%d",(p+i));//scanf需要的参数是空间的地址
	}
	for(i = 0;i < 10;i++)
	{
		printf("%d ",*(p+i));
	}

	free(p);//动态开辟的空间使用后要进行释放
	//释放的是指针p指向的空间，使空间归还给操作系统
	//但是p依然指向着那块空间，还保留着地址，此时p就是野指针了，所以还得对p指针赋值NULL
	p = NULL;//将NULL赋值给p，表示p是空指针
	
	return 0;
}

总结：malloc和free函数最好成对使用

  

三、calloc和realloc

3.1calloc

  C语言还提供了一个函数叫 calloc ， calloc 函数也用来动态内存分配。原型如下：

void* calloc (size_t num, size_t size);
//num表示开辟空间的个数
//size表示一个空间的大小是多少，单位是字节
//void* 表示返回所开辟空间的起始地址

  注意事项：

  • 函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
  • 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0，其他使用方法和malloc函数一模一样。

  具体使用方式：

#include<stdio.h>
#include<stdlib.h>

int main()
{
	//申请10个整型的空间
	//int* p = (int*)malloc(10*sizeof(int));
	int* p = (int*)calloc(10,sizeof(int));
	
	if(p == NULL)
	{
		//空间开辟失败
		perror("calloc");//perror函数会打印出错误信息
		return 1;//1表示异常返回，在主函数main()中
	}
	
	//可以使用40个字节的空间了
	int i = 0;
	for(i = 0;i < 10;i++)
	{
		printf("%d ",*(p+i));//结果为：0 0 0 0 0 0 0 0 0 0 
	}
	free(p);//动态开辟的空间使用后要进行释放
	//释放的是指针p指向的空间，使空间归还给操作系统
	//但是p依然指向着那块空间，还保留着地址，此时p就是野指针了，所以还得对p指针赋值NULL
	p = NULL;//将NULL赋值给p，表示p是空指针
	return 0;
}

  

3.2realloc

  函数原型如下：

void* realloc (void* ptr, size_t size);
//ptr表示要调整的内存地址
//size表示调整之后新大小
//返回值为调整之后的内存起始位置

  这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。

  具体使用方式：

int main()
{
	//申请10个整型的空间
	int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	//使用空间
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", p[i]);//*(p+i)
	}

	//调整空间-希望变成20个整型空间
	int* p = (int*)realloc(p, 20 * sizeof(int));
	//这里对realloc函数返回空间的起始地址传递给指针p是否正确？
	if (ptr != NULL)
	{
		p = ptr;
	}
	//使用
	//...
	
	//释放
	free(p);
	p = NULL;

	return 0;
}


//用法二：realloc不仅可以调整空间，可以开辟空间
int * p = (int *)realloc(NULL,40);
//等价于 int * p = (int*)malloc(10*sizeof(int))

  在上面的代码中的这一部分，我们怎么判断是否正确呢？这就需要了解一下，realloc函数调整内存空间的细节了

//调整空间-希望变成20个整型空间
	int* p = (int*)realloc(p, 20 * sizeof(int));
	//这里对realloc函数返回空间的起始地址传递给指针p是否正确？

  realloc在调整内存空间的是存在两种情况：

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

  注意：情况1和情况2都是正常可以分配空间的情况，如果未分配成功的话，会返回NULL空指针。
在这里插入图片描述
  
  所以通过上面的细节，我们知道了假如realloc函数分配空间失败后返回NULL，然后我们将指针p去接受，会导致我们连原来已经分配好的空间都找不到了，但是我们希望就算分配失败了也不应该将原来的空间都找不到。所以我们可以使用另一个指针ptr去接收它的返回值，然后再进行判断这个指针是否为NULL,如果不是NULL，则再将prt的值赋值给p。

int main()
{
	//申请10个整型的空间
	int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	//使用空间
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", p[i]);//*(p+i)
	}

	//调整空间-希望变成20个整型空间
				//int* p = (int*)realloc(p, 20 * sizeof(int));不使用这种方式，有危险
	int* ptr = (int*)realloc(p, 20 * sizeof(int));
	//ptr不为NULL时，再赋值给p
	if (ptr != NULL)
	{
		p = ptr;
	}
	//使用
	//...
	
	//释放
	free(p);
	p = NULL;

	return 0;
}

  

四、 常见的动态内存的错误

4.1对NULL指针的解引用操作

//错误写法
void test()
 {
 int *p = (int *)malloc(INT_MAX/4);
 *p = 20;//如果p的值是NULL，就会有问题
 //因为malloc函数可能会分配空间失败返回NULL，然而当对NULL空指针解引用操作*会出错
 free(p);
 p=NULL;
 }

//正确写法
void test()
 {
 	int *p = (int *)malloc(INT_MAX/4);
 	if(p == NULL)
 	{
		perror("malloc");
		return 1;
	}
 	*p = 20;
 	free(p);
 	p=NULL;
 }

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

//错误写法
void test()
 {
 int i = 0;
 int *p = (int *)malloc(10*sizeof(int));
 if(NULL == p)
 {
 exit(EXIT_FAILURE);
 }
 for(i=0; i<40; i++)
 {
 *(p+i) = i;//当i是10的时候越界访问
 }
 free(p);
 }

//正确写法
void test()
 {
 int i = 0;
 int *p = (int *)malloc(10*sizeof(int));
 if(NULL == p)
 {
 exit(EXIT_FAILURE);
 }
 for(i=0; i<10; i++)
 {
 *(p+i) = i;//当i是10的时候越界访问
 }
 free(p);
 }

4.3对非动态开辟内存使用free释放

//错误写法
void test()
{
 int a = 10;
 int *p = &a;
 free(p);//ok?
 //free只能对动态内存处理
 }

4.4 使用free释放一块动态开辟内存的一部分

//错误写法
void test()
 {
 int *p = (int *)malloc(100);
 p++;//此时的p指针并不是指向了动态内存分配的起始地址，而是跳过了4个字节的空间
 free(p);//p不再指向动态内存的起始位置
 }

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

//错误写法
void test()
 {
 int *p = (int *)malloc(100);
 free(p);
 free(p);//重复释放,相当于对p野指针进行了释放，这是不允许的
 }

//正确写法
void test()
 {
 int *p = (int *)malloc(100);
 //...
 free(p);
 p=NULL;

//...
 free(p);
 p=NULL;
 }

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

void test()
 {
 int *p = (int *)malloc(100);
 if(NULL != p)
 {
 *p = 20;
 }
 }
int main()
 {
 test();
 while(1);
 }

  

五、动态内存经典笔试题分析

题目1

//错误写法
void GetMemory(char *p)//p是str的临时拷贝
 {
 p = (char *)malloc(100);//后面没有free释放，导致内存泄漏
 }
void Test(void)
 {
 char *str = NULL;
 GetMemory(str);
 strcpy(str, "hello world");//str还是空指针，导致了对NULL指针解引用操作，程序崩溃
 //要知道strcpy的实现
 printf(str);//这样的写法没有错,是对的,类型于printf("hehe\n")，"hehe\n"是常量字符串，值是首字符的地址
 }


//正确写法
//写法一
void GetMemory(char **p)
 {
 *p = (char *)malloc(100);
 }
void Test(void)
 {
 char *str = NULL;
 GetMemory(&str);
 strcpy(str, "hello world");
 printf(str);
 free(str)
 str = NULL;
 }
//写法二
void GetMemory()
 {
 char * p = (char *)malloc(100);
 return p;
 }
void Test(void)
 {
 char *str = NULL;
 str =GetMemory();
 strcpy(str, "hello world");
 printf(str);
 free(str)
 str = NULL;
 }

题目2

char *GetMemory(void)
{
 char p[] = "hello world";//当出了该函数，数组是局部变量，有作用域，空间中的数据会被销毁
 return p;
}
void Test(void)
{
 char *str = NULL;
 str = GetMemory();
 //虽然str指针接收了字符数组的首元素地址，指向了原来的字符数组空间，但是那空间已经归还操作系统了，不在属于这个程序了
 //str是野指针了
 printf(str);
}

  注意：题目2就是典型的错误，返回栈空间地址的问题。

题目3

//错误写法
void GetMemory(char **p, int num)
 {
 *p = (char *)malloc(num);
 }
void Test(void)
 {
 char *str = NULL;
 GetMemory(&str, 100);
 strcpy(str, "hello");
 printf(str);//结果可以打印出hello，但是不使用后，要将动态申请的内存空间给释放掉，
 //所以导致内存泄漏
 }

//正确写法
void GetMemory(char **p, int num)
 {
 *p = (char *)malloc(num);
 }
void Test(void)
 {
 char *str = NULL;
 GetMemory(&str, 100);
 strcpy(str, "hello");
 printf(str);
 free(str);
 str = NULL;
 }

题目4

//错误写法
void Test(void)
 {
 	char *str = (char *) malloc(100);
 	strcpy(str, "hello");
 	free(str);//此时str是野指针，但是str还是指向原来的空间
 	if(str != NULL)
 	{
 		strcpy(str, "world");//strcpy函数中年会对野指针str进行了解引用操作，非法访问
 		printf(str);
 	}
 }

//正确写法
void Test(void)
 {
 	char *str = (char *) malloc(100);
 	strcpy(str, "hello");
 	free(str);
 	str = NULL;
 	if(str != NULL)
 	{
 		strcpy(str, "world");
 		printf(str);
 	}
 }

  

六、柔性数组

  也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

struct S
{
	int n;
	char c;
	double d;
	int arr[];//未知大小的数组 - arr就是柔性数组的成员
	//也可以写成int arr[0]
};

6.1 柔性数组的特点：

  • 结构中的柔性数组成员前面必须至少一个其他成员。
  • sizeof 返回的这种结构大小不包括柔性数组的内存。
  • 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
struct S
{
	int n;
 	int arr[0];//柔性数组成员
};
int main()
{
 	printf("%d\n", sizeof(struct S));//输出的是4
 	return 0;
}

6.2 柔性数组的使用

struct S
{
	int n;
 	int arr[];//柔性数组成员
};
int main()
{
 	struct S* ps = (struct S*)malloc(sizeof(struct S) + 20*sizeof(int));
 	//20*sizeof(int)是为arr数组动态分配的,表示数组arr有20个整型
 	if(ps == NULL)
 	{
		perror("malloc()");
		return 1;
	}

	//使用空间
	ps->n=100;
	int i = 0;
	for(i = 0; i < 20 ; i++)
	{
		ps->arr[i] = i + 1;
	}

	//调整ps指向空间的大小
	struct S* ptr = (struct S*)realloc(ps,sizeof(struct S) + 40 * sizeof(int));
	if(ps != NULL)
	{
		ps = ptr;
		ptr = NULL;//防止ptr为野指针
	}
	else
	{
		return 1;
	}

	//使用空间
	for(i = 0 ; i < 40 ; i++)
	{
		printf("%d ",ps->arr[i]);
	}

	//释放空间
	free(ps);
	ps = NULL;
	
 	return 0;
}

6.3 柔性数组的优势

//代码一
struct S
{
	int n;
	int* arr;
};

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}
	int*tmp = (int*)malloc(20*sizeof(int));
	if (tmp != NULL)
	{
		ps->arr = tmp;
	}
	else
	{
		return 1;
	}
	ps->n = 100;
	int i = 0;
	//给arr中的20个元素赋值为1~20
	for (i = 0; i < 20; i++)
	{
		ps->arr[i] = i + 1;
	}
	//调整空间
	tmp = (int*)realloc(ps->arr, 40*sizeof(int));
	if (tmp != NULL)
	{
		ps->arr = tmp;
	}
	else
	{
		perror("realloc");
		return 1;
	}
	//
	for (i = 0; i < 40; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	//释放
	free(ps->arr);//先释放第二次申请的空间
	ps->arr = NULL;

	free(ps);//再释放第一次申请的空间
	ps = NULL;

	return 0;
}

//代码二
struct S
{
	int n;//4
	int arr[];
};

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 20*sizeof(int));
	if(ps == NULL)
	{
		perror("malloc()");
		return 1;
	}
	//使用这些空间
	ps->n = 100;
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		ps->arr[i] = i + 1;
	}

	//调整ps指向空间的大小
	struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 40 * sizeof(int));
	if (ptr != NULL) 
	{
		ps = ptr;
		ptr = NULL;
	}
	else
	{
		return 1;
	}
	//使用
	for (i = 0; i < 40; i++)
	{
		printf("%d ", ps->arr[i]);
	}

	//释放空间
	free(ps);
	ps = NULL;

	return 0;
}

  
  上述 代码一 和 代码二 可以完成同样的功能，但是 代码二 的实现有两个好处：
在这里插入图片描述

  

七、总结C/C++中程序内存区域划分

在这里插入图片描述
在这里插入图片描述

帧渴爱
关注
  • 31
    点赞
  • 踩
  • 44
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
C语言实现植物大战僵尸----学习过程
Everybodynow的博客
04-01 6937
大一下学期c语言课程设计要我们用c语言制作一款游戏，之前网上冲浪时候发现了c语言实现植物大战僵尸的教程，就想来跟着教程做一遍，并记录下自己的学习过程与经验。
【JAVA复习系列】第一部分
weixin_46272919的博客
06-09 815
这系列文章是我自己复习使用，会一边学习一边更改，也会补充一些我自己使用的资料啥的
疯狂的程序员 41-50
qq_41284481的博客
06-18 3334
（41） 网吧 绝影想了想，还是摇了摇头，这反而让周总更加充满了疑惑。 日子一天一天过去，DAP的进展是越发困难，周总和绝影对这个CASE彼此都是心照不宣。直到有一天，周总极其神秘地把绝影叫进办公室，说：“明天，我们一起去南京。” 绝影早就料到自己会去南京，虽然他是一万个不想去，但是周总这么一说，他还是感觉很突然，忙问：“小张呢？他也去吗？” “暂时还不安排，如果需要，我们先去，如果有必要我会把他...
【全栈计划 —— 单片机】——Part_01 单片机数字电路基础+C51基础概念
weixin_52621323的博客
04-12 6930
为了在学习单片机之前具备一定的数字电路基础以及重新拾起C语言进行开始，将需要注意的重点全部去粗留精的总结出来了
链表的C语言实现之动态内存分配
08-03
动态内存分配是C语言中一种关键的内存管理技术。与静态内存分配不同，动态内存分配允许在程序运行时按需分配和释放内存。这样，程序员可以根据实际需求动态地创建和销毁数据结构，例如链表中的节点。 在C语言中，...
C语言 动态内存分配详解
01-20
C语言 动态内存分配详解 动态内存分配涉及到堆栈的概念：堆栈是两种数据结构。堆栈都是数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除。 栈（操作系统）：由操作系统自动分配释放 ，...
c语言情人节的红玫瑰-C 语言基础
07-01
c语言情人节的红玫瑰-C 语言基础
爱心代码c语言-爱心代码c语言源码.zip
05-16
爱心代码c语言-爱心代码c语言源码.zip爱心代码c语言-爱心代码c语言源码.zip爱心代码c语言-爱心代码c语言源码.zip爱心代码c语言-爱心代码c语言源码.zip爱心代码c语言-爱心代码c语言源码.zip爱心代码c语言-爱心代码...
[C/C++入门][循环]14、计算2的幂(2的n次方）
qq_14840819的专栏
07-15 912
计算2的幂（即2的n次方）非常经典。你懂几种方法呢？很多人只会一种，我们来分析一下。
[C/C++入门][ifelse]15、判断奇偶数
qq_14840819的专栏
07-16 340
在数学中，判断一个整数是否为奇数或偶数的依据是基于数的模运算。对于任意整数 n，当 n除以2的余数等于0 时，n 是偶数；当 余数为1 时，n 是奇数。计算机中% 表示模运算，即求余数。尝试运行以下这段代码，看看它如何工作。如果有疑问，随时留在评论区，我们一起讨论吧。
PD协议芯片ECP5701+充电管理芯片+升压芯片搭配应用TYPE-C口充电及升压供电系统
IC_Aihui的博客
07-18 699
能芯科技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 431
PD取电快充协议芯片接收到请求信号后，会根据电池的容量、充电器的功率以及当前电池的状态等因素，计算出合适的电压和电流，然后向充电器发送反馈信号。总的来说，TYPE-C接口和PD取电快充协议的结合，是现代电子设备充电技术的一大进步，它们的普及和应用，无疑让我们的生活更加便捷，更加智能。比如可以配置适配器输出需要的电压，给。而TYPE-C接口作为新一代的USB接口，具有正反插、传输速度快、充电体验好等优点，已经成为了快充技术的主要接口形式。◇ 可自动匹配 PD 输出 5V，9V，12V，15V，20V电压。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 游乐园门票 (200分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
07-14 600
- 一日票: 仅限当日有效 - 三日票: 从购买当日起,连续3天内有效 - 周票: 从购买当日起,连续7天内有效 - 月票: 从购买当日起,连续30天内有效 现在给定每种门票的价格,以及LYA计划在未来一年内的游玩日期,请帮助LYA计算出她需要支付的最低门票费用。
[C/C++入门][变量和运算]9、数据类型以及占用存储空间大小
qq_14840819的专栏
07-15 890
么？让我们用小朋友都能看明白的方法来理解一下：想象一下，你的玩具箱里有不同大小的盒子，有的盒子很小，只能放一个小型的玩具，有的盒子很大，可以装下好多好多的玩具。这些盒子就像电脑里的不同数据类型。当你玩玩具时，如果你只需要用到一个小的玩具或者零件，你会选择哪个盒子呢？当然是那个最小的盒子啦，因为它刚好够用，而且不会浪费空间。同样的道理，当我们用电脑写程序的时候，如果我们只需要记录一些简单的东西，比如一个字母或者一个小数字，我们就用。
C的分文件编写与动态库
zhaojiazb的博客
07-15 451
C的文件分为了函数声明的.h文件、函数实现的.c文件和功能实现的mian.c文件以下使用一个输出两数之间最大值函数来说明分文件编写。
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 831
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 903
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
C语言动态内存分配详解-malloc函数
在C语言中，动态内存分配是一种在程序运行期间根据实际需求动态地分配内存的方法。它允许程序员在不知道所需内存大小或者内存需求随程序运行变化时分配内存。动态内存分配与静态内存分配（如在变量声明时分配内存）...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值