C/C++内存管理

目录

 一、C/C++内存分布

二、calloc、malloc、realloc函数的区别及用法?

三、C++内存管理方式

3.1 new/delete操作内置类型

 3.1.1 笔试题-delete与delete[]

3.2 new和delete操作自定义类型

3.2.1 笔试题-new和delete操作自定义类型与内置类型的不同

四、operator new与operator delete函数  

4.1 先看一下它们的底层逻辑:

4.2 new和delete的实现原理：

五、定位new表达式(placement-new) 

六、面试题

 一、C/C++内存分布

 1. 选择题：
选项 : A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在哪里？__静态（全局变量）__ staticGlobalVar在哪里？__静态_（静态全局变量）_
staticVar在哪里？__静态__ localVar在哪里？__栈__
num1 在哪里？__栈__
char2在哪里？_栈___ * char2在哪里？__栈（char2是一个数组，我们在栈上创建空间，然后把常量字符串的内容拷贝过来初始化这块由数组在栈上开辟的空间，所以*char2还是在栈上）_
pChar3在哪里？__栈__ * pChar3在哪里？___代码段（pchar指针指向常量字符串，解引用得到常量字符串在代码段）_
ptr1在哪里？__栈__ * ptr1在哪里？_堆___
2. 填空题：
sizeof(num1) = __40（sizeof数组名，4*10=40，计算的是数组的大小）__;
sizeof(char2) = __5（包含\0）__; strlen(char2) = _4___;
sizeof(pChar3) = __4/8__; strlen(pChar3) = _4___;
sizeof(ptr1) = __4/8__;

int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
	static int staticVar = 1;
	int localVar = 1;
	int num1[10] = { 1, 2, 3, 4 };
	char char2[] = "abcd";
	const char* pChar3 = "abcd";
	int* ptr1 = (int*)malloc(sizeof(int) * 4);
	int* ptr2 = (int*)calloc(4, sizeof(int));
	int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
	free(ptr1);
	free(ptr3);
}

 笔试题：

下面有关c++内存分配堆栈说法错误的是( )
 
 
A.对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制
B. 对于栈来讲，生长方向是向下的，也就是向着内存地址减小的方向；对于堆来讲，它的生长方向是向上的，是向着内存地址增加的方向增长
C.对于堆来讲，频繁的 new/delete 势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题
D.一般来讲在 32 位系统下，堆内存可以达到4G的空间，但是对于栈来讲，一般都是有一定的空间大小的

A.栈区主要存在局部变量和函数参数，其空间的管理由编译器自动完成，无需手动控制，堆区是自己申请的空间，在不需要时需要手动释放

B.栈区先定义的变量放到栈底，地址高，后定义的变量放到栈顶，地址低，因此是向下生长的，堆区则相反

C.频繁的申请空间和释放空间，容易造成内存碎片，甚至内存泄漏，栈区由于是自动管理，不存在此问题

D.32位系统下，最大的访问内存空间为4G,所以不可能把所有的内存空间当做堆内存使用，故错误

二、calloc、malloc、realloc函数的区别及用法?

三者都是分配内存，都是stdlib.h库里的函数，但是也存在一些差异。

calloc、malloc、realloc函数的区别及用法_魏波.的博客-CSDN博客_calloc

1).malloc函数。其原型void *malloc(unsigned int num_bytes)；
        num_byte为要申请的空间大小，需要我们手动的去计算;

        如int *p = (int *)malloc(20*sizeof(int)),如果编译器默认int为4字节存储的话，那么计算结果是80Byte，一次申请一个80Byte的连续空间，并将空间基地址强制转换为int类型，赋值给指针p,此时申请的内存值是不确定的。

