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

为什么要使用动态内存

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

内存拷贝函数

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;
}