C/C++动态内存及二维数组的动态分配

C++动态内存问题
1、基础类型的动态内存

void test()
{
 int *aPtr = nullptr;
 aPtr = new int;
 // ...不要忘了 有new 就有delete!
 delete aPtr;
}

2、一维数组的动态内存分配

void test1D()
{
 unsigned int m = 0;
 cin >> m;
 double *aPtr = nullptr;
 aPtr = new double[m];
 // ...不要忘了释放内存，很容易忘
 delete[] aPtr;
}

3、二维数组的动态内存分配

3.1 首先，方法很多，先说我最喜欢的方法：vector容器法：
（1）

// 定义完了，可以直接与一维数组差不多的使用方式
void test2D()
{
 unsigned int m = 0, n = 0;
 cin >> m >> n;
 // 包含vector-->#include <vector>
 // 说明： vector容器的在命名空间std中，但是实现在<vector>中
 // 设置行为m
 vector<vector<int>>twoDArray(m);
 // 设置列的长度
 for (int i = 0; i < m; i++)
 {
  twoDArray[i].resize(n);
 }
 // ...不要忘了释放内存
 // 但是我认为vector那么好，用完了自己应该会自动调用析构函数的，自动释放内存。
 twoDArray.~vector();
}
// 这样也相对麻烦：
// *****************************************************
// 也可以同时设置行列
 vector<vector<int>>array2D(m, vector<int>(n));

(2) C++动态二维数组的定义：
（2）.1 这里又可以分为连续内存的动态二维数组和内存不连续的动态内存数组，使用起来没什么差别，个人觉得连续的可能更方便使用，效率更高。

…看比赛去了，今天TES VS JDG决赛

…回来了，这一把京东翻盘TES，两边都打的很精彩！

void test2D_NEXT()
{
 // 二维，就是一维的成员是一个指针，又指向了一个内存块--这样分配的内存，一维数组是连续的，但是二维不连续。
 // 所以先定义一个一维数组
 unsigned int m = 0;
 unsigned int n = 0;
 int **aPtr = nullptr;
 // 设置行数：
 aPtr = new int*[m];
 // 设置列数：
 for (size_t i = 0; i < m; i++)
 {
  // aPtr[i] 就是一个指针，利用这个指针可以再开辟一个数组
  aPtr[i] = new int[n];
 }
 // 一切动态内存不释放都是耍流氓。因为动态内存在堆里，系统不会自动释放，栈里会自动释放。
 // 释放内存：先释放列，再释放行
 for (size_t j = 0; j < m; j++)
 {
  delete[] aPtr[j];
 }
 delete[] aPtr;
}

（2）.2 同（1）中类似，但是内存是连续的：

…比赛又开始了…
…TES可以的，比赛很精彩！

void test_2D_continuable()
{
 unsigned int m = 0, n = 0;
 cin >> m >> n;
 int **aPtr = nullptr;
 // 直接开辟一整块内存，再分区---但是m n 不能输入为0
 aPtr = new int*[sizeof(int)*m*n];
 for (size_t i = 0; i < m; i++)
 {
  aPtr[i] = new int[sizeof(int)*n]; // 大块拆开成小块，储存列值
 }
 // 测试 --赋值--输出二维数组
 int t = 0;
 for (size_t i = 0; i < m; i++)
 {
  for (size_t j = 0; j < n; j++)
  {
   aPtr[i][j] = t;
   t++;
  }
 }
 for (size_t i = 0; i < m; i++)
 {
  for (size_t j = 0; j < n; j++)
  {
   cout << aPtr[i][j] << "  ";
  }
  puts("");
 }
 // 释放内存--连续的话，释放就比较轻松！
 delete aPtr;
}

可以了，先到这里。

