C/C++：内存管理

news2024/10/4 18:49:02

文章目录

  • 前言
  • 一、内存分区
    • 1. 内存划分情况
    • 2. 最大内存计算
  • 二、malloc/calloc/realloc 与 free
    • 1. malloc
    • 2. calloc
    • 3. realloc
    • 4. free
    • 5. 差异对比
    • 6. 失败处理
  • 三、内存分配题目
    • 1. 题目
    • 2. 内存区域划分
  • 四、C++内存管理方式
    • 1. new 与 delete
    • 2. new/delete操作内置类型
    • 3. new和delete操作自定义类型
  • 五、operator new与operator delete函数
    • 1. 原理
    • 2. 异常捕获方法
  • 六、new和delete的实现原理
    • 1. 内置类型
    • 2. 自定义类型
  • 七 、定位new表达式(placement-new)
  • 八、对比malloc/free和new/delete的区别
  • 总结

前言

今天我们来看C/C++中对于内存的管理
在这里插入图片描述

一、内存分区

1. 内存划分情况

在C/C++中，数据的存储位置取决于数据类型和作用域。通常分为以下几类：

  1. 栈（Stack）

    • 自动变量：局部变量、函数参数等会存储在栈上。当函数调用时，栈帧分配用于存储这些变量，函数结束后栈帧被销毁，变量随之消失。
    • 特点：栈内存分配快，自动管理，但空间有限（通常为几MB）。

  2. 堆（Heap）

    • 动态分配的内存：使用malloc、calloc（C语言）或new（C++）分配的内存位于堆上。程序员需手动管理堆内存，使用free（C语言）或delete（C++）释放。
      • 特点：堆空间大，但分配速度较慢，且需要手动释放，易出现内存泄漏。

  3. 全局/静态区（Global/Static）

  • 全局变量：定义在函数外部的变量，作用域为整个程序，存储在全局/静态区。
  • 静态变量：使用static修饰的变量，即使定义在函数内，生命周期也是整个程序运行期间，存储在全局/静态区。
  • 特点：内存一直保留，直到程序结束。

  1. 常量区（Text Segment/ROData）

    • 字符串字面值：如"Hello, World!"这样的字符串存储在常量区，只读不可修改。
    • const修饰的变量：也可以存储在常量区，具体取决于编译器实现。

  2. 代码区（Code Segment）

  • 函数代码：编译后的程序代码（如函数体）存储在代码区，程序执行时从这里读取指令。

在这里插入图片描述

2. 最大内存计算

在32位（x86）和64位（x64）架构中，CPU的寻址能力决定了能够访问的最大内存空间。

  1. 32位（x86）架构

    • 寻址能力：在32位系统中，CPU使用32位地址（即4字节）来表示内存地址。
    • 最大寻址空间：32位地址可以表示的最大数值为 ( 2^{32} ) ，即 4,294,967,296 个地址（字节），也就是4GB内存空间。
    • 具体解释：CPU可以通过一个32位地址生成从0到(2^{32}-1)的地址，这意味着它能够访问最多4GB的内存。

  2. 64位（x64）架构

    • 寻址能力：在64位系统中，CPU使用64位地址（即8字节）来表示内存地址。
    • 理论最大寻址空间：64位地址理论上可以表示的最大数值为 ( 2^{64} )，即 18,446,744,073,709,551,616 个地址（字节），也就是 16 exabytes（EB） 的内存空间。
    • 实际情况：目前的操作系统和硬件并不会使用所有的64位地址位。现代操作系统和硬件会限制实际的可用内存寻址范围。例如，Windows 64位系统支持的最大内存一般为几TB到几十TB，具体取决于版本和硬件的限制。

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

二、malloc/calloc/realloc 与 free

在C语言中，malloc、calloc、realloc 和 free 是动态内存管理的四个重要函数。它们在程序运行时负责分配、重新分配和释放内存。下面详细讲解它们的工作机制，并总结它们的区别。

