1. 内存管理

1.1 全局区

 1 #include<iostream>
 2 using namespace std;
 3 
 4 // 全局变量
 5 int g_a = 10;
 6 int g_b = 10;
 7 
 8 // const修饰的全局变量，全局常量
 9 const int c_g_a = 10;
10 const int c_g_b = 10;
11 
12 int main() {
13 
14     //全局区
15 
16     //全局变量、静态变量、常量
17     //常量：字符串常量、const修饰的全局变量
18 
19     //创建普通局部变量
20     int a = 10;
21     int b = 10;
22 
23     cout << "局部变量a的地址为： " << (int)&a << endl;
24     cout << "局部变量b的地址为： " << (int)&b << endl;
25     cout << "全局变量g_a的地址为： " << (int)&g_a << endl;
26     cout << "全局变量g_b的地址为： " << (int)&g_b << endl;
27 
28 
29     // 静态变量 加static
30     static int s_a = 10;
31     static int s_b = 10;
32     cout << "静态变量s_a的地址为： " << (int)&s_a << endl;
33     cout << "静态变量s_b的地址为： " << (int)&s_b << endl;
34 
35 
36     // 常量
37     // 字符串常量
38     cout << "字符串常量的地址为： " << (int)&"hello world!" << endl;
39 
40 
41     // const修饰的变量
42     //const修饰的全局变量
43     cout << "const修饰的全局变量c_g_a的地址为： " << (int)&c_g_a << endl;
44     cout << "const修饰的全局变量c_g_b的地址为： " << (int)&c_g_b << endl;
45     
46     //const修饰的局部变量
47     const int c_l_a = 10;
48     const int c_l_b = 10;
49 
50     cout << "const修饰的局部变量c_l_a的地址为： " << (int)&c_l_a << endl;
51     cout << "const修饰的局部变量c_l_b的地址为： " << (int)&c_l_b << endl;
52 
53     system("pause");
54     
55     return 0;
56 }
57 
58 //总结
59 //内存四区：代码去（程序运行前）、全局区（程序运行前）、栈区、堆区
60 //代码区：存放CPU指令，共享+只读的特点
61 //全局区：全局变量、静态变量、常量（字符串常量、const修饰的全局变量（全局常量））
62 //全局区的数据再程序结束后由系统释放

1.2 栈区

 1 #include<iostream>
 2 using namespace std;
 3 
 4 // 栈区数据注意事项  --不要返回局部变量的地址
 5 // 栈区的数据由编译器管理开辟和释放
 6 // 形参数据也放在栈区
 7 
 8 int* func() {
 9     int a = 10; //局部变量 存放在栈区，栈区的数据在函数执行完成后自动释放
10     return &a;  //返回局部变量的地址，错误示例
11 }
12 
13 int main() {
14 
15     //使用指针接受func函数的返回值
16     //int* p = func();
17     //cout << *p << endl;
18     //程序报错“返回局部变量或临时变量的的地址”
19 
20     system("pause");
21 
22     return 0;
23 }
24 
25 //总结
26 //栈区：编译器自动分配与释放，存放函数的参数值、局部变量
27 //注意：不能返回局部变量的地址，栈区开辟的数据由编译器自动释放

1.3 堆区

 1 #include<iostream>
 2 using namespace std;
 3 
 4 int* func() {
 5     //利用new关键字 可以将数据开辟到堆区，delete关键字用来释放
 6 
 7     //new int(10); 创建堆区数据，初始化为10,产生该数据的地址
 8     //可以使用指针来接收
 9 
10     //指针的本质是局部变量，存放在栈区，指针保存的数据存放在堆区
11 
12     int* p = new int(10);
13 
14     return p;
15 
16 }
17 
18 int main() {
19 
20     //在堆区开辟数据
21     int* p = func();
22 
23     cout << *p << endl;
24     cout << *p << endl;
25 
26     system("pause");
27 
28     return 0;
29 
30 }
31 
32 //总结
33 //堆区数据由程序员管理开辟和释放
34 //堆区数据利用new关键字进行开辟内存，并返回地址
35 //new开辟的堆区内存通过delete关键字进行释放

1.4 new操作符

 1 #include<iostream>
 2 using namespace std;
 3 
 4 //1、new的基本语法
 5 int* func() {
 6     //在堆区创建整型数据
 7     //new返回的是 该数据类型的指针
 8     int* p = new int(10);
 9     return p;
10 }
11 
12 void test01() {
13     int* p = func();
14     cout << *p << endl;
15     cout << *p << endl;
16     cout << *p << endl;
17     //堆区数据 由程序员管理开辟，程序员管理释放；
18     //如果想释放堆区数据，利用关键字 delete；
19 
20     delete p;
21     //cout << *p << endl;//内存已经被释放，再次访问就是非法操作，会报错；
22 }
23 
24 //2、在堆区利用new开辟数组
25 
26 
27 void test02() {
28     //在堆区，创建10整型数据的数组
29     //使用[]在堆区创建数组
30     int* arr = new int[10]; //10表示数组有10个元素
31     for (int i = 0; i < 10; i++) {
32         arr[i] = i + 100; //给是个元素赋值 100~109
33     }
34 
35     for (int i = 0; i < 10; i++) {
36         cout << arr[i] << endl;
37     }
38 
39     //释放堆区数字
40     //释放数组要记得加[]，表示释放数组
41     delete[] arr;
42 }
43 
44 
45 int main() {
46 
47     //test01();
48     test02();
49     system("pause");
50     return 0;
51 }
52 
53 
54 
55 
56 //总结
57 //C++利用new关键字开辟堆区数据
58 //堆区数据由程序员手动开辟，手动释放，关键字delete
59 // 语法：new 数据类型
60 // 利用new创建的数据，会返回该数据对应类型的指针
61 //

参考：《黑马程序员》C++教程