C/C++ 为什么要使用动态内存？

为什么要使用动态内存？

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

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

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

(1)C 内存分配：

void *malloc(size_t size);

void free(void *);

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

(2)C++内存分配：

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

#include<string.h>

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

#include <iostream>
#include <string.h>
#include <windows.h>
using namespace std;
int main() {
    int farmer[10] = { 20,22,36,41,52,36,78,95,82,15 };
    int num = 0;
    int* salary = NULL;

    printf("请输入需要雇佣的农民数量：\n");
    scanf_s("%d",&num);

    if (num < 10) {
        cout << "请输入一个大于9的数！" << endl;
        system("pause");
        exit(1);
    }
    //后面新增的都是18
    salary = new int[num];
    //第一种：逐个赋值
    //for (int i = 0; i < sizeof(farmer) / sizeof(int); 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;
}

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
//通过返回动态内存的指针 
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; 
}

#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 
    a1[0]=0; 
    printf("This is a demo.\n"); 
}
int main(void){ 
    printf("--start--\n"); 
    demo(); 
    printf("--end--\n"); 
    system("pause"); 
    return 0; 
}