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

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

调试时静态变量与全局变量直接跳过，只有运行到指针变量所在行时才分配地址。函数在栈中占用一个连续的区域，一个函数占用的区域被称作帧（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

待续。。。