1. malloc

  1. malloc (Memory Allocation)
    • 功能：分配指定大小的内存块。
    • 语法：
      void* malloc(size_t size);
      其中，size 是要分配的内存大小（以字节为单位），返回值是指向已分配内存块的指针。如果分配失败，malloc 返回 NULL。
    • 特点：
      • malloc 分配的内存块中的数据不初始化，内容可能是随机的（内存中的残留数据）。
      • 适用于一次性分配特定大小的内存。
    • 示例：
      int* ptr = (int*) malloc(10 * sizeof(int)); // 分配存储10个整数的内存

2. calloc

  1. calloc (Contiguous Allocation)
    • 功能：分配内存并初始化为零。
    • 语法：
      void* calloc(size_t num, size_t size);
      其中，num 是要分配的元素个数，size 是每个元素的大小（以字节为单位）。返回指向内存块的指针，如果失败，返回 NULL。
    • 特点：
      • calloc 分配的内存会自动初始化为全零。
      • 适用于需要多个连续内存块的情况，且希望这些内存块初始化为零。
    • 示例：
      int* ptr = (int*) calloc(10, sizeof(int)); // 分配并初始化存储10个整数的内存

calloc 就相当于 malloc + memset
在这里插入图片描述

3. realloc

  1. realloc (Reallocation)
    • 功能：重新分配已分配内存的大小。
    • 语法：
      void* realloc(void* ptr, size_t new_size);
      其中，ptr 是指向之前分配的内存块的指针，new_size 是新内存块的大小（以字节为单位）。realloc 返回指向新内存块的指针。
    • 特点：
      • 用于扩展或缩小已经分配的内存块。
      • 如果需要扩展且原有内存块之后的空间不够，realloc 会在新位置分配内存，并复制旧数据，然后释放原有内存块；如果足够，则会在原位置上扩展。
      • 如果缩小内存块，多余的内存将被释放，但原始数据仍保留。
    • 示例：
      int* ptr = (int*) realloc(ptr, 20 * sizeof(int)); // 将原来10个整数的内存扩展到20个

realloc扩容空间的做法：
在这里插入图片描述

4. free

  1. free (Memory Deallocation)
    • 功能：释放之前用 malloc、calloc 或 realloc 分配的内存。
    • 语法：
      void free(void* ptr);
      其中，ptr 是指向需要释放的内存块的指针。
    • 特点：
      • 必须为动态分配的内存显式调用 free，否则会导致内存泄漏（内存不会被释放，导致系统内存资源逐渐减少）。
      • 释放后，指针指向的内存不再有效，访问它会导致未定义行为（例如：访问已释放的内存可能引发段错误）。
    • 示例：
      free(ptr); // 释放之前分配的内存

5. 差异对比

总结：malloc、calloc、realloc 与 free 的区别

函数名主要功能内存初始化参数用途
malloc分配指定大小的内存块无（内容未初始化）size：分配的字节数动态分配内存
calloc分配并初始化内存全部初始化为0num：元素个数
size：每个元素的大小		分配多个内存块并初始化为零
realloc重新分配已分配的内存原数据保留ptr：原内存指针
new_size：新大小		扩展或缩小现有内存
free释放已分配的内存无（释放操作）ptr：待释放的内存指针释放不再需要的内存

区别和应用场景：

  1. 内存初始化：malloc 分配的内存不初始化，calloc 分配的内存会被初始化为 0。
  2. 用法不同：
    • 使用 malloc 适合一次性分配已知大小的内存。
    • 使用 calloc 适合分配多个元素的内存块，并且需要初始化为零。
    • 使用 realloc 适合在内存不足或需要调整内存时动态调整内存大小。
  3. 释放内存：所有通过 malloc、calloc、realloc 分配的内存，最后都必须通过 free 释放，否则会造成内存泄漏。

6. 失败处理

对于如果开空间失败了怎么办

//realloc, calloc同理
int* ptr = (int*) malloc(10 * sizeof(int));
if (ptr == NULL) {
    // 内存分配失败的处理逻辑
    perror("malloc fail!");
    exit(-1);
}

三、内存分配题目

1. 题目

我们先来看下面的一段代码和相关问题：

int globalVar = 1;

