【C语言】—— 动态内存管理

【C语言】——动态内存管理

一、动态内存管理概述

1.1、动态内存的概念

  在了解为什么要有动态内存管理之前,我们得先知道动态内存的定义

  动态内存是指动态的内存空间,意思就是:能动态开辟的内存空间动态就是申请了这块空间后,可动态的修改这块空间的大小,根据需要,动态地释放和分配内存空间
  

1.2、动态内存的必要性

  为什么要有动态内存呢?
  既然有动态内存,那与之相对的就是静态内存
  什么是静态内存呢?其实静态内存我们天天都在用,只是不知道它是静态内存而已
  
下面两种内存开辟方式就是静态内存

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

  

但是静态内存的开辟有两个缺点

  • 空间开辟的大小是固定
  • 数组在申明的时候,必须指定数组的长度,数组空间一旦确定了大小不能调整

  但是,在实际需求中,我们往往只有在程序运行时才能知道所需的空间大小,用数组开辟空间,往往容易造成内存溢出(空间开小),或者内存浪费(空间开大),无法满足实际的需求
  
  因此,C语言引入了动态内存开辟,让程序员自己可以申请和释放空间,并根据需要,自己调整开辟后空间的大小。这样不仅提高了内存的利用率,也极大地增强了程序的灵活性扩展性
  
  

二、 m a l l o c malloc malloc 函数

2.1、函数介绍

  C语言中提供了一个动态内存分配的函数: m a l l o c malloc malloc

在这里插入图片描述

功能:向内存申请一块连续可用的空间(可当成数组),并返回指向这块空间的指针

  • 参数 s i z e size size_ t t t s i z e size size

    • 分配的内存的大小,以字节为单位。即开辟 s i z e size size 字节大小的空间
    • 如果参数为 0 m a l l o c malloc malloc 的行为是标准未定义的,取决于编译器
        
  • 返回值 v o i d void void *

    • 返回指向开辟空间的指针,因为 m a l l o c malloc malloc 函数 事先并不知道使用者开辟空间存放什么类型的数据,因此指针为 v o i d void void* 类型,以便能接受所有类型。
    • 使用者可根据自己的需要,将其强制类型转换成自己所需要的类型,以便能进行解引用操作。
    • 如果开辟失败,则返回 空指针,因此 m a l l o c malloc malloc 的返回值一定要做检查

  

2.2、应用举例

#include<stdlib.h>int main()
{int* p = NULL;p = (int*)malloc(10 * sizeof(int));if (NULL == p){perror("malloc fail");return 1;}return 0;
}

上述代码是使用 m a l l o c malloc malloc 函数开辟 10 个整型变量的空间,也即 40 个字节的空间

  • 首先,因为 m a l l o c malloc malloc 函数的返回值是指针,我们需用指针变量 p p p 接收其返回值,创建 p p p 时,并不知道其指向的空间,所以先初始化为 NULL。
  • 接着,使用 m a l l o c malloc malloc 函数开辟空间,因为我们要存放的是整型变量,而 m a l l o c malloc malloc 的返回值类型为 v o i d void void* 我们通过强制类型转换将其返回类型转换为 i n t int int* ,并用 p p p 来接收
  • 因为 m a l l o c malloc malloc 函数有可能开辟失败1,只有当返回值不为空的情况我们才使用它,因此需判断 p p p 指针是否为空。若为空,则用 p e r r o r perror perror 函数2打印出错误信息,并返回 13
  • 若开辟成功,我们就可以愉快地使用这块空间啦

在这里插入图片描述

  需要注意的是: m a l l o c malloc malloc 开辟的空间并不会将其初始化
  
  

三、 c a l l o c calloc calloc 函数

  开辟动态内存空间,C语言还提供了一个函数叫 c a l l o c calloc calloc ,原型如下:

在这里插入图片描述

  • 函数的功能是为 n u m num num 个大小为 s i z e size size 的元素开辟一块空间,并将这块空间初始化为 0
  • 与函数 m a l l o c malloc malloc 的区别只在于 c a l l o c calloc calloc 会返回地址之前把申请的空间的每个字节初始化为全 0

