C语言之旅:动态内存管理

目录

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

二.malloc和free

2.1 malloc

2.2 free

2. 3malloc和free的使用

三. calloc 

四. raelloc

4.1 代码示例:

4.2 注意事项:

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

4.4 对非动态开辟内存使⽤free释放

4.5 使用free释放⼀块动态开辟内存的⼀部分

 4.6 对同⼀块动态内存多次释放

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

4.8 内存的分布:

五.  练习

题目1:

题目2:

题目3:

题目4:

六.柔性数组

6.1 什么是柔性数组

6.2柔性数组的使用

6.3柔性数组的优势


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

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

上述的开辟空间的⽅式有两个特点:

• 空间开辟大小是固定的。

• 数组在申明的时候,必须指定数组的⻓度,数组空间⼀旦确定了大小不能调整 但是对于空间的需求,不仅仅是上述的情况。有时候我们需要的空间大小在程序运⾏的时候才能知 道,那数组的编译时开辟空间的⽅式就不能满足了。

C语言引⼊了动态内存开辟,让程序员自己可以申请和释放空间,就比较灵活了。

二.malloc和free

2.1 malloc

malloc 是一个用于动态内存分配的库函数,它属于标准库 <stdlib.h>。malloc 函数允许你在程序运行时分配指定数量的字节,并返回一个指向所分配内存的指针。

void* malloc (size_t size);

如果内存分配成功,它将返回一个非空。

如果失败,它将返回 NULL。

返回值的类型是 void* ,所以malloc函数并不知道开辟空间的类型,具体在使⽤的时候使用者自己来决定。

• 如果参数 size 为0,malloc的⾏为是标准是未定义的,取决于编译器。

2.2 free

free 是一个用于释放之前由 malloc、calloc 或 realloc 函数分配的内存的函数。它定义在 <stdlib.h> 头文件中。

当你使用 malloc、calloc 或 realloc 函数在堆上分配内存时,你负责在不再需要这块内存时使用 free 函数来释放它。如果不这样做,你的程序将会消耗越来越多的内存,直到耗尽所有可用的内存,这通常会导致程序崩溃或其他不可预见的错误。

函数的原型如下:

void free(void *ptr);

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

 • 如果参数 ptr 指向的空间不是动态开辟的,那free函数的⾏为是未定义的。

 • 如果参数 ptr 是NULL指针,则函数什么事都不做。 

2. 3malloc和free的使用

代码示例:

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

int main() {
    int n = 5;   
    int* arr; 
    arr= (int*)malloc(n * sizeof(int));

    // 检查malloc是否成功分配了内存  
    if (arr == NULL) {
        printf("内存分配失败!\n");
        return 1; // 返回一个错误代码  
    }

    // 使用分配的内存  
    for (int i = 0; i < n; i++) 
    {
        arr[i] = i * 2; 
    }
   
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // 释放分配的内存  
    free(arr);

    return 0; // 程序成功执行完毕  
}

三. calloc 

calloc 是 C 和 C++ 语言中的一个库函数,用于动态内存分配。与 malloc 函数相似,calloc 也用于在堆上分配内存,但它会额外地将分配的内存区域初始化为零。

calloc原型:

void *calloc(size_t num, size_t size);

参数:
num:要分配的元素数量。
size:每个元素的大小(以字节为单位)。

代码示例:

#include <stdlib.h>  
#include <stdio.h> 
int main() 
{
    int* ptr;
    int num = 5;
    int size = sizeof(int);

    // 使用 calloc 分配内存并初始化为零  
    ptr = (int*)calloc(num, size);

    if (ptr == NULL) 
    {
        perror("calloc");
        exit(0);
    }
    
    for (int i = 0; i < num; i++) 
    {
        printf("%d ", ptr[i]);  
    }
    free(ptr);

    return 0;
}

输出结果:

0 0 0 0 0

如果我们申请空间时要对其初始化,那么就可以用calloc。

四. raelloc

