C++高级编程（三）动态内存

蔚落 2022-06-05 10:18 220阅读 0赞

*  **栈：**在**函数内部**声明的所有变量都将占用栈内存。
 *  **堆：**这是程序中未使用的内存，在程序运行时可用于动态分配内存。

![20171124152843472][]

![20171124160119673][]

调试时静态变量与全局变量直接跳过，只有运行到指针变量所在行时才分配地址。函数在栈中占用一个连续的区域，一个函数占用的区域被称作帧（frame）。同时栈是线程独立的，每个线程都有自己的栈。

new 与 malloc() 函数相比，其主要的优点是，new 不只是分配了内存，它还创建了对象。

二维数组new与delete

int **array
    // 假定数组第一维长度为 m， 第二维长度为 n
    // 动态分配空间
    array = new int *[m];
    for( int i=0; i<m; i++ )
    {
        array[i] = new int [n]  ;
    }
    //释放
    for( int i=0; i<m; i++ )
    {
        delete [] arrar[i];
    }
    delete [] array;

三维数组new与delete

int ***array;
    // 假定数组第一维为 m， 第二维为 n， 第三维为h
    // 动态分配空间
    array = new int **[m];
    for( int i=0; i<m; i++ )
    {
        array[i] = new int *[n];
        for( int j=0; j<n; j++ )
        {
            array[i][j] = new int [h];
        }
    }
    //释放
    for( int i=0; i<m; i++ )
    {
        for( int j=0; j<n; j++ )
        {
            delete array[i][j];
        }
        delete array[i];
    }
    delete [] array;

对象的动态内存分配与普通变量类似。

#include<iostream>
    
    using namespace std;
    
    class A
    {
    public:
    	A()
    	{
    		cout << "构造函数" << endl;
    	}
    	~A()
    	{
    		cout << "析构函数" << endl;
    	}
    };
    
    
    int main()
    {
    	A *a = new A();
    	cout << endl;
    	A *b = new A[2];
    	cout << endl;
    
    	
    	delete a;
    	cout << endl;
    	delete[]b;
    	cout << endl;
    	
    	A **c = new A*[2];
    	for (int i = 0; i < 2; i++)
    	{
    		c[i] = new A[3];
    	}
    	cout << endl;
    
    	for (int i = 0; i < 2; i++)
    	{
    		delete[]c[i];
    	}
    	delete[]c;
    
    
    	system("pause");
    	return 0;
    }

delete 与 delete\[\] 区别：

1、针对简单类型 使用 new 分配后的不管是数组还是非数组形式内存空间用两种方式均可 如：

int *a = new int[10];   
    delete a;   
    delete [] a;

此种情况中的释放效果相同，原因在于：**分配简单类型内存**时，内存大小已经确定，系统可以**记忆**并且进行管理，在析构时，系统并不会调用析构函数， 它直接通过指针可以获取实际分配的内存空间，哪怕是一个数组内存空间(在分配过程中 系统会记录分配内存的大小等信息，此信息保存在结构体\_CrtMemBlockHeader中。

**2、针对类Class，两种方式体现出具体差异**

当你通过下列方式分配一个类对象数组：

class A
    {
        
        private:
            char *m_cBuffer;
            int m_nLen;
        public:
            A(){
         m_cBuffer = new char[m_nLen]; }
            ~A() {
         delete [] m_cBuffer; }
    };
    A *a = new A[10];
    
    // 仅释放了a指针指向的全部内存空间 但是只调用了a[0]对象的析构函数 剩下的从a[1]到a[9]这9个用户自行分配的m_cBuffer对应内存空间将不能释放 从而造成内存泄漏
    delete a; 
    // 调用使用类对象的析构函数释放用户自己分配内存空间并且   释放了a指针指向的全部内存空间
    delete [] a;

所以总结下就是，如果ptr代表一个用new申请的内存返回的内存空间地址，即所谓的指针，那么：

*   delete ptr -- 代表用来释放内存，且只用来释放ptr指向的内存。
 *   delete\[\] rg -- 用来释放rg指向的内存，！！还逐一调用数组中每个对象的 destructor！！

**对于像 int/char/long/int\*/struct 等等简单数据类型，由于对象没有 destructor，所以用 delete 和 delete \[\] 是一样的！但是如果是C++ 对象数组就不同了！**

利用动态内存, 我们也可以做出链表, 可以不断增长的数组:

#include <iostream>
    #include <cstdio>
    
    using namespace std;
    
    struct node
    {//链表的节点
    	int data;//数据
    	int num;//节点编号
    	struct node *next;//指向下一个节点
    };
    
    int main()
    {
    	struct node *head/*头节点*/, *p, *q;
    	head = NULL;
    	p = NULL;
    	q = new node;
    	q->next = NULL;
    	q->num = 1;
    	int a = -1;
    	cout << "请输入第1个数字:";
    	cin >> a;
    	q->data = a;
    	head = q;
    	while (a != 0)
    	{
    		p = q;
    		q = new node;
    		q->next = NULL;
    		p->next = q;
    		q->num = p->num + 1;
    		cout << "请输入第" << q->num << "个数字:";
    		cin >> a;
    		q->data = a;
    	}
    
    	//前面都是输入,这以下都是输出
    
    	q = head;
    	p = NULL;
    	while (q->data != 0)
    	{
    		printf("%d %d\n", q->num, q->data);
    		q = q->next;
    	}
    
    	//释放内存
    
    	q = head;
    	while (q->next !=NULL)
    	{
    		p = q;
    		q = q->next;
                    delete p;
    	}
    	
    	system("pause");
    	return 0;
    }

**->:** 用指针访问结构体内的变量。

在链表中插入、删除节点也很简单, 先给next赋下一个节点地址,再加数据即可。

参考：

http://www.runoob.com/cplusplus/cpp-dynamic-memory.html

待续。。。

[20171124152843472]: /images/20220605/e6de49b3889d47c88faa5429cfc2762e.png
[20171124160119673]: /images/20220605/1eed006023534b28be07d992afb93b34.png