举个例子:

#include<stdio.h>
#include<stdlib.h>
int main()
{int* p = (int*)calloc(10, sizeof(int));if (NULL != p){int i = 0;for (i = 0; i < 10; i++){printf(" %d", *(p + i));}printf("\n");}return 0;
}

  
运行结果:

在这里插入图片描述

  
  

四、 f r e e free free 函数

4.1、函数介绍

  
  上述 m a l l o c malloc malloc 函数、 c a l l o c calloc calloc 函数以及后面讲的 r e a l l o c realloc realloc 函数所申请的空间,并不满足作用域的规则。只有当程序退出时,用他们开辟的动态空间才会归还给操作系统,换言之,程序不退出,就不会主动归还空间。这时,我们就需要 f r e e free free函数 来对其主动释放

   f r e e free free 函数是专门用于动态开辟的内存空间的释放回收,声明如下:

在这里插入图片描述

  
f r e e free free 函数用来释放动态开辟的内存

  • 如果参数 p t r ptr ptr 指向的空间不是动态开辟的,那 f r e e free free 函数的行为是未定义
  • 如果参数是 p t r ptr ptr 是NULL指针,则函数什么事都不做
  • 需要注意的是, f r e e free free 函数不会改变指针所指向的值,释放后它依然指向相同的内存空间。因此我们要手动将释放后的 p t r ptr ptr 置空,避免出现野指针。

m a l l o c malloc malloc c a l l o c calloc calloc 以及 f r e e free free 函数的声明都在 < s t d l i b . h > <stdlib.h> <stdlib.h>
  

4.2、应用举例

  
我们来看个例子:

#include<stdio.h>
#include<stdlib.h>int main()
{int* ptr = NULL;ptr = (int*)malloc(10 * sizeof(int));if (NULL != ptr){int i = 0;for (i = 0; i < 10; i++){*(ptr + i) = 0;}}free(ptr);ptr = NULL;return 0;
}

在这里插入图片描述

  
  那我们来看看下面这种情况行不行呢?

int main()
{int* ptr = NULL;ptr = (int*)malloc(5 * sizeof(int));if (NULL != ptr){int i = 0;for (i = 0; i < 5; i++){*ptr = 0;ptr++;}}free(ptr);ptr = NULL;return 0;
}

  当然是不行的,为什么呢?
  因为传递给 f r e e free free 函数的是要释放空间的 起始地址
  上面函数的 p t r ptr ptr 以及不再指向要释放空间的起始地址了,当然是不行的。
  
  

五、 r e a l l o c realloc realloc 函数

5.1、函数介绍

  
  可能有小伙伴问:前面你说动态内存可根据需要,动态调整所开辟空间的大小,但前面介绍 m a l l o c malloc malloc c a l l o c calloc calloc 以及 f r e e free free函数 都只是在将动态空间的开辟和释放,如何调整空间的大小呢?别急,我们接下来要讲的 r e l l o c relloc relloc函数 就是完成调整开辟空间的大小的任务的

   r e a l l o c realloc realloc 函数的出现让动态内存管理更加灵活
  
  有时我们会发现之前申请的空间太小了,有时我们又会觉得申请的空间太大了,那为了合理的使用内存,,我们一定会对内存的大小做出灵活的调整。那 r e a l l o c realloc realloc函数 就可以做到对动态开辟内存大小的调整

先来看看 r e l l o c relloc relloc函数 的声明:

在这里插入图片描述

  • p t r ptr ptr 是要调整的内存地址
  • s i z e size size 是调整之后的大小(可以变大,也可变小)
  • 返回值为调整之后的内存起始位置

r e a l l o c realloc realloc 调整内存大小分为三种情况:

在这里插入图片描述

  1. 原有空间之后有足够大的空间

  如上图: r e l l o c relloc relloc 已经开辟 20 个字节的空间,现在我想扩容到 40 字节,同时原有空间后方空间足够扩展新空间
  
  此时 r e a l l o c realloc realloc 函数直接在后方追加空间,原来空间的数据不发生变化

  
