动态分配内存问题（C++实现）

动态分配内存

一、动态内存分配的原因

动态分配内存不像数组等静态内存分配方法那样需要预先分配储存空间，而是由系统根据程序的需要及时分配，且分配大小就是程序要求的大小。其实现结果类似链表，但也有差异。

注意：
1.动态分配的数组没有名字，需要通过指针p来访问。
2.用指针操作和访问数组一样，但区别是首先要判断是否分配成功：p = NULL即为失败，否则成功。
3.动态分配的空间在堆区。

二、动态分配内存所用的函数

new：进行动态内存申请
delete：进行动态内存释放（动态分配的内存必须进行释放，否则内存泄漏！！！）

三、应用举例

1.一维数组申请

eg:从键盘输入整数 n（n 为变量），动态分配大小为 n 的 int 类型数组，从键盘输入 n 个整数，排序后输出。
代码实现：

#include <iostream>
#include<algorithm>
using namespace std;
int main() {
	int n;
	cin >> n;
	int* p = new int[n];
	for (int i = 0; i < n; i++)
		cin >> p[i];
	sort(p, p + n);
	for (int i = 0; i < n; i++)
		cout << p[i] << ' ';
	delete[] p;
	system("pause");
}

小结：

Type* p = new Type[N];
//N：可能存在程序内的内存需求，只能在运行时确定
delete[] p;

说明：系统为类型的N个元素动态分配空间，并返回指向序列的首元素的指针，该指针被分配给p（指针）。 那么p现在指向一个有效的内存块，其中包含N个int类型元素的空间。

2.二维数组申请

eg:从键盘输入整数 n 和 m（m 和 n 都是变量），表示一个矩阵的行和列，从键盘输入 n 行数据，每行包含 m 个整数，空格隔开，代表矩阵元素。使用动态分配内存存储该矩阵，并将矩阵转置后输出。
基本思路（多维类似）：先动态生成一维指针数组，每个指针再赋值为动态一维数组
代码实现：

#include <iostream>
using namespace std;
int main() {
	int m, n;
	cin >> m >> n;
	int** p = new int* [m];//分配一维指针，分配m个int* 类型的一维指针。 
	for (int i = 0; i < m; i++) {
		p[i] = new int[n];
	}
	//输入矩阵
	for (int i = 0; i < m; i++)
		for (int j = 0; j < n; j++)
			cin >> p[i][j];
	//输出转置
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++) {
			cout << p[j][i] << ' ';
		}
		cout << endl;
	}
	//释放
	for (int i = 0; i < m; i++) {
		delete[] p[i];
     }
	delete[] p;
	system("pause");
}

小结：

Type** p = new Type*[N];
for (int i = 0; i < N; i++) {
		p[i] = new int[M];
	}
//N/M：可能存在程序内的内存需求，只能在运行时确定
for (int i = 0; i < N; ++i) {
		delete[] p[i];
     }
delete[] p;

说明：系统为类型的N个元素动态分配空间,并返回指向序列首元素的指针。这里需要注意的是， P是指向指针的指针，因此P中的N个元素均为指针类型，在for循环中系统再为P中的每一个指针（共N个）每一个分配的M各元素。P[i]中储存的是M个元素中首元素的地址。

3.变量申请

Type* p = new Type;
delete p;

4.结构体申请

struct a {
int aa; 
char bb;
};
int N;
cin >> N;
a *p = new a[N];
cout<<p[0].aa<<p[0].bb;