C++基础知识02.内存分配

天行健

内存分配

C++ 程序在运行时，计算机内存被分为：<span style="color:red">程序代码区、全局数据区、堆区、栈区</span>四个部分。

• 静态存储分配
• 栈内存分配
• 堆内存分配
• new 关键字和 delete 关键字

内存分配的三种方式

不同的内存分配方式，有不同的内存调度机制。C++ 语言的三种内存分配方式分别是：静态存储区分配、栈内存分配和堆内存分配。

静态存储区分配

静态分配方式下的内存在程序编译的时候就已经分配好了且存在于程序的整个运行过程。例如 static 变量，其生命周期随程序的结束而结束，而非像一般变量随函数或作用域的结束而结束。

除了 static 变量，还有一种全局对象 static object，也可以存放在静态存储区。

栈内存分配

栈内存分配方式下的内存是存在于某作用域的一块空间。例如调用某个函数时，函数内局部变量的存储单元可以在栈上创建，函数执行结束时，这些内存单元会被自动释放。

函数内局部变量的生命周期：起于变量声明，止于函数执行结束。

堆内存分配

堆内存分配，也称<b>动态内存分配</b>，通常使用 new 和 delete 关键字进行管理。堆内存空间可由用户手动分配和释放，所以其生存周期由用户指定，较为灵活。但频繁的分配、释放大小不同的堆空间会产生内存碎片。

管理堆内存

C 语言中一般使用 malloc() 函数来分配内存空间，free() 函数来释放内存空间。但在 c++ 语言中我们使用 new 关键字来分配内存空间，delete 关键字来释放内存空间。

在学习使用 new 和 delete 关键字之前我们先初步了解一下指针的概念及其一般形式。

指针是一个变量，其值是另一个变量的地址。指针变量声明的一般形式为：

type *pointerVar-name

其中 type 为指针的数据类型，* 是定义指针的关键符，pointerVar-name 指定指针变量名。

例如：char *p，即定义了一个字符型指针变量 p。

指针的另一些基本内容会在后续的实验中详细介绍，本次实验对指针的内容仅做了解。现在我们正式学习 new 关键字和 delete 关键字。

<b>new 关键字</b>用于堆内存的分配，可自动计算所要分配内存空间的大小，其基本使用形式为：

指针变量名 = new 类型

例如：

int *p; //定义一个整型指针变量
p = new int;

其中 p = new int; 表示动态分配一个存放整型数据的内存空间，并将其首地址赋给整型指针变量 p，此时省略指针变量 p 前的 *。

<b>delete 关键字</b>用于堆内存的释放，其基本形式为：

delete 指针变量

例如：

int *p; //定义一个整型指针变量
p = new int;
//省略指针操作过程
delete p;

其中 delete p; 表示释放指针变量 p 指向的内存空间，此时省略指针变量 p 前的 *。

注意：使用 new 获取的内存空间必须使用 delete 进行释放。

我们用实例来加深一下 new 和 delete 关键字的使用方式，新建 mans.cpp 文件，输入：

#include <iostream>
using namespace std;

int main(){
    int *p; //定义一个整型的指针变量 p。
    p = new int; //动态分配一个存放整型数据的内存空间，并将其首地址赋给整型指针变量 p。
    *p = 6; //为指针指向的内存块赋值为 6。
    cout<<*p<<endl; //输出内存块的赋值。
    delete p;//释放指针变量 p 指向的内存空间。
    return 0;
}

程序首先定义了整型指针变量 p，然后使用 new 关键字为其分配 int 型的内存空间，并让指针 p 指向分配的内存空间。随后为内存块赋值为 6，并且输出所赋的值。最后释放指针变量 p。

new

#include<iostream>

using namespace std;

int number;
class demo{
public:
    int a;
};
int main(){
    demo d; // 栈内存分配，不会内存清零，所以出现的值可能很奇怪。
    cout<<d.a<<endl;
    demo *dd = new demo; // new 对象，会对对象做内存清零的操作，因此内存分配速度比 malloc 慢，malloc 不会做内存清零操作。
    cout<<dd->a<<endl;
}

