11.动态内存管理

最新推荐文章于 2024-09-18 09:24:01 发布
最新推荐文章于 2024-09-18 09:24:01 发布
阅读量912 收藏 15
点赞数 30
分类专栏： c语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Q2691463021/article/details/137124500
版权

1. 为什么存在动态内存分配

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

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

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

  1. 空间开辟大小是固定的。

  2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。

这时候就只能试试动态存开辟了。

2. 动态内存函数的介绍

2.1 malloc

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

void* malloc (size_t size);   //Size of the memory block, in bytes.
  • Allocate(v. 分配， 分派) memory block

Allocates a block of size bytes of memory, returning a pointer to the beginning of the block.

分配一个size字节的内存块，返回一个指向该内存块开头的指针。

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

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

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

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

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

free

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

void free (void* ptr);

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

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

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

malloc和free都声明在 stdlib.h 头文件中。

//举个例子
#pragma once
#include<stdio.h>
#include<stdlib.h>

int main()
{
	int arr[10] = { 0 };
	//动态内存开辟
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}

	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}

	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}

	//没有free
	//并不是说内存空间就不回收了
	//当程序退出的时候，系统会自动回收内存空间的

	return 0;
}

// 完善上述代码
#pragma once
#include<stdio.h>
#include<stdlib.h>

int main()
{
	int arr[10] = { 0 };
	//动态内存开辟
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	
	free(p);     // 释放malloc在堆区申请的空间
	p = NULL;    
  //虽然已经释放空间，将空间的使用权还给造作系统，但p仍然指向那块空间，为了预防野指针，因此将p置为空指针

	return 0;
}

2.2 calloc

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

void* calloc (size_t num, size_t size);

  • 函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。

  • 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。

// 开辟10个整型的空间
#pragma once
#include<stdio.h>
#include<stdlib.h>

int main()
{
	int*p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	
    //打印
	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 = NULL;

	return 0;
}

2.3 realloc

  • realloc函数的出现让动态内存管理更加灵活。

  • 有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那realloc函数就可以做到对动态开辟内存大小的调整。

函数原型如下：

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

Pointer to a memory block previously allocated with malloc, calloc or realloc.
Alternatively(adv. 要不然，或者), this can be a null pointer, in which case a new block is allocated (as if malloc was called).

指向先前分配的内存块的指针malloc, calloc, realloc;或者，这可以是一个空指针，在这种情况下，一个新的内存块被分配
  • size_t size

New size for the memory block, in bytes.

内存块的新大小，以字节为单位。

size_t is an unsigned integral type.

  • ptr 是要调整的内存地址

  • size 调整之后新大小

  • 返回值为调整之后的内存起始位置。

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

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

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

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

image-20220822133810643

// 举例说明
#pragma once
#include<stdio.h>
#include<stdlib.h>

int main()
{
    // 因为malloc的返回类型为void*，因此需要强转类型为int*
	int* p = (int*)malloc(40); 
	if (NULL == p)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	
    //使用
	//1 2 3 4 5 6 7 8 9 10
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}
	
    //扩容
	int* ptr = (int*)realloc(p, 8000);
	if (ptr != NULL)
	{
		p = ptr;
        // 不能够直接将realloc返回的指针放到p里面，如果调整空间大小失败，则会返回空指针，会把p置为空指针，则malloc返回的指针再也找不到，会造成空间泄露；
        // 确定ptr不为空指针，再通过赋值，让p来维护realloc申请的空间；
     }
	
    //使用
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	free(p);
	p = NULL;

	return 0;
}

3. 常见的动态内存错误

3.1 对NULL指针的解引用操作

//错误示范
#pragma once
#include<stdio.h>
#include<stdlib.h>

int main()
{
	int* p = (int*)malloc(40);
    //如果p的值是NULL，就会有问题
	*p = 20;
    
	free(p);
	p = NULL;
	return 0;
}

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

// 解决方案
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 1;
	}
    
	*p = 20;
	free(p);
	p = NULL;
	return 0;
}

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

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

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
    
	//方式
	int i = 0;
	for (i = 0; i <= 10; i++)
	{
        //malloc开辟了40byte， 当i = 10时，会越界访问
		p[i] = i;          
	}

	free(p);
	p = NULL;
	return 0;
}

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

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

int main()
{
	int a = 10;
	int* p = &a;
	//.....
    
	//p所指向的空间不是动态开辟的，用free释放，会使程序崩溃
	free(p); 
	p = NULL;

	return 0;
}

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

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

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 1;
	}
    
	//使用
	int i = 0;
	for (i = 0; i < 5; i++)
	{
         // 经过5次循环，p里面存放的已经不是malloc返回的起始地址了，由于不能free释放一块动态开辟内存的一部分，所以程序会崩溃
		*p = i;
		p++;   
	}

	//释放
	free(p);
	p = NULL;

	return 0;
}

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

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