2. 原有空间之后没有足够大的空间

  还是上面那个图,现在我想将他扩容到 400 字节,很明显,已开辟空间后方没有足够的空间,总不能把别人踢开,自己霸占吧
  这时, r e a l l o c realloc realloc 函数就会堆空间 另外找一个 合适大小的空间
  
具体流程如下:

  • r e a l l o c realloc realloc 函数先在堆空间上找一块新的空间,并且满足大小要求
  • 后将旧空间的数据拷贝到新空间中
  • 接着释放旧空间
  • 最后返回新空间的起始地址

  
3. 空间调整失败

   r e a l l o c realloc realloc 可能出现空间调整失败的情况,此时返回的是空指针

  
  
   r e a l l o c realloc realloc 不仅仅能将空间的变大,还能将空间变小,只需要第二个参数的值小于原空间的大小就好了,因为缩小空间比较简单,这里就不再过多介绍,但需要注意的是,缩小空间可能会造成数据丢失,因此需小心使用

  同时 r e a l l o c realloc realloc函数 不仅能调整空间大小,还能完成 m a l l o c malloc malloc函数 的功能:当第一个参数 p t r ptr ptr 传递的是 空指针 时, r e a l l o c realloc realloc 函数就不再是调整空间大小了,你都没空间,我还怎么调。此时 r e a l l o c realloc realloc 函数会 新开辟 s i z e size size 字节大小的空间
  
  

5.2、应用举例

  看了上面三种情况,大家想一想,应该怎样接收 r e a l l o c realloc realloc 调整之后的返回值呢?
  可以直接用原来的指针 p p p 接收吗?

  显然是不行,如果 r e a l l o c realloc realloc 调整成功,那确实没问题,但如果失败了呢?此时返回的是空指针。本来 p p p 还维护着原来的空间,现在直接变空指针,那原来的空间再也找不到了,这就造成了内存泄漏

  正确的方法是创建新的指针 p t r ptr ptr 来接收,当 p t r ptr ptr 不为 NULL,再将 p t r ptr ptr 的值传给 p p p
  
如下:

#include<stdlib.h>int main()
{int* p = (int*)malloc(5 * sizeof(int));if (NULL == p){perror("malloc fail");return 1;}//1 2 3 4 5for (int i = 0; i < 5; i++){*(p + i) = i + 1;}//希望将空间调整为40个字节int* ptr = NULL;ptr = (int*)realloc(p, 40);if (NULL != ptr){p = ptr;}else{perror("realloc fail");}//调整成功,使用40个字节;调整失败,继续使用20个字节/**************业务处理**************/free(p);p = NULL;return 0;
}

  
  

六、常见的动态内存错误

6.1、对NULL指针进行解引用

  

#include<stdlib.h>int main(
{int* p = (int*)malloc(INT_MAX);*p = 20;//如果p的值是空指针,就会有问题free(p);p = NULL;return 0;
}

  
  动态开辟的空间,应该先对返回值进行判断,确保空间开辟成功
  上述代码所要开辟的空间太大,开辟失败,返回的是空指针,而下面一句代码对空指针进行解引用,是错误的
  

#include<stdlib.h>int main()
{int* p = (int*)malloc(10 * INT_MAX);if (NULL == p){perror("malloc fail");return 1;}*p = 20;free(p);p = NULL;return 0;
}

在这里插入图片描述

  

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

  

#include<stdlib.h>int mian()
{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;}free(p);p = NULL;return 0;
}

  可以看到,当 i i i = 10 时,就是对 m a l l o c malloc malloc 开辟的空间越界访问了。
  动态内存的空间与数组是非常相似的,要注意不能对其越界访问
  

6.3、对非动态开辟的内存使用 f r e e free free 释放

void test()
{int a = 10;int* p = &a;free(p);//ok?
}

  变量 a a a 并不是动态开辟的变量,用 f r e e free free 释放是错误的
  
  