1.malloc
（1）malloc分配函数：需要给出申请空间大小（以字节为单位）
（2）返回值是一个首地址，用指针接收
（3）使用sizeof计算元素大小
（4）使用malloc函数申请内存空间，用完后需要释放，否则会造成内存泄露
（5）释放函数free需要指向分配内存的指针
（6）基本形式：void malloc(unsigned int size);
（7）分配指定大小的内存空间，但是不会把分配的空间清0
（8）free(指针);//释放堆空间，标记删除，不清楚内容
（9）示例：
①malloc与一维数组
《1》去加方括号，指针，数组两变换,无论几维数组，几个*都可以
《2》随机生成10个整数，保存到堆区
int *parr = malloc(sizeof(int) * 10);//在堆区开辟10个整型的空间
for(int i = 0 ; i < 10 ; i ++){
parr[i] = arc4random()%(100 - 10 + 1) + 10;//生成10个【10，100】的随机数
}
for(int i = 0 ; i < 10 ; i ++){
printf(“%d “,parr[i]);//输出
}
printf(“\n”);//换行
free(parr);//释放申请的空间
②malloc与二维数组
《1》分配2行三列的二维数组
《2》int (*pa)[3] = malloc(sizeof(int)23);
int (*pa)[3] = malloc(sizeof(int) * 2 * 3);//开辟一个2行3列的整型空间
pa[0][0] = 1;//赋值
pa[0][1] = 13;
③malloc与字符串
《1》将字符串“Hello，Lanou”保存到堆区
方案一：
char *pst = malloc(sizeof(char) * 12);//开辟12个char型空间,注意字符串结尾的\0
strcpy(pst,”Hello,Lanou”);//拷贝字符串
printf(“%s\n”,pst);//输出
free(pst);//释放内存
方案二：
char a[] = “Hello,Lanou”;//在栈区拷贝常量区的字符串
char *ps = malloc(sizeof(a));//开辟该字符串大小的空间
strcpy(ps,a);//将栈区的字符串拷贝到堆区
free(ps);//释放内存
④malloc与字符串数组
《1》char (*p)[255] = malloc(5 * 255);//开辟5个字符串，每个字符串255字节的空间
《2》strcpy(p[0],”iPhone”);//拷贝字符串到第一个字符串数组
⑤malloc与结构体
typedef struct person{//创建一个有2个元素的结构体
char name[20];
int age;
}Person;
方案一：
int main(){
Person *pp = malloc(sizeof(Person));//开辟一个该结构体大小的空间
strcpy(pp->name,”六娃”);//字符串拷贝，赋值
printf(“%s\n”,pp->name);//输出
pp->age = 34;//整型赋值
printf(“%d\n”,pp->age);//输出
free(pp); //释放内存
}
方案二：
《根据结构体可以直接赋值的特点》
Person p = {“贝爷”,20};//先给结构体赋初值
Person *pi = malloc(sizeof(Person));//开辟一个该结构体大小的空间
*pi = p;//直接把栈区的结构体的所有值拷贝给堆区的pi
⑥malloc与结构体数组
《1》指针用箭头，结构体数组用点
《2》3个元素的结构体数组
方案一：
Person *pt = malloc(sizeof(Person) * 3);//开辟3个该结构体大小的空间
strcpy(pt[0].name , “Lanou”);//((pt + 0) ->name)，字符串拷贝
pt[0].age = 10;//给该结构体数组的第一个结构体的一个元素赋值
printf(“%s\n”,pt[0].name);//输出
free(pt);//释放内存
方案二：
Person pt[3] = {{“erdanzi”,23},{“bee”,20},{“liuwa”,30}};
Person *pp = malloc(sizeof(Person) * 3);
for(int i = 0 ; i < 3 ; i ++){
pp[i] = pt[i];//结构间可以直接赋值
}
for(int i = 0 ; i < 3 ; i ++){
printf(“%s %d\n”,pp[i].name,pp[i].age);
}
free(pp);//释放内存
2.其他内存分配函数
①calloc
《1》void *calloc(unsigned n , unsigned size);
《2》使用free释放
《3》分配n个size大小的空间
《4》与malloc不同的是calloc申请的内存空间会初始化成0
《5》不建议使用，容易造成访问越界。C语言没有越界保护，程序员需要自己检查越界
②realloc
《1》void *realloc(void * , unsigned newSize)
《2》使用free释放
《3》按给定的地址以及给定的大小重新分配
《4》从小到大，数据不会丢失
《5》从大到小，数据可能会丢失
示例：
//原来分配的空间
int *p = malloc(100);
//重新分配的空间
p = realloc(p,150);
3.内存操作函数
①meset
《1》void *memset(void *s , int c , size_t n);
《2》不仅用于堆区，也用于栈区
《3》s开始，长度为n的所有字节赋值为c
《4》通常用于清除结构体或者数组数据
②memcpy
《1》void *memcpy(void *dest , const void *source , size_t n);
《2》从source拷贝n个字节到dest中
《3》不仅用于堆区，也用于栈区
③memcmp
《1》int memcmp(const void *buf1 , const void *buf2 , unsigned int count)
《2》内存比较，比较结果分为>0 , <0 , =0
《3》既可以用于堆内存，也可以用于栈内存