int main()
{
	int* p = (int*)malloc(40);
	//....
	free(p);
	//...
    //对同一动态内存多次释放，会使程序崩溃
	free(p);

	return 0;
}

// 解决方案
1.同一块动态内存释放一次
2.释放p所指向的空间之后，将p置空，这样就访问不到原先申请的空间，也就不会造成野指针

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

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

void test()
{
	int* p = (int*)malloc(100);
	//....
    
	int flag = 0;
	scanf("%d", &flag);//当输入5时，则不会运行到释放p，会造成内存泄漏
	if (flag == 5)
		return;

	free(p);
	p = NULL;
}

int main()
{
	test();
	while(1);
    //......
	return 0;
}

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

int* test()
{
	//开辟的
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return p;
	}
	//....
	return p;
}

int main()
{
	int* ret = test();
    //忘记释放了;
    while(1);
	return 0;
}

4. 几个经典的笔试

4.1 题目1

void GetMemory(char *p) 
{
 	p = (char *)malloc(100);
}

void Test(void) 
{
 	char *str = NULL;
 	GetMemory(str);
 	strcpy(str, "hello world");
 	printf(str);
}
  • 请问运行Test 函数会有什么样的结果？
void GetMemory(char* p) 
{
    // 此处开辟的空间没有被释放，会造成内存泄漏
 	p = (char *)malloc(100);  
}

void Test(void) 
{
 char *str = NULL;
    
 // 此处是传值传参
 GetMemory(str);
 // 此处的str是空指针，会导致程序崩溃
 strcpy(str, "hello world"); 
 printf(str);
}


// 解决方案1
void GetMemory(char** p)
{
	*p = (char*)malloc(100);
    if (NULL == *p)
        return 1;
}

void Test(void)
{
	char* str = NULL;
    // 此处是传址传参
	GetMemory(&str);
	
    // str存放的就是动态开辟的100字节的地址
	strcpy(str, "hello world");
	printf(str);
	
    //释放
	free(str);
	str = NULL;
}

int main()
{
	Test();
	return 0;
}

// 解决方案2
char* GetMemory()
{
	char* p = (char*)malloc(100);
    if (NULL == p)
    {
        return 1;
    } 
	return p;
}

void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	
    //str存放的就是动态开辟的100字节的地址
	strcpy(str, "hello world");
	printf(str);
	
    // 释放
    free(str);
	str = NULL;
}

int main()
{
	Test();
	return 0;
}

4.2 题目2：

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

void Test(void) 
{
 	char *str = NULL;
 	str = GetMemory();
 	printf(str);
}

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

char* GetMemory(void) 
{
    //当程序出这个局部区间，则创建的栈被销毁，所以返回的p为野指针
 	char p[] = "hello world"; 
 	return p;
}

void Test(void) 
{
 	char *str = NULL;
 	str = GetMemory();
 	printf(str);
}

4.3 题目3：

void GetMemory(char **p, int num) 
{
 	*p = (char *)malloc(num);
    if (NULL == *p)
    {
        return 1;
    }
}

void Test(void)
{
 	char *str = NULL;
 	GetMemory(&str, 100);
 	strcpy(str, "hello");
 	printf(str);
}

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

void GetMemory(char **p, int num) 
{
    //由于开辟的空间并没有被释放，因此会造成内存泄漏
 	*p = (char *)malloc(num);   
    if (NULL == *p)
    {
        return 1;
    }
}

void Test(void)
{
 	char *str = NULL;
 	GetMemory(&str, 100);
 	strcpy(str, "hello");
 	printf(str);
}

4.4 题目4：

void Test(void) 
{
 	char *str = (char *) malloc(100);
    if (NULL == str)
    {
        return 1;
    }
    
 	strcpy(str, "hello");
 	free(str);
 
 	if(str != NULL)
 	{
 		strcpy(str, "world");     //由于str已经被释放了，因此，此处的str为野指针
 		printf(str);
 	}
}

5. C/C++程序的内存开辟

image-20220822171334679

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

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

  2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。

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

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

  5. 实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁，所以生命周期变长。

6. 柔性数组

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

例如：

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

// 有些编译器会报错无法编译可以改成：
typedef struct st_type
{
 	int i;
 	int a[];//柔性数组成员
}type_a;

6.1 柔性数组的特点：

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

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

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

//例如：

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

printf("%d\n", sizeof(typa_a)); 
//输出为4； 分配的内存并没有大于结构体内存，无法适应柔性数组的预期大小

6.2 柔性数组的使用


// 方案1
struct S
{
	int n;
	int arr[];//柔性数组成员
};

