C++ 内存管理以及常考面试题

最新推荐文章于 2024-06-27 18:29:45 发布

好雨知时节呀

最新推荐文章于 2024-06-27 18:29:45 发布

阅读量1.2k

点赞数

分类专栏： c++

本文链接：https://blog.csdn.net/tomatolee221/article/details/91356477

版权

c++ 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

直接管理内存

C++语言定义了两个运算符来分配和释放动态内存。运算符 new 分配内存，delete 释放 new 分配的内存。

使用 new 动态分配和初始化对象

在自由空间分配的内存是无名的，因此 new 无法为其分配的对象命名，而是返回一个指向该对象的指针：

int *pi = new int;      //  pi 指向一个动态分配的，未初始化的无名对象；

以上 new 表达式在自由空间构造一个 int 型对象，并返回指向该对象的指针。

默认情况下，动态分配的带对象是默认初始化，这意味着内置类型或组合类型的对象的值是未定义的，而类类型对象将用默认构造函数进行初始化：

string *ps = new string;    // 初始化为空 string
int *pi = new int;           // pi 指向一个未初始化的 int

我们可以使用直接初始化方式来初始化一个动态分配的对象。
（1）使用传统的构造方式—> 使用圆括号；
（2）使用列表初始化—> 使用花括号；

int *pi = new int(1024);    // pi 指向的对象的值为 1024
string *ps = new string(10, '9');   // *ps 为“9999999999”

// vector 有6个元素，依次从0到5
vector<int> *pv = new vector<int>{0, 1, 2, 3, 4, 5};

（3）使用值初始化，只需要在类型名之后跟一对空括号即可：

string *ps = new string();      // 值初始化为空 string
string *ps1 = new string;    // 默认初始化为空 string

int *pi = new int();        // 值初始化0，*pi 为 0
int *pi1 = new int;        //  默认初始化； *pi1 的值未定义

对于定义了自己构造函数的类类型来说，要求值初始化时没有意义的；不管采用什么形式，对象都会通过默认构造函数来初始化。
但是对于内置类型，俩种形式的差别就很大了；值初始化的内置类型对象有着良好定义的值，而默认初始化的对象的值则是未定义的。类似的是类中那些依赖于编译器默认的构造函数的内置类型成员，如果它们未在类中被初始化，那么它们的值也是未定义的。

动态分配 const 对象

用 new 分配 const 对象是合法的：

//分配并初始化一个 const int
const int *pi = new const int(1024);

//分配并默认初始化一个 const 的空 string
const string *pcs = new const string;

类似其他任何 const 对象，一个动态分配的 const 对象必须进行初始化。对于一个定义了默认构造函数的类类型，其 const 动态对象可以隐式初始化，而其他类型的对象就必须显示初始化。由于分配的对象是 const 的， new 返回的指针是一个指向 const 的指针。

内存耗尽

虽然现代计算机通常都配备大容量的内存，但是自由空间被耗尽的情况还是有可能发生的。一旦一个程序用光了它所有的可用的内存， new 表达式就会失败。默认情况下，如果 new 不能分配所要求的内存空间，它会抛出一个类型为 bad_alloc 的异常。我们可以改变使用 new 的方式来阻止它抛出异常：

//如果分配失败， new 返回一个空指针
int *p1 = new int;      // 如果分配失败， new 抛出 std::bad_alloc

int *p2 = new (nothrow) int;    // 如果分配失败， new 返回一个空指针

我们称这种形式的 new 为 定位 new。

释放动态内存

为了防止内存耗尽，在动态内存使用完毕后，必须将其归还给系统。我们通过 delete 表达式来将动态内存归还给系统。 delete 表达式接受一个指针，指向我们想要释放的对象：

delete p;   // p 必须指向一个动态分配的对象或是一个空指针

与 new 表达式相似，delete 表达式也执行两个动作：
（1）销毁给定的指针指向对象；
（2）释放对应的内存；

指针值和 delete

我们传递给 delete 的指针必须指向动态分配的内存，或者是一个空指针。释放一块并非 new 分配的内存，或者将相同的指针值释放多次，其行为都是未定义：

int i, *pi1 = &i, *pi2 = nullptr;
double *pd = new double(33), *pd2 = pd;

delete i;   // 错误：i 不是一个指针
delete pi1; //未定义：pi1 指向一个局部变量
delete pd;  //正确
delete pd2; //未定义：pd2 指向的内存已经被释放了
delete pi2; //正确：释放一个空指针是可以的