当我们申请分配了一块内存,但在程序执行过程中发现这块内存的大小不够或过大时,可以使用realloc来动态地调整其大小。

函数原型:

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

ptr:指向之前分配的内存块的指针。如果 ptr 为 NULL,则 realloc 的行为与 malloc 相同,即分配一块新的内存。
size:新分配的大小(以字节为单位)。

4.1 代码示例:

int main() {
    int* ptr = NULL;
    size_t Size = 4; // 初始分配4个整数的空间  

    // 初始内存分配  
    ptr = (int*)malloc(Size * sizeof(int));
    if (ptr == NULL) {
        perror("malloc");
        return 1;
    }

    // 初始化分配的内存空间  
    for (size_t i = 0; i < Size; ++i) 
    {
        ptr[i] = i + 1; 
    }

    // 打印初始数据  
    for (size_t i = 0; i < Size; ++i) 
    {
        printf("%d ", ptr[i]);
    }
    printf("\n");

    // 扩展内存  
    Size *= 2;  
    int* Ptr1 = realloc(ptr, Size * sizeof(int));
    if (Ptr1 == NULL) 
    {
        perror("realloc");
        // 如果realloc失败,释放原始内存并退出程序  
        free(ptr);
        return 1;
    }

    // 如果realloc成功,更新ptr指针  
    ptr = Ptr1;

    // 初始化新分配的内存空间(这里仅初始化新增的部分)  
    for (size_t i = Size / 2; i < Size; ++i) 
    {
        ptr[i] = i + 1;   
    }
    
    for (size_t i = 0; i < Size; ++i) 
    {
        printf("%d ", ptr[i]);
    }
    printf("\n");
    free(ptr);
    ptr = NULL;

    return 0;
}

4.2 注意事项:

1. 检查malloc和realloc的返回值:确保malloc和realloc调用成功分配了内存。如果它们返回NULL,表示内存分配失败。

2. 不要直接对realloc的返回值进行操作:在将realloc的返回值赋给原始指针之前,先检查它是否为NULL。如果realloc失败,它会释放原始内存并返回NULL。如果你直接对realloc的返回值进行操作,而没有检查它是否为NULL,你可能会丢失对原始数据的引用,并且如果之后尝试访问原始数据,可能会导致程序崩溃。

3. 避免野指针:在释放内存后,将指针设置为NULL,以避免野指针。

五. 常⻅的动态内存的错误

5.1 对NULL指针的解引用操作

代码示例:

void test() 
{
    int* p = (int*)malloc(sizeof(int));
  
    *p = 20; 
    free(p); 
    p = NULL; 
}

malloc因为任何原因(如内存不足或整数溢出)未能成功分配内存,它会返回NULL。但是在这个函数中,没有检查malloc的返回值是否为NULL。如果p是NULL,那么解引用*p = 20;将会导致程序崩溃。

正确代码示例:

void test() 
{
    int* p = (int*)malloc(sizeof(int)); 
    if (p == NULL)     
    {
        // 处理内存分配失败的情况  
        perror("malloc ");
        return;
    }
    *p = 20;   
    free(p); // 释放内存  
    p = NULL; // 避免野指针 
}

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

代码示例:

void test()
{
	int i = 0;
	int* p = (int*)malloc(10 * sizeof(int));
	if (NULL == p)
	{
		perror("malloc");
		return;
	}
	for (i = 0; i <= 10; i++)
	{
		*(p + i) = i;//当i是10的时候越界访问 
	}
	free(p);
}

正确代码:

void test()
{
	int i = 0;
	int* p = (int*)malloc(10 * sizeof(int));
	if (NULL == p)
	{
		perror("malloc");
		return;
	}
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	free(p);
}

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

错误示范:

int main() 
{
    int a = 10; 
    int* ptr = &a; 

    // 错误的尝试
    free(ptr);   

    return 0;
}

