C++中在堆区中动态分配内存存储数据

在c++中，通过关键字new,malloc和calloc可以实现在内存堆区进行动态的开辟空间，从而存储数据。这些数据需要被程序员手动释放，否则会导致内存的溢出。而导致程序崩溃。

关键字new

这里我们介绍利用new在堆区储存变量和数组。

//利用new在堆区存储变量
#include<iostream>
using namespace std;
int main(){
    int *p1=new int;
    *p1=10;
    int *p2=new int(20);

    cout<<*p1<<endl;
    cout<<*p2<<endl;
    
    delete p1;
    delete p2;
    return 0;
}

new关键字的原理是在堆区开辟一个空间，然后把这个空间的地址传递回去。

在我们上面的两个例子中，通过new开辟了一个int的空间，然后把地址返回给指针p1。然后荣通过用来给p1指向的空间赋值。

第二个例子则是在开辟空间后马上给这块空间赋值为20，然后把这块空间的地址返回给p2。

最后delete空间p1,p2。手动释放堆区内存。将内存还给堆区。

//利用关键字new在堆区开辟数组
#include<iostream>
using namespace std;
int main(){
    int *arr=new int[10];
    if (arr==NULL)
        return -1;
   
    for (int i=0;i<10;i++){
        arr[i]=i;
    }
   
    delete[] arr;
    return 0;
}

这就是利用关键字new在堆区开辟空间的语法规则。在这个例子中，我们通过new申请了一块10*int大小的空间，并将地址返回给指针arr。给这个空间赋值，最后通过关键字delete来释放空间。注意数组空间的释放和单纯对变量释放的不同。

似乎已经够用了。但是我们还没有考虑到二位数组的情况。

//利用关键字new在堆区开辟二维数组空间
#include<iostream>
using namespace std;

int main(){
    int m,n;
    //利用m和n分别来控制二维数组的行和列
    int **arr=new int*[m];
    if (arr==NULL)
        return -1;
    for (int i=0;i<m;i++){
        arr[i]=new int[n];
        if (arr[i]==NULL)
            return -1;
    }

    for(int i=0;i<m;i++){
        delete[] arr[i];
    }
    delete[] arr;
    return 0;
}

对这段代码的解释：
int ** arr表示创立的一个二级指针，而int *[m]代表一个数组，这个数组里面存放是int *型的数据，也就是说，里面存的是指向一个数组的地址。然后通过循环给指针数组里面的每一个指针都指向一个数组。也就是数组的数组，二维数组。最后，先用循环释放一维数组成员指向的空间。再通过delete释放二维数组指针。

关键字malloc

关键字malloc的使用需要调用头文件stdlib，释放由malloc开辟的空间需要用关键字free。

#include<iostream>
#include<stdlib.h>
using namespace std;

int main(){
    int *a=(int *)malloc(sizeof(int));
    if (a==NULL)
        return -1;
    *a=10;
    cout<<*a<<endl;
    free(a);
    return 0;
}

malloc关键字和new一样，都是返回一个指向对应堆区空间的指针。而且这个指针是void *型的，所以我们要将这样的指针转换成int *型。malloc后面的括号装的是字节数。

//利用malloc在堆区动态开辟一维数组空间
#include<iostream>
#include<stdlib.h>
using namespace std;
int main(){
    int a=4;
    int *arr=(int *)malloc(a*sizeof(int));
    if (arr==NULL)
        return -1;
    //添加对数组的处理
    free(arr);
    return 0;
}

对于这段代码的解释和上一个例子近似，我们对malloc分配的空间进行了修改，从而使arr处理的是一个在堆区的一维数组.

//利用malloc在堆区动态开辟二维数组空间
#include<iostream>
#include<stdlib.h>
using namespace std;
int main(){
    int a,b;
    int **arr=(int **)malloc(a*sizeof(int*));
    if (arr==NULL)
        return -1;
    for (int i=0;i<a;i++){
        arr[i]=(int *)malloc(b*sizeof(int));
        if(arr[i]==NULL){
            //一旦由一行出现分配失败，就释放所有空间
            for(int j=0;j<i;j++){
                free(arr[j]);
            }
            free (arr);
            return-1;
        }
    }
    //添加对数组的处理

    for(int i=0;i<a;i++){
        free(arr[i]);
    }
    free(arr);
    return 0;
}

这段的处理和利用new开开辟空间是一个道理。这里不详细展开。

calloc关键字

calloc关键字和malloc关键字几乎一致，只是在空间大小上由不同的表述，这里不详细展开。