面一家音视频开发公司c++岗位时候问到了这个内存泄露相关的问题，问的是在平时碰到了内存泄露相关的问题吗？

1.忘记free啊
2.循环里使用了malloc，循环写死内存用光了啊
3.数组访问越界或指针非法访问啊
4.向系统申请分配内存进行使用(new)，可是使用完了以后却不归还(delete)，结果你申请到的那块内存你自己也不能再访问（也许你把它的地址给弄丢了），而系统也不能再次将它分配给需要的程序。
5.在函数中调用构造函数使用了new，却没有释放，虽然最终系统会进行回收，但还是会造成内存的泄露，应该使用析构函数进行释放的操作。
等等…

1.内存泄露

1.什么是内存泄露？
内存泄露是指程序中已动态分配的堆内存因为某种原因未释放或无法释放，造成内存空间的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。

2.内存泄露的分类？
（1）常发性内存泄露：发生泄露的代码会被多次执行到
（2）偶发性内存泄露：发生泄露的代码在某些环境或操作下才会发生
（3）一次性内存泄露：只会被执行一次
（4）隐式内存泄露：程序在运行过程中不断分配内存，直达结束后才释放。严格来说这不算内存泄露，但是服务器运行时间很长，可能会耗尽所有内存

实例：
当运行下面的Test函数会有什么样的后果？

void GetMemory(char **p,int num)
{
	*p = (char *)malloc(num);	
} 

void Test(void)
{
	char *str = NULL;
	GetMemory(&str,100);
	strcpy(str,"hello");
	printf("%s\n",str);
}

答案：内存泄露
解读：调用malloc()申请内存空间， 使用完毕之后没有free()释放内存空间并使得指针指向NULL

2.内存溢出

1.什么是内存溢出？
内存溢出是指应用系统中存在无法回收的内存或使用的内存过多，最终使得程序运行要用到的内存大于系统能提供的最大内存。此时程序无法运行，系统提示内存溢出。有时会自动关闭软件。

2.造成内存溢出的原因？
（1）内存泄露的堆积最终导致内存溢出
（2）需要保存多个耗用内存过大的对象或者加载单个超大对象时，其大小超过了当前的可用内存空间

3.内存溢出与内存越界的区别？
（1）内存溢出：要求分配的内存超过了系统所能够给予的，于是产生溢出
（2）内存越界：向系统申请了一块内存，而在使用的时候超过了申请的范围，常见的如数组访问越界

3.堆栈溢出

堆栈溢出一般包括堆内存溢出和栈内存溢出，两者都属于缓冲区溢出

（1）堆内存溢出：可能是堆的尺寸设置的太小、动态申请的内存没有释放等

（2）栈内存溢出：可能是堆的尺寸设置的太小、递归层次太深、函数调用层次过深、分配了过大的局部变量等

4.野指针

看下面第一个实例：
当运行下面的Test函数会有什么样的后果？

char *GetMemory(void)
{
	char p[] = "hello world";
	return p;
}

void Test(void)
{
	char *str = NULL;
	str = GetMemory();
	printf("%s\n",str);
}

答案：打印野指针内容，可能是乱码
解读：GetMemory()返回的是栈内存的指针，但是函数执行完完，该栈上内存就会被释放，该指针地址不是NULL，称为野指针，新内容不可知。

再看一个实例：
当运行下面的Test函数会有什么样的后果？

void test()
{
	char *str = (char *)malloc(100);
	strcpy(str,"hello");
	free(str);
	if(str != NULL)
	{
		strcpy(str,"world");
		printf("%s\n",str);
	}
}

答案：篡改堆区野指针指向的内容，后果难以预料，非常危险
解读：
（1）free(str)之后，str称为野指针，没有设置为NULL，而 if(str != NULL) 语句不能组织篡改操作
（2）野指针不是NULL指针，是指向被释放的或者访问受限的内存的指针

造成野指针的原因：
（1）指针变量没有初始化，任何刚创建的指针不会自动生成为NULL
（2）指针被free或者delete之后没有设置为NULL
（3）指针操作超越了变量的作用范围，比如要返回指向栈内存的指针或引用，因为栈内存在函数结束后就被释放了

内存泄漏

百度百科上的定义：内存泄漏（Memory Leak）是指程序中己动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。

一看定义，坑好像更多了，动态分配，堆内存是什么？
某种原因包含哪种原因？
未释放我能理解，无法释放是什么时候
看后果很严重，运行速度减慢！系统崩溃！那么内存究竟为什么这么强？？

危害举了一个例子，比如服务器应用软件，需要长时间的运行，如果没有有效的内存管理，每次处理客户发来的信息都没有释放内存，产生内存泄漏，那么这样就会影响服务器的性能，引起整个系统的崩溃。

