下载文档原格式
C语言中多维数组的内存分配和释放(malloc与free)的方法
写代码的时候会碰到多维数组的内存分配和释放问题，在分配和释放过程中很容易出现错误。
下面贴上一些示例代码，以供参考。
如果要给二维数组(m*n)分配空间，代码可以写成下面：
（注意红色部分）
释放应该是：
如果为三维数组(m*n*p)分配空间呢，应该是：
释放代码为逆过程，具体代码为：
三维以上的多维数组的分配和释放，原理与上面的一样。
C中如何为第二维长度固定的二维数组分配内存
在所写的代码中，有时需要为一个二维数组分配内存，该二维数组的第一维长度不定，而第二维是固定（类似arr[n][3]的数组）。
我们可以想到的是用双指针代替数组，当然可以；也可以直接对n赋值后，直接定义arr[n][3] （C99标准支持），但这里要说的是另一种方法。
这里以将点云数据读入二维数组为例，由于点云点数n不定，可以确定的是，点是三维点，可以用以下方式定义并分配内存：
double (*arr)[3] = malloc (n*3*sizeof(double));
但在VC编译环境下，将会报错——无法从“void *”转换为“double (*)*3+” ，此时应该在malloc函数之前进行类型转换，应该如何转换呢？怎样转换才能成double (*)[3]类型呢，可以进行如下转换：
double (*arr)[3] = (double ((*)[3]))malloc (n*3*sizeof(double));。
内存分配和释放⼏乎是所有程序的基本要求，同时也是最容易出现问题的地⽅之⼀。
通过遵循⼏条简单的规则，你可以避免很多常见的内存分配问题。
原则1 ⽤new、delete取代malloc、calloc、realloc和freemalloc、calloc、realloc和free是C语⾔的⽤法，它们不会理会对象的存在与否，更不会去调⽤构造和析构函数，所以在C++中经常会引起⿇烦。
如果混⽤这些函数会造成更⼤的⿇烦。
⽐如要防⽌⽤malloc分配，⽤delete释放，这些都需要花费格外的精⼒。
原则2 new、delete和new[]、delete[]要成对使⽤调⽤new所包含的动作：从系统堆中申请恰当的⼀块内存。
若是对象，调⽤相应类的构造函数，并以刚申请的内存地址作为this参数。
调⽤new[n]所包含的动作：从系统堆中申请可容纳n个对象外加⼀个整型的⼀块内存；将n记录在额外的哪个整型内存中。
（其位置依赖于不同的实现，有的在申请的内存块开头，有的在末尾）；调⽤n次构造函数初始化这块内存中的n个连续对象。
调⽤delete所包含的动作：若是对象，调⽤相应类的析构函数（在delete参数所指的内存处）；该该内存返回系统堆。
调⽤delete[]所包含的动作：从new[]记录n的地⽅将n值找出；调⽤n次析构函数析构这快内存中的n个连续对象；将这⼀整快内存（包括记录n的整数）归还系统堆。
可以看出，分配和释放单个元素与数组的操作不同，这就是为什么⼀定要成对使⽤这些操作符的原因。
原则3 确保所有new出来的东西适时被delete掉不需要的内存不能及时被释放（回系统）就是⼤家常听到的内存泄露（memory leak）。
狭义的内存泄露是指分配的内存不再使⽤，从更⼴义上说，没有及时释放也是内存泄露，只是程度较轻⽽已。
内存泄露不管有多少，只要运⾏的时间够长，最终都回耗尽所有的内存。
内存泄露的问题极难查找，因为当出现问题时，内存已然耗尽，此时CPU正在运⾏什么程序，什么程序就崩溃（哪怕是系统程序）。
c语言的内存申请和释放C语言的内存申请和释放一、引言在编程中，对于数据的存储和处理是至关重要的。
对于需要使用大量数据或者动态数据结构的程序来说，内存管理是一项非常重要的任务。
C语言作为一种强大的编程语言，为程序员提供了灵活的方法来申请和释放内存。
本文将详细介绍C语言中的内存申请和释放，以帮助读者更好地理解和掌握这一关键概念。
二、什么是内存申请简单来说，内存申请是指程序在运行过程中向操作系统请求分配一块用于存储数据的内存空间。
这块内存空间被称为堆内存，其大小可以根据需要进行动态调整。
内存申请可以通过C语言提供的标准库函数来完成，其中最常用的函数是malloc()。
malloc()函数的原型如下：void *malloc(size_t size);其中，size_t是一种无符号整数类型，表示要申请的内存块的大小，单位是字节。
函数返回的是一个指向分配内存起始地址的指针。
如果申请失败，则返回NULL指针。
三、如何进行内存申请下面是使用malloc()函数进行内存申请的一般步骤：1. 引入头文件#include <stdlib.h>在开始使用malloc()函数之前，我们首先要确保已经引入了<stdlib.h>头文件，以保证能够正常调用malloc()函数。
2. 确定内存大小根据程序的需求，确定需要申请的内存大小。
这个大小可以是编译时已知的常量，也可以是运行时需要计算得出的变量。
3. 调用malloc()函数使用malloc()函数申请内存，将返回的指针保存到一个指针变量中。
例如，int *p = (int *)malloc(sizeof(int));表示申请了一个int类型的变量所占的内存大小。
4. 检查内存是否申请成功由于内存分配可能失败，所以在调用malloc()函数之后，应该检查返回的指针是否为NULL。
如果为NULL，则表示内存申请失败。
5. 使用申请到的内存在成功申请到内存之后，可以使用指针变量来操作这块内存。
C语言中内存的分配与释放C语言中内存的分配与释放最近遇到了点麻烦，立刻上在约提问了一个C语言的专家，感觉挺不错的，专家指出一个容易被忽略掉的东西，于是问题迎刃而解。
记下来跟大家分享下，文中内容如有错误还望大家一定帮忙指出下，谢谢！学过C语言的都知道，内存分配了用完之后是要释放的，都是到malloc和calloc 函数以及free函数。
那么分配了内存之后是不是真就free(pointer)这么简单呢？这里提及要注意的地方，参数pointer必须是调用malloc或calloc函数后返回的指针，而给free函数传递其它的值可能会造成死机或者结果是灾难性的。
重点是指针的值，而不是用来申请动态内存的指针本身。
可以看下代码，假如先前有void * p =malloc(sizeof(double)*6);也有double * dp=(double *)(malloc(sizeof(double)*6));那么此刻如果free(dp)就会出现不可预知的错误，free(p)是正确的，若又p=dp,(或者p=(void *)dp),然后free(p)也是正确的所谓灾难性的无非就是释放内存中出现把不该释放的东西给释放了，然后引起了一些问题。
那么，怎么来验证free(dp)就是错误的呢？这也许是个内存泄露的问题，呵呵。
可以试下这样一段代码：for(;;){double * p=malloc(sizeof(double)*6);free(p);}然后，看看你的内存是否超支(不够)了？再看看realloc函数，它可以用来重新分配经m,c,r三者分配的内存。
那么重新分配真的是给一块新的地址嘛？事实上并不是这样的，r有两个参数，一个是指针，引用之前分配的内存，重新分配的内存是在原来基础之上，大小则由第二个参数决定。
也就是说，如果你家庭总收入6000元，总管(通常是母的)给儿子分配了1000元的零花钱，现在由于一些"不可抗力"因素，要重新分配money,那么，传递参数realloc(1000元的地址,newsize),newsize<=1000U。
C语言的内存分配方式1.静态内存分配：静态内存分配是指在程序编译时，为变量和对象分配固定的内存空间。
这些变量和对象在程序的整个生命周期中都存在，不会被自动释放。
静态变量声明在函数体外部，它们在程序启动时自动初始化，只分配内存一次，并且在程序结束时被释放。
静态变量可以在函数内部使用static关键字进行声明。
这些变量也只分配一次内存空间，但它们具有全局可见性，在函数调用之间保持状态。
2.栈内存分配：栈内存分配是指在函数调用时，为局部变量和函数参数分配内存空间。
栈是一种后进先出（LIFO）的数据结构，用于存储临时变量，函数调用信息等。
栈内存的分配和释放都由编译器自动处理，不需要手动管理。
当函数调用结束时，栈帧被销毁，局部变量的内存空间也被释放，可以被重新使用。
3.堆内存分配：堆内存分配是指在程序运行时，动态地为变量和对象分配内存空间。
堆是一种由操作系统维护的动态数据结构，它提供了灵活的内存管理方式。
在C语言中，可以使用malloc, calloc, realloc等函数分配堆内存。
这些函数分配的内存空间在不需要时需要手动释放，以防止内存泄漏。
堆内存的分配方式灵活，可以根据程序的需要动态调整。
但是，堆内存的分配和释放需要程序员手动管理，如果管理不当，可能会导致内存泄漏或者内存溢出等问题。
总结：C语言的内存分配方式包括静态内存分配、栈内存分配和堆内存分配。
静态内存分配在程序编译时完成，分配的内存空间在整个程序的生命周期内存在。
栈内存分配在函数调用时完成，分配的内存空间在函数调用结束时被自动释放。
堆内存分配在程序运行时动态进行，分配的内存空间需要手动释放。
不同的内存分配方式有各自的特点和适用场景，程序员需要根据具体情况选择合适的内存分配方式，以实现高效的内存管理。
c中内存分配与释放（malloc，realloc，calloc，free）函数内容的整理malloc:原型：extern void *malloc(unsigned int num_bytes); 头文件：在TC2.0中可以用malloc.h 或alloc.h (注意：alloc.h 与malloc.h 的内容是完全一致的)，而在V isual C++6.0中可以用malloc.h或者stdlib.h。
功能：分配长度为num_bytes字节的内存块返回值：如果分配成功则返回指向被分配内存的指针(此存储区中的初始值不确定)，否则返回空指针NULL。
当内存不再使用时，应使用free()函数将内存块释放。
函数返回的指针一定要适当对齐，使其可以用于任何数据对象。
说明：关于该函数的原型，在旧的版本中malloc 返回的是char型指针，新的ANSIC标准规定，该函数返回为void型指针，因此必要时要进行类型转换。
名称解释：malloc的全称是memory allocation，中文叫动态内存分配。
函数声明void *malloc(size_t size); 说明：malloc 向系统申请分配指定size个字节的内存空间。
返回类型是void* 类型。
void* 表示未确定类型的指针。
C,C++规定，void* 类型可以强制转换为任何其它类型的指针。
备注：void* 表示未确定类型的指针，更明确的说是指申请内存空间时还不知道用户是用这段空间来存储什么类型的数据（比如是char还是int或者...）从函数声明上可以看出。
malloc 和new 至少有两个不同: new 返回指定类型的指针，并且可以自动计算所需要大小。
比如：int *p; p = new int; //返回类型为int* 类型(整数型指针)，分配大小为sizeof(int); 或：int* parr; parr = new int [100]; //返回类型为int* 类型(整数型指针)，分配大小为sizeof(int) * 100; 而malloc 则必须要由我们计算字节数，并且在返回后强行转换为实际类型的指针。
C语言技术中的堆结构使用技巧堆是C语言中一种重要的数据结构，它可以用来动态分配内存空间，提供了一种灵活的方式来管理程序的内存。
在本文中，我们将探讨一些堆结构的使用技巧，帮助读者更好地理解和应用C语言中的堆。
1. 动态内存分配在C语言中，我们可以使用malloc函数来动态分配内存空间。
堆结构的使用技巧之一就是正确地分配和释放内存。
在使用malloc函数时，需要注意以下几点：- 分配的内存空间应该足够存储所需的数据，避免内存溢出。
- 分配的内存空间使用完毕后，应该使用free函数释放内存，避免内存泄漏。
2. 动态数组堆结构还可以用来创建动态数组。
与静态数组不同，动态数组的大小可以在运行时确定，提供了更大的灵活性。
使用堆创建动态数组的技巧包括：- 使用malloc函数分配足够大小的内存空间来存储数组。
- 使用指针来访问数组元素，可以通过指针操作来修改或访问数组中的数据。
- 使用free函数释放动态数组的内存空间，避免内存泄漏。
3. 堆排序堆结构还可以用于排序算法中的堆排序。
堆排序是一种高效的排序算法，它利用堆的性质进行排序。
堆排序的技巧包括：- 构建一个最大堆或最小堆，将待排序的数组转化为堆结构。
- 通过不断调整堆的结构，使得堆满足最大堆或最小堆的性质。
- 依次取出堆顶元素，将其放入已排序的部分，再重新调整堆的结构。
- 重复以上步骤，直到所有元素都被取出并放入已排序的部分。
4. 堆的优先级队列堆结构还可以用来实现优先级队列。
优先级队列是一种特殊的队列，其中的元素按照优先级进行排序。
堆结构的使用技巧包括：- 使用堆来实现优先级队列，将优先级较高的元素放在堆的顶部。
- 当需要插入新元素时，根据优先级将其插入到堆中的合适位置。
- 当需要取出元素时，取出堆顶元素，然后重新调整堆的结构。
总结：堆结构在C语言技术中有着广泛的应用。
通过正确地使用动态内存分配、动态数组、堆排序和优先级队列等技巧，我们可以更好地利用堆结构来管理程序的内存和实现各种功能。
写代码的时候会碰到多维数组的内存分配和释放问题，在分配和释放过程中很容易出现错误。
下面贴上一些示例代码，以供参考。
如果要给二维数组(m*n)分配空间，代码可以写成下面：char **a, i;// 先分配m个指针单元，注意是指针单元// 所以每个单元的大小是sizeof(char *)a = (char **)malloc(m * sizeof(char *));// 再分配n个字符单元，// 上面的m个指针单元指向这n个字符单元首地址for(i = 0; i < m; i++)a[i] = (char *)malloc(n * sizeof(char));（注意红色部分）释放应该是：int i;for(i=0;i<m;i++)free((void *)a[i]);free((void *)a);如果为三维数组(m*n*p)分配空间呢，应该是：char ***a, i, j;a = (char ***)malloc(m * sizeof(char **));for(i = 0; i < m; ++i)a[i] = (char **)malloc(n * sizeof(char *));for(i = 0; i < m; ++i)for(j = 0; j < n; ++j)a[i][j] = (char *)malloc(p * sizeof(char));释放代码为逆过程，具体代码为：int i,j,;for(i = 0; i < m; ++i)for(j = 0; j < n; ++j)free((void *)a[i][j]);for(i = 0; i < m; ++i)free((void *)a[i]);free((void *)a);三维以上的多维数组的分配和释放，原理与上面的一样。
（转）C中如何为第二维长度固定的二维数组分配内存在所写的代码中，有时需要为一个二维数组分配内存，该二维数组的第一维长度不定，而第二维是固定（类似arr[n][3]的数组）。
C语言中的动态内存分配与释放在C语言中，动态内存分配和释放是一项重要的技术，它允许程序在运行时动态地分配所需的内存，并在不需要时释放该内存。
本文将介绍C语言中的动态内存分配与释放的原理、方法和注意事项。
1. 动态内存分配的原理动态内存分配是通过使用C语言中的内存管理函数来实现的。
最常用的内存管理函数是malloc()、calloc()和realloc()。
这些函数允许程序员根据需要在堆内存中分配一定大小的内存块，并返回一个指向分配内存的指针。
2. malloc()函数的使用malloc()函数用于在堆内存中分配指定大小的内存块，并返回一个指向该内存块的指针。
其函数原型为：```void* malloc(size_t size);```其中，size_t是一个无符号整数类型，表示要分配的内存块的大小（以字节为单位）。
malloc()函数返回的指针可以用于访问分配的内存块。
如果分配成功，malloc()函数将返回一个指向分配内存的指针；如果分配失败，则返回NULL。
3. calloc()函数的使用calloc()函数用于在堆内存中分配指定数量和大小的连续内存块，并返回一个指向该内存的指针。
其函数原型为：```void* calloc(size_t num, size_t size);```其中，num表示要分配的内存块的数量，size表示每个内存块的大小（以字节为单位）。
calloc()函数将分配num * size大小的内存块，并将其初始化为0。
如果分配成功，calloc()函数将返回一个指向分配内存的指针；如果分配失败，则返回NULL。
4. realloc()函数的使用realloc()函数用于更改已分配内存块的大小。
其函数原型为：```void* realloc(void* ptr, size_t size);```其中，ptr是一个指向已分配内存块的指针，size表示要调整的内存块的大小（以字节为单位）。
堆分配存储的方法
堆分配存储的方法是指在程序运行期间动态地分配和释放内存空间的方法。
常见的堆分配存储的方法有以下几种：
1. malloc和free：malloc是动态分配内存的函数，用于在堆上
分配一块指定大小的内存空间。
free函数用于释放先前malloc
分配的内存空间。
这种方法是C语言中常用的堆分配存储的
方法。
2. new和delete：new是C++中的关键字，用于在堆上分配一
块指定大小的内存空间，并调用构造函数进行初始化。
delete
关键字用于释放new分配的内存空间，并调用析构函数进行
清理工作。
这种方法是C++中常用的堆分配存储的方法。
3. calloc和realloc：calloc是一个动态分配内存的函数，用于
在堆上分配一块指定大小的内存空间，并初始化为0。
realloc
函数用于重新分配先前动态分配的内存空间的大小。
这种方法常用于C语言中。
4. new[]和delete[]：new[]是new的数组形式，用于在堆上分
配连续的一组指定大小的内存空间，并调用构造函数进行初始化。
delete[]则用于释放new[]分配的内存空间，并调用析构函
数进行清理工作。
这种方法常用于C++中对数组的堆分配存储。
注意：使用堆分配存储的方法需要手动管理内存的分配和释放，
需要确保正确地释放已使用的内存，避免内存泄漏和野指针等问题。
【c语⾔】分配内存与释放内存提⽰：现在内存区定出⼀⽚相当⼤的连续空间（如1000字节）。
然后开辟与释放都在此空间进⾏。
假设指针变量p原已指向未⽤空间的开头，调⽤alloc(n)后，开辟了n个字节可供程序适使⽤。
现在需要使 p的值变为p+n，表⽰空⽩未⽤区从p+n地址开始，同时要将开辟区的起始地址(p)作为函数值返回，以表⽰可以利⽤从此点开始的单元。
如果要开辟的区太⼤(n⼤），超过了预想的(1000)字符，则alloc(n)函数返回指针NULL，表⽰开辟失败。
#include <stdio.h>#define LEN (1000)unsigned char base[LEN];unsigned char *p=(unsigned char *)base;void *Alloc(unsigned int n){unsigned char *pp=p;if(p+sizeof(unsigned int)+n<base+LEN&&n>0){*(unsigned int*)p=n;p+=sizeof(unsigned int)+n;pp+=sizeof(unsigned int);}else{pp=NULL;}return pp;}void Free(unsigned char *ptr){if(!ptr)return;p-=sizeof(unsigned int)+*(unsigned int *)(ptr-sizeof(unsigned int));}int main(){unsigned char *a=NULL;printf("base=%p,p=%p,a=%p\n",base,p,a);a=Alloc(10);printf("base=%p,p=%p,a=%p\n",base,p,a);Free(a);printf("base=%p,p=%p,a=%p\n",base,p,a);return0;}。
多维数组在内存中的存储方式
多维数组在内存中的存储方式取决于编程语言和内存布局。
一般而言，多维数组在内存中是按照行主序（row-major order）或列主序（column-major order）存储的。
在行主序存储方式中，多维数组的元素按照行进行存储。
具体来说，它们在内存中按照连续的地址分配，首先存储第一行的所有元素，然后存储第二行的所有元素，依此类推。
在列主序存储方式中，多维数组的元素按照列进行存储。
具体来说，它们在内存中按照连续的地址分配，首先存储第一列的所有元素，然后存储第二列的所有元素，依此类推。
不同编程语言的默认存储方式可能不同。
例如，C语言中的多维数组以行主序存储，而Fortran语言中的多维数组以列主序存储。
此外，某些编程语言或库也允许开发人员显式指定存储方式。
总之，多维数组在内存中可以按照行主序或列主序存储，具体取决于编程语言和内存布局。
malloc内存管理原理malloc是C语言中用于动态分配内存的函数，它的内存管理原理是非常重要的。
本文将围绕malloc的内存管理原理展开阐述，从内存分配、内存释放、内存对齐以及内存泄漏等方面进行详细介绍。
一、内存分配在C语言中，使用malloc函数可以动态地申请一块指定大小的内存空间。
malloc函数的原型为：void *malloc(size_t size)。
其中，size_t是一个无符号整型，表示要分配的内存空间的大小。
malloc 函数会在堆中寻找一块足够大的连续内存空间，如果找到，则返回该内存块的地址；如果没有找到，则返回NULL。
二、内存释放在使用malloc函数分配内存后，当不再需要这块内存空间时，应该及时释放，以便让操作系统回收这块内存，避免内存泄漏。
释放内存的函数是free，其原型为：void free(void *ptr)。
其中，ptr 是指向要释放的内存块的指针。
调用free函数后，该内存块会被标记为空闲状态，可以供后续的malloc函数再次分配使用。
三、内存对齐内存对齐是指变量在内存中的存放位置相对于内存起始地址的偏移量必须是该变量所需对齐字节数的整数倍。
为了提高内存访问效率，避免因访问未对齐的内存而导致的性能损失，malloc函数在分配内存时会进行内存对齐。
具体对齐方式和字节数取决于操作系统和编译器的实现。
四、内存泄漏内存泄漏是指程序在动态分配内存后，没有及时释放，导致这部分内存无法再被程序所使用。
内存泄漏会导致系统的可用内存逐渐减少，最终可能导致程序崩溃。
在使用malloc函数分配内存后，应该确保在不再需要这块内存时进行释放，以免造成内存泄漏。
在实际开发中，为了避免内存泄漏的发生，可以养成良好的编程习惯，即在使用malloc函数分配内存后，及时使用free函数释放内存。
此外，还可以使用内存检测工具，如Valgrind，来检测程序中的内存泄漏问题。
malloc函数作为C语言中的内存管理函数，其内存管理原理包括内存分配、内存释放、内存对齐和内存泄漏等方面。
c语言内存分配与释放的函数C 语言内存分配与释放的函数非常重要，特别是在处理大型程序，以及对内存使用有严格要求的程序。
内存分配与释放是 C 语言中最常见的操作，因此，掌握内存分配与释放函数的使用方法对于程序员来说是非常必要的。
一、内存分配函数1. malloc 函数malloc 函数是 C 语言中最常用的内存分配函数之一，其基本语法格式如下：void *malloc(size_t size);其中，size_t 是无符号整型的数据类型，它表示需要分配的内存大小。
在内存分配成功后，malloc 函数将返回指向分配内存区域的指针；否则返回 NULL。
需要注意的是，分配出来的内存在函数执行结束后并不会被释放，必须由程序员调用 free 函数来释放内存。
2. calloc 函数calloc 函数可以用来分配一片连续的内存，而且会将其清零。
其函数原型如下：void *calloc(size_t nmemb, size_t size);其中，nmemb 表示需要分配的内存单元数量，size 表示单个单元的大小。
calloc 函数返回一个指向已分配内存区域的指针，其用法和 malloc 函数类似。
3. realloc 函数realloc 函数用于将原来已分配的内存区重新调整大小，其函数原型如下：void *realloc(void *ptr, size_t size);其中，ptr 是指向已分配内存区域的指针，size 表示重新分配后内存的大小。
realloc 函数返回一个指向已调整内存区域的指针。
二、内存释放函数1. free 函数free 函数用于释放一个之前已经分配的内存区域。
其语法格式如下：void free(void *ptr);其中，ptr 是指向要释放的内存区域的指针。
使用 free 函数需要注意的是，释放的只能是由 malloc、calloc 或 realloc 函数分配的内存，不能是栈或全局变量等。
在C语言中，内存的申请和释放需要使用动态内存分配函数和析构函数。
1. 内存申请：使用动态内存分配函数malloc()或calloc()可以申请一定大小的内存空间。
malloc()函数用于申请单块内存，而calloc()函数用于申请多块内存。
malloc()函数的语法如下：void* malloc(size_t size);其中，size表示需要申请的内存空间大小，返回值为指向申请到的内存空间的指针。
calloc()函数的语法如下：void* calloc(size_t num, size_t size);其中，num表示需要申请的内存空间数量，size表示每个内存空间的大小，返回值为指向申请到的内存空间的指针。
2. 内存释放：使用free()函数可以释放动态申请的内存空间。
free()函数的语法如下：void free(void* ptr);其中，ptr表示需要释放的内存空间指针。
在释放内存之前，需要先检查申请到的内存空间是否已经被释放，否则会导致内存泄漏。
3. 使用智能指针在C++中，可以使用智能指针来管理动态分配的内存空间。
智能指针可以自动释放内存空间，避免了内存泄漏的问题。
智能指针的语法如下：#include <memory>std::unique_ptr<T> make_unique(T* ptr);std::shared_ptr<T> make_shared(T* ptr);std::weak_ptr<T> make_weak(T* ptr);其中，T表示需要管理的对象类型。
make_unique()和make_shared()函数分别用于创建unique_ptr和shared_ptr类型的智能指针，make_weak()函数用于创建weak_ptr类型的智能指针。
使用智能指针的优点在于，可以避免手动管理内存空间的问题，同时也可以避免内存泄漏的问题。
写代码的时候会碰到多维数组的内存分配和释放问题，在分配和释放过程中很容易出现错误。
下面贴上一些示例代码，以供参考。
如果要给二维数组(m*n)分配空间，代码可以写成下面：
char **a, i;
// 先分配m个指针单元，注意是指针单元
// 所以每个单元的大小是sizeof(char *)
a = (char **)malloc(m * sizeof(char *));
// 再分配n个字符单元，
// 上面的m个指针单元指向这n个字符单元首地址
for(i = 0; i < m; i++)
a[i] = (char *)malloc(n * sizeof(char));
（注意红色部分）
释放应该是：
int i;
for(i=0;i<m;i++)
free((void *)a[i]);
free((void *)a);
如果为三维数组(m*n*p)分配空间呢，应该是：
char ***a, i, j;
a = (char ***)malloc(m * sizeof(char **));
for(i = 0; i < m; ++i)
a[i] = (char **)malloc(n * sizeof(char *));
for(i = 0; i < m; ++i)
for(j = 0; j < n; ++j)
a[i][j] = (char *)malloc(p * sizeof(char));
释放代码为逆过程，具体代码为：
int i,j,;
for(i = 0; i < m; ++i)
for(j = 0; j < n; ++j)
free((void *)a[i][j]);
for(i = 0; i < m; ++i)
free((void *)a[i]);
free((void *)a);
三维以上的多维数组的分配和释放，原理与上面的一样。
（转）
C中如何为第二维长度固定的二维数组分配内存
在所写的代码中，有时需要为一个二维数组分配内存，该二维数组的第一维长度不定，而第二维是固定（类似arr[n][3]的数组）。
我们可以想到的是用双指针代替数组，当然可以；也可以直接对n赋值后，直接定义arr[n][3]（C99标准支持），但这里要说的是另一种方法。
这里以将点云数据读入二维数组为例，由于点云点数n不定，可以确定的是，点是三维点，可以用以下方式定义并分配内存：
double (*arr)[3] = malloc (n*3*sizeof(double));
但在VC编译环境下，将会报错——无法从“void *”转换为“double (*)[3]”，此时应该在malloc 函数之前进行类型转换，应该如何转换呢？怎样转换才能成double (*)[3]类型呢，可以进行如下转换：
double (*arr)[3] = (double ((*)[3]))malloc (n*3*sizeof(double));
搞定！：）。
