本task是关于C++ 程序的编译过程、内存以及头文件的一些知识点，重点在内存方面进行展开，包括内存的分区、内存对齐、内存泄漏、内存泄漏的防止方法、现有的检测内存泄漏的工具等等。

由于问题之间的关联性，可能有些问题并非是本章相关的知识点，例如一些问题涉及到了类中的虚函数、创建类的对象的底层原理等等，但为了保持问题上下的连贯性，也放在了这里。

1. C++ 程序编译过程

编译预处理：处理以 # 开头的指令；

编译、优化：将源码 .cpp 文件翻译成 .s 汇编代码；

汇编：将汇编代码 .s 翻译成机器指令 .o 文件；

链接：因为.cpp文件中的函数可能会引用了另一个.cpp文件中定义的符号或者调用某个库文件的函数，即汇编程序生成目标文件（.o文件）后不会立刻执行，而是通过【链接】将对应目标文件连成整体，生成.exe可执行文件。

这里说的可执行的程序.exe文件。注意exe是Windows平台的二进制文件，在Linux中并不存在，Linux中并不是以文件后缀来区分文件类型的，所以.o文件也有可能是Linux中的二进制文件。

• 动态链接和静态链接：

  • 静态链接：程序运行前，将各个目标模块及其库函数链接成一个完整的可执行程序。
  • 动态链接：代码被放到动态链接库或共享对象的某个目标文件中，链接程序只是在最终的可执行程序中记录了共享对象的名字等信息，在程序执行时，动态链接库的全部内容会被映射到运行时对应的虚拟地址空间。

• 静态链接：

  • 优点：既然可执行程序具备了程序运行的所有内容，所以优点就是运行时速度快。
  • 缺点：如果目标文件进行更新操作（或有些库更新了），就需要重新编译链接生成可执行程序，即更新会有一丢丢困难；而且每个可执行程序都会有目标文件的一个副本，链接时可能同一个库链接了好几次，有点浪费空间。

• 动态链接（程序执行时才载入引用的库）：
  • 优点：节省内存、更新方便；
  • 缺点：每次执行都需要链接，相比静态链接有一定的性能损失。

2. C++ 内存管理

C++ 内存分区：栈、堆、全局/静态存储区、常量存储区、代码区。

//存储在栈
int x=0;
int *p=NULL; 

//存储在堆区，注意这里的数组名为p，而不是int(关键字int)
int *p=new int[20];

//全局区
存储全局变量和静态变量

//常量区
string str="hello";

//代码区
存储逻辑代码的二进制

  

• 栈：存放函数的局部变量、函数参数、返回地址等，由编译器自动分配和释放。
• 堆：动态申请的内存空间，就是由 malloc 分配的内存块，由程序员控制它的分配和释放，如果程序执行结束还没有释放，操作系统会自动回收。
• 全局区 / 静态存储区（.bss 段和 .data 段）：存放全局变量和静态变量，程序运行结束操作系统自动释放，在 C 语言中，未初始化的放在 .bss 段中，初始化的放在 .data 段中，C++ 中不再区分了。
• 常量存储区（.data 段）：存放的是常量，不允许修改，程序运行结束自动释放。
• 代码区（.text 段）：存放代码，不允许修改，但可以执行。编译后的二进制文件存放在这里。

#include <iostream>
using namespace std;

/*
说明：C++ 中不再区分初始化和未初始化的全局变量、静态变量的存储区，如果非要区分下述程序标注在了括号中
*/

int g_var = 0; // g_var 在全局区（.data 段）
char *gp_var;  // gp_var 在全局区（.bss 段）

int main()
{
	// var 在栈区
    int var;       
    // p_var 在栈区             
    char *p_var;   
    // arr 为数组变量，存储在栈区；"abc"为字符串常量，存储在常量区             
    char arr[] = "abc";         
    // p_var1 在栈区；"123456"为字符串常量，存储在常量区
    char *p_var1 = "123456";    
    // s_var 为静态变量，存在静态存储区（.data 段）
    static int s_var = 0;       
    // 分配得来的 10 个字节的区域在堆区
    p_var = (char *)malloc(10); 
    free(p_var);
    return 0;
}

  

来看CSAPP中的图（如下），Linux虚拟内存系统地址空间分配，图中缺少了用户空间顶端的 env 区，以及 .text上的 rodata段，但其实 .text和 .rodata都只是 ro（read only，只读） 的，算是归为一类吧。

3. 栈和堆的区别

4. 全局变量、局部变量、静态全局变量、静态局部变量

C++ 变量根据定义的位置的不同的生命周期，具有不同的作用域，作用域可分为 6 种：全局作用域，局部作用域，语句作用域，类作用域，命名空间作用域和文件作用域。