在这个例子中,a是在栈上分配的,它的生命周期与包含它的函数相同。不能使用free来释放它,因为free只适用于通过malloc、calloc或realloc等函数在堆上动态分配的内存。

正确代码:

int main() 
{
    int* a = (int*)malloc(sizeof(int));     if (a == NULL) 
    { 
        return 1;
    }
    *a = 10;  
    free(a);
    a = NULL;  

    return 0;
}

4.5 使用free释放⼀块动态开辟内存的⼀部分

int main() 
{
    int* a = (int*)malloc(10 * sizeof(int)); 
    if (a == NULL) 
    {       
        perror("malloc");
        return 1;
    }
   
    for (int i = 0; i < 10; ++i) 
    {
        a[i] = i;
    }
    // 错误尝试:释放内存块的一部分   
    free(a + 5); 

    return 0;
}

正确的做法是保留原始指针a,并在不再需要整个内存块时调用free(a);来释放它。

正确代码示例:

int main() 
{
    int* a = (int*)malloc(10 * sizeof(int)); 
    if (a == NULL) 
    {
        perror("malloc");
        return 1;
    }
  
    for (int i = 0; i < 10; ++i) 
    {
        a[i] = i;
    }

    // 正确释放整个内存块  
    free(a);   
    a = NULL; // 避免野指针 
    return 0;
}

 4.6 对同⼀块动态内存多次释放

错误示例:

int main()
{
	int* a = (int*)malloc(10 * sizeof(int));
	if (a == NULL)
	{
		perror("malloc");
		return 1;
	}
	free(a);
	free(a);//重复释放
	return 0;
}

正确示范:

int main()
{
    int* a = (int*)malloc(10 * sizeof(int));
    if (a == NULL)
    {
        perror("malloc");
        return 1;  
    }
    free(a);
    a = NULL;
    return 0; 
}

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

错误示例:

void test() 
{
    int* a = (int*)malloc(sizeof(int)); 
    if (a == NULL) 
    {     
        perror("malloc");
        exit(1);
    }
  
}

int main() 
{
    for (int i = 0; i < 1000; ++i) 
    {
        test(); // 每次调用都会泄漏一个int大小的内存  
    }  
    return 0;
}

在test函数每次调用都会分配一个新的int大小的内存块,但从未释放它。由于test在main函数的循环中被调用了1000次,因此程序结束时会有1000个int大小的内存块被泄漏。

正确做法在test函数中添加free函数进行释放。

切记:动态开辟的空间⼀定要释放,并且正确释放。

4.8 内存的分布:

五.  练习

题目1:

void GetMemory(char *p)
 {
 p = (char *)malloc(100);
 }
 void Test(void)
 {
 char *str = NULL;
 GetMemory(str);
 strcpy(str, "hello world");
 printf("%s\n", str);
 }

GetMemory 函数中分配的内存无法被 Test 函数中的 str 指针访问。因为 C 语言中函数参数是通过值传递的,所以 GetMemory 函数中接收到的 p 是 str 指针的一个副本。当 p 被重新分配内存后,原始的 str 指针在 Test 函数中并未改变,它仍然是一个空指针。

在 strcpy 函数调用中,将字符串 "hello world" 复制到 str 所指向的内存,但由于 str 是 NULL,这将导致程序崩溃。

正确写法:

void GetMemory(char** p) 
{
    *p = (char*)malloc(100); 
    if (*p == NULL) 
    {
  
        perror("malloc");
        exit(1);
    }
}

void Test(void)
{
    char* str = NULL;
    GetMemory(&str); 
    if (str != NULL) 
    {
        strcpy(str, "hello world");   
        printf("%s\n", str); 
        free(str);  
        str = NULL;
    }
}

题目2:

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

GetMemory函数中的p是一个在栈上分配的字符数组,它包含了字符串"hello world"和一个的终止符\0。当GetMemory返回时,这个数组不再存在,但是str仍然指向原来的内存位置。因此,当在Test函数中使用str时,访问它会导致未定义,可能是崩溃,也可能是打印出其他值。

