C++程序的内存分区

1. 栈区（stack）：由编译器自动分配释放，存放函数的参数值，局部变量值等。
2. 堆区（heap）：一般由程序员分配释放，随叫随到，挥之即走。
3. 全局/静态区（static）：全局变量和静态变量的存储是放在一起的，在程序编译时分配。
4. 文字常量区：存放常量字符串。
5. 程序代码区：存放函数体（包括类的成员函数、全局函数）的二进制代码

以下是代码演示：

#include 
#include 
#include 
 
int laoyezi = 58;
 
//1.栈的内存
void say_hello(const char * msg){ //函数的参数和局部变量存放在栈区
//int x,y,z;
    if(msg){
        printf("Hello, %s!", msg);
   }else {
        printf("Hello, who are u?\n");
        }
 
    printf("老爷子今年 %d 岁!\n", laoyezi);
 
    //printf("小姐今年 %d 岁!\n", girl);
}
 
void gui_fang(int jiaren){
    static int girl = 17;
 
    if(girl==17) {
        girl = 18;
    }else {
        girl = 16;
    }
 
    printf("小姐今年 %d 岁!\n", girl);
}
 
int main(void) {
    int num = 0;
    int *salary = NULL;
 
    //4.字符串常量
    char *p = "童养媳";
    char *p1 = "童养媳";
    printf("p: 0x%p p1: 0x%p\n", p, p1);
 
    system("pause");
    exit(0);
 
    //3 .全局变量/静态变量
    printf("老爷子今年 %d 岁!\n", laoyezi);
    gui_fang(0);
    gui_fang(0);
    //salary = new int(666);
 
    //2. 堆，动态没存分配
    salary = new int; //在堆区分配动态内存
    *salary = 100;
    printf("salary: %d\n", *salary);
    delete salary;
 
    system("pause");
    exit(0);
 
    //say_hello("骚年们！");
    printf("请输入需要雇佣的农民数量：\n");
    scanf_s("%d", &num);
    if(num<=0){
    //提示用户重新输入
    }
    salary = new int[num];
 
    for(int i=0; i
        *(salary+i)= i+1;
    }
    for(int i=0; i
        printf("第%d 个农民的薪资: %d\n", i+1, salary[i]);
    }  
  
    printf("---over---\n");
    delete[] salary;
 
    //切记，delete 后的动态内存，禁止访问
    /*for(int i=0; i
        printf("第%d 个农民的薪资: %d\n", i+1, salary[i]);
    }*/
 
    system("pause");
    return 0;
}

为什么要使用动态内存

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

// demo9-2.c
#include 
#include 
#include
 
int main(void) 
{
	int farmer[10] = { 20, 22, 25, 19, 18, 23 ,17, 28, 30, 35 };
	int num = 0;
	int* salary = NULL;
 
	printf("请输入需要雇佣的农民数量：\n");
	scanf_s("%d", &num);
 
	if (num <= 10) {
 
		//提示用户重新输入
	}
 
	//后面新增的都是 18
	salary = new int[num];
 
	//第一种，逐个赋值
	/*for(int i=0; i
	{
		*(salary+i)= farmer[i];
	}*/
 
	//第二种，内存拷贝
	memcpy(salary, farmer, sizeof(farmer));
	for (int i = sizeof(farmer) / sizeof(int); i < num; i++) 
	{
		//salary[i] = 18;
		*(salary + i) = 18;
	}
 
	for (int i = 0; i < num; i++) 
	{
		printf("第%d 个农民的薪资: %d\n", i + 1, salary[i]);
	}
 
	delete[] salary;
 
	system("pause");
	return 0;
}

内存拷贝函数

void *memcpy(void *dest, const void *src, size_t n);

#include

功能：从源 src 所指的内存地址的起始位置开始拷贝 n 个字节到目标 dest 所指的 内存地址的起始位置中

new 分配内存布局图

 

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

// demo9-3.c
#include 
#include 
#include 
//通过返回动态内存的指针
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);
	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
 
	system("pause");
	return 0;
}

C 内存分配：

void *malloc(size_t size); void free(void *); malloc 在内存的动态存储区中分配一块长度为 size 字节的连续区域返回该区域 的首地址.

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

// demo 9-4.c
#include 
#include
#include
//栈区的空间大小是有限制的，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
	a1[0] = 0;
	printf("This is a demo.\n");
}
int main(void) 
{
	printf("--start--\n");
	demo();
	printf("--end--\n");
 
	system("pause");
	return 0;
}