存储类

存储类定义 C++ 程序中变量/函数的范围（可见性）和生命周期。这些说明符放置在它们所修饰的类型之前。下面列出 C++ 程序中可用的存储类：

• auto
• register
• static
• extern
• mutable
• thread_local (C++11)

从 C++ 11 开始，auto 关键字不再是 C++ 存储类说明符，且 register 关键字被弃用。

auto 存储类

自 C++ 11 以来，<b>auto</b> 关键字用于两种情况：声明变量时根据初始化表达式自动推断该变量的类型、声明函数时函数返回值的占位符。

C++98 标准中 auto 关键字用于自动变量的声明，但由于使用极少且多余，在 C++11 中已删除这一用法。

根据初始化表达式自动推断被声明的变量的类型，Java 的 var 与 C++ 的 auto 类似。

register 存储类

<b>register</b> 存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 '&' 运算符（因为它没有内存位置）。

register int miles;

寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 'register' 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。

static 存储类

<b>static</b> 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。

static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。

在 C++ 中，当 static 用在类数据成员上时，会导致仅有一个该成员的副本被类的所有对象共享。

#include <iostream>
// 函数声明

void func(void);
static int count = 10;
/* 全局变量 */
int main(){
        while(count--){
            func()；
    }
    return 0;
}
// 函数定义
void func(void){
        static int i = 5;
    // 局部静态变量
    i++;
    std::cout << "变量 i 为 "<< i ;
    std::cout << " , 变量 count 为 "<< count << std::endl;
}

当上面的代码被编译和执行时，它会产生下列结果：

变量 i 为 6 , 变量 count 为 9
变量 i 为 7 , 变量 count 为 8
变量 i 为 8 , 变量 count 为 7
变量 i 为 9 , 变量 count 为 6
变量 i 为 10 , 变量 count 为 5
变量 i 为 11 , 变量 count 为 4
变量 i 为 12 , 变量 count 为 3
变量 i 为 13 , 变量 count 为 2
变量 i 为 14 , 变量 count 为 1
变量 i 为 15 , 变量 count 为 0

extern 存储类

extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 'extern' 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。

当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解，extern 是用来在另一个文件中声明一个全局变量或函数。

extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候，如下所示：

第一个文件：main.cpp

#include <iostream>
int count;
extern void write_extern();
int main(){
        count = 5;
        write_extern();
}

第二个文件：support.cpp

#include <iostream>
extern int count;
void write_extern(void){  
        std::cout <<"Count is "<< count << std::endl;
}

在这里，第二个文件中的 extern 关键字用于声明已经在第一个文件 main.cpp 中定义的 count。现在 ，编译这两个文件，如下所示：

$ g++ main.cpp support.cpp -o write

这会产生 <b>write</b> 可执行程序，尝试执行 <b>write</b>，它会产生下列结果：

$ ./write Count is 5

mutable 存储类

<b>mutable</b> 说明符仅适用于类的对象，它允许对象的成员替代常量。也就是说，mutable 成员可以通过 const 成员函数修改。

thread_local 存储类

使用 thread_local 说明符声明的变量仅可在它在其上创建的线程上访问。 变量在创建线程时创建，并在销毁线程时销毁。 每个线程都有其自己的变量副本。

thread_local 说明符可以与 static 或 extern 合并。

可以将 thread_local 仅应用于数据声明和定义，thread_local 不能用于函数声明或定义。

以下演示了可以被声明为 thread_local 的变量：

#include <iostream>
#include<vector>

using namespace std;

thread_local int x;

// 命名空间下的全局变量
class X {
    static thread_local std::string s;
    // 类的static成员变量
};

//static thread_local std::string X::s; // X::s 是需要定义的
void foo() {
    thread_local std::vector<int> v; // 本地变量
}

goople

不管你信不信，反正我是信了。