正确写法:

char* GetMemory(void)
{
    char* p = malloc(strlen("hello world") + 1);  // 分配足够的内存来存储字符串和终止符
    if (p == NULL) 
    {       
        perror("malloc");
        exit(1);
    }
    strcpy(p, "hello world");  
    return p; 
}

void Test(void)
{
    char* str = NULL;
    str = GetMemory();
    if (str != NULL) 
    {
        printf("%s\n", str); 
        free(str); 
    }
}

在这个修正后的代码中,GetMemory函数使用malloc在堆上分配足够的内存来存储字符串"hello world"和它的终止符。

题目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);
 }

未释放内存:应该在Test函数的末尾添加free(str);

正确写法:

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);
     if(str != NULL)
     {
     strcpy(str, "world");
     printf(str);
     }
 }

free(str)后,str指针并未被置为NULL,在if(str != NULL)检查中,这个条件始终为真。free(str)被调用后,str成为了一个野指针,因为它指向的内存已经被释放,但指针本身的值(内存地址)没有改变。

正确写法:

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

六.柔性数组

6.1 什么是柔性数组

柔性数组,是C99标准中引入的一个特性.在C语言中,结构体的最后一个元素可以是一个大小未知的数组,这就是柔性数组。

typedef struct st_type
{
	int i;
	int a[0]; //柔性数组成员
};

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

typedef struct st_type
{
 int i;
 int a[];//柔性数组成员 
}type_a;

柔性数组的特点:

• 结构中的柔性数组成员前面必须至少⼀个其他成员。

• sizeof返回的这种结构大小不包括柔性数组的内存。

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

例如:

typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员 
}type_a;
int main()
{
	printf("%d\n", sizeof(type_a));//输出的是4 
	return 0;
}

6.2柔性数组的使用

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

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

int main()
{
    int i = 0;
    type_a* p = (type_a*)malloc(sizeof(type_a) + 100 * sizeof(int));
    //业务处理 
    p->i = 100;
    for (i = 0; i < 100; i++)
    {
        p->a[i] = i;
    }
    free(p);
    return 0;
}

6.3柔性数组的优势

代码示例:

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


typedef struct st_type
{
    int i;
    int* p_a; 
} type_a;

// 分配内存并初始化type_a结构体的函数  
type_a* c_type_a(int size) 
{
    type_a* p = (type_a*)malloc(sizeof(type_a));
    if (p == NULL) 
    {
        perror("malloc");
        return NULL;
    }

    p->p_a = (int*)malloc(size * sizeof(int));
    if (p->p_a == NULL) 
    {
        perror("malloc");
        free(p); 
        return NULL;
    }
    p->i = size; 

    for (int i = 0; i < size; i++) 
    {
        p->p_a[i] = 0;
    }
    return p;

}

