首先我们要了解，内存区域大概分为四个区域：
1.代码区：这里主要存放我们写的代码的二进表达式，即CPU可以看懂的机械指令。这个区域有两个特征：只读和共享；前者可以保证代码的不会被随意修改；后者可以保证相同代码多次阅读不需要创建多个副本。
2.全局区：这里主要存放的是静态的变量、全局变量、常量等；这里的常量可以细分为字符串常量和全局常量，而局部常量（const修饰的在main函数内部的常变量）。
int a = 10;//全局变量
const int b = 10;//全局常量
int main()
{
static int c = 10;//静态变量
const int d = 10;//局部常量
"abcedf";//字符串常量
上面的两个区都是在程序运行前就已经存在，而程序运行后才会涉及下面的两个区
3.栈区：栈区上面主要由编译器分配，开辟空间来存放函数的局部变量、形参等，在函数结束后会自动释放，生命周期由编译器决定。
4.堆区：堆区是由操作者自己开辟的空间，在程序结束后由操作系统统一回收。
这里关于在堆区开辟空间的概念，与我们在C语言中类似，在C语言中我们使用malloc函数来开辟堆区内存，而在C++中我们使用new关键字来开辟内存：
首先我们来看一种简单的开辟：
我们要开辟一个int类型变量的空间，用new语句实现的结构如下：
写成代码形式就是：
int* p = new int(10);
类似于C语言中的：
int* p = (int)malloc(sizeof(int));
*p = 10;
类似的，用完也要对内存空间进行释放，这里C++用的是delete关键字：
delete p;
p = NULL;
一维数组创建与整型差不多，结构上有细微的差别：
int* arr = new int[10];
它的int后面跟的不再是赋予初始值的”()“，而是"[]"。表示开辟的是数组的连续空间。中括号里面跟的就是数组的大小。
类似的，我们释放内存就要提示编译器，释放的是数组的内存空间；
delete [] arr;
arr = NULL;
二维数组的创建就有点麻烦了，假设我们需要开辟一个5行3列的二维数组。
我们需要先创建一个二级指针来指向这个数组，然后开辟存放每一行的一维数组的首地址所需的内存空间；然后写一个循环结构：开辟每一行数组的空间；具体实现如下：
//用new创建二维数组
const int M = 5, N = 3;
int** qarr =NULL ;
qarr = new int* [M];//开辟每一行一维数组的首地址的空间
int flag = 0;
for (int i = 0; i < M; i++)
{
qarr[i] = new int[N];//每一个一维数组里每一个元素都要开辟自己的空间
for (int j = 0; j < N; j++)
{
qarr[i][j] = flag;
flag++;
}
}
for (int i = 0; i < M; i++)
{
for (int j = 0; j < N; j++)
printf("%d ", qarr[i][j]);
printf("\n");
}
for (int i = 0; i < M; i++)
delete[]qarr[i];
delete[]qarr;
对应的，因为我们是先开辟二维数组中每一行的一维数组的首地址空间，再开辟每一行中每一个元素的空间，所以我们释放的时候，应该先释放每一个数组中的每一个元素的空间，再释放存放一维数组首地址的内存空间
引用可以理解为给变量起一个别名，例如你的名字和你的身份证号都是指的你；它与我们C语言中的typedef不同，它是为变量起别名；
它的一般结构是：
int a = 89;
int& b = a;
这里我们输出a和b，就会发现它们是一致的，都是再同一块内存上变化。
int main()
{
int a = 89;
int& b = a;
cout << a << endl;
cout << b << endl;
a = 10;
cout << a << endl;
cout << b << endl;
b = 78;
cout << a << endl;
cout << b << endl;
return 0;
}
输出如下：
1.引用不能在初始化前；我们可以理解为，你是先有名字，然后再去拿你的身份证，不可能先有你的身份证而没有你的名字；
2.一旦引用，引用对象就不能更改；这个可以简单理解为，你的身份证号就是你自己，不可能你的身份证号指的是别人；
3.引用不能作为函数返回值：因为引用本质就是函数使用时在栈区开辟的空间，一旦函数结束，那么开辟的变量空间也会被释放，所以即使你返回了这块空间的引用，但是本质上还是指向这块空间，一旦这块空间被释放，那么后续即使能访问指向的这块空间，但这是非法访问了！
int& func()
{
int a = 10;
int& b = a;
return b;
}
int main()
{
int &c = func();
cout << c << endl;
return 0;
}
4.引用可以作为左值： 这里 我们需要理解，引用是可以作为左值的，也就是说可以作为等号的左边，即它是可以被改变的。
int main()
{
int a = 10;
int &c = a;
c = 100;
cout << c << endl;
return 0;
}
5.引用可以作为形参修饰实参：；我们知道，函数的局部变量会在函数结束生命周期结束，那么如果我们接收的形参是实参的引用呢？那么函数的形参和实参就可以理解为都是指向同一块内存的变量名，当改变形参(实参的引用)，那么实参也会发生变化。
其实引用的实质就是一个指针常量！
若int &b=a；
那么以后看到b就等价于*a， 所以int &b=a就类似于 int *const b=&a；
6.常量引用： 有时侯，如果我们的函数参数选择引用来接收实参，那么我们可能会不经意修改了实参的内容，所以我们可以设计一种常量引用，这种方法可以保证引用不会被修改（感觉类似于const int* x，不能通过解引用来改变x的值）；
void print(const int &c)
{
//c=102;--非法操作，加了const的引用不能改
cout << c << endl;
}
int main()
{
int a = 10;
int& b = a;
const int& d = a;
print(a);
b = 100;//引用可以改
cout << b << endl;
a = 101;//变量可以改
cout << a << endl;
//d = 103;--非法操作，加了const的引用不能改
return 0;
}