学习笔记：动态内存分配

申请分配单个元素

格式为 type *pointer = new int ();

           ......//语句

         delete p;

括号中的数据就是初始值，如果不希望设置初始值，可以将括号去掉 

运用举例

int* p;
	p = new int(5);
	if (p == NULL)
	{
		return 1;
	}
	cout << *p;
	delete p;
    p=NULL;

需要判断内存是否分配成功，不成功会返回一个空指针

于是我们可以通过判断p是否为空指针来判断内存是否分配成功

new运算符用于动态内存分配

，delete用于释放分配的内存

内存分配后一定要释放，否则会造成内存泄漏

内存泄漏（Memory Leak）是指程序中已动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。

 申请分配数组

格式

Type* pointer = new Type[N]; 
//...
delete[] pointer;

运用例子 

int* p = new int[5];
	if (p == NULL)
	{
		return 1;
	}
//使用动态内存分配数组
//赋值0-4，并输出
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		p[i] = i;
	}
	for (i = 0; i < 5; i++)
	{
		cout << p[i];
	}
	delete [] p;
    p=NULL;

 二维指针动态内存分配

举例:申请一个3x4的二维数组 

	int** p;
	p = new int* [3];
	//分配一维指针，分配三个int* 类型的一维指针。 
	for (int i = 0; i < 3; ++i)
	{
		p[i] = new int[4];
	}
	for (int i = 0; i < 3; i++) {
		delete[] p[i];
	}
	delete[] p;
    p=NULL;

 先释放3个一维指针的内存，再释放二维指针的内存

指针数组动态内存分配

int* p[3];    //申请含有三个int* 类型的指针数组 
      //跟二维指针不同的是，这里数组p不用手动申请内存
      //申请指针数组后，p内存自动生成
	for (int i = 0; i < 3; ++i)  //申请一个3x4的空间
    {
       p[i] = new int[4];
	}
	//.....
	for (int i = 0; i < 3; ++i)
	{
		delete[] p[i];
	}
//同时这里也不需要清理p[]的内存,p[]是指针数组，静态
    p[3]=NULL;

数组指针动态内存分配

 int(*a)[4];//创建一个有4列指针    
//a的增量的基数为4个int
	  a = new int[3][4];//分配3*4数组内存
	  delete[]a; //清理分配的内存
	  a = NULL;//将指针a指向空

二维数组分配内存是先给第一维分配内存，再给第二维分配。（数组指针除外，这个相当于直接给一个数组分配内存，然后其指向这个数组）

释放分配的内存时，先释放第二维，再释放第一维（数组指针除外，其只需要将分配的数组内存释放，然后将指针指向空）

用free 或delete 释放了内存之后，立即将指针设置为NULL，防止产
生“野指针”。

实例 

实例:通过动态内存分配对n个数排序 

#define _CRT_SECURE_NO_WARNINGS 1 
#include<iostream>
#include<iomanip>
using namespace std;
int main(void)
{
	
	int* p;
	int n ;
	cout << "输入要排序的元素个数:" << endl;
	cin >> n;
	p = new int[n];
	if (p == NULL) {
		return 1;
	}
	for (int i = 0; i < n; i++)
	{
		cin >> p[i];
	}
	for (int i = 0; i < n-1; i++)
	{
		for (int j = i + 1; j < n; j++)
		{
			if (p[i] > p[j])
			{
				int tmp = p[i];
				p[i] = p[j];
				p[j] = tmp;
			}
		}
	}
	cout << "排序结果为:" << endl;
	for (int i = 0; i < n; i++)
	{
		cout << p[i]<<" ";
	}
	delete[]p;
	p = NULL;
	return 0;
}

 实例:通过动态内存分配找出输入的N个数中的最大值

#include<iostream>
#include<iomanip>
using namespace std;

int main(void){
	int num,iPosMax;
	int *ipBuff;
	cout << "输入元素个数：";

	cin >> iSize;
	ipBuff = new int[num];
	if (ipBuff == NULL){
		return 1;
	}
    cout << "输入" << num << "个数：";
	for (int i = 0; i < num; i++){
	    cin >> ipBuff[i];
	}

	iPosMax = 0;

	for (int i = 1; i < num; i++ ){
		if (ipBuff[i] > ipBuff[iPosMax]){
			iPosMax = i;
		}
	}

	cout << "最大值：" << ipBuff[iPosMax] << endl;
	cout << "位  置：" << iPosMax << endl;
	delete [] ipBuff;
	ipBuff = NULL;
	return 0;
}

实例:动态内存分配实现n阶方阵转置 

#include<iostream>
#include<iomanip>
using namespace std;

int main(void) {
	int n;//作为阶数
	int i, j;
	cout << "请输入阶数:" << endl;
	cin >> n;
	int** p=new int* [n];
	for (i = 0; i < n; i++)
	{
		p[i] = new int[n];
	}
	cout << "请输入矩阵中的数据:" << endl;
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < n; j++)
		{
			cin >> p[i][j];
		}
	}
	for (i = 0; i < n ; i++)
	{
		for (j = 0; j < i; j++)//以对角线为中心两侧元素交换
		{
			int tmp = p[i][j];
			p[i][j] = p[j][i];
			p[j][i] = tmp;
		}
	}
	cout << "转置后的结果为:" << endl;
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < n; j++)
		{
			cout <<setw(3) << p[i][j];
		}
		cout << endl;
	}
	for (i = 0; i < n; i++)//释放内存
	{
		delete []p[i];
	}
	delete[]p;
	for (i = 0; i < n; i++)
	{
		p[i] = NULL;
	}
	return 0;
}