C++内部存储结构

虚拟内存的分区

1.栈区（stack)

由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

2.堆区（heap）

一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式类似于链表。

在cpp中使用malloc/free，new/delete分配和释放

注意在cpp中没有垃圾回收机制，使得代码运行速度明显更快，但是同时也有很大的可能会出现内存泄漏的问题。（一个内存在分配后，无法通过任何方法进行访问，但是从客观上这个内存区域是被使用过的）。

3.静态存储区（static)

存全局变量，静态变量。程序编译时内存已分配好，并存在于程序整个运行期间，程序结束后由系统统一释放。

在CPP和C中对本区域的处理有一定的区别

1. cpp：在cpp中不区分初始化和未初始化的全局变量/静态变量的存储区域

2. c：在c中未初始化和初始化的变量的存储是分开的。

4.文字常量区

存放常量字符串，程序结束时由系统释放。

5.程序代码区

存放函数体的二进制代码

#define MAx 100;          //宏不分配存储空间
int a;                   //存储于静态存储区
static f;                //存储于静态存储区
int add(int b,int c)      //函数参数存储在栈中
{
    int d=0;           //局部变量存储在栈中
    d=b+c;
    int* p;             //指针的存储区域位于栈上
    p=(int*)malloc(sizeof(int))   //分配的空间位于堆上
    char s[]='abcdef';     //s是一个指针位于栈上，'abcdef'存储在字符常量区
    return d;
}           //整个函数编译后二进制码存储在程序代码区

Cpp的存储数据方案

1. 自动存储持续类型

函数定义中声明的变量等，在程序开始执行所属代码块（使用花括号围起来的区域）时创建，在执行结束后被自动释放（存储区域位于栈上）

//自动存储持续性
int count()
{
    int a;           //a的持续性将被限制在函数内
    return a;        
}

int main()
{
    int a;           //这个a被限制在main函数内，count函数中的a不会对其产生影响。
    {
        int weight;   
        //weight被限制在这个代码块内，不能被代码块外访问，但是这个代码块内可以访问a
    }
}

一种更复杂的情况

#include <iostream>

int main()
{
    int weight=0;
    {
        int weight = 1;
        std::cout << weight;     //在局部中如果定义一个完全一样的变量将会把原变量隐藏
    }
    std::cout << weight;      //在区块以外又将使得原定义重新可见
}

2. 静态存储持续型

在函数外定义的变量和用static定义的变量，在整个程序运行过程中将会持续存在。（位于静态存储区）

以下有两个概念

1. 静态：变量的生存周期为从创建到最后程序结束，数据存储在静态存储区

2. 链接性：可以被访问的范围

静态变量的链接性和定义方法

cpp11以上的所有版本中不对静态变量的初始化进行强制要求，未初始化变量将在编译过程中自动初始化为0.

#include <iostream>

int global_1;             //外部链接性静态持续变量(能被其他文件访问）
static int global_2;
//内部链接性静态持续变量（只能被当前文件访问）（在前面加上static标识）

int fun()
{
    static int global_3  //无链接性静态持续变量（只能在代码块内访问）
}
int main()
{

}

更复杂的情况

局部变量导致全局变量被隐藏，以及访问在代码块内被隐藏的变量。

double number=15;
void fun()
{
    double number=11;
    std::cout<<number<<endl;                  //内部变量会覆盖全局变量
    std::cout<<::number<<endl;                
                                  //域名解析运算符::使得可以直接访问被隐藏的全局变量
}

静态持续性与外部链接性

链接性为外部的变量称为外部变量，存储持续性为静态，作用域为整个文件，外部变量也被称为全局变量。

单定义规则

cpp中的变量必须遵循单定义原则，即一个变量只能有一次定义，但是在每次使用的过程中必须进行声明。

int a;              //定义一个全局变量（定义声明，简称为定义，分配存储空间）
extern int b;       //声明调用b（引用声明，简称为声明，不分配存储空间）
extern int c=15;    //如果在声明的过程中进行初始化，声明转化为定义，分配存储空间

静态持续性与内部链接

使用static定义变量，使得变量只能被当前文件访问，静态内部变量和静态外部变量是可以共存的。

//file_1
int errors=15;
void cout_1()
{
    std::cout<<errors
}

//file_1
static int errors=10;
void cout_2()
{
    std::cout<<errors     //静态内部变量会隐藏外部变量
}

静态存储持续性，无链接性

静态局部变量智慧在初始创建的时候进行一次初始化，在之后再调用相应代码块的时候将不会再进行初始化，而是保留原有的数据。

函数链接性

cpp继承c不允许在一个函数中定义另一个函数，即函数的存储类型默认是静态的，在默认情况下函数的存储类型是外部的，使用关键字static可以将函数链接性设置为内部。

//file_1
int add()        //链接性为外部
{
    return 0;
}

static int mutiple()  //链接性为内部
{
    return 0;
}

int a()
{
    int b()          //非法
    {
        return 0;
    }
    return 0;
}

//file_2
extern int add()         //在另一个文件中引用声明

3. 线性存储持续型（cpp11引入）

变量使用thread_local声明其生命周期将和所属线程一样长。

4. 动态存储持续型

用new分配，用delete释放或在程序终止后释放，存储空间位于堆上。

动态内存运算不遵循作用域和链接性规则，可以在一个函数中分配内存，在另一个函数中释放。

指针的文件间引用

//file_1
float* p_make=new float [20];

//file_2
extern float* p_make;    //在另一个文件中引用指针