2).calloc函数，其原型void *calloc(size_t n, size_t size)；
        其比malloc函数多一个参数，并不需要人为的计算空间的大小，比如如果他要申请20个int类型空间，会int *p = (int *)calloc(20, sizeof(int)）,这样就省去了人为空间计算的麻烦。但这并不是他们之间最重要的区别，malloc申请后空间的值是随机的，并没有进行初始化，而calloc却在申请后，对空间逐一进行初始化，并设置值为0;

        既然calloc不需要计算空间并且可以直接初始化内存避免错误，那为什么不直接使用calloc函数，那要malloc要什么用呢？
        实际上，任何事物都有两面性，有好的一面，必然存在不好的地方。这就是效率。calloc函数由于给每一个空间都要初始化值，那必然效率较malloc要低，并且现实世界，很多情况的空间申请是不需要初始值的，这也就是为什么许多初学者更多的接触malloc函数的原因。

3).realloc函数和上面两个有本质的区别，其原型void realloc(void *ptr, size_t new_Size)
        用于对动态内存进行扩容(及已申请的动态空间不够使用，需要进行空间扩容操作)，ptr为指向原来空间基址的指针， new_size为接下来需要扩充容量的大小。

        如果size较小，原来申请的动态内存后面还有空余内存，系统将直接在原内存空间后面扩容，并返回原动态空间基地址；如果size较大，原来申请的空间后面没有足够大的空间扩容，系统将重新申请一块(20+size)*sizeof(int)的内存，并把原来空间的内容拷贝过去，原来空间free;如果size非常大，系统内存申请失败，返回NULL,原来的内存不会释放。注意：如果扩容后的内存空间较原空间小，将会出现数据丢失，如果直接realloc(p, 0);相当于free(p).

realloc实例：栈的c语言实现中：

 
void StackPush(ST* ps, STDataType x)//入栈或者说压栈
{
	assert(ps);
	//判断栈是否满了，满了就扩容,
	if (ps->capacity == ps->top)
	{
		//考虑第一次入栈，栈为空的时候（加上判断）,给栈初始容量4
		int newcapcity = (ps->capacity == 0) ? 4 : (ps->capacity * 2);
		ps->a = (STDateType*)realloc(ps->a, newcapcity);
		if (ps->a == NULL)
		{
			printf("realloc error!\n");
			exit(-1);
		}
	}
	ps->a[ps->top] = x;
	++ps->top;
}

三、C++内存管理方式

        C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

3.1 new/delete操作内置类型

void Test()
{
// 动态申请一个int类型的空间
int* ptr4 = new int;
// 动态申请一个int类型的空间并初始化为10
int* ptr5 = new int(10);
// 动态申请3个int类型的空间
int* ptr6 = new int[3];
delete ptr4;
delete ptr5;
delete[] ptr6;
}

 3.1.1 笔试题-delete与delete[]

ClassA *pclassa=new ClassA[5];
 
delete pclassa;
 
c++语言中，类ClassA的构造函数和析构函数的执行次数分别为( )
 
A.5,1
B.1,1
C.5,5
D.程序可能崩溃

A.申请对象数组，会调用构造函数5次，delete由于没有使用[]，此时只会调用一次析构函数，但往往会引发程序崩溃
 
B.构造函数会调用5次
 
C.析构函数此时只会调用1次，要想完整释放数组空间，需要使用[]
 
D.正确

​
 
设已经有A,B,C,D4个类的定义，程序中A,B,C,D析构函数调用顺序为？ （ ）
 
C c;
 
void main()
 
{
 
  A*pa=new A();
 
  B b;
 
  static D d;
 
  delete pa;
 
}
 
 
A.A B C D
B.A B D C
C.A C D B
D.A C B D
 
 
​

        分析:首先手动释放pa， 所以会先调用A的析构函数，其次C B D的构造顺序为 C D B，因为先构造全局对象，在构造局部静态对象，最后才构造普通对象，然而析构对象的顺序是完全按照构造的相反顺序进行的，所以答案为 B 

 3.2 new和delete操作自定义类型

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

对如下代码进行调试分析：

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
int main()
{
	// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间
	//还会调用构造函数和析构函数
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(1);
	free(p1);
	delete p2;
	// 内置类型是几乎是一样的
	
	int* p3 = (int*)malloc(sizeof(int)); // C
	int* p4 = new int; // C++
	free(p3);
	delete p4;
	
	A* p5 = (A*)malloc(sizeof(A) * 10);
	A* p6 = new A[10];
	free(p5);
	delete[] p6;
	
	return 0;
}

图1说明new进行了初始化，调用了构造函数;打印了A();

图2说明delete调用了析构函数，打印了~A();

但是图3发现对于p4，C和C++都没有进行初始化,是因为内置类型，构造函数不做处理。

 图4，各10次调用。

3.2.1 笔试题-new和delete操作自定义类型与内置类型的不同

