地震监测系统 1.C++的内存分配 2.为什么使用动态内存 3.动态内存的分配、使用、释放 4.内存泄漏5.变量的四种存储类型6.变量的作用域和生存周期

1.C++的内存分配

2.为什么使用动态内存 

1，栈区：函数的参数和局部变量存放在栈区

2，堆区（heap):一般由程序员分配释放，随叫随到，随之即走。

动态内存分布数组的方式

//动态内存分布数据的方式
int main(void)
{
	int num = 0;
	int* salary = NULL;
	printf("请输入需要雇佣的农民数量：\n");
	scanf("%d", &num);
	salary = new int[num];
	for (int i = 0; i < num; i++)
	{
		*(salary + i) = i + 1;
	}
	for (int i = 0; i < num; i++)
	{
		printf("第%d农民的薪资：%d\n", i+1, salary[i]);
	}
	delete[] salary;//delete 后的动态内存，禁止访问
	system("pause");
	return 0;
}

动态内存分布数据的方式

	int* salary = NULL;
	salary = new int(1);
	printf("salary:%d\n",* salary);
	delete salary;
	system("pause");
	exit(0);//结束程序

 3，全局/静态区（static):全局变量和静态变量的存储是放在一起的，在程序编译时分配

静态变量

void gui_fang(int jia_ren)
{
	static int girl = 17;//静态变量
	if (girl ==17) {
		girl =18;
	}
	else {
		girl = 16;
	}
	printf("girl:%d\n", girl);
}

int main(void)
{
	gui_fang(0);
	gui_fang(0);
	system("pause");
	return 0;
}

 4，文字常量区：存放常量字符串

5.代码区 ,存放函数体的二进制代码

 2.为什么要使用动态内存

        1.按需分配，根据需要分配内存，不浪费

        2.被调用函数之外需要使用被调用函数内部的指针对应的空间

        3.突破栈区的限制，可以给程序更多的内存

  1.按需分配，根据需要分配内存，不浪费。                         数据的两种拷贝方式

int main(void)
{
	int farmer[10] = { 20,29,35,43,54,65,76,87,93,12 };
	int num = 0;
	int* salary = NULL;
	printf("请输入需要雇佣的农民数量：\n");
	scanf("%d", &num);
	salary = new int[num];

	//第一种逐个复制
	for (int i = 0; i < sizeof(farmer)/sizeof(int); i++)
	{
		*(salary + i) = farmer[i]	;
	}
	//内存拷贝，必须包括头文件 string
	memcpy(salary, farmer, sizeof(farmer));// 拷贝的目的地址，需要拷贝的东西的地址，拷贝的东西的大小
	for (int i = 0; i < sizeof(farmer) / sizeof(int); i++)
	{
		printf("第%d农民的薪资：%d\n", i + 1, salary[i]);
	}
	delete[] salary;//delete 后的动态内存，禁止访问
	system("pause");
	return 0;
}

 2.被调用函数之外需要使用被调用函数内部的指针对应的空间

 

#include<stdio.h>
#include<Windows.h>
#include<string>



using namespace std;

//通过，返回动态内存的指针
int* demo(int count)
{
	int* ap = NULL;
	//new delete C++动态内存分布操作符，c语言是malloc
	ap = (int*)malloc(sizeof(int) * count);

	/*ap = new int[count];*/

	for (int i = 0; i < count; i++)
	{
		ap[i] = 100 + i;
	}
	for (int i = 0; i <count; i++)
	{
		printf("*(ap+%d)=%d\n", i, *(ap + i));
	}
	return ap;

}
//通过二级指针来保护
void demo1(int count, int** pointer_p)
{
	int* ap = NULL;

	*pointer_p = (int*)malloc(sizeof(int) * count);
	/*pointer_p= new int[count];*/

	ap = *pointer_p;
	
	for (int i = 0; i < count; i++)
	{
		ap[i] = 100 + i;
	}
	for (int i = 0; i < count; i++)
	{
		printf("*(ap+%d)=%d\n", i, *(ap + i));
	}

}

//动态内存分布数据的方式
int main(void)
{	
	//两种方式获取被调用函数内部的内存
	int* pointer = NULL;
	int count = 10;

	//第一种,通过，返回动态内存的指针
	/*pointer = demo(count);*/

	//第二种，通过二级指针来保存
	demo1(count, &pointer);

	for (int i = 0; i < 10; i++)
	{
		printf("*(pointer+%d)=%d\n", i, *(pointer + i));
	}
	//用完了记得释放
	free(pointer);//c语言中的释放内存函数，相当于delete
	/*delete pointer;*/
	system("pause");
	return 0;
}

3. 栈区的空间大小是由限制的，windows一般是1M-M

void demo2()
{
	int a[102400 * 2];//100k*2*4=800k

	a[0] = 0;
	printf("thie is a demo");
}
//动态内存分布数据的方式
int main(void)
{	

	demo2();
}

 3.如果使用堆的话，64位 Windows 10 系统的限制是2G

void demo2()
{
	/*int a[102400 * 2];*///100k*2*4=800k

	/*a[0] = 0;*/
	int* a1 ;
	a1 = (int*)malloc(1024 * 1000 * 1000);//分配1G

	printf("thie is a demo");
}

 

 

 

 

    //分配基础类型
	//第一种分配动态内存不执行初始化
	int* p1 = new int;
	*p1 = 100;
	//第二种分配动态内存执行初始化
	int* p2 = new int(100);
	//mallo分配动态内存
	int* p3 = (int*)malloc(sizeof(int));

	free(p1);//基础类型可以混搭 new ,delete ,mallo free
	delete p2;
	delete p3;
	//分配数组变量
	int* p4 = (int*)malloc(sizeof(int) * 10);

	int* p5 = new int[10];

	delete p4;//free(p4)
	delete[] p5;//free(p5)

4，内存泄漏 ：借的内存必须还

void A_live()
{
	int* p = new int[1024];
	//挥霍
	p[0] = 0;
}
void B_live()
{
	int* p = new int[1024];
	//正常开支
	p[0] = 0;
	delete[] p;
}
int main(void)
{	
	
	for (int i = 0; i < 10000; i++)
	{
		B_live();
		Sleep(50);
	}


	system("pause");
	return 0;
}

5.变量的4种存储类型

使用数据都有两种类型

数据类型:如 int,float

存储类型：总共有四种存储类型变量，分别为自动变量（auto）、静态变量（static),外部变量（extern）以及寄存器变量（register)。

 6.变量的作用域和生存周期

 

---

---

---