它是拿C语言做的例子，看完危害，我们再来看看百度百科的泄露原因：

从变量存在的时间来分类，分为静态存储变量和动态存储变量
静态存储变量：程序运行期间分配了固定存储空间的变量
动态存储变量：程序运行期间根据实际需要动态地分配存储空间的变量。
所以它们的区别就在于，一个是一开始固定分配好了，一个是根据实际需要，你要多少我分配给你多少。感觉动态分配很棒，他怎么实现的呢？

内存中供用户使用的区域：程序存储区，静态存储区，动态存储区
程序用的数据呆在静态存储区和动态存储区
静态存储区数据在程序的开始就分配好内存区，在整个程序执行过程中它们所占的存储单元是固定的，在程序结束时就释放（真省心啊），因此静态存储区数据一般为全局变量。全局变量的坑等下补，我们把全局变量和静态变量，静态存储区的关系捋一下

动态存储区数据则是在程序执行过程中根据需要动态分配和动态释放的存储单元（分配了要释放呀！）动态存储区数据有三类函数形参变量（三类函数时哪三类）、局部变量和函数调用时的现场保护与返回地址。现场保护又是什么。。

程序中动态分配的存储空间，在程序执行完毕后需要进行释放。
没有释放动态分配的存储空间而造成内存泄漏，是使用动态存储变量的主要问题。
一般情况下，开发人员使用系统提供的内存管理基本函数，如malloc、recalloc、calloc、free等，完成动态存储变量存储空间的分配和释放。

无论是C还是C++程序，运行时候的变量主要有三种分配方式：堆分配、栈分配、全局和静态内存分配。内存泄漏主要是发生在堆内存分配方式中，即“配置了内存后，所有指向该内存的指针都遗失了”，若缺乏语言这样的垃圾回收机制，这样的内存片就无法归还系统。

总结一下，内存泄露，是指程序在申请内存后（申请这个用词还是形象呀），无法释放或未释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光。
内存泄漏是指你向系统申请分配内存进行使用(new)，可是使用完了以后却不归还(delete)，结果你申请到的那块内存你自己也不能再访问（也许你把它的地址给弄丢了），而系统也不能再次将它分配给需要的程序。
举个例子，就像你申请把一个物品装在保险柜里，你用它的时候给它分配了一个保险柜，可是用完了没有把你的保险柜收回，你走就走了，可是记不了保险柜的地址，再也找不到这个保险柜了，你觉得没问题，我有好多保险柜呢，可是如果这个问题一直发生，你的保险柜会全部用光的。
哈哈哈，对C++来说，内存泄漏就是new出来的对象没有delete，俗称野指针。你这个没有对象的野指针哈哈哈哈哈。这句话怎么理解呢，我决定去看看野指针的定义！

野指针

百度百科上，野指针的定义：野指针指向一个已删除的对象或未申请访问受限内存区域的指针。与空指针不同，野指针无法通过简单地判断是否为 NULL避免，而只能通过养成良好的编程习惯来尽力减少。对野指针进行操作很容易造成程序错误。需对指针进行初始化

引用百度百科上的野指针介绍，讲的还是蛮清楚的

为什么会出现野指针：

指针变量未初始化
任何指针变量刚被创建时不会自动成为NULL指针，它的缺省值是随机的，它会乱指一气。所以，指针变量在创建的同时应当被初始化，要么将指针设置为NULL，要么让它指向合法的内存（int *p = &a， 这就是指向合法的内存了。）。如果没有初始化，编译器会报错“ ‘point’ may be uninitializedin the function ”。
指针释放后未置空
有时指针在free或delete后未赋值 NULL，便会使人以为是合法的。别看free和delete的名字（尤其是delete），它们只是把指针所指的内存给释放掉，但并没有把指针本身干掉。此时指针指向的就是“垃圾”内存。释放后的指针应立即将指针置为NULL，防止产生“野指针”。
看到2我明白了，上面说的：对C++来说，内存泄漏就是new出来的对象没有delete，俗称野指针。我觉得不太准确，内存泄漏说的是为对象申请的内存未被释放，野指针说的是指向已被删除的或者未申请受限访问内存的指针。怎么能说内存泄漏俗称野指针呢？这就像说保险柜没清理（内存泄漏）和指向特殊保险柜的指示牌（野指针）是一回事一样。
3.指针操作超越变量作用域
就是在你超过作用域后，内存已经释放，这时指向那个被释放的内存的指针就是野指针，你却还调用，这样不好。这个例子就是原因

class A {
public:
  void Func(void){ cout << “Func of class A” << endl; }
};
class B {
public:
  A *p;
  void Test(void) {
    A a;
    p = &a; // 注意 的生命期 ，只在这个函数Test中，而不是整个class B
  }
  void Test1() {
  p->Func(); // p 是“野指针”
  }
};

