动态内存分配笔记

动态内存分配

静态分配：在栈上分配，用户申请，操作系统释放。
动态分配：在堆上分配，程序员向系统申请，并负责归还。

为什么要动态分配内存？
程序运行时才确定需要多少空间
需要较多的内存空间

动态存储分配函数：
void *malloc(size);
参数size，欲分配的字节数
返回值：成功，void型指针。
		失败，返回空指针
头文件：<cstdlib>和<camlloc>
int *p=(int *)malloc(4); *p=12;//整数占4个字节
int *q=(int *)malloc(8);*q[0]=1;*q[1]=2;//数组有两个元素，占8个字节

动态内存释放函数：
void free(void *memblock);
参数memblock:指针，指需要释放的内存.
返回值：无。
头文件：<cstdlib>和<cmalloc>;
free(p);
free(q);

动态申请内存操作符 new
声明方式：
new 类型名T （初值列表）
功能：申请T类型对象的内存空间，并依初值列表赋予初值。
结果值：成功，T类型的指针，指向新分配的内存。
		失败：0（NULL);

释放内存操作符 delete
delete 指针P
功能：释放指针P所指向的内存。P必须是new操作的返回值。
例子：
int *p = new int (4);		int *p=new int [4];
*p =3; 						p[0]=1;p[2]=5;
delete p;					delete[]p;
p=NULL;						p=NULL;


数组指针//注意区别指针数组（数组的元素是指针类型）
定义：指向数组的指针。
语法：类型名 （*指针名）【下标表达式1】【下标表达式2】.....；
例子：
int a[3][4];
int (*p)[4]=a;
p[0][2]=5;p[2][3]=10;

指向数组元素的指针与指向数组的指针
指向数组元素的指针：
int a[4];
int *p=a;或者 int *p =&a[0];
指向数组的指针：
int a[4];
int (*p)[4]=&a;
另一个例子：
int b[3][4];
int (*p)[4]=b;

动态创建多维数组
new 类型名T 【下标表达式1】【下标表达式2】....；
如果内存分配成功，new 运算返回新分配内存首地址的指针，是一个T类型的数组。
例子：
char （*fp）[3];
fp = new char [2][3];
*fp 指向fp[0][0];
有2*3=6个元素；

例子：
#include<iostream>
using namespace std;
int main() 
{
	int (*p)[4][5];
	p=new int [2][4][5];
	for(int i=0;i<2;i++)
	{
		for(int j=0;j<4;j++)
		{
			for(int k=0;k<5;k++)
			{
				*(*(*(p+i)+j)+k)=100*i+10*j+k;
			}//通过指针访问数组元素
		}
	}
		for(int i=0;i<2;i++)
	
	{
			for(int j=0;j<4;j++)
		
		{
				for(int k=0;k<5;k++)
				{
					cout<<*(*(*(p+i)+j)+k)<<" ";//可以改成：cout<<p[i][j][k];通过指针下标访问
				}
				cout<<endl;
		}
	}
}

动态创建多维数组：上面的数组只有第一个维度是可变的，怎么创建每个维度都是可变的呢？
多级指针：
指向指针的指针：
语法：
类型名 **指针名；
int a=5;
int *p=&a;
int **q=&p;
**q=10;//修改a的值

动态分配多维数组：m*n*k的三维数组；
int ***p=new int **[m];
for(int i=0;i<m;i++)
{
	p[i]=new int *[n]
	for(intj=0;j<n;j++)
	{
		p[i][j]=new int [k];
	}
}
p[m][n][k];
释放：
for(int i=0;i<m;i++)
{
	for(int j=0;j<n;j++)
	{
		delete []p[i][j];
	}
	delete []p[i];
}
delete []p;
p=NULL;