C++动态内存申请

//---------------------------------------//
//----------动态内存申请---------//
//
// 包括指针申请，一位数组申请
// 二维数组申请，内存连续和不连续的问题
// 三维数组申请，内存连续和不连续的问题 
//---------------------------------------//

#include <iostream>
using namespace std;

int main() {
    //cout << sizeof(char) << "  " << sizeof(int) << "  " << sizeof(long) << "  " << sizeof(long long) << endl;

    //----------------- 单个数据申请 和 释放

    //int *p = (int*)malloc(sizeof(int));   //c语言的申请用法
    int *p1 = new int; //new + type 类型需要匹配
    int *p2 = new int(121); //初始化一个值

    *p1 = 12; //写入
    cout << *p1 << "  " << *p2 << endl; //读取

    delete p1; //delete+指针
    delete p2;

    //C++标准规定：delete空指针是合法的，没有副作用。
    //所以我们在Delete指针后赋值为NULL或0是个好习惯。对一个非空指针delete后，若没有赋NULL，若再次delete的话
    //有可能出现问题。如下代码：  
    p1 = NULL;          //如果把这句话注释掉，，不能运行，为了避免出现问题，指针被delete之后应该赋值NULL
    delete p1;
    //可以看出delete是释放指针指向的内存，并不是指针本身所占有的内存。所以delete后，指针的还是指向那块区域，并
    //未清0，所以如果下次用到，就会发生xxx空间不能访问的异常。以后delete后要赋值为空

    //------------------ 数组的申请和释放

    int *a = new int[5]; //申请数组
    memset(a, 0, 5 * sizeof(int)); //使用函数批量初始化 全称 memery set. c++没有提供数组初始化，可以用函数实现。
    //int *a1 = (int*)malloc(5*4); //c语言的的数组申请

    a[0] = 121;
    cout << a[0] << endl;
    delete[] a; //释放数组，对于标准语法而言，如果不匹配释放，结果是不确定的。
    a = NULL;

    //------------------ 二维数组[m*n]的申请和释放  ----  分配的内存不连续 -----
    int m = 5, n = 4;
    int **ta;
    //申请内存
    ta = new int*[m];
    for (int i = 0; i < m; i++) {
        ta[i] = new int[n];
    }

    //赋值

    // 不能用如下的初始化赋值，因为 ta 对应申请的语句是：  ta = new int*[m];
    //因此该数组存放的是指针地址[该地址为n个数的起始地址]，并不是我们存放的数据
    //memset(ta,0,m*n*sizeof(int));         

    // 不能用如下的初始化赋值，因为 ta[0] 对应申请的语句是：  ta[i] = new int[n];   
    //因为每个n维数组申请的地址并不是连续的，因此不能简单的以ta[0]作为起始地址去赋值
    //memset(ta[0], 0, m*n * sizeof(int));           //

    //正确使用memset进行赋值
    for (int i = 0; i < m; i++) {
        memset(ta[i], 0, n * sizeof(int));
    }

    //或者按下标读取
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) 
            ta[i][j] = i * m + j;
    }

    //释放内存
    for (int i = 0; i < m; i++) {
        delete[] ta[i];
        ta[i] = NULL;
    }
    delete[] ta;
    ta = NULL;


    //------------------ 二维数组[m*n]的申请和释放  ----  分配的内存连续 ----- 这种和 定义变量时系统自动分配地址比较类似
    int **ta_l;
    //申请内存
    ta_l = new int*[m];
    //一次性分配所有的内存
    ta_l[0] = new int[m*n];
    //给每个地址进行赋值
    for (int i = 1; i < m; i++) {
        //不推荐用第一种方法进行指针地址的赋值，因为涉及到数据结构在内存中的存放问题，字节对齐以及CPU位数等
        //ta_l[i] = ta_l[i-1] + sizeof(int) * n ;       
        ta_l[i] = &(ta_l[0][i*n]);
    }

    //赋值

    // 不能用如下的初始化赋值，因为 ta 对应申请的语句是：  ta = new int*[m];
    //因此该数组存放的是指针地址[该地址为n个数的起始地址]，并不是我们存放的数据
    //memset(ta_l,0,m*n*sizeof(int));

    //因为内存连续，所以下面的方法可以用
    memset(ta_l[0], 0, m*n * sizeof(int));           //


    for (int i = 0; i < m; i++) {
        memset(ta_l[i], 0, n * sizeof(int));
    }
    //或者按下标读取
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++)
            ta_l[i][j] = i * m + j;
    }

    //释放内存

    //因为delete释放的时候要和new一一对应，因此不能用下面的释放方法
    //for (int i = 0; i < m; i++) {
    //    delete[] ta_l[i];
    //    ta_l[i] = NULL;
    //}
    //正确方法如下：
    delete[] ta_l[0];
    for (int i = 0; i < m; i++) {
        ta_l[i] = NULL;
    }

    delete[] ta_l;
    ta_l = NULL;

    //------------------ 三维数组[x*y*z]的申请和释放  ----  分配的内存不连续 -----
    int x = 3, y = 4, z = 5;
    int ***tha;
    tha = new int **[x];        //申请用于存储二维数组指针
    for (int i = 0; i < x; i++) {
        tha[i] = new int *[y];  //申请用于存储一维数组指针
        for (int j = 0; j < y; j++) {
            tha[i][j] = new int[z];     //申请用于存放 【数据】  内存是不连续的
        }
    }

    //赋值

    //正确使用memset进行赋值
    for (int i = 0; i < x; i++) {
        for (int j = 0; j < y; j++) {
            memset(tha[i][j], 0, z * sizeof(int));
        } 
    }

    //或者按下标读取
    for (int i = 0; i < x; i++) {
        for (int j = 0; j < y; j++) {
            for (int q = 0; q < z; q++)
                tha[i][j][q] = (i * y + j) * z + q;
        }
    }

    //释放内存
    for (int i = 0; i < x; i++) {
        for (int j = 0; j < y; j++) {
            delete[] tha[i][j];
            tha[i][j] = NULL;
        }
        delete[] tha[i];
        tha[i] = NULL;
    }
    delete[] tha;
    tha = NULL;


    //------------------ 三维数组[x*y*z]的申请和释放  ----  分配的内存连续 -----
    tha = new int **[x];        //申请用于存储二维数组指针 

    tha[0] = new int *[x*y];  //申请用于存储一维数组指针 [连续的]
    for (int i = 1; i < x; i++) {       //开始分配
        tha[i] = &(tha[0][i*y]);
    }

    tha[0][0] = new int[x*y*z];     // 申请用于存放 【数据】  [连续的]
    for (int i = 0; i < x; i++) {   // 开始分配
        for (int j = 0; j < y; j++) {
            if (i == 0 && j == 0)
                continue;
            tha[i][j] = &(tha[0][0][(i*y + j)*z]);
        }
    }

    //内存连续，可用如下赋值：
    memset(tha[0][0], 0, x*y*z * sizeof(int));

    //正确使用memset进行赋值
    for (int i = 0; i < x; i++) {
        for (int j = 0; j < y; j++) {
            memset(tha[i][j], 0, z * sizeof(int));
        }
    }

    //或者按下标读取
    for (int i = 0; i < x; i++) {
        for (int j = 0; j < y; j++) {
            for (int q = 0; q < z; q++)
                tha[i][j][q] = (i * y + j) * z + q;
        }
    }

    //释放内存
    delete[] tha[0][0];
    delete[] tha[0];
    delete[] tha;
    tha = NULL;

    system("pause");
    return 0;
}