简介
C 语言的内存管理，分成两部分。一部分是系统管理的，另一部分是用户手动管理的。
系统管理的内存，主要是函数内部的变量（局部变量）。这部分变量在函数运行时进入内存，函数运行结束后自动从内存卸载。这些变量存放的区域称为”栈“（stack），
”栈“所在的内存是系统自动管理的。
用户手动管理的内存，主要是程序运行的整个过程中都存在的变量（全局变量），这些变量需要用户手动从内存释放。如果使用后忘记释放，它就一直占用内存，直到程序退出，这种情况称为”内存泄漏“（memory leak）。这些变量所在的内存称为”堆“（heap），
”堆“所在的内存是用户手动管理的
。
void 指针
前面章节已经说过了，**每一块内存都有地址，通过指针变量可以获取指定地址的内存块。**指针变量必须有类型，否则编译器无法知道，如何解读内存块保存的二进制数据。
但是，向系统请求内存的时候，有时不确定会有什么样的数据写入内存，需要先获得内存块，稍后再确定写入的数据类型。
为了满足这种需求，
C 语言提供了一种不定类型的指针，叫做 void 指针
。它只有内存块的地址信息，没有类型信息，等到使用该块内存的时候，再向编译器补充说明，里面的数据类型是什么。
另一方面，**void 指针等同于无类型指针，可以指向任意类型的数据，但是不能解读数据。**void 指针与其他所有类型指针之间是互相转换关系，任一类型的指针都可以转为 void 指针，而 void 指针也可以转为任一类型的指针。
int x = 10;
void* p = &x; // 整数指针转为 void 指针
int* q = p; // void 指针转为整数指针
上面示例中，整数指针和 void 指针可以互相转换。
注意，由于不知道 void 指针指向什么类型的值，所以不能用
*
运算符取出它指向的值。
char a = 'X';
void* p = &a;
printf("%c\n", *p); // 报错
上面示例中，
p
是一个 void 指针，所以这时无法用
*p
取出指针指向的值。
void 指针的重要之处在于，很多内存相关函数的返回值就是 void 指针，只给出内存块的地址信息，所以放在最前面进行介绍。
malloc()
malloc()
函数用于分配内存，该函数向系统要求一段内存，系统就在“堆”里面分配一段连续的内存块给它。它的原型定义在头文件
stdlib.h
。
void* malloc(size_t size)
它接受一个非负整数作为参数，表示所要分配的内存字节数，返回一个 void 指针，指向分配好的内存块。这是非常合理的，因为
malloc()
函数不知道，将要存储在该块内存的数据是什么类型，所以只能返回一个无类型的 void 指针。
可以使用
malloc()
为任意类型的数据分配内存，常见的做法是先使用
sizeof()
函数，算出某种数据类型所需的字节长度，然后再将这个长度传给
malloc()
。
int* p = malloc(sizeof(int));
*p = 12;
printf("%d\n", *p); // 12
上面示例中，先为整数类型分配一段内存，然后将整数
12
放入这段内存里面。这个例子其实不需要使用
malloc()
，因为 C 语言会自动为整数（本例是
12
）提供内存。
有时候为了增加代码的可读性，可以对
malloc()
返回的指针进行一次强制类型转换。
int* p = (int*) malloc(sizeof(int));
上面代码将
malloc()
返回的 void 指针，强制转换成了整数指针。
由于
sizeof()
的参数可以是变量，所以上面的例子也可以写成下面这样。
int* p = (int*) malloc(sizeof(*p));
malloc()
分配内存有可能分配失败，这时返回常量 NULL。Null 的值为0，是一个无法读写的内存地址，可以理解成一个不指向任何地方的指针。它在包括
stdlib.h
等多个头文件里面都有定义，所以只要可以使用
malloc()
，就可以使用
NULL
。由于存在分配失败的可能，所以最好在使用
malloc()
之后检查一下，是否分配成功。
int* p = malloc(sizeof(int));
if (p == NULL) {
// 内存分配失败
// or
if (!p) {
//...
}
上面示例中，通过判断返回的指针
p
是否为
NULL
，确定
malloc()
是否分配成功。
malloc()
最常用的场合，就是为数组和自定义数据结构分配内存。
int* p = (int*) malloc(sizeof(int) * 10);
for (int i = 0; i < 10; i++)
p[i] = i * 5;
上面示例中，
p
是一个整数指针，指向一段可以放置10个整数的内存，所以可以用作数组。
malloc()
用来创建数组，有一个好处，就是它可以创建动态数组，即根据成员数量的不同，而创建长度不同的数组。
int* p = (int*) malloc(n * sizeof(int));
上面示例中，
malloc()
可以根据变量
n
的不同，动态为数组分配不同的大小。
注意，
malloc()
不会对所分配的内存进行初始化，里面还保存着原来的值。如果没有初始化，就使用这段内存，可能从里面读到以前的值。程序员要自己负责初始化，比如，字符串初始化可以使用
strcpy()
函数。
char* p = malloc(4);
strcpy(p, "abc");
// or
*p = "abc";
上面示例中，字符指针
p
指向一段4个字节的内存，
strcpy()
将字符串“abc”拷贝放入这段内存，完成了这段内存的初始化。
free()
free()
用于释放
malloc()
函数分配的内存，将这块内存还给系统以便重新使用，否则这个内存块会一直占用到程序运行结束。该函数的原型定义在头文件
stdlib.h
里面。
上面代码中，
free()
的参数是
malloc()
返回的内存地址。下面就是用法实例。
int* p = (int*) malloc(sizeof(int));
*p = 12;
free(p);
注意，分配的内存块一旦释放，就不应该再次操作已经释放的地址，也不应该再次使用
free()
对该地址释放第二次。
一个很常见的错误是，在函数内部分配了内存，但是函数调用结束时，没有使用
free()
释放内存。
void gobble(double arr[], int n) {
double* temp = (double*) malloc(n * sizeof(double));
// ...
}
上面示例中，函数
gobble()
内部分配了内存，但是没有写
free(temp)
。这会造成函数运行结束后，占用的内存块依然保留，如果多次调用
gobble()
，就会留下多个内存块。并且，由于指针
temp
已经消失了，也无法访问这些内存块，再次使用。
calloc()
calloc()
函数的作用与
malloc()
相似，也是分配内存块。该函数的原型定义在头文件
stdlib.h
。
两者的区别主要有两点：
（1）
calloc()
接受两个参数，第一个参数是数据类型的单位字节长度，第二个是该数据类型的数量。
void* calloc(size_t n, size_t size);
calloc()
的返回值也是一个 void 指针。分配失败时，返回 NULL。
（2）
calloc()
会将所分配的内存全部初始化为
0
。
malloc()
不会对内存进行初始化，如果想要初始化为
0
，还要额外调用
memset()
函数。
int *p = calloc(10, sizeof(int));
// 等同于
int *q = malloc(sizeof(int) * 10);
memset(q, 0, sizeof(int) * 10);
上面示例中，
calloc()
相当于
malloc() + memset()
。
calloc()
分配的内存块，也要使用
free()
释放。
realloc()
realloc()
函数用于修改已经分配的内存块的大小，可以放大也可以缩小，返回一个指向新的内存块的指针。如果分配不成功，返回 NULL。该函数的原型定义在头文件
stdlib.h
。
void* realloc(void* block, size_t size)
它接受两个参数。
-
block
：已经分配好的内存块指针（由
malloc()
或
calloc()
或
realloc()
产生）。
-
size
：该内存块的新大小，单位为字节。
realloc()
可能返回一个全新的地址（数据也会自动复制过去），也可能返回跟原来一样的地址。
realloc()
优先在原有内存块上进行缩减，尽量不移动数据，所以通常是返回原先的地址。如果新内存块小于原来的大小，则丢弃超出的部分；如果大于原来的大小，则不对新增的部分进行初始化（程序员可以自动调用
memset()
）。
下面是一个例子，
b
是数组指针，
realloc()
动态调整它的大小。
int* b;
b = malloc(sizeof(int) * 10);
b = realloc(b, sizeof(int) * 2000);
上面示例中，指针
b
原来指向10个成员的整数数组，使用
realloc()
调整为2000个成员的数组。这就是手动分配数组内存的好处，可以在运行时随时调整数组的长度。
realloc()
的第一个参数可以是 NULL，这时就相当于新建一个指针。
char* p = realloc(NULL, 3490);
// 等同于
char* p = malloc(3490);
如果
realloc()
的第二个参数是
0
，就会释放掉内存块。
由于有分配失败的可能，所以调用
realloc()
以后，最好检查一下它的返回值是否为 NULL。分配失败时，原有内存块中的数据不会发生改变。
float* new_p = realloc(p, sizeof(*p * 40));
if (new_p == NULL) {
printf("Error reallocing\n");
return 1;
}
注意，
realloc()
不会对内存块进行初始化。
restrict 说明符
声明指针变量时，可以使用
restrict
说明符，告诉编译器，该块内存区域只有当前指针一种访问方式，其他指针不能读写该块内存。这种指针称为“受限指针”（restrict pointer）。
int* restrict p;
p = malloc(sizeof(int));
上面示例中，声明指针变量
p
时，加入了
restrict
说明符，使得
p
变成了受限指针。后面，当
p
指向
malloc()
函数返回的一块内存区域，就味着，该区域只有通过
p
来访问，不存在其他访问方式。
int* restrict p;
p = malloc(sizeof(int));
int* q = p;
*q = 0; // 未定义行为
上面示例中，另一个指针
q
与受限指针
p
指向同一块内存，现在该内存有
p
和
q
两种访问方式。这就违反了对编译器的承诺，后面通过
*q
对该内存区域赋值，会导致未定义行为。
memcpy()
memcpy()
用于将一块内存拷贝到另一块内存。该函数的原型定义在头文件
string.h
。
void* memcpy(
void* restrict dest,
void* restrict source,
size_t n
);
上面代码中，
dest
是目标地址，
source
是源地址，第三个参数
n
是要拷贝的字节数
n
。如果要拷贝10个 double 类型的数组成员，
n
就等于
10 * sizeof(double)
，而不是
10
。该函数会将从
source
开始的
n
个字节，拷贝到
dest
。
dest
和
source
都是 void 指针，表示这里不限制指针类型，各种类型的内存数据都可以拷贝。两者都有 restrict 关键字，表示这两个内存块不应该有互相重叠的区域。
memcpy()
的返回值是第一个参数，即目标地址的指针。
因为
memcpy()
只是将一段内存的值，复制到另一段内存，所以不需要知道内存里面的数据是什么类型。下面是复制字符串的例子。
#include <stdio.h>
#include <string.h>
int main(void) {
char s[] = "Goats!";
char t[100];
memcpy(t, s, sizeof(s)); // 拷贝7个字节，包括终止符
printf("%s\n", t); // "Goats!"
return 0;
}
上面示例中，字符串
s
所在的内存，被拷贝到字符数组
t
所在的内存。
memcpy()
可以取代
strcpy()
进行字符串拷贝，而且是更好的方法，不仅更安全，速度也更快，它不检查字符串尾部的
\0
字符。
char* s = "hello world";
size_t len = strlen(s) + 1;
char *c = malloc(len);
if (c) {
// strcpy() 的写法
strcpy(c, s);
// memcpy() 的写法
memcpy(c, s, len);
}
上面示例中，两种写法的效果完全一样，但是
memcpy()
的写法要好于
strcpy()
。
使用 void 指针，也可以自定义一个复制内存的函数。
void* my_memcpy(void* dest, void* src, int byte_count) {
char* s = src;
char* d = dest;
while (byte_count--) {
*d++ = *s++;
return dest;
}
上面示例中，不管传入的
dest
和
src
是什么类型的指针，将它们重新定义成一字节的 Char 指针，这样就可以逐字节进行复制。
*d++ = *s++
语句相当于先执行
*d = *s
（源字节的值复制给目标字节），然后各自移动到下一个字节。最后，返回复制后的
dest
指针，便于后续使用。
memmove()
memmove()
函数用于将一段内存数据复制到另一段内存。它跟
memcpy()
的主要区别是，它允许目标区域与源区域有重叠。如果发生重叠，源区域的内容会被更改；如果没有重叠，它与
memcpy()
行为相同。
该函数的原型定义在头文件
string.h
。
void* memmove(
void* dest,
void* source,
size_t n
);
上面代码中，
dest
是目标地址，
source
是源地址，
n
是要移动的字节数。
dest
和
source
都是 void 指针，表示可以移动任何类型的内存数据，两个内存区域可以有重叠。
memmove()
返回值是第一个参数，即目标地址的指针。
int a[100];
// ...
memmove(&a[0], &a[1], 99 * sizeof(int));
上面示例中，从数组成员
a[1]
开始的99个成员，都向前移动一个位置。
下面是另一个例子。
char x[] = "Home Sweet Home";
// 输出 Sweet Home Home
printf("%s\n", (char *) memmove(x, &x[5], 10));
上面示例中，从字符串
x
的5号位置开始的10个字节，就是“Sweet Home”，
memmove()
将其前移到0号位置，所以
x
就变成了“Sweet Home Home”。
memcmp()
memcmp()
函数用来比较两个内存区域。它的原型定义在
string.h
。
int memcmp(
const void* s1,
const void* s2,
size_t n
);
它接受三个参数，前两个参数是用来比较的指针，第三个参数指定比较的字节数。
它的返回值是一个整数。两块内存区域的每个字节以字符形式解读，按照字典顺序进行比较，如果两者相同，返回
0
；如果
s1
大于
s2
，返回大于0的整数；如果
s1
小于
s2
，返回小于0的整数。
char* s1 = "abc";
char* s2 = "acd";
int r = memcmp(s1, s2, 3); // 小于 0
上面示例比较
s1
和
s2
的前三个字节，由于
s1
小于
s2
，所以
r
是一个小于0的整数，一般为-1。
下面是另一个例子。
char s1[] = {'b', 'i', 'g', '\0', 'c', 'a', 'r'};
char s2[] = {'b', 'i', 'g', '\0', 'c', 'a', 't'};
if (memcmp(s1, s2, 3) == 0) // true
if (memcmp(s1, s2, 4) == 0) // true
if (memcmp(s1, s2, 7) == 0) // false
上面示例展示了，
memcmp()
可以比较内部带有字符串终止符
\0
的内存区域。
作者：阮一峰
最后分享给大家有幸从阿里前技术总监那里得到他本人吐血整理的“582页Android NDK七大模块学习宝典”，从原理到实战，一应俱全！
秉承好东西的当然要共享的原则，今天就来秀一把，试试这“582页Android NDK七大模块学习宝典”是否也能让你事半功倍！这份宝典主要涉及以下几个方面：
-
NDK 模块开发
-
JNI 模块
-
Native 开发工具
-
Linux 编程
-
底层图片处理
-
音视频开发
-
机器学习
一、NDK 模块开发
主要内容：
-
C++与 C#数据类型总结
-
C 与 C++之内存结构与管理
-
C 与 C++之预处理命令与用 typedef 命名已有类型
-
C 与 C++之结构体、共用体
-
C 与 C++之指针
-
C/C++ 之多线程机制
-
C/C++ 之函数与初始化列表
二、JNI 模块
主要内容：
静态注册、动态注册、JNINativeMethod、数据类型映射、jni 函数默认参数
Android NDK 开发 JNI 类型签名和方法签名、JNI 实现 java 与 c/c++相互通讯
三、Native 开发工具
主要内容：
十大最受欢迎的 React Native 应用开发编辑器、react-native 打包流程
ABI 管理、处理 CPU 功能、NEON 支持
环境搭建、NDK 项目、Cmake、Makefile
FFmpeg 编译、FFmpeg+LIBX264+FACC 交叉编译 实现 264 流录制、移植 FFmpeg 在 arm 交叉编译时遇到的问题、FFmpeg 交叉编译、X264 FAAC 交叉编译、解决所有移植问题
配置 NDK 环境、建立 app 项目、生成.h 头文件、创建 C 文件,实现 native 方法、jni.h 文件
四、Linux 编程
-
Linux 环境搭建，系统管理，权限系统和工具使用（vim 等）
Linux 环境的搭建、Linux 系统管理操作(25 个命令)
Shell 脚本、编写简单 Shell 脚本、流程控制语句、计划任务服务程序
五、底层图片处理
四种图片格式、推荐几种图片处理网站、squoosh 在线无损图片压缩工具，JPG/webP/PNG/ 互转
计算原始宽高、计算近似宽高、第一次采样获取目标图片、循环逼近目标大小
GIF 图片的解析、GIF 图片的合成（序列图像合成 GIF 图像）
六、音视频开发
Camera 与手机屏幕采集、图像原始数据格式 YUV420(NV21 与 YV12 等)、音频采集与播放系统、编解码器 MediaCodec、MediaMuxer 复用与 MediaExtractor
ffmpeg 模块介绍、音视频解码,音视频同步、I 帧,B 帧,P 帧解码原理、x264 视频编码与 faac 音频编码、OpenGL 绘制与 NativeWindow 绘制
RTMP 协议、、音视频通话 P2P WebRtc
高斯模糊、高反差保留、强光处理、融合
流程列表、视频拍摄、视频编辑、视频导出
变速入口分析、音频变速实现、视频变速实现
七、机器学习
灰度化和二值化、腐蚀与膨胀、人脸检测、身份证识别
最后
由于篇幅限制，文档的详解资料太全面，细节内容太多，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！
除了上面的之外我还自己整理了以下一系列的学习进阶资料：
《Android开发七大模块核心知识笔记》
《1599页Android大厂面试宝典》