6.4、使用 f r e e free free 释放一块动态开辟内存的一部分

  这种情况即是,传给 f r e e free free 的指针并不是动态开辟内存的起始地址,指针跑后面去了。

void test()
{int* p = (int*)malloc(100);p++;free(p);//p不再指向动态内存的起始位置
}

  注意:动态内存一定是 一同申请,一同释放。无法做到只释放一部分空间
  

6.5、对同一块动态内存多重释放


void test()
{int* p = (int*)malloc(100);//···free(p);free(p);//重复释放
}

  这种释放有办法可以避免:释放完后及时 p p p 置为空指针,这样,即使再次释放,传的是空指针, f r e e free free 什么都不会做,不会造成什么影响
  

6.6、动态开辟内存忘记释放(内存泄漏)

#include<stdlib.h>
void test()
{int* p = (int*)malloc(100);if (NULL != p){*p = 20;}
}int main()
{test();while (1);return 0;
}

  上述代码,你会发现,一旦出了函数,就再也找不到开辟的那 100 个字节的空间(这代码写的比较极端,一直死循环,程序一直不结束) 。找不到开辟的空间更别提将其释放,空间就一直在那占着,就造成了内存泄漏

  想一想,如果我们一直向内存申请空间,但从来不释放。要知道,内存的总大小是有限的,这样就会把内存耗干,机器就挂了。

  
总结: m a l l o c malloc malloc c a l l o c calloc calloc r e a l l o c realloc realloc 申请的空间,尽量做到:

  • 谁(可能是函数)申请的就谁释放,即 m a l l o c malloc malloc f r e e free free 成对出现
  • 如果不能释放,要告诉使用的人记得释放

  
  

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

7.1、题一

void GetMemory(char* p)
{p = (char*)malloc(100);
}void Test(void)
{char* str = NULL;GetMemory(str);strcpy(str, "hello world");printf(str);
}int main()
{Test();return 0;
}

请问运行 T e s t Test Test 函数会有什么样的结果?

运行 T e s t Test Test 函数,程序会崩溃
  
为什么呢?我们来分析一下
  
先来看这段代码想要做什么:

  1. 首先,它定义了一个 G e t M e m o r y GetMemory GetMemory函数,很明显,这个函数是完成动态开辟空间任务的
  2. 接着 T e s t Test Test函数 中创建了指针 s t r str str,将变量传给 G e t M e m o r y GetMemory GetMemory,即希望指针 s t r str str 管理动态开辟的空间
  3. 最后往空间中存入 " h e l l o w o r l d " "hello world" "helloworld",并打印

  
  代码的逻辑没问题,那就是代码本身出问题咯

在这里插入图片描述

  通过调试我们发现, G e t M e m o r y GetMemory GetMemory函数 并没有改变 s t r str str 的值,它依然是个空指针。

  为什么呢?因为 G e t M e m o r y GetMemory GetMemory传值传参,而不是传址传参!传值传参无法改变主调函数中的值,出了函数 s t r str str 依然是空指针,而后面打印 s t r str str 指向的内容,是要对其解引用的,对空指针解引用自然会出问题。
  同时,函数中 m a l l o c malloc malloc实打实开辟了空间的,只有程序结束才销毁,而函数中的变量出了函数作用域就销毁,这样函数中所开辟的 100 个字节空间出了 G e t M e m o r y GetMemory GetMemory函数 后也无法找到,造成内存泄漏=

  可能有小伙伴会问: G e t M e m o r y GetMemory GetMemory函数 的参数类型就是 c h a r char char* 啊,为什么还是传值传参呢?这里我们要指针传址传参的本质:传递的是变量的地址,因为主调函数中要传的值本身就是指针 c h a r char char* 类型,要改变指针变量,就要传递指针变量的指针,即二级指针。这里可不敢看到 G e t M e m o r y GetMemory GetMemory函数 参数中是 c h a r char char* 就认为他是传址传参
  