• 从作用域看：

  • 全局变量：具有全局作用域。全局变量只需在一个源文件中定义，就可以作用于所有的源文件。当然，其他不包含全局变量定义的源文件需要用 extern 关键字再次声明这个全局变量。
  • 静态全局变量：具有文件作用域。它与全局变量的区别在于如果程序包含多个文件的话，它作用于定义它的文件里，不能作用到其它文件里，即被 static 关键字修饰过的变量具有文件作用域。这样即使两个不同的源文件都定义了相同名字的静态全局变量，它们也是不同的变量。
  • 局部变量：具有局部作用域。它是自动对象（auto），在程序运行期间不是一直存在，而是只在函数执行期间存在，函数的一次调用执行结束后，变量被撤销，其所占用的内存也被收回。
  • 静态局部变量：具有局部作用域。它只被初始化一次，自从第一次被初始化直到程序运行结束都一直存在，它和全局变量的区别在于全局变量对所有的函数都是可见的，而静态局部变量只对定义自己的函数体始终可见。

• 从分配内存空间看：

  • 静态存储区：全局变量，静态局部变量，静态全局变量。
  • 栈：局部变量。

• 几个说明：

  • 静态变量和栈变量（存储在栈中的变量）、堆变量（存储在堆中的变量）的区别：
    静态变量会被放在程序的静态数据存储区（.data 段）中（静态变量会自动初始化），这样可以在下一次调用的时候还可以保持原来的赋值。而栈变量或堆变量不能保证在下一次调用的时候依然保持原来的值。
  • 静态变量和全局变量的区别：
    静态变量用 static 告知编译器，自己仅仅在变量的作用范围内可见。

5. 全局变量定义在头文件中有什么问题？

如果在头文件中定义全局变量，当该头文件被多个文件 include 时，该头文件中的全局变量就会被定义多次，导致重复定义，因此不能再头文件中定义全局变量。

6. 对象创建限制在堆或栈

后期补充。

7. 内存对齐

在64位机器中，double（8B） int（4B） short（2B）char（1B）。
【存储对齐的重要条件】
（1）每个成员按其类型的方式对齐，char的对齐值为1，short为2，int为4（单位均为B字节）；
存放起始地址%该成员长度=0。
（2）struct长度必须是成员中最大的对齐值的整数倍（不够就补空字节），以便在处理数组时保证每一项都边界对齐。
【前提】以下栗子均是按字节编址。
【分析】若N为对齐值，则该成员的“存放起始地址%N=0”，而结构体中的成员都是按定义的先后顺序排放的。
【实例1】设B结构体从地址0x0000开始，第一个成员b的对齐值是1（char是1B），所以其存放地址0x0000符合0x0000%1=0；第二个成员a的对齐值是4（int是4B），如果放在0x0002，2不能被4整除（注意不是看2能否被4整除，而是看2H），不行（不能保证边界对齐），
只能存放在0x0004到0x0007这4个连续的字节中，满足0x0004%4=0且紧邻第一个成员；
第三个成员c的对齐值是2，可以存放在0x0008到0x0009这2个字节中，满足0x0008%2=0且紧邻第二个成员。
结构体长度必须是最大对齐值（此处为4）的整数倍，故0x000A到0x000B也为B所占用，共12B。

struct A{
    int a;
    char b;
    short c;
}
struct B{
    char b;
    int a;
    short c;
}

  

【实例2】设A结构体从地址0x0000开始，第一个成员a的对齐值是4（int是4B），所以其存放在0x0000到0x0003这4个连续字节；第二个成员b的对齐值是1（char是1B），存放在0x0004中，满足0x0004%4=0且紧邻第一个成员；第三个成员c的对齐值是2，可以存放在0x0006到0x0007这2个字节中，满足0x0006%2=0且紧邻第二个成员。
结构体长度必须是最大对齐值（此处为4）的整数倍，故占用0x0000到0x0007，共8B。
【结果】sizeof（A）=8；sizeof（B）=12。

/*
说明：程序是在 64 位编译器下测试的
*/
#include <iostream>

using namespace std;

struct A
{
    short var; // 2 字节
    int var1;  // 8 字节 （内存对齐原则：填充 2 个字节） 2 (short) + 2 (填充) + 4 (int)= 8
    long var2; // 12 字节 8 + 4 (long) = 12
    char var3; // 16 字节 （内存对齐原则：填充 3 个字节）12 + 1 (char) + 3 (填充) = 16
    string s;  // 48 字节 16 + 32 (string) = 48
};

int main()
{
    short var;
    int var1;
    long var2;
    char var3;
    string s;
    A ex1;
    cout << sizeof(var) << endl;  // 2 short
    cout << sizeof(var1) << endl; // 4 int
    cout << sizeof(var2) << endl; // 4 long
    cout << sizeof(var3) << endl; // 1 char
    cout << sizeof(s) << endl;    // 32 string
    cout << sizeof(ex1) << endl;  // 48 struct
    return 0;
}

  

8. 类的大小

后期补充。

9. 内存泄露

内存泄漏：由于疏忽或错误导致的程序未能释放已经不再使用的内存。