static int staticGlobalVar = 1;

void Test()

{

	static int staticVar = 1;

	int localVar = 1;

	

	int num1[10] = {1, 2, 3, 4};

	char char2[] = "abcd";

	char* pChar3 = "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);

}
  1. 选择题：

选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)

globalVar在哪里？C staticGlobalVar在哪里？C

staticVar在哪里？C localVar在哪里？A

num1 在哪里？A

分析:

globalVar全局变量在数据段 staticGlobalVar静态全局变量在静态区

staticVar静态局部变量在静态区 localVar局部变量在栈区

num1局部变量在栈区

char2在哪里？A *char2在哪里？A

pChar3在哪里？A *pChar3在哪里？D

ptr1在哪里？A *ptr1在哪里？B

分析:

char2局部变量在栈区

char2是一个数组，把后面常量串拷贝过来到数组中，数组在栈上，所以*char2在栈上

pChar3局部变量在栈区 *pChar3得到的是字符串常量字符在代码段

ptr1局部变量在栈区 *ptr1得到的是动态申请空间的数据在堆区
在这里插入图片描述

  1. 填空题：

sizeof(num1) = 40;//数组大小,10个整形数据一共40字节

sizeof(char2) = 5;//包括\0的空间

strlen(char2) = 4;//不包括\0的长度

sizeof(pChar3) = 4;//pChar3为指针

strlen(pChar3) = 4;//字符串“abcd”的长度，不包括\0的长度

sizeof(ptr1) = 4;//ptr1是指针

2. 内存区域划分

在这里插入图片描述

  1. 栈

    • 又称堆栈，用于存储非静态局部变量、函数参数、返回值等，栈是向下增长的。

  2. 内存映射段

    • 高效的I/O映射方式，用于加载共享的动态内存库。通过系统接口创建共享内存，进行进程间通信。（如果还没学到这部分内容，现在只需了解即可。）

  3. 堆

    • 用于程序运行时的动态内存分配，堆是向上增长的。

  4. 数据段

    • 存储全局变量和静态变量。

  5. 代码段

    • 包含可执行代码和只读常量。

四、C++内存管理方式

1. new 与 delete

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦(主要是在对类)，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

2. new/delete操作内置类型

这段代码展示了在C++中如何使用new和delete进行动态内存分配和释放。下面逐行讲解代码的含义：