正确写法应该是这样:

void GetMemory(char** p)
{*p = (char*)malloc(100);
}void Test(void)
{char* str = NULL;//传str的地址GetMemory(&str);strcpy(str, "hello world");printf(str);//释放动态空间free(str);str = NULL;
}

当然, G e t M e m o r y GetMemory GetMemory函数 我们也可以直接让他返回 p p p,以实现目的

char* GetMemory()
{char* p = (char*)malloc(100);return p;
}void Test(void)
{char* str = GetMemory();strcpy(str, "hello world");printf(str);free(str);str = NULL;
}

  
  

7.2、题二

char* GetMemory(void)
{char p[] = "hello world";return p;
}void Test(void)
{char* str = NULL;str = GetMemory();printf(str);
}int main()
{Test();return 0;
}

运行结果:

在这里插入图片描述

  为什么会这样呢?
  问题还是出在 G e t M e m o r y GetMemory GetMemory函数

   G e t M e m o r y GetMemory GetMemory函数 中创建的 p p p 数组,在出了函数作用域后就销毁了,因此函数返回 p p p,用 s t r str str 接收,而实际上 s t r str str 接收的地址是指向一块已经归还的空间,此时的 s t r str str野指针。再去访问 s t r str str 所指向的空间是非法访问,打印出的值是随机值。
  
  

7.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);
}
int main()
{Test();return 0;
}

  可能有小伙伴会觉得这段代码咋一看好像没什么问题啊

  确实,大家有没有发现代码与我们第一题修改后的代码非常像,但大家仔细想想它还缺少什么?

  这段代码唯一的问题是:没有 f r e e free free,动态申请内存空间后他并没有还回去。

  虽然这里没有 f r e e free free 程序也没有问题,因此程序结束后会自动释放空间,但以后遇到复杂的情况就不好说了,因此我们要 养成主动释放内存空间的习惯
  
  

7.4、题四

void Test(void)
{char* str = (char*)malloc(100);strcpy(str, "hello");free(str);if (str != NULL){strcpy(str, "world");printf(str);}
}
int main()
{Test();return 0;
}

  这题的问题相信大家都能看得出来:
  
   T e s t Test Test函数 上来先开辟 100 字节动态空间,并创建 s t r str str 变量维护它,再向空间中放 " h e l l o " "hello" "hello"
  
  但紧接着,释放 s t r str str却没将 s t r str str 置空,此时的 s t r str str野指针。将空间释放,即将其还给操作系统,我们是没有使用权限了,但是这块空间本身还在
  
  下面的 i f if if 语句判断为真,往 s t r str str 指向的空间放入 " w o r l d " "world" "world",此时 s t r str str 指向的空间我们已经没有使用权限了,但依然进行修改,为非法内存访问。
  
  

八、柔性数组

8.1、什么是柔性数组

  
  也许有些小伙伴从来没有听过柔性数组这个概念,但是它确实是存在的
  C99 中,结构体的最后一个元素允许是未知大小的数组,这就叫做:柔性数组成员
  

typedef struct st_type
{int i;int a[0];
}type_a;

  有些编译器会报错无法编译,可以改成:

typedef struct st_type
{int i;int a[];
}type_a;

  
  

8.2、柔性数组的特点

  • 结构体中的柔性数组成员前面必须至少一个其他成员
  • s i z e o f sizeof sizeof 返回的这种结构体大小不包括柔性数组的内存
  • 包含柔性数组成员的结构体一般用 m a l l o c malloc malloc函数 进行内存的动态分配,并且分配的内存应该大于结构体的大小,以适应柔性数组的预期大小

例如:

typedef struct st_type
{int i;int a[0];
}type_a;
int main()
{printf("%d\n", sizeof(type_a));return 0;
}

运行结果:

在这里插入图片描述

  
  

8.2、柔性数组的使用