对于 delete i 的请求，编译器会生成一个错误消息，因为它知道 i
不是一个指针。执行 delete pi1 和 delete pi2 所产生的错误则更具潜在的危害：通常情况下，编译器不能分辨一个指针指向的是静态还是动态分配的对象。类似的，编译器也不能分辨一个指针所指向的内存是否已经被释放了。对于这些 delete 表达式，大多数编译器是会编译通过的，尽管他们是错误的。

虽然一个 const 对象的值不能被改变，但它本身是可以被销毁的。如同任何其他动态对象一样，想要释放一个 const 动态对象，只要 delete 指向它的指针即可：

const int *pci = new const int(1024);
delete pci;

delete 之后重置指针值：

当delete 一个指针后，指针值就变得无效了。虽然指针已经无效，但是很多机器上指针依然保存着（已经释放了的）动态内存的地址。在 delete 之后，指针就变成了空悬指针，即指向一块曾经保存数据对象但是现在已经无效的内存的指针。为了避免这种情况我们在 delete 之后将 nullptr 赋予指针，这样就清楚地指出指针不指向任何对象。

动态数组

new 和 delete 运算符一次分配/释放一个对象，但是某些应用需要一次为很多对象分配内存的功能。例如，vector 和 string 都是在连续内存中保存它们的元素，因此，当容器需要重新分配内存时，必须一次性为很多元素分配内存。

new 和数组

为了让 new 分配一个对象数组，我们要在类型名之后跟一对方括号，在其中指明要分配的对象的数目。例以下，new 分配要求数量的对象并（分配成功的情况下）返回指向第一个对象的指针：

int *pi = new int[n];      // pi 指向第一个int

方括号内的大小必须是整型，但不必是常量。

也可以用一个表示数组类型的类型别名来分配一个数组，这样，new 表达式中就不需要方括号了：

typedef int arr[42];    // arr 表示 42 个 int 的组类型
int *p = new arr;       // 分配一个 42 个 int 的数组； p 指向第一个int

虽然以上代码中 new 没有使用方括号 [] 但是编译器执行这个表达式时还是会用 new[] ，即编译器执行如下形式：

int *p = new int[42];

分配一个数组会得到一个元素类型的指针

虽然我们通常称 new T[] 分配的内存为“动态数组”，但是这种叫法上有些误导。当用 new 分配一个数组时，我们并未得到一个数组类型的对象，而是得到一个数组元素类型的指针。

初始化动态分配对象的数组

默认情况下， new 分配的对象，不管是单个分配的还是数组中，都是默认初始化的。可以对数组中的元素进行值初始化，方法是在大小后面跟一个空括号。

int *pi = new int[10]();
string *str = new string[10]();

或者：

int *pi = new int[5]{0, 1, 2, 3, 4};
string *str = new string[10]{"a", "an", "the", string(3, 'x')};

与内置数组对象的列表初始化一样，初始化器会用来初始化动态数组中开始部分的元素。如果初始化器数目小于元素数目，剩余元素将进行值初始化。如果大于元素数目，则 new 表达式失败，不会分配任何内存。在本例子中会抛出一个类型为 bad_array_new_length 的异常。

动态分配一个空数组是合法的

char arr[0];    // 错误：不能定义长度为 0 的数组
char *cp = new char[0]; // 正确：但 cp 不能解引用

释放动态数组

为了释放动态数组，我们使用一种特殊的 delete ------在指针前加上一个空方括号------ [] ：

delete p;   // p 必须指向一个动态分配的对象或空
delete [] pa; // pa 必须指向一个动态分配的数组或空

第二条语句销毁 pa 指向的数组中的元素，并释放对应的内存。数组中的元素按逆序销毁。

new 和 delete 操作自定制对象：

 class Test { 
 public:    
    Test()       
        : _data(0)    
        {       
            cout<<"Test():"<<this<<endl;    
        }
 
    ~Test()    {       
        cout<<"~Test():"<<this<<endl;   
        }  
 private:   
    int _data; 
    };
 
void Test2() {   
    // 申请单个Test类型的空间    
    Test* p1 = (Test*)malloc(sizeof(Test));    
    free(p1);       
    // 申请10个Test类型的空间    
    Test* p2 = (Test*)malloc(sizoef(Test) * 10);
    free(p2);
    
 }
 
 void Test2() {   
    // 申请单个Test类型的对象    
    Test* p1 = new Test;    delete p1;        
    // 申请10个Test类型的对象    
    Test* p2 = new Test[10];    
    delete[] p2; 
}