int main()
{

	struct S* ps = (struct S*)malloc(sizeof(struct S) + 40);
 //包含柔性数组成员的结构用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
    
	if (ps == NULL)
	{
		//....
		return 1;
	}
	ps->n = 100;
	
    int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	
    for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	
    //如果空间不足，可以扩容
    struct S* ptr = (struct S*)realloc(ps, sizeof(struct S)+80);
	if (ptr != NULL)
	{
		ps = ptr;
		ptr = NULL;
	}
	//...
	
    //释放
	free(ps);
	ps = NULL;

	return 0;
}

// 方案2
struct S
{
	int n;
	int* arr;
};

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL)
	{
		return 1;
	}
    
	ps->n = 100;
	ps->arr = (int*)malloc(40);
	
    if (ps->arr == NULL)
	{
		//....
		return 1;
	}
	    
    //使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	
    for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}

	//扩容
	int*ptr = (int*)realloc(ps->arr, 80);
	if (ptr == NULL)
	{
		return 1;
	}
	//使用
	
	//释放
	free(ps->arr);
	free(ps);
	ps = NULL;

	return 0;
}
the_nov
关注
专栏目录
深入浅出：Python内存管理机制
shinuone的博客
10-23 4674
python采用自动内存管理机制：又叫垃圾回收器(garbage collector，gc)。负责定期地扫描并自动回收不再使用的内存和对象，使得开发者可以专注于程序逻辑，而不必担心内存管理问题。
LwIP 之五 详解内存堆（mem.c/h）动态内存管理策略
技术干货
05-13 1万+
对于嵌入式开发来说，内存管理及使用是至关重要的，内存的使用多少、内存泄漏等时刻需要注意！合理的内存管理策略将从根本上决定内存分配和回收效率，最终决定系统的整体性能。LwIP为了能够灵活的使用内存，为使用者提供两种简单却又高效的动态内存管理机制：动态内存堆管理（heap）、动态内存池管理（pool）。这两中内存管理策略的实现分别对应着源码文件mem.c/h和memp.c/h。
c语言篇（动态内存管理）
小马同学的博客
12-10 5071
动态内存管理，很重要的一篇文章，看完这篇让你深入理解动态内存的设置，和避免开辟的时候出现的一些问题！！！！
【C语言】小王带您轻松实现动态内存管理（简单易懂）
小王学代码
01-15 2561
本文主要是对于malloc、calloc、realloc、free函数的介绍和使用细节的说明，还有一些关于动态内存管理的函数，学会了这些，对于以后数据结构的内容会更加得心应手，所以希望大家能多多支持，接下来，下一章，我们跟大家讲解一下，文件管理的内容。学会了就可以更新通讯录啦
操作系统之内存管理
qq_51481704的博客
12-13 5512
内存的管理 一、单项选择题 1．2011年计算机联考真题】在虚拟内存管理中，地址变换机构将逻辑地址变换为物理地址，形成该逻辑地址的阶段是（C ）。 A．编辑 B．编译 C．链接 D．装载 2．下面关于存储管理的叙述中正确的是（ D）。 A．存储保护的目的是限制内存的分配 B．在内存为M，有N个用户的分时系统中，每个用户占用M/N的内存空间 C．在虚拟内存系统中，只要磁盘空间无限大，作业就能拥有任意大的编址空间 D．实现虚拟内存管理必须有相应硬件的支持 3．【2009年计算机联考真题】分区分配内存管理方
C / C++ 内存管理
热门推荐
bit_zyx的博客
06-22 1万+
目录 1、C / C++内存分布 2、C语言中动态内存管理方式 malloc / calloc / realloc / free 3、C++内存管理方式 new / delete 操作内置类型 new / delete 操作自定义类型 4、operator new与operator delete函数（重要点进行讲解） operator new与operator delete函数（重点） operator new......
oracle自动分配内存,oracle 11g自动内存管理
weixin_31463457的博客
04-02 1499
一：Oracle 11g自动内存管理概述oracle11g中的新的内存管理特性自动化内存管理(automatic memory management)。在该新特性之下SGA与PGA将会根据需要自动的扩展与收缩。你只需要设置两个内存管理相关的参数memory_target与memory_max_target.1)memory_target:该参数设置整个oracle数据库实例可以使用的内存量，ora...
动态内存管理（开辟以及释放动态内存空间）
2021dragon的博客
03-05 2535
文章目录前言malloc函数calloc函数realloc函数free函数 - 避免内存泄漏常见的动态内存错误 前言 如果我们被问道：如何创建一个可以根据用户需求来开辟大小的数组？ 可能有些博友会写出如下代码： #include <stdio.h> int main() { int n = 0; scanf("%d", &n); int arr[n]; return 0; } 这个代码在C99标准下是可以运行的，但大多数编译器并不支持C99标准，所以这种代码缺乏了跨平台性（可移
【侯捷】C++内存管理机制
明朗晨光的专栏
12-11 3820
万丈高楼平地起 源码之前 了无密码 0. Overview 0.1 应具备的基础 曾经动态分配并使用 memory 曾经使用过 C++ 标准库的容器（containers） 0.2 目标 从平地到万丈高楼，从最基础的C++语言构件到高知名度的内存管理器，彻底了解高高低低的方方面面。 0.3 工具 Dev-C++ 5.11， with GNU 4.9.2 Visual C++ 6.0 0.4 网络资源 0.5 书籍 1. 第一讲 primitives 本章讲解基础的用于分配内存和销毁内存的”工.
Spark优化篇：动态内存管理
lucklilili
04-15 2657
Spark内存管理分为静态内存管理和统一内存管理，Spark1.6之前使用的是静态内存管理，Spark1.6之后的版本默认使用的是统一内存管理。 动态内存机制图： 内存估算： Other Memory = 自定义数据结构*每个 Executor 核数 解：Other Memory基本很简单，就是根据自定义的Map、List * executor-cores = ？ Storage Memory = 广播变量 + cache/Executor 数量 设：数据100GB、num-ex..
操作系统专业课程设计连续动态分区内存管理模拟实现样本.doc
12-13
操作系统专业课程设计连续动态分区内存管理模拟实现样本 操作系统专业课程设计连续动态分区内存管理模拟实现样本是一种操作系统课程设计的模拟实现样本，旨在模拟实现操作系统的内存管理机制。该样本涵盖了操作系统...
cublas64_11.dll cublasLt64_11.dll cusolver64_11.dll
09-14
CUBLASLt是CUBLAS的一个扩展，专注于更复杂的矩阵操作，如稀疏矩阵-向量乘法和动态内存管理。它优化了大型矩阵运算的性能，尤其在处理不规则数据时，性能提升更为显著。 3. **cusolver64_11.dll**：这是CUSOLVER库...
c_memory.rar_memory_动态内存
09-22
在C和C++编程中，动态内存管理是一个关键的概念，涉及到程序运行时的内存分配与释放。本资料集主要探讨了以下几个方面的知识点： 1. **函数间动态内存的传递**： 在C和C++中，函数参数是按值传递的，如果需要在...
Hi3559A/C V100 集成了双核 A73 和双核 A53，支持 8K30/4K120 视频录制
芯片代理商，AI视觉从业者
09-18 1738
7680 x 4320@15fps JPEG 解码​​​​​​​。提供了高效且丰富的计算资源，支撑客户消费类应用和行业类应用。输出，最高频率支持到 2.5Gbps/Lane​​​​​​​。高动态范围技术标准，并支持多路全景硬件拼接。端 ISP tuning tools​​​​​​​。15mm x 15mm 封装大小​​​​​​​。设计，为用户提供了卓越的图像处理能力。，大小核架构和双操作系统，使得功耗和启。NAND Flash 接口​​​​​​​。的输入，用于双方向的视觉悬停和避障。
精品推荐-2024年ClickHouse技术最佳应用实践资料（脱敏）PPT合集（30份）.zip
最新发布
09-22
2024年ClickHouse技术最佳应用实践资料（脱敏）PPT合集，30份。 1、Clickhouse在安全行业产品的落地实践 2、vivo OLAP发展与应用实践 3、阿里云ClickHouse 企业版云原生Serverless 介绍 4、ClickHouse在vivo ABTest的应用实践 5、NineData面向ClickHouse数据集成实践 6、ClickHouse与大模型 7、ClickHouse数据管理与同步的关键技术 8、ClickHouse在可观测性的应用实践和优化 9、阿里云上ClickHouse存算分离架构分享 10、Clickhouse数据迁移踩坑与最佳实践分享 11、ClickHouse在B站标签和多维分析场景的实践 12、基于Clickhouse的DataOps实践 ……等等30份。
【高创新】基于鲸鱼优化算法WOA-TCN-Attention的用负荷预测算法研究Matlab实现.rar
09-22
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
【高创新】基于金枪鱼优化算法TSO-CNN-BiLSTM-Attention的用客流量预测算法研究Matlab实现.rar
09-22
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
学生宿舍管理规定.docx
09-22
学生宿舍管理规定.docx
【高创新】基于沙猫群优化算法SCSO-CNN-BiLSTM-Attention的用客流量预测算法研究Matlab实现.rar
09-22
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
Oracle 11g自动内存管理：简化DBA工作
Oracle 11g 自动内存管理是Oracle数据库的一个重要特性，它在内存管理上实现了显著的简化和效率提升。相较于之前的版本，11g引入了自动化内存管理（Automatic Memory Management, AMM），这是在SGA（System Global ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值