#include<stdio.h>
#include<stdlib.h>typedef struct st_type
{int i;int a[0];
}type_a;int main()
{int i = 0;type_a* p = (type_a*)malloc(sizeof(type_a) + 10 * sizeof(int));if (NULL == p){perror("malloc fail");return 1;}//业务处理p->i = 10;for (i = 0; i < 10; i++){p->a[i] = i;}//调整空间type_a* ptr = (type_a*)realloc(p, sizeof(type_a) + 20 * sizeof(int));if (ptr != NULL){p = ptr;}free(p);p = NULL;return 0;
}

柔性数组的结构:在这里插入图片描述

  既然这块空间是 m a l l o c malloc malloc 出来的,也就是说他可以通过 r e a l l o c realloc realloc 来调整大小,所以这个数组可变长变短,不就是柔性
  
  

8.3、柔性数组的优势

  
  上述 t y p e type type_ a a a 结构,也可以设计为下面的结构,也能完成同样的效果

#include<stdio.h>
#include<stdlib.h>typedef struct st_type
{int i;int* p_a;
}st_type;
int main()
{st_type* p = (st_type*)malloc(sizeof(st_type));p->i = 100;p->p_a = (int*)malloc(p->i * sizeof(int));///业务处理for (i = 0; i < 100; i++){p->p_a[i] = i;}//释放空间free(p->p_a);p->p_a = NULL;free(p);p = NULL;return 0;
}

图示:

在这里插入图片描述

  上述两个方法都可以达到类似的效果

  但是使用柔性数组有两个好处
  

  • 方便内存释放
      如果我们的代码是在一个给别人用的函数中,你在里面做了二次内存分配,并把结构体返回给用户。用户调用 f r e e free free 可以释放结构体,但是用户并不知道结构体内的成员也需要 f r e e free free,所以你不能指望用户来发现这个事
      所以,如果我们把结构体的内存以及其成员要的内存一次性分配好了,并返回给用户一个结构体指针,用户做一次 f r e e free free 就可以把所有的内存释放掉
      
  • 有利于访问速度
      连续的内存有益于提高访问速度,也有益于减少内存碎片4

  
  

九、C/C++中内存区域划分

在这里插入图片描述

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

  • 内核空间操作系统核心(内核)运行的地方,在这个区域,操作系统可以直接访问硬件,并执行特权指令。我们用户是无权访问这块空间的
  • 栈区:在执行函数时,函数内局部变量的存储单元都是在栈上创建,函数执行结束时这些存储单元自动释放。栈内存分配运算内置于处理器的指令中,效率很高,但是分配的内存容量有限。栈区只要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
  • 堆区:堆区一般是用来存储程序运行期间动态分配内存的地方。堆区的内存分配是在程序运行时动态进行的,程序员可以通过调用标准库函数(如 m a l l o c malloc malloc c a l l o c calloc calloc r e a l l o c realloc realloc等)来在堆区中分配内存,并在不需要时手动释放这些内存(使用 f r e e free free函数)。使用堆区需要注意内存泄漏 m e m o r y l e a k memory leak memoryleak)的问题,即程序在不再需要某块内存时没有释放它,导致程序占用的内存越来越多。
  • 数据段:数据段也叫做静态区,主要用来存放全局变量、静态数据、全局变量。程序结束后由系统释放
  • 代码段:存放函数体(类成员函数和全局函数)的二进制代码、只读常量(字符串常量)

  1. 内存开辟失败:动态内存开辟失败的原因一般都是所空间太大,没有足够的空间 ↩︎

  2. p e r r o r perror perror函数:有关该函数的具体介绍请看:《【C语言】——字符串函数的使用与模拟实现(下)》 ↩︎

  3. 返回值为 1: m a i n main main 函数程序正常退出,返回值为 0;异常退出,返回值为 1 ↩︎

  4. 我们开辟内存时,不会紧接着上一块内存开辟,而会留下一点空隙,开辟次数越多,留下的空隙也就也多,这些空隙称为内存碎片。 ↩︎

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/diannao/12231.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

无列名注入