申请内存是怎么一回事？

在C++中，进行堆内存管理的是new和delete
对应C中的malloc和free
但是 malloc 和 free 是函数，而new 和 delete 是运算符
这篇博客讲C++和C的内存管理挺不错的

总结一下，
我们谈到了内存泄漏是什么，野指针是什么及它的成因
C++和C的内存管理

其实留下了一堆坑，比如堆内存，还有需要单独开一篇文章来说C和C++的内存管理，我认为这是这两个编程语言比较重要的特性。
--------------------- 
作者：ydycef 
来源：CSDN 
原文：https://blog.csdn.net/sinat_41613352/article/details/84559681 
版权声明：本文为博主原创文章，转载请附上博文链接！

       内存问题一直以来都是C/C++开发中比较麻烦的问题，总的来讲，可以分成内存碎片、内存泄漏和内存越界这几类其中，以内存越界最为复杂，而且难以定位。下面我们将通过技术手段逐一分析并解决这三个问题。

一、操作系统的内存管理

进程的虚拟内存空间是地址是连续的，整个内存空间以页为单位进行划分，并不是每个页当前都映射了物理地址（commited），应用程序通过操作系统提供的API对内存进行管理，以页为单位，将虚拟内存地址映射到物理地址或者解除虚拟地址和物理地址的映射，某些情况下操作系统也会自动进行这个过程：例如当物理内存不足时，会根据一定的策略将部分虚拟空间的数据保存到硬盘上，同时解除虚拟空间和物理地址的映射，把空出来的物理地址映射到当前cpu需要访问的虚拟空间（拆东墙补西墙）。

一、内存碎片

        当应用程序通过操作系统提供的API动态的申请内存和归还内存，那么难以避免的就会造成当前已分配的内存在进程中占用着不连续的虚拟空间，反过来，不被应用程序占用的空闲内存空间也是不连续的，那么即便这些空闲内存的总量大于下次应用程序申请的空间大小，因为不连续，所以也无法成功申请到。空闲内存不连续的问题越严重（不连续的内存快越多，每块内存越小），分配不成功的概率就越大。

       我们通过以下几个技术手段解决这个问题：

      1、 建立小内存池机制，相同大小或者大小接近的内存都放到同一个内存池，这样从内存池的每个内存块之间浪费的内存会非常小或者没有浪费。

      2、内存池向系统申请内存时都以页为单位进行申请大块内存（Block），内存池对外分配内存也以优先使用使用率最高的Block，这样会有更高的概率将整个Block归还系统。

二、内存泄漏

      内存泄漏产生的原因比较简单明确，就是申请的内存已经不需要再次被使用了，但是并没有归还给内存分配器（管理器）或者系统。正确的使用智能指针可以有效的避免内存泄漏的发生，这是推荐的方式。我们下面介绍另外一种在X86下解决内存泄漏的方式。

       我们在每次进行内存分配的时候将调用的堆栈记录下来，并且和分配的内存块进行关联，这样，分配的每一块内存都有一个明确的来源，这样我们可以随时统计哪些地方分配了多少内存（内存快照）。我们可以在需要时生成一个内存快照，通过对比内存快照可以确定这段时间内哪些地方分配或者释放了多少内存。

三、内存越界

       内存越界是比较难以定位，并且也是非常危险的一个问题。内存越界通常发生的场景有（不限于以下）：

       1、读写超出内存的有效范围，例如数组下标越界，指针加减运算错误

       2、已释放的内存，其指针仍然被某些地方非法持有（野指针），并且进行了读或者写

       内存越界读产生的危险总体而言要小于越界写。因为数据读错了，很大概率会立刻暴露问题，比较容易定位，但是越界写的话，很有可能会在后续某个完全不相干的位置或者时间里出现问题，这时已经很难再找回之前写坏数据的现场了。下面我们讨论一种定位内存越界写的方案。

       内存越界写主要的问题是往往写的时候没有引发异常，如果我们能在越界写的时候让程序抛出异常，那么这个问题基本就定位了。为此，我们可以令内存分配器每次分配都返回一个永远不重复的地址，这个地址指向的内存前面和后面的一页或者几页的地址空间都是没有映射到物理内存的，那么当对这块内存的读写超出边界的时候就会触发暴力读写的异常。同样，当这块内存被释放以后，我们将这块内存所指向的虚拟地址和物理地址的映射解除，那么后续尝试对这个地址进行读写的时候也会触发暴力读写的异常，这样我们就可以快速定位问题所在。

以下是完整的内存解决方案：

https://github.com/daphnis-kau/XMemory