int main()
{
    // 动态申请一个int类型的空间
    int* ptr4 = new int;
  • 动态申请单个int类型的内存：
    • 使用new int分配一个int类型的内存空间，并返回其地址，赋值给指针ptr4。
    • 此时，内存中的值未初始化，可能是一个随机值。
    // 动态申请一个int类型的空间并初始化为10
    int* ptr5 = new int(10);
  • 动态申请单个int类型的内存并初始化：
    • 使用new int(10)分配内存并将其初始化为10。指针ptr5指向这个内存位置。
    // 动态申请10个int类型的空间
    int* ptr6 = new int[3];
  • 动态申请数组：
    • 使用new int[3]分配一个能够存储3个int的数组。内存中的值未初始化，因此每个元素的值都是随机的。
    int* ptr7 = new int[3]{ 1,2,3 };
  • 动态申请数组并初始化：
    • 使用new int[3]{ 1,2,3 }分配一个能够存储3个int的数组，并将第一个元素初始化为1，第二个元素初始化为2，第三个元素初始化为3。未指定的元素会被初始化为0。
    int* ptr8 = new int[5]{ 1,2,3 };
  • 动态申请更大数组并部分初始化：
    • 使用new int[5]{ 1,2,3 }分配一个能够存储5个int的数组，前3个元素分别被初始化为1、2、3，后2个元素自动初始化为0。
    delete ptr4;
    delete ptr5;
  • 释放单个变量的内存：
    • 使用delete释放由new分配的单个int类型的内存。ptr4和ptr5所指向的内存空间被释放。
    delete[] ptr6;
    delete[] ptr7;
    delete[] ptr8;
  • 释放数组的内存：
    • 使用delete[]释放动态分配的数组内存。ptr6、ptr7和ptr8分别指向的数组内存被正确释放。
    • 注意：内存泄漏
      使用 delete 释放一个数组分配的内存可能会导致内存泄漏(如：释放这个数组不加[]),delete ptr6;。delete 只会释放第一个元素的内存，后续元素的内存没有被正确释放，这会使得程序中的内存使用逐渐增加。

3. new和delete操作自定义类型

现在我们有一个A类：

class A
{
public:
	A(int a = 1)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};

int main() {
    // new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间
    // 还会调用构造函数和析构函数
    A* p1 = (A*)malloc(sizeof(A)); // 使用malloc申请内存
    A* p2 = new A(1); // 使用new申请内存，并调用构造函数
  • 内存分配：
    • malloc：分配内存给一个 A 类型的对象（p1），但不会调用构造函数。
    • new A(1)：分配内存并调用构造函数，初始化 _a 为 1，并将指针赋值给 p2。
    free(p1); // 使用free释放内存
    delete p2; // 使用delete释放内存
  • 内存释放：
    • free(p1)：释放通过 malloc 分配的内存，不会调用析构函数。
    • delete p2：释放通过 new 分配的内存，同时会调用析构函数，打印析构信息。
    // 内置类型是几乎是一样的
    int* p3 = (int*)malloc(sizeof(int)); // C
    int* p4 = new int; // C++
    free(p3); // 释放p3
    delete p4; // 释放p4
  • 内置类型的内存管理：
    • malloc 和 free 的使用与 new 和 delete 处理内置类型（如 int）几乎一样。
    • malloc 不会初始化内存，而 new 会为内置类型分配内存。
    A* p5 = (A*)malloc(sizeof(A)*10); // 使用malloc申请10个A对象的内存
    A* p6 = new A[10]; // 使用new申请10个A对象的内存
  • 数组的内存分配：
    • malloc：分配内存给10个 A 类型的对象，但不会调用构造函数。
    • new A[10]：分配内存并调用构造函数，为每个对象初始化。
    free(p5); // 释放通过malloc分配的内存
    delete[] p6; // 释放通过new[]分配的内存，调用每个对象的析构函数
  • 数组内存释放：
    • free(p5)：释放10个 A 类型对象的内存。
    • delete[] p6：释放通过 new[] 分配的内存，确保调用每个对象的析构函数。

总结

  • new 和 delete vs malloc 和 free：
    • new 和 delete 用于分配和释放自定义类型的内存时，会自动调用构造函数和析构函数，而 malloc 和 free 只进行内存分配和释放，不调用构造和析构函数。

五、operator new与operator delete函数

1. 原理

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。

/*
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间
失败，尝试执行空 间不足应对措施，如果改应对措施用户设置了，则继续申请，否
则抛异常。
*/
void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
// try to allocate size bytes
void *p;
while ((p = malloc(size)) == 0)
if (_callnewh(size) == 0)
{
// report no memory
// 如果申请内存失败了，这里会抛出bad_alloc 类型异常
static const std::bad_alloc nomem;
_RAISE(nomem);
}

/*
operator delete: 该函数最终是通过free来释放空间的
*/
void operator delete(void *pUserData)
{
_CrtMemBlockHeader * pHead;
RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
if (pUserData == NULL)
return;
_mlock(_HEAP_LOCK); /* block other threads */
__TRY
/* get a pointer to memory block header */
pHead = pHdr(pUserData);
/* verify block type */
_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
_free_dbg( pUserData, pHead->nBlockUse );
__FINALLY
_munlock(_HEAP_LOCK); /* release other threads */
__END_TRY_FINALLY
return;
}
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)

通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。

2. 异常捕获方法

#include <iostream>
#include <exception>
using namespace std;

class A {
public:
    A(int a = 0) : _a(a) {
        cout << "A constructed: " << _a << endl;
    }
    
    ~A() {
        cout << "A destructed." << endl;
    }

private:
    int _a;
};

void Func() {
    int* p1 = new int[1024 * 1024 * 100]; // 试图分配内存
    cout << p1 << endl;

    int* p2 = new int[1024 * 1024 * 100]; // 试图分配内存
    cout << p2 << endl;

    int* p3 = new int[1024 * 1024 * 100]; // 试图分配内存
    cout << p3 << endl;

    int* p4 = new int[1024 * 1024 * 100]; // 试图分配内存
    cout << p4 << endl;

    int* p5 = new int[1024 * 1024 * 100]; // 试图分配内存
    cout << p5 << endl;
}

int main() {
    try {
        Func(); // 调用函数以分配内存
    } catch (const exception& e) {
        cout << "Memory allocation failed: " << e.what() << endl; // 捕获异常并打印信息
    }

    return 0;
}

六、new和delete的实现原理

1. 内置类型

如果申请的是内置类型的空间，new和malloc，delete和free基本类似，
不同的地方是：
new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。

2. 自定义类型

new 和 delete 原理

操作原理说明
new
1. 调用 operator new通过调用 operator new 函数申请足够的内存空间。
2. 执行构造函数在申请的内存空间上执行构造函数，完成对象的构造并返回指向对象的指针。
delete
1. 执行析构函数在对象的内存空间上执行析构函数，清理对象中占用的资源。
2. 调用 operator delete通过调用 operator delete 函数释放对象所占用的内存空间。
new T[N]
1. 调用 operator new[]调用 operator new[] 函数，通过实际调用 operator new 函数申请 N 个对象所需的内存空间。
2. 执行 N 次构造函数在申请的内存空间上执行 N 次构造函数，构造 N 个对象。
delete[]
1. 执行 N 次析构函数在释放的对象空间上执行 N 次析构函数，清理 N 个对象中占用的资源。
2. 调用 operator delete[]调用 operator delete[] 函数释放内存空间，实际在 operator delete[] 中调用 operator delete 来释放内存。

七 、定位new表达式(placement-new)

使用这个的理由是，我们对一个已经存在的对象，不能在外面显示调用它的构造函数，但是析构函数可以。
为了解决这个问题，引入定位new表达式。

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式：
new (place_address) type或者new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表

使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
// 定位new/replacement new
int main()
{
	// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没
	//有执行
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参
	p1->~A();
	free(p1);
	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	p2->~A();
	operator delete(p2);
	return 0;
}

八、对比malloc/free和new/delete的区别

malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。不同的地方是：

  1. malloc和free是函数，new和delete是操作符
  2. malloc申请的空间不会初始化，new可以初始化
  3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可
  4. malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
  5. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
  6. 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理释放

总结

到这里，内存管理的东西就结束了，谢谢大家~

在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

数据科学基础复习（简）

数据科学基础复习（简）

可视化、数据可视化 在狭义上&#xff0c;数据可视化是与信息可视化&#xff0c;科学可视化和可视分析学平行的概念&#xff0c;而在广义上数据可视化可以包含这3类可视化技术。 数据科学的主要任务 数据科学研究目的与任务 大数据及其运动规律的揭示从数据到智慧的转化数据…
阅读更多...
【web安全】——命令执行漏洞/代码执行漏洞

【web安全】——命令执行漏洞/代码执行漏洞

1.命令执行漏洞 1.1漏洞原理 应用有时需要调用一些执行系统命令的函数&#xff0c;如PHP中的system、exec、shell_exec、passthru、popen、proc_popen等&#xff0c;当用户能控制这些函数的参数&#xff0c;并且开发人员对这个参数没有严格的过滤时就可以将恶意系统命令拼接到…
阅读更多...
仿RabbitMQ实现消息队列服务端（二）

仿RabbitMQ实现消息队列服务端（二）

文章目录 ⽹络通信协议设计信道管理模块连接管理模块服务器模块实现 ⽹络通信协议设计 其中⽣产者和消费者都是客⼾端&#xff0c;它们都需要通过⽹络和BrokerServer进⾏通信。具体通信的过程我们使⽤Muduo库来实现&#xff0c;使⽤TCP作为通信的底层协议&#xff0c;同时在这个…
阅读更多...
中级软件设计师：一文搞懂下午第二题——数据库设计

中级软件设计师：一文搞懂下午第二题——数据库设计

中级软件设计师&#xff1a;一文搞懂下午第二题——数据库设计 1. 数据库设计过程1.1 ER模型1.1.0 浅谈UML1.1.1 实体&#xff08;Entity&#xff09;1.1.2 联系1.1.3 联系类型1.1.4 实体间的联系模型 1.2 属性&#xff08;Attribute&#xff09;1.3 关系&#xff08;Relations…
阅读更多...
Python案例--动态奖金计算（个税计算）

Python案例--动态奖金计算（个税计算）

在企业财务管理中&#xff0c;员工的奖金计算是一项关键任务&#xff0c;它直接关系到员工的积极性和忠诚度。一个合理的奖金制度能够激励员工更好地完成工作&#xff0c;提高企业的整体竞争力。本文将通过Python编程语言&#xff0c;详细探讨如何根据企业利润计算员工的奖金。…
阅读更多...
ROS C++ : 使用ros::AsyncSpinner，实现多线程处理ROS消息

ROS C++ : 使用ros::AsyncSpinner，实现多线程处理ROS消息

文章目录 1、原理说明1.1、ros::MultiThreadedSpinner1.2、ros::AsyncSpinner1.3、多线程原理1.3.1、 消息发布1.3.2、 消息订阅 2、ros::AsyncSpinner 示例13、ros::AsyncSpinner 示例24、使用 ros::AsyncSpinner&#xff0c; 多线程处理回调示例 1、原理说明 ROS提供了2中方…
阅读更多...
风场可视化效果的实现,免费的预测数据获得方法

风场可视化效果的实现,免费的预测数据获得方法

风场可视化是气象学、海洋学等领域中的重要研究工具&#xff0c;它能够直观地展示大气或海洋中的风速、风向等信息。通过风场的可视化&#xff0c;科研人员可以更好地理解气象数据的空间分布特征&#xff0c;分析风场的动力学特性。本文将介绍如何利用Python中的matplotlib、Ba…
阅读更多...
git维护【.gitignore文件】

git维护【.gitignore文件】

在工程下添加 .gitignore 文件【git忽略文件】 *.class .idea *.iml *.jar /*/target/
阅读更多...
如何通过几个简单步骤创建博客

如何通过几个简单步骤创建博客

搭建博客不仅可以表达自我和分享知识&#xff0c;还可以成为一种潜在的收入来源。如果你也对搭建博客感兴趣&#xff0c;下面的几个步骤将帮助你轻松入门。 一、选择一个主题 确定你的兴趣点&#xff1a;首先&#xff0c;你需要选择一个你感兴趣且擅长的领域。你悉的领域既能激…
阅读更多...
基于SpringBoot+Vue的蛋糕甜品商城系统

基于SpringBoot+Vue的蛋糕甜品商城系统

系统展示 用户前台界面 管理员后台界面 系统背景 随着互联网技术的飞速发展&#xff0c;电子商务已经深入人们的日常生活&#xff0c;各行各业都在积极拥抱数字化转型。蛋糕甜品行业也不例外&#xff0c;传统的销售模式已经无法满足消费者日益增长的多样化、便捷化需求。因此&a…
阅读更多...
每日学习一个数据结构-树

每日学习一个数据结构-树

文章目录 树的相关概念一、树的定义二、树的基本术语三、树的分类四、特殊类型的树五、树的遍历六、树的应用场景 树的遍历一、前序遍历二、中序遍历三、后序遍历使用java代码实现遍历总结 树的相关概念 树是一种重要的非线性数据结构&#xff0c;在计算机科学中有着广泛的应用…
阅读更多...
Pikachu-File Inclusion-远程文件包含

Pikachu-File Inclusion-远程文件包含

远程文件包含漏洞 是指能够包含远程服务器上的文件并执行。由于远程服务器的文件是我们可控的&#xff0c;因此漏洞一旦存在&#xff0c;危害性会很大。但远程文件包含漏洞的利用条件较为苛刻&#xff1b;因此&#xff0c;在web应用系统的功能设计上尽量不要让前端用户直接传变…
阅读更多...
【GT240X】【04】你必须知道的 50 多个 Linux 命令

【GT240X】【04】你必须知道的 50 多个 Linux 命令

文章目录 一、介绍二、五十个linux命令一览表三、50个命令详解四、结论 你必须知道的 50 多个 Linux 命令 一、介绍 你经常使用 Linux 命令&#xff1f;今天&#xff0c;我们将介绍 50 多个你必须知道的 Linux 命令。下面列出的命令是一些最有用和最常用的 Linux 命令&#x…
阅读更多...
jmeter学习（5）定时

jmeter学习（5）定时

Jmeter之定时器_jmeter定时器-CSDN博客 Jmeter(十三) - 从入门到精通 - JMeter定时器 - 上篇&#xff08;详解教程&#xff09;-腾讯云开发者社区-腾讯云 (tencent.com) 定时器是在每个sampler之前执行的&#xff0c;无论定时器位置在sampler之前还是子节点下面当执行一个sam…
阅读更多...
TypeScript 算法手册 【基数排序】

TypeScript 算法手册 【基数排序】

文章目录 1. 基数排序简介1.1 基数排序定义1.2 基数排序特点 2. 基数排序步骤过程拆解2.1 找出数组中的最大值2.2 从最低位开始&#xff0c;对每一位进行计数排序2.3 对某一位数进行计数排序2.4 将排序结果复制回原数组 3. 基数排序的优化3.1 处理负数3.2 字符串排序案例代码和…
阅读更多...
Go语言实现随机森林 (Random Forest)算法

Go语言实现随机森林 (Random Forest)算法

在 Go 语言中实现随机森林&#xff08;Random Forest&#xff09;算法通常涉及以下几个步骤&#xff1a; 数据准备&#xff1a;将数据集分为训练集和测试集&#xff0c;确保数据格式适合算法使用。 决策树的构建&#xff1a;随机森林是由多个决策树构成的&#xff0c;首先需要…
阅读更多...
MySQL 实验1：Windows 环境下 MySQL5.5 安装与配置

MySQL 实验1：Windows 环境下 MySQL5.5 安装与配置

MySQL 实验1&#xff1a;Windows 环境下 MySQL5.5 安装与配置 目录 MySQL 实验1&#xff1a;Windows 环境下 MySQL5.5 安装与配置一、MySQL 软件的下载二、安装 MySQL三、配置 MySQL1、配置环境变量2、安装并启动 MySQL 服务3、设置 MySQL 字符集4、为 root 用户设置登录密码 一…
阅读更多...
使用前端三剑客实现一个备忘录

使用前端三剑客实现一个备忘录

一&#xff0c;界面介绍 这个备忘录的界面效果如下&#xff1a; 可以实现任务的增删&#xff0c;并且在任务被勾选后会被放到已完成的下面。 示例&#xff1a; &#xff08;1&#xff09;&#xff0c;增加一个任务 &#xff08;2&#xff09;&#xff0c;勾选任务 &#xff…
阅读更多...
【知乎直答】批量多线程生成原创文章软件-AI智能搜索聚合

【知乎直答】批量多线程生成原创文章软件-AI智能搜索聚合

【知乎直答】批量多线程生成原创文章软件介绍&#xff1a; 1、知乎发布的全新AI产品“知乎直答”是其AI搜索功能的产品化成果&#xff0c;旨在提升用户的提问、搜索体验以及结果生成和归纳的质量。 2、数据基础&#xff1a;该产品基于知乎平台上的真实问答数据及全网高质量问答…
阅读更多...
Chromium 中前端js XMLHttpRequest接口c++代码实现

Chromium 中前端js XMLHttpRequest接口c++代码实现

在JavaScript中发出HTTP请求的主要方式包括&#xff1a;XMLHttpRequest对象、Fetch API、Axios库和各种其他的HTTP客户端库。 本人主要分析下XMLHttpRequest接口在c中对应实现 一、上前端代码 <!DOCTYPE html> <html lang"en"> <head> <meta…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023