在进行sql注入时&#xff0c;一般都是使用 information_schema 库来获取表名与列名&#xff0c;因此有一种场景是传入参数时会将 information_schema 过滤 在这种情况下&#xff0c;由于 information_schema 无法使用&#xff0c;我们无法获取表名与列名。 表名获取方式 Inn…

FullCalendar日历组件集成实战(3)

背景 有一些应用系统或应用功能&#xff0c;如日程管理、任务管理需要使用到日历组件。虽然Element Plus也提供了日历组件&#xff0c;但功能比较简单&#xff0c;用来做数据展现勉强可用。但如果需要进行复杂的数据展示&#xff0c;以及互动操作如通过点击添加事件&#xff0…

SwiftUI中的常用图形(Shapes)

概述 在SwiftUI中&#xff0c;常用的图形&#xff08;Shape&#xff09;主要有&#xff1a; Circle&#xff1a;圆形 Ellipse&#xff1a;椭圆形 Capsule&#xff1a;胶囊形 Rectangle&#xff1a;矩形 RoundedRectangle&#xff1a;圆角矩形 上面的这些图形都继承了Shape协议…

Hive读写文件机制

Hive读写文件机制 1.SerDe是什么&#xff1f; SerDe是Hive中的一个概念&#xff0c;代表着“序列化/反序列化” &#xff08;Serializer/Deserializer&#xff09;。 SerDe在Hive中是用来处理数据如何在Hive与底层存储系统&#xff08;例如HDFS&#xff09;之间进行转换的机制…

2024国考行测、申论资料大全,做好备考真的很重要!

1. 国考是什么? 国考,全称国家公务员考试,是选拔国家公务员的重要途径。通过国考,你将有机会进入政府部门,为国家建设贡献力量。 2. 国考难在哪里? 国考之所以难,主要体现在以下几个方面: (1) 竞争激烈 每年国考报名人数都在百万以上,而录取率却不足2%。千军万马过独木桥…

node和npm版本太高导致项目无法正常安装依赖以及正常运行的解决办法:如何使用nvm对node和npm版本进行切换和管理

1&#xff0c;点击下载 nvm 并且安装 进入nvm的github&#xff1a; GitHub - coreybutler/nvm-windows: A node.js version management utility for Windows. Ironically written in Go. 这里下载发行版&#xff0c;Releases coreybutler/nvm-windows GitHub 找到 这个 nv…

洗地机哪款好用?希亦、追觅、顺造、米家等高品质洗地机推荐

家用洗地机已经成为家庭清洁的重要利器&#xff0c;其多功能性能帮助您轻松应对各种清洁任务&#xff0c;从而保持家居环境的清洁整洁。然而&#xff0c;市场上品牌繁多、功能各异的洗地机让人眼花缭乱。为了帮助大家做出明智的选择&#xff0c;我们将在本文中提供全面的选购指…

选择法(数值排序)(C语言)

一、运行结果&#xff1b; 二、源代码&#xff1b; # define _CRT_SECURE_NO_WARNINGS # include <stdio.h>//声明排序函数sort; void sort(int a[], int n);int main() {//初始化变量值&#xff1b;int i, a[10];//填充数组&#xff1b;printf("请输入10个整数\n&…

蓝桥杯备战22.k倍区间——前缀和

目录 题目 分析 暴力求解 优化思路 AC代码 题目链接&#xff1a; P8649 [蓝桥杯 2017 省 B] k 倍区间 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn) 题目 分析 很明显这题是一道前缀和的题 暴力求解 只得了28分 #include<iostream> using namespace std; co…

求学生平均成绩(C语言)

一、运行结果&#xff1b; 二、源代码&#xff1b; # define _CRT_SECURE_NO_WARNINGS # include <stdio.h>//声明平均数函数average; float average(float score[10]);int main() {//初始化变量值&#xff1b;float score[10], aver;int i 0;//填充数组&#xff1b;pr…

探秘WebSQL:轻松构建前端数据库

