欠债还钱，天经地义（二）

为什么要使用动态内存

1.按需分配，根据需要分配内存，不浪费
2.调用函数时仍需要使用被调用函数内部的指针对应的地址（类似二级指针）
3.突破栈区的限制，可以给程序分配更多的内存

//按需分配，即用即删
#include <stdio.h> 
#include <stdlib.h> 
#include<string.h>

int main(void){
	int *p = NULL;
	int a[5] = {1,4,5,7,9};

	p = new int[5];	//分配内存

	for(int i=0; i<5; i++){
		*(p+i) = a[i];
	}
	
	for(int i=0; i<5; i++){
		printf("%d",*(p+i));
	}
	
	delete [] p;	//删除动态内存
	return 0;
}

//调用函数时仍需要使用被调用函数内部的指针对应的地址（类似二级指针）
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

#define NUM 10

//通过返回动态内存的指针 
int * demo(int count){
	int *p = NULL;
	p = new int[count];	//分配数组内存
	for(int i=0; i<count; i++){
		p[i] = i;
	}	

	return p;
}

int main (void){
	int *a = NULL;
	a = demo(NUM);
	
	for(int i=0; i<NUM; i++){
		printf("%d ",a[i]);
	}	

	delete [] a;
	return 0;
}

//突破栈区的限制，可以给程序分配更多的内存
#include <stdlib.h> 
#include<stdio.h>
#include<string.h> 

//栈区的空间大小是有限制的，windows 上一般是 1M - 2M 
void demo(){ 
	//int a1[102400*2]; //100k*2*4 = 800K 
	//int a1[102400*3]; //100k*3*4 = 1200K = 1.2M 
	int * a1; //如果使用堆的话，64 位 windows 10 系统的限制是 2G 
	a1 = (int *)malloc((int)(1024*1000*1000));//分配 2G 
	//malloc是C语言分配内存的方式，与C++的new相同
	a1[0]=0; 
	printf("This is a demo.\n"); 
	free(a1);
}

int main(void){ 
	printf("--start--\n"); 
	demo(); 
	printf("--end--\n"); 
	
	system("pause"); 
	return 0; 
}

    

new 和 delete 基本语法

    在软件项目开发过程中，我们经常需要动态地分配和撤销内加粗样式存空间，特 别是数据结构中结点的插入与删除。在 C 语言中是利用库函数 malloc 和 free 来 分配和撤销内存空间的。C++提供了较简便而功能较强的运算符 new 和 delete 来 取代 malloc 和 free 函数。

(注意： new 和 delete 是运算符，不是函数，因此执行效率高。)

    虽然为了与 C 语言兼容，C++仍保留 malloc 和 free 函数，但建议少侠不 用 malloc 和 free 函数，而用 new 和 delete 运算符。

new int; //开辟一个存放整数的存储空间，返回一个指向该存储空间的地址(即指针)

new int(10); //开辟一个存放整数的空间，并指定该整数的初值为 10，返回一个指向该存 储空间的地址

new char[100]; //开辟一个存放字符数组(包括 100 个元素)的空间，返回首元素的地址

new int[5][4]; //开辟一个存放二维整型数组(大小为 5*4)的空间，返回首元素的地址

float * p=new float (3.14159); //开辟一个存放单精度数的空间，并指定该实数的 初值为//3.14159，将返回的该空间的地址赋给指针变量 p

    
new 运算符 动态分配堆内存
使用方法：
指针变量 = new 类型(常量）;
指针变量 = new 类型[表达式]; //数组
指针变量 = new 类型[表达式][表达式] //二维数组

作用：
从堆上分配一块“类型”指定大小的存储空间，返回首地址

其中：
“常量”是初始化值，可缺省 。
创建数组对象时，不能为对象指定初始值

delete 运算符 释放已分配的内存空间
使用方式：
普通类型（非数组）使用:     delete 指针变量；
数组 使用:                    delete[ ] 指针变量；

其中“指针变量” 必须是一个 new 返回的指针！

//demo
#include <stdlib.h> 
#include <iostream> 

using namespace std;

//分配基础类型 
int main007(void) { 
	//第一种分配动态内存不执行初始化 
	int *p1 = new int; 
	*p1 = 100; 
	
	//第二种分配动态内存同时执行初始化 
	int *p2 = new int(100); 
	
	// 第三种 malloc 返回值是 void * 
	int *p3 = (int *)malloc(sizeof(int)); 
	
	free(p1); //基础类型可以 new free 可以混搭 
	delete p3; //基础类型可以 malloc delete 可以混搭 
	delete p2; //free(p2); 同样效果 
	system("pause"); 
	return 0; 
}

//分配数组变量 
int main(void) { 
	int *p1 = (int *) malloc(sizeof(int)*10); 
	int *p2 = new int[10]; 
	delete p1; // free(p1); 可以混搭 
	free(p2); //可以混搭 delete[] p2; 
	
	system("pause"); 
	return 0; 
}

C 内存分配：
void *malloc(size_t size);
void free(void *);

malloc 在内存的动态存储区中分配一块长度为 size 字节的连续区域返回该区域 的首地址

 
    在开发使用动态内存的过程中一定要谨记，好借好还再借不难，借了人家的内存一定要记着还回去，不然有可能会发生内存泄露，就好比你用北冥神功疯狂吸取电脑的内力，电脑还浑然不知，最后内力枯竭，系统崩溃