• 内存泄漏常指 堆内存泄漏，因为堆是动态分配的，由用户来控制，如果使用不当，则会产生内存泄漏。比如使用 malloc、calloc、realloc、new 等分配内存时，使用完后要调用相应的 free 或 delete 释放内存。
• 3类内存泄漏：
  • 堆内存泄漏：new/mallc分配内存，未使用对应的delete/free回收
  • 系统资源泄漏， Bitmap, handle,socket等资源未释放
  • 没有将基类析构函数定义称为虚函数，（使用基类指针或者引用指向派生类对象时）派生类对象释放时将不能正确释放派生对象部分。

举个简单栗子：指针重新赋值

char * p = (char *)malloc(10);
char * np = (char *)malloc(10);

  

其中，指针变量 p 和 np 分别被分配了 10 个字节的内存。

如果执行p=np;后，指针变量 p 被 np 指针重新赋值，其结果是 p 以前所指向的内存位置变成了孤立的内存。它无法释放，因为没有指向该位置的引用，从而导致 10 字节的内存泄漏。

10. 怎么防止内存泄漏？内存泄漏检测工具的原理？

内部封装：将内存的分配和释放封装到类中，在构造的时候申请内存，析构的时候释放内存。

#include <iostream>
#include <cstring>

using namespace std;

class A
{
private:
    char *p;
    unsigned int p_size;

public:
    A(unsigned int n = 1) // 构造函数中分配内存空间
    {
        p = new char[n];
        p_size = n;
    };
    ~A() // 析构函数中释放内存空间
    {
        if (p != NULL)
        {
            delete[] p; // 删除字符数组
            p = NULL;   // 防止出现野指针
        }
    };
    char *GetPointer()
    {
        return p;
    };
};
void fun()
{
    A ex(100);
    char *p = ex.GetPointer();
    strcpy(p, "Test");
    cout << p << endl;
}
int main()
{
    fun();
    return 0;
}

  

但这样做并不是最佳的做法，在类的对象复制时，程序会出现同一块内存空间释放两次的情况，如下程序：

void fun1()
{
    A ex(100);
    A ex1 = ex; 
    char *p = ex.GetPointer();
    strcpy(p, "Test");
    cout << p << endl;
}

  

对于 fun1 这个函数中定义的两个类的对象而言，在离开该函数的作用域时，会两次调用析构函数来释放空间，但是这两个对象指向的是同一块内存空间，所以导致同一块内存空间被释放两次（在VS中是报错block_type_is_valid），可以通过增加计数机制来避免这种情况，或者使用智能指针 or 内存泄漏检测工具valgrind：

11. 智能指针有哪几种？智能指针的实现原理？

智能指针的实现原理： 计数原理。
智能指针是为了解决动态内存分配时带来的内存泄漏以及多次释放同一块内存空间而提出的。C++11 中封装在了 <memory> 头文件中。

C++11 中智能指针包括以下三种：

• 共享指针（shared_ptr）：资源可以被多个指针共享，使用计数机制表明资源被几个指针共享。通过 use_count() 查看资源的所有者的个数，可以通过 unique_ptr、weak_ptr 来构造，调用 release() 释放资源的所有权，计数减一，当计数减为 0 时，会自动释放内存空间，从而避免了内存泄漏。
• 独占指针（unique_ptr）：独享所有权的智能指针，资源只能被一个指针占有，该指针不能拷贝构造和赋值。但可以进行移动构造和移动赋值构造（调用 move() 函数），即一个 unique_ptr 对象赋值给另一个 unique_ptr 对象，可以通过该方法进行赋值。
• 弱指针（weak_ptr）：指向 share_ptr 指向的对象，能够解决由shared_ptr带来的循环引用问题。

参考阅读：
1、https://www.cnblogs.com/yuanlibin/p/10002654.html
2、https://www.cnblogs.com/diysoul/p/5930388.html
3、https://www.cnblogs.com/diysoul/p/5930372.html
4、https://www.cnblogs.com/JCpeng/p/15031742.html
5、智能指针的视频

12. 一个 unique_ptr 怎么赋值给另一个 unique_ptr 对象？

借助 std::move() 可以实现将一个 unique_ptr 对象赋值给另一个 unique_ptr 对象，其目的是实现所有权的转移。

// A 作为一个类 
std::unique_ptr<A> ptr1(new A());
std::unique_ptr<A> ptr2 = std::move(ptr1);

  

13. 使用智能指针会出现什么问题？怎么解决？

待补充。

14. C++和Python区别

15. C++和C的区别

16. 继承、封装、多态

Reference

[1] 现代C++教程 ：https://changkun.de/modern-cpp/zh-cn/01-intro/

文章来源: andyguo.blog.csdn.net，作者：山顶夕景，版权归原作者所有，如需转载，请联系作者。

原文链接：andyguo.blog.csdn.net/article/details/122762760