欢迎来到我的博客&#xff0c;代码的世界里&#xff0c;每一行都是一个故事 探秘WebSQL&#xff1a;轻松构建前端数据库 前言WebSQL简介WebSQL的基本操作WebSQL的实际应用WebSQL的局限性和替代方案 前言 在Web的世界里&#xff0c;我们总是追求更好的用户体验和更快的响应速度…

添砖Java之路(其八)——继承,final关键字

目录 继承&#xff1a; super关键字&#xff1a; 方法重写&#xff1a; 继承特点&#xff1a; 继承构造方法&#xff1a; final关键字&#xff1a; 继承&#xff1a; 意义&#xff1a;让类于类之间产生父类于子类的关系&#xff0c;子类可以直接使用父类中的非私有成员(包…

Seal^_^【送书活动第4期】——《Web渗透测试技术》

Seal^_^【送书活动第4期】——《Web渗透测试技术》 一、参与方式二、本期推荐图书2.1 前 言2.2 关于本书2.3 本书读者2.4 图书简介2.5 作者荐语2.6 编辑推荐2.7 目 录 三、正版购买 掌握Web渗透测试技术&#xff0c;提高Web应用安全性。 一、参与方式 1、关注博主的账号。 2、点…

Linux下Code_Aster源码编译安装及使用

目录 软件介绍 基本依赖 其它依赖 一、源码下载 二、解压缩 三、编译安装 四、算例运行 软件介绍 Code_aster为法国电力集团&#xff08;EDF&#xff09;自1989年起开始研发的通用结构和热力耦合有限元仿真软件。Code_aster可用于力学、热学和声学等物理现象的仿真分析&…

CVPR2022人脸识别Partial FC论文及代码学习笔记

论文链接&#xff1a;https://openaccess.thecvf.com/content/CVPR2022/papers/An_Killing_Two_Birds_With_One_Stone_Efficient_and_Robust_Training_CVPR_2022_paper.pdf 代码链接&#xff1a;insightface/recognition/arcface_torch at master deepinsight/insightface G…

基于lidar的多目标跟踪

文章目录 基本流程编译过程注意事项基本流程 基于雷达点云的目标追踪主要包括以下几个步骤: 点云预处理: 滤除噪点和无效点(如NaN值)进行平面分割,提取地面点云对剩余的点云进行聚类,得到可能的目标点云目标检测 对聚类后的点云进行分析,判断是否为有效目标可以利用目标的尺寸…

怎么转换音频?看这3款音频转换器

随着数字媒体的发展&#xff0c;音频文件在我们的日常生活中占据了越来越重要的地位。有时候在不同的应用场景里&#xff0c;无论是音乐、语音还是其他类型的音频内容&#xff0c;我们都需要对其进行转换以满足不同的需求。 本文将为您介绍3款常用的音频转换器&#xff0c;帮助…

Springboot+mybatis-plus+dynamic-datasource+继承DynamicRoutingDataSource切换数据源

Springbootmybatis-plusdynamic-datasource继承DynamicRoutingDataSource切换数据源 背景 最近公司要求支持saas&#xff0c;实现动态切换库的操作&#xff0c;默认会加载主租户的数据源&#xff0c;其他租户数据源在使用过程中自动创建加入。 解决问题 1.通过请求中设置租…

数据可视化训练第7天(json文件读取国家人口数据,找出前10和后10)

数据 https://restcountries.com/v3.1/all&#xff1b;建议下载下来&#xff0c;并不是很大 import numpy as np import matplotlib.pyplot as plt import requests import json #由于访问url过于慢&#xff1b;将数据下载到本地是json数据 #urlhttps://restcountries.com/v3…

MATLAB蚁群算法求解带时间窗的旅行商TSPTW问题代码实例

MATLAB蚁群算法求解带时间窗的旅行商TSPTW问题代码实例 蚁群算法编程求解TSPTW问题实例&#xff1a; 在经纬度范围为(121, 43)到(123, 45)的矩形区域内&#xff0c;散布着1个商家&#xff08;编号1&#xff09;和25个顾客点&#xff08;编号为226&#xff09;&#xff0c;各个…