代码区：存放CPU执行的机器指令，代码区是可共享，并且是只读的。

数据区：存放已初始化的全局变量、静态变量（全局和局部）、常量数据。

BBS区：存放的是未初始化的全局变量和静态变量。

栈区：由编译器自动分配释放，存放函数的参数值、返回值和局部变量，在程序运行过程中实时分配和释放，栈区由操作系统自动管理，无须程序员手动管理。

堆区：堆是由malloc()函数分配的内存块，使用free()函数来释放内存，堆的申请释放工作由程序员控制，容易产生内存泄漏。

C语言包含4种储存类型，如下表：

注意：块指的是写在左右花括号：{ }内的一组语句。局部变量是声明在块内的变量。从 C++ 17 开始，auto 关键字不再是 C++ 存储类说明符，且 register 关键字被弃用。

1、auto存储类型

C++ 98标准/C++03标准

同C语言的意思完全一样：auto被解释为一个自动存储变量的关键字，也就是申明一块临时的变量内存。

C++ 11标准

在C++11标准的语法中，auto被定义为自动推断变量的类型。

例如,

auto d=4.38;      //double
auto s("hello");  //const char*
auto z = new auto(10); // int*
auto x1 = 5, x2 = 5.0, x3='c';//错误，必须是初始化为同一类型

注意：C++11的auto关键字时有一个限定条件，那就是必须给申明的变量赋予一个初始值，否则编译器在编译阶段将会报错。

2、extern存储类型

extern用来声明在当前文件中引用在当前项目中的其它文件中定义的全局变量。如果全局变量未被初始化，那么将被存在BBS区中，且在编译时，自动将其值赋值为0，如果已经被初始化，那么就被存在数据区中。全局变量，不管是否被初始化，其生命周期都是整个程序运行过程中，为了节省内存空间，在当前文件中使用extern来声明其它文件中定义的全局变量时，就不会再为其分配内存空间。

例如，

#include <iostream>
int i;  //相当于这个全局变量是在其它文件中定义的
extern int i; //声明引用全局变量i  
int main(void)  
{  
 
    std::cout << "in main i=" << i << std::endl;
    return 0;  
}  

注意：如果要调用另外一个文件中的全局变量，如果再声明一个同名的全局变量，那么编译器会因为重名报错，这个时候就要使用extern变量。extern声明告诉编译器这个变量的定义在其他文件中，所以并不会为它分配内存。

3、register存储类型

声明为register的变量在由内存调入到CPU寄存器后，则常驻在CPU的寄存器中，因此访问register变量将在很大程度上提高效率，因为省去了变量由内存调入到寄存器过程中的好几个指令周期。

例如，

#include <iostream>
using namespace std;  
int main(void)  
{  
    register int i,sum=0;  
    for(i=0;i<100;i++)  
        sum=sum+1;  
    cout << sum  << endl;
    return 0;  
}  

4、static存储类型

被声明为静态类型的变量，无论是全局的还是局部的，都存储在数据区中，其生命周期为整个程序，如果是静态局部变量，其作用域为一对{}内，如果是静态全局变量，其作用域为当前文件。静态变量如果没有被初始化，则自动初始化为0。静态变量只能够初始化一次。

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

例如，

#include <iostream>
using namespace std;  
int sum(int a)  
{  
    auto int c=0;  
    static int b=3;  
    c++;  
    b++;  
    printf("a=%d,\tc=%d,\tb=%d\t",a,c,b);  
    return (a+b+c);  
}  
int main()  
{  
    int i;  
    int a=2;  
    for(i=0;i<100;i++)  
         cout << "sum(a)=" << sum(a) << endl;  
    return 0;  
}  

5、字符串常量

字符串常量存储在数据区中，其生存期为整个程序运行时间，但作用域为当前文件。

例如，

#include <iostream>
using namespace std; 
char *a="cjavapy";  
void test()  
{  
    char *c="cjavapy";  
    if(a==c)  
       cout << "yes,a==c" << endl;
    else  
       cout << "no,a!=c" << endl;
}  
int main()  
{  
    char *b="cjavapy";  
    char *d="cjava";  
    if(a==b)  
        cout << "yes,a==b" << endl;
    else  
         cout << "no,a!=b" << endl;
    test();  
    if(a==d)  
        cout << "yes,a==d" << endl;
    else  
        cout << "no,a!=d" << endl;
    return 0;  
}  

6、mutable 存储类型

mutable 说明符仅适用于类的对象，这将在本教程的最后进行讲解。它允许对象的成员替代常量。也就是说，mutable 成员可以通过 const 成员函数修改。主要用于 const 成员函数，允许特定成员变量在 const 对象中被修改，常用于控制成员变量的状态。

#include <iostream>
#include <string>

class Person {
private:
    std::string name;
    mutable int accessCount = 0; // 用 `mutable` 声明的变量

public:
    Person(const std::string& name) : name(name) {}

    // 定义 const 成员函数
    std::string getName() const {
        accessCount++; // 可以修改 `mutable` 成员变量
        return name;
    }

    int getAccessCount() const {
        return accessCount;
    }
};

int main() {
    const Person person("Alice");

    // 多次调用 getName()，增加访问计数器
    std::cout << "Name: " << person.getName() << "\n";
    std::cout << "Name: " << person.getName() << "\n";
    std::cout << "Access count: " << person.getAccessCount() << "\n"; // 输出访问次数

    return 0;
}

7、thread_local 存储类型

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

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

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

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

#include <thread>
#include <iostream>
using namespace std; 
thread_local int g_n = 1;

void f()
{
    g_n++;
    printf("id=%d, n=%d\n", std::this_thread::get_id(),g_n);
}

void foo()
{
    thread_local int i=0;
    printf("id=%d, n=%d\n", std::this_thread::get_id(), i);
    i++;
}

void f2()
{
    foo();
    foo();
}
int main()
{
    g_n++;   //修改操作并不影响g_n在线程t2和t3中的初始值(值为1)
    f();    
    std::thread t1(f);
    std::thread t2(f);
    t1.join();
    t2.join();

    f2();
    std::thread t4(f2);
    std::thread t5(f2);
    t4.join();
    t5.join();
    return 0;
}