注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。

operator new与operator delete函数

operator new与operator delete函数

/* operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试 执行空               间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。 */ 
void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc) {    
	// try to allocate size bytes    
	void *p;    
	while ((p = malloc(size)) == 0)        
		if (_callnewh(size) == 0) {
	    	// report no memory            
	    	// 如果申请内存失败了，这里会抛出bad_alloc 类型异常            
	    	static const std::bad_alloc nomem;            
	    	_RAISE(nomem);        
	    }
    return (p); 
}
 
/* operator delete: 该函数最终是通过free来释放空间的 */ 
void operator delete(void *pUserData) {        
	_CrtMemBlockHeader * pHead;
	
    RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
    if (pUserData == NULL) 
 		return;
 
    _mlock(_HEAP_LOCK);  /* block other threads */        
    __TRY
 
            /* get a pointer to memory block header */            
            pHead = pHdr(pUserData);
 
             /* verify block type */            
             _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
 
            _free_dbg( pUserData, pHead->nBlockUse );
 
     __FINALLY            
     		_munlock(_HEAP_LOCK);  /* release other threads */        
     __END_TRY_FINALLY
 
        return; 
}
 
/* free的实现 */ 
#define   free(p)               _free_dbg(p, _NORMAL_BLOCK)

new和delete的实现原理

内置类型
如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常， malloc会返回NULL。
自定义类型
new的原理

调用operator new函数申请空间
在申请的空间上执行构造函数，完成对象的构造

delete的原理

在空间上执行析构函数，完成对象中资源的清理工作
调用operator delete函数释放对象的空间
new T[N]的原理
调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请
在申请的空间上执行N次构造函数

delete[]的原理

在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

常见面试题

malloc/free和new/delete的区别

malloc/free和new/delete的共同点是：
都是从堆上申请空间，并且需要用户手动释放。
不同的地方是：

malloc和free是函数，new和delete是操作符
malloc申请的空间不会初始化，new可以初始化
malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可
malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理

请设计一个类，该类只能在堆上创建对象

实现思想：
构造函数私有化

将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建

class HeapOnly{     
public:         
   static HeapOnly* CreateObject() {              
   	return new HeapOnly;        
   }
private:        
   HeapOnly() {}        
   // C++98    // 1.只声明,不实现。因为实现可能会很麻烦，而你本身不需要    // 2.声明成私有    
   HeapOnly(const HeapOnly&)；       
    // or            // C++11        
    HeapOnly(const HeapOnly&) = delete; 
}

请设计一个类，该类只能在栈上创建对象

class StackOnly{    
public:        
	static StackOnly CreateObject(){              
		return StackOnly();       
	} 
private:    
	StackOnly(){} 
};

只能在栈上创建对象，即不能在堆上创建，因此只要将new的功能屏蔽掉即可，即屏蔽掉operator new和定位new表达式，注意：屏蔽了operator new，实际也将定位new屏蔽掉。

class StackOnly {   
 public: 
        StackOnly()  {} 
private:
        void* operator new(size_t size);    
        void operator delete(void* p); 
};

内存泄漏

什么是内存泄漏，内存泄漏的危害

什么是内存泄漏：
内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
内存泄漏的危害：
长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

内存泄漏分类

C/C++程序中一般我们关心两种方面的内存泄漏：
堆内存泄漏(Heap leak)
堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

系统资源泄漏
指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

如何避免内存泄漏？

工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
采用RAII思想或者智能指针来管理资源。
有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。
总结一下:
内存泄漏非常常见，解决方案分为两种：
事前预防型。如智能指针等。
事后查错型。如泄漏检测工具。

如何一次在堆上申请4G的内存？

#include <iostream> 
using namespace std;
 
int main(){
    void* p = new char[0xfffffffful];
    cout << "new:" << p << endl;
    return 0; 
}

好雨知时节呀

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
C++ 内存管理以及常考面试题

直接管理内存C++语言定义了两个运算符来分配和释放动态内存。运算符 new 分配内存，delete 释放 new 分配的内存。使用 new 动态分配和初始化对象在自由空间分配的内存是无名的，因此 new 无法为其分配的对象命名，而是返回一个指向该对象的指针：int *pi = new int; // pi 指向一个动态分配的，未初始化的无名对象；以上 new 表达式...
复制链接

扫一扫