使用 char* p = new char[100]申请一段内存，然后使用delete p释放，有什么问题？( )
 
 
A.会有内存泄露
B.不会有内存泄露，但不建议用
C.编译就会报错，必须使用delete []p
D.编译没问题，运行会直接崩溃

A.对于内置类型，此时delete就相当于free，因此不会造成内存泄漏
 
B.正确
 
C.编译不会报错，建议针对数组释放使用delete[],如果是自定义类型，不使用方括号就会运行时错误
 
D.对于内置类型，程序不会崩溃，但不建议这样使用

 

四、operator new与operator delete函数  

        new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是
系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过
operator delete全局函数来释放空间。

4.1 先看一下它们的底层逻辑:

         new: operator new申请空间 + 调用构造//或者更底层就是还是会调用malloc,只是多了个报异常罢了。
        delete: 调用析构 + operator delete释放空间

下面看一段代码：代码1与代码2的区别？

1
	Stack st;
 
2
	Stack* ps = new Stack;
	delete ps;

class Stack
{
public:
	Stack(int capacity = 4)
		: _a(new int[capacity])
		, _size(0)
		, _capacity(capacity)
	{
		cout << "Stack(int capacity = 4)" << endl;
	}
	~Stack()
	{
		delete[] _a;
		_size = _capacity = 0;	
		cout << "~Stack()" << endl;	 
	}
private:
	int* _a;
	int _size;
	int _capacity;
};
int main()
{
	//1
	Stack st;
 
	//2
	Stack* ps = new Stack;
	delete ps;
	
	return 0;
}

 operator new与operator delete函数-云社区-华为云 (huaweicloud.com)

        operator new: malloc + 报异常
        operator delete: 就是free

//调用构造和析构
	A* p1 = new A;
	delete p1;
 
	//不会调用构造和析构
	A*p2 = (A*)operator new(sizeof(A));
	operator delete(p2);

        new[] : 函数里面调的是operator new[] -> operator new + 构造
        delete[] : 函数里面调的是 operator delete[] -> operator delete + 析构
        其实从本质上看, 底层都是通过malloc和free来申请和释放空间的, 只不过是C++在这基础上做了封装, 使用更简单, 减少了申请空间和释放空间的风险. 让其使用更安全。

4.2 new和delete的实现原理：

内置类型
        如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：
        new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。
自定义类型
new的原理：
        1. 调用operator new函数申请空间
        2. 在申请的空间上执行构造函数，完成对象的构造
delete的原理：
        1. 在空间上执行析构函数，完成对象中资源的清理工作
        2. 调用operator delete函数释放对象的空间
new T[N]的原理：
        1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对
象空间的申请
        2. 在申请的空间上执行N次构造函数
delete[]的原理：
        1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
        2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释
放空间

五、定位new表达式(placement-new) 

        定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
        使用格式：
                new (place_address) type或者new (place_address) type(initializer-list)

                place_address必须是一个指针，initializer-list是类型的初始化列表。
 使用场景：
         定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。 

        那如何显示构造了，显然不能，在C++中，有一种特殊的成员函数，它的名字和类名相同，没有返回值，不需要用户显式调用（用户也不能调用），而是在创建对象时自动执行。这种特殊的成员函数就是构造函数（Constructor）。

p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	A* p1 = (A*)malloc(sizeof(A));

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
// 定位new/replacement new
int main()
{
	//p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参
	p1->~A();
	delete p1;
	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	p2->~A();
	operator delete(p2);
	return 0;
}

【C++要笑着学】C++动态内存管理 | new/delete底层探索 | new/delete实现原理 | 定位new-云社区-华为云 (huaweicloud.com)

带参与不带参： 

析构函数释放
 
析构函数是可以显式调用的（构造函数不行）
 
p->~A;

六、面试题

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

不同的地方是：
1. malloc和free是函数，new和delete是操作符
2. malloc申请的空间不会初始化，new可以初始化
3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可

// 动态申请一个int类型的空间
int* ptr4 = new int;
// 动态申请一个int类型的空间并初始化为10
int* ptr5 = new int(10);
// 动态申请3个int类型大小的空间
int* ptr6 = new int[3];

4. malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
5. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常

int* p3 = (int*)malloc(sizeof(int)); // C
	int* p4 = new int; // C++
	free(p3);
	delete p4;

6. 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理。