int main() 
{
      
    type_a* ta = c_type_a(10);
    if (ta != NULL)
    {
       
        for (int i = 0; i < ta->i; i++) 
        {
            ta->p_a[i] = i;   
        }    
        for (int i = 0; i < ta->i; i++) 
        {
            printf("%d ", ta->p_a[i]);
        }
        printf("\n");
          
        free(ta->p_a);
        ta->p_a = NULL;
        free(ta);

    }

    return 0;

第⼀个好处是:方便内存释放.

如果我们的代码是在⼀个给别⼈用的函数中,你在⾥⾯做了⼆次内存分配,并把整个结构体返回给用户。⽤⼾调⽤free可以释放结构体,但是用户并不知道这个结构体内的成员也需要free,所以你不能 指望用户来发现这个事。所以,如果我们把结构体的内存以及其成员要的内存⼀次性分配好了,并返 回给用户⼀个结构体指针,用户做⼀次free就可以把所有的内存也给释放掉。

第⼆个好处是:这样有利于访问速度.

 连续的内存有益于提高访问速度,也有益于减少内存碎片。

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

IC设计企业如何实现安全便捷的芯片云桌面跨网摆渡?

IC设计企业&#xff0c;主要专注于集成电路的设计。这些企业通常包括集成电路、二极管、三极管和特殊电子元件等产品的设计和生产。IC设计企业在其运营和产品设计过程中&#xff0c;会涉及和产生多种文件&#xff0c;如&#xff1a; 项目需求文档&#xff1a;这是项目启动的基础…

骨干高企瞪羚计划30万奖励!武汉市骨干高企瞪羚计划项目申报条件

武汉市骨干高企瞪羚计划项目申报条件、奖励政策内容整理如下&#xff0c;武汉各区企业申报骨干高企瞪羚计划有不明白的可随时了解: 武汉市骨干高企瞪羚计划项目申报对象 &#xff08;一&#xff09;江岸区未上市高新技术企业&#xff0c;注册成立时间不超过10年。 &#xff08;…

STM32HAL库-中断篇

中断 中断简介 中断是一种事件处理机制&#xff0c;可以暂停主程序的运行&#xff0c;转而处理特定事件程序。 中断的作用和意义&#xff1a; 实时控制 在确定事件内对响应事件做出相应 故障处理 检测到故障需要第一时间处理 数据传输 如串口通信&#xff0c;不确定数…

计算机网络5——应用层3万维网2

文章目录 一、万维网的文档1、超文本标记语言 HTML2、动态万维网文档3、活动万维网文档 二、万维网的信息检索系统1、全文检索搜索与分类目录搜索2、Google 搜索技术的特点 三、博客和微博1、博客2、微博 四、社交网站 一、万维网的文档 1、超文本标记语言 HTML 要使任何一台…

初识C语言——第二十一天

猜数字小游戏的实现&#xff1a; 学会了之后可以自己制作彩票抽奖&#xff0c;哈哈&#xff01; 代码实现&#xff1a; #include <stdlib.h> #include <time.h>void menu()//无返回值函数 {printf("**************************\n");printf("****…

C语言性能深度剖析:从底层优化到高级技巧及实战案例分析

C语言以其接近硬件的特性、卓越的性能和灵活性&#xff0c;在系统编程、嵌入式开发和高性能计算等领域中占据着举足轻重的地位。本文将深入探讨C语言性能优化的各个方面&#xff0c;包括底层原理、编译器优化、内存管理和高级编程技巧&#xff0c;并结合多个代码案例来具体分析…

什么是趋肤效应

很多同行来问什么是趋肤效应&#xff0c;趋肤效应应该是附在表面&#xff0c;为什么变成了附在线路横截面的底面&#xff1f;下面就和小易&#xff0c;一起具体了解下趋肤效应。 趋肤效应也称集肤效应&#xff0c;英文术语是Skin effection,它是指在电流流过导体时&#xff0c;…

vscode+clangd阅读Linux内核源码

1. 禁用或卸载官方C/C插件. 2. 安装clangd插件 3. 清除之前的产物 4. 生成.config文件 5.编译生成内核镜像 6.编译内核模块 7.编译设备树文件 8.生成compile_commands.json文件 运行上述命令后&#xff0c;在内核源码根目录生成了compile_commands.json文件 9.设置clangd插…

分布式系统的一致性与共识算法(四)

Etcd与Raft算法 Raft保证读请求Linearizability的方法: 1.Leader把每次读请求作为一条日志记录&#xff0c;以日志复制的形式提交&#xff0c;并应用到状态机后&#xff0c;读取状态机中的数据返回(一次RTT、一次磁盘写)2.使用Leader Lease&#xff0c;保证整个集群只有一个L…

超简约在线生成短网址源码带后台

基于 PHP、SQLite 进行开发&#xff0c;直接上传到服务器&#xff0c;安装一下就行 源码下载&#xff1a;https://download.csdn.net/download/m0_66047725/89268253 更多资源下载&#xff1a;关注我。

TensorFlow的学习

0.基础概念 术语表&#xff1a; https://developers.google.cn/machine-learning/glossary?hlzh-cn#logits 1.快速入门 https://tensorflow.google.cn/tutorials/quickstart/beginner?hlzh-cn 2.基于Keras进行图像分类 https://tensorflow.google.cn/tutorials/keras/cl…

哈希表+DFS快速解决力扣129题:求根节点到叶节点数字之和

❤️❤️❤️ 欢迎来到我的博客。希望您能在这里找到既有价值又有趣的内容&#xff0c;和我一起探索、学习和成长。欢迎评论区畅所欲言、享受知识的乐趣&#xff01; 推荐&#xff1a;数据分析螺丝钉的首页 格物致知 终身学习 期待您的关注 导航&#xff1a; LeetCode解锁100…

roscore启动报错的解决方法【将环境变量配置于最后】

今天在启动rviz时发生一个很奇怪的报错&#xff1a; rviz: error while loading shared libraries: librviz.so: cannot open shared object file: No such file or directory 我感觉很纳闷&#xff01;再试着启动一下roscore&#xff0c;发现如下报错&#xff1a; [rosout-1…

代码随想录——填充每个节点的下一个右侧节点指针 II(Leetcode117)

题目链接 层序遍历 /* // Definition for a Node. class Node {public int val;public Node left;public Node right;public Node next;public Node() {}public Node(int _val) {val _val;}public Node(int _val, Node _left, Node _right, Node _next) {val _val;left _l…

白话机器学习7:五种降维方法的原理即Python代码实现

一、主成分分析法&#xff08;PCA&#xff09; PCA是一种常用的线性降维技术&#xff0c;它可以将高维数据投影到低维空间&#xff0c;同时保留数据中的主要变异方向。 你可以选择保留的主成分数量&#xff0c;这取决于你的具体应用和数据集。通常&#xff0c;你可以通…

flutter开发实战-JSON和序列化数据

flutter开发实战-JSON和序列化数据 大多数移动应用都需要与 web 服务器通信&#xff0c;同时在某些时候轻松地存储结构化数据。当创造需要网络连接的应用时&#xff0c;它迟早需要处理一些常见的 JSON。使用Json时候&#xff0c;可以使用json_serializable 一、引入json_anno…

安泰ATA-7015高压放大器在材料极化中的应用研究

材料极化是材料科学中一个重要的研究领域&#xff0c;它涉及到材料内部电荷和极化性质的调控和分析。高压放大器在材料极化研究中起着至关重要的作用&#xff0c;通过提供高压力和高电场条件&#xff0c;研究人员可以深入探讨材料的电子结构、相变行为以及许多其他关键性质。 材…

监控 Apache Web 服务器性能指标

Apache Web 服务器以其可靠性、灵活性和强大的功能而闻名&#xff0c;几十年来一直是互联网的支柱&#xff0c;从小型个人博客到大型电子商务平台&#xff0c;Apache 的多功能性使其能够轻松处理各种 Web 应用程序。 Apache 的 Web 服务器是如何工作的 尽管 Web 服务器涉及复…

【PB案例学习笔记】-03用户名密码校验

写在前面 通过一个个由浅入深的编程实战案例学习&#xff0c;提高编程技巧&#xff0c;以保证小伙伴们能应付公司的各种开发需求。 文章中设计到的源码&#xff0c;小凡都上传到了gitee代码仓库https://gitee.com/xiezhr/pb-project-example.git 需要源代码的小伙伴们可以自行…

企业OA办公系统开发笔记:1、搭建后端环境

文章目录 企业办公系统&#xff1a;搭建环境一、项目介绍1、介绍2、技术栈3、项目模块4、数据库 二、搭建环境1、搭建后端1.1、搭建父工程clfwzx-oa-parent1.2、搭建工具类父模块common1.3、搭建工具类common的子模块1.4、搭建实体类模块model和项目模块service-oa 2、配置依赖…