什么是内存的动态分配？
我们知道全局变量是分配在内存中的静态存储区的，非静态的局部变量是分配在内存中的动态存储区的，这个存储区是一个称为栈的区域。
除此之外，C语言还允许建立内存动态分配区域，以存放一些临时用的数据，这些数据不必在程序的声明部分定义，也不必等到函数结束时才释放，而是需要时随时开辟，不需要时随时释放。这些数据是临时存放在一个特别的自由存储区，称为堆区。可以根据需要，向系统申请所需大小的空间。由于未在声明部分定义它们为变量或数组，因此不能通过变量名或数组名去引用这些数据，只能通过指针来引用。
为什么要进行动态内存分配？静态能存分配不是更方便吗？
使用静态内存分配方式创建的局部变量出了作用域后就会被销毁，而使用动态内存分配的内存，生命周期更加灵活，用的时候申请，不用的时候释放，更加灵活。
静态内存分配方式创建的局部变量是在栈上创建的，栈的大小相对于堆来说是比较小的，而动态内存分配的空间实在堆上创建的，内存的绝大部分都是堆，所以需要较大内存时，静态内存分配就不好用了。
vs2013中栈的大小仅为1M。
char arr[1024 * 1024] = {0};
申请1M大小的数组都会失败。
CentOS 7上栈的大小可以通过指令ulimit -a查看。
[sss@aliyun file]$ ulimit -a
core file size (blocks, -c) 0
data seg size (kbytes, -d) unlimited
scheduling priority (-e) 0
file size (blocks, -f) unlimited
pending signals (-i) 7270
max locked memory (kbytes, -l) 64
max memory size (kbytes, -m) unlimited
open files (-n) 65535
pipe size (512 bytes, -p) 8
POSIX message queues (bytes, -q) 819200
real-time priority (-r) 0
stack size (kbytes, -s) 8192
cpu time (seconds, -t) unlimited
max user processes (-u) 4096
virtual memory (kbytes, -v) unlimited
file locks (-x) unlimited
可以看到stack size的大小为8192KB。
虽然栈的大小可以调整，但是也不能太大，机器的绝大部分内存都是给堆用的。
如何进行动态内存分配?
接口介绍
void* malloc (size_t size);
参数：
size：申请空间的大小，单位字节。
返回值：申请成功，返回申请到空间的首地址；申请失败，返回NULL。
注意：size为0，行为取决于编译器。
void free (void* ptr);
参数：
ptr：动态开辟空间的首地址。
注意：如果ptr指向的空间不是动态开辟的，未定义行为。
如果ptr为NULL，函数什么也不做。
void* calloc (size_t num, size_t size);
参数：
num：元素的数量。
size：元素的大小。
返回值：申请成功，返回申请到空间的首地址；失败，返回NULL。
注意：与malloc的区别是，calloc会将申请到的空间每个字节都初始化为0。
void* realloc(void* ptr, size_t size);
参数：
ptr：要调整的内存地址。
size：调整之后的新大小。
返回值：调整之后的内存起始位置。
注意：realloc调整空间有两种情况。
当原空间后有足够的空间，则直接追加，原有数据不变。
当源空间后没有足够空间，则在堆上另找一个空间来使用，将原空间的内容拷贝过来。
代码演示
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
static int randomNumber(){
return 1 + rand() % (99 - 1 + 1);
}
static void arrInit(int* arr, int len){
if(!arr){
return;
}
int i = 0;
for(; i < len; ++i){
arr[i] = randomNumber();
}
}
static void arrDisplay(int* arr, int len){
if(!arr){
return;
}
int i = 0;
for(; i < len; ++i){
printf("%d ", arr[i]);
}
printf("\n");
}
int main(){
srand((unsigned int)time(0));
int len, *arr;
printf("Please input the length of the array: \n");
scanf("%d", &len);
arr = (int*)malloc(sizeof(int) * len);
if(!arr){
printf("malloc failed!\n");
exit(1);
}
arrInit(arr, len);
printf("The array is: \n");
arrDisplay(arr, len);
free(arr);
arr = NULL;
return 0;
}
运行结果
[sss@aliyun file]$ !gcc
gcc dynamic_array.c -o dynamic_array
[sss@aliyun file]$ ./dynamic_array
Please input the length of the array:
5
The array is:
15 15 79 78 44
[sss@aliyun file]$ ./dynamic_array
Please input the length of the array:
10
The array is:
40 21 95 26 80 75 7 21 41 44
[sss@aliyun file]$ ./dynamic_array
Please input the length of the array:
15
The array is:
2 61 85 50 62 51 59 51 8 88 17 37 35 7 24
[sss@aliyun file]$ ./dynamic_array
Please input the length of the array:
20
The array is:
78 65 49 54 37 74 39 45 78 78 29 72 21 4 25 91 18 91 60 95
几种常见的动态内存错误
对NULL指针的解引用操作
void test()
{
int* p = (int*)malloc(4);
*p = 20;
free(p);
}
注意：未对返回值进行判空，内存申请失败会返回NULL指针。
对动态开辟空间的越界访问
void test()
{
int* p = (int*)malloc(sizeof(int) * 4);
assert(p != NULL);
for(int i = 0; i <= 4; ++i)
{
p[i] = i;
}
}
注意：典型的越界访问。
对非动态开辟的内存使用free释放
void test()
{
int a = 10;
int* p = &a;
free(p);
}
注意：free只能释放malloc系列函数申请的动态内存，二者要配合使用。
使用free释放动态内存的一部分
void test()
{
int* p = (int*)malloc(100);
++p;
free(p);
}
注意：未定义行为。
同一块动态内存多次释放
void test()
{
int* p = (int*)malloc(100);
free(p);
free(p);
}
注意：p被free释放后，p不再指向动态内存空间，再次释放属于未定义行为。
动态内存开辟，忘记释放
void test()
{
int* p = (int*)malloc(100);
assert(p != NULL);
*p = 20;
}
int main()
{
test();
while(1);
system("pause");
return 0;
}
注意：内存泄漏。
建议
动态申请内存后，对返回值进行判空操作。
动态内存释放后，将相应指针置空(指向NULL)。
几个简单例题
题目一
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void getMemory(char* p){
p = (char*)malloc(100);
}
void test(){
char* str = NULL;
getMemory(str);
strcpy(str, "hello, world!");
printf("str: %s\n", str);
}
int main(){
test();
return 0;
}
运行结果
[sss@aliyun dynamic_alloc]$ !gcc
gcc q1.c -o q1
[sss@aliyun dynamic_alloc]$ ./q1
Segmentation fault
解析：段错误，形参的改变无法影响到实参。str仍旧是NULL。对NULL解引用，段错误。
题目二
#include <stdio.h>
char* getMemory(){
char p[] = "hello, world!";
return p;
}
void test(){
char* str = NULL;
str = getMemory();
printf("str: %s\n", str);
}
int main(){
test();
return 0;
}
运行结果
[sss@aliyun dynamic_alloc]$ !gcc
gcc q2.c -o q2
q2.c: In function ‘getMemory’:
q2.c:7:2: warning: function returns address of local variable [-Wreturn-local-addr]
return p;
^
[sss@aliyun dynamic_alloc]$ ./q2
str:
解析：局部变量出了作用域就被释放。虽然str得到了p的地址，但p指向的内容已经被释放。
题目三
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void getMemory(char** p, int num){
*p = (char*)malloc(num);
}
void test(){
char* str = NULL;
getMemory(&str, 100);
strcpy(str, "hello, world!");
printf("str: %s\n", str);
}
int main(){
test();
return 0;
}
运行结果
[sss@aliyun dynamic_alloc]$ !gcc
gcc q3.c -o q3
[sss@aliyun dynamic_alloc]$ ./q3
str: hello, world!
解析：程序是对的，但是漏了free();
题目四
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void test(){
char* str = (char*)malloc(100);
strcpy(str, "hello");
free(str);
if(str != NULL){
strcpy(str, "world");
printf("str: %s\n", str);
}
}
int main(){
test();
return 0;
}
运行结果
[sss@aliyun dynamic_alloc]$ gcc q4.c -o q4
[sss@aliyun dynamic_alloc]$ ./q4
str: world
解析：申请空间后没有判空，对野指针进行了操作。
野指针产生原因
野指针指向一个已删除的对象或未申请访问受限内存区域的指针。
指针变量未初始化
任何指针变量刚被创建时不会自动成为NULL指针（static修饰的指针除外），它的缺省值是随机的，它会乱指。所以，指针变量在创建的同时应当被初始化，要么将指针设置为NULL，要么让它指向合法的内存。如果没有初始化，编译器会报错“ ‘point’ may be uninitializedin the function ”。
指针释放之后未置NULL
有时指针在free或delete后未赋值NULL，便会使人以为是合法的。别看free和delete的名字，它们只是把指针所指的内存给释放掉，但并没有把指针本身删除掉。此时指针指向的就是垃圾内存。释放后的指针应立即置NULL，防止产生野指针。
C程序内存开辟
C程序内存区域划分
C程序内存分配的几个区域
栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量是有限的。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
堆区（heap）：一般由程序猿分配释放，若程序猿不释放，程序结束时可能有OS回收。分配方式类似于链表。
数据段（静态区）（static）：存放全局变量、静态数据。程序结束后由系统释放。
代码段：存放函数体（类成员和全局函数）的二进制代码。
注意：普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁，所以声明周期更长。
柔性数组
也许你没有听说过**柔性数组（flexible array）**这个概念，但是它缺失是存在的。C99中，结构体中最后一个元素允许是未知大小的数组，这就叫做柔性数组成员。
语法：
typedef struct st_type{
int i;
int a[0]; // 柔性数组成员。
} st_type;
这种写法编译器可能不认识，可以改成如下写法：
typedef struct st_type{
int i;
int a[]; // 柔性数组成员。
} st_type;
柔性数组的特点
结构中的柔性数组成员前面必须至少有一个其他成员。
sizeof返回的这种结构大小不包括柔性数组的内存。
包含柔性数组成员的结构用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
typedef struct st_type{
int i;
int a[];
} st_type;
sizeof(st_type)：4。
柔性数组的使用
/*** 代码一 ***/
int i = 0;
st_type* p = (st_type*)malloc(sizeof(st_type) + 100 * sizeof(int));
p->i = 100;
for(; i < 100; ++i){
p->a[i] = i;
}
free(p);
这样，柔性数组成员a，相当于获得了100个整型元素的连续空间。
柔性数组的优势
前面的st_type结构体也可以设计为：
/*** 代码二 ***/
typedef struct st_type{
int i;
int* p_a;
} st_type;
st_type* p = (st_type*)malloc(sizeof(type_a));
p->i = 100;
p->p_a = (int*)malloc(p->i * sizeof(int));
int i = 0;
for(; i < 100; ++i){
p->p_a[i] = i;
}
free(p->p_a);
p->p_a = NULL;
free(p);
p = NULL;
代码一和代码二可以完成同样的功能，但是代码一有两个好处：
方便内存释放。如果我们的代码是在一个给别人用的函数中，你在里面做了两次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
有利于访问速度。
连续的内存有益于提高访问速度，也有益于减少内存碎片。
351
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
