一、作用域

一个C语言变量的作用域可以是代码块作用域、函数作用域、或者文件作用域；代码块是{}直接的一段代码，出现{}之外的变量就是全局变量， 同一个作用域不能出现重名的变量，但是不同作用域是可以的。

#include<stdio.h>int a = 2;//文件作用域int main()
{int a = 0;//函数作用域{int a = 1;//代码块作用域}printf("%d\n",a); //优先访问当前作用域的变量,也就是a=0return 0;
}

当函数作用域的变量名和文件作用域的变量名一样时，函数作用域的变量优先被当前函数访问。

1.1 作用域和生命周期

类型	作用域	生命周期
auto变量	一对{}内	当前函数内
static局部变量	一对{}内	整个程序运行期间
extern变量	整个程序内	整个程序运行期间
static全局变量	当前文件内	整个程序运行期间
extern函数	整个程序内	整个程序运行期间
static函数	当前文件内	整个程序运行期间
register变量	一对{}内	当前函数内

auto自动变量
一般情况下代码块内部定义的变量都是自动变量，当然也可以显示的使用auto关键字。auto变量是自动在内存中出现和消失的，不需要我们管理内存。 文件作用域的变量就不是auto变量了，静态变量也不是auto变量。

register寄存器变量
通常变量在内存当中，如果能把变量放到CPU的寄存器里面，代码的执行效率会更高，例如：register int I;

静态变量
静态变量分为局部静态变量和全局静态变量，静态变量的内存位置在程序执行期间一直不改变的变量。C语言的静态变量是可以定义在代码块和函数内的，这点和java是不同的，java的static只能出现在类的成员位置上。静态变量在程序刚加载到内存的时候就出现了，所以和定义静态变量所在的{}无关，一直到程序结束的时候才会从内存中消失，同时静态变量只会初始化一次。

局部静态变量只能被这个代码块内部访问，而全局静态变量只能被当前文件任意位置访问。

局部静态变量
局部静态变量是指定义在代码块的作用域内的静态变量。

#include<stdio.h>void test()
{static int a = 0; //静态变量只会初始化一次,和{}无关 ,它只能被test函数使用,其他函数无法使用.a++;printf("a=%d\n",a);
}int main()
{int i;for(i = 0;i<10;i++){test(); //调用上面的test方法}//printf("main call a=%d\n",a);无法访问代码块内的静态变量,编译直接报错return 0;
}

结果如下:

a=1
a=2
a=3
a=4
a=5
a=6
a=7
a=8
a=9
a=10

可以看到a的值是会一直累加的且初始化一次后不会重新初始化,它的生命周期是随程序的。

全局静态变量
代码块作用域外的静态变量叫静态全局变量，它在程序执行期间一直存在，但只能被定义这个变量的文件访问，其他文件无法使用extern关键字访问。

#include<stdio.h>static int a = 0;void test()
{a++;
}int main()
{test();printf("a=%d\n",a);// a=1 //静态全局变量可以被当前文件任意位置访问,和全局变量一样,但是全局变量还可以被其他文件访问,作用范围最大a++; printf("a=%d\n",a);// a=2return 0;}

全局变量
在文件作用域定义的变量叫做全局变量(文件变量)， 全局变量的存储方式和静态变量相同，但可以被多个文件通过extern关键字访问。

外部变量与extern关键字
外部变量是指定义在非当前文件中的全局变量，也就是说定义在其他的C文件中的变量(也叫全局变量)， 如果要使用其他C文件中定义的全局变量，则需要在当前文件中使用extern关键字声明一下。

extern int i  //声明一个外部变量

同时使用gcc编译的时候，需要将外部变量所在的c文件一起编译，例如:

gcc -o a men2.c  mem3.c

同样的，如果要使用其他c文件定义的函数，也可以使用extern关键字在当前文件中显示声明一下。

全局函数和静态函数
在C语言中函数默认都是全局的，在所有的C文件中都可以通过extern关键字访问，而静态函数是使用关键字static可定义的函数，和静态全局变量一样只能被它定义的文件访问，其他文件都无法访问。

二、内存区域划分

C语言在内存中一共分为如下几个区域，分别是：

1. 代码区：代码区code，程序被操作系统加载到内存的时候，所有的可执行代码都加载到代码区，这块内存是不可以在运行期间修改的，它是只读的。
2. 常量区(全局区)：存放常量(程序在运行的期间不能够被改变的量，例如: 10，字符串常量”abcde”， 数组的名字等)。
3. 静态区(全局区)：所有的全局变量/常量、静态变量/常量都存储到这个静态区，程序运行期间一直有效。
4. 栈区(stack)：每个线程都有自己专属的栈(stack)，栈是一种先进后出的内存结构，所有的自动变量、函数的形参、函数的返回值，都是由编译器自动放入栈中，当一个自动变量超出其作用域时，自动从栈中弹出。对于自动变量什么时候入栈是不需要程序控制的，由C语言编译器实现；栈不会很大，一般都是以K位单位，当栈空间满了但是还往栈内存中压变量，就会出现栈溢出错误。
   C语言函数的参数入栈顺序是从由到左的, 而出栈就是从左到由的.
5. 堆区(heap)：一个进程就一个堆，它是被所有线程共享的，堆(heap)和栈一样也是一种在程序运行过程中可以随时修改的内存区域，但是没有栈那样先进后出的顺序， 堆是一个大容器，它的容量要远远大于栈，在C语言中堆内存的申请和释放需要手动通过代码来完成。

三、堆内存的分配和释放

操作系统在管理内存时，最小单位是内存页,而不是字节，什么意思呢?
意思就是说假如你在程序中申请了1k(1024字节)的内存大小，操作系统可能会返回4k的大小，这种做的好处是效率提高了，避免频繁的分配内存，但是缺点就是浪费了一些内存。

3.1 malloc分配堆内存

void * malloc(size_t _Size);

这个函数在堆中分配参数_Size指定大小的内存，单位是字节，函数返回值void*指针，表示任意类型的指针。使用时需要导入stdlib.h头文件。

3.2 free释放堆内存

void free(void *p);

free负责释放malloc分配的堆内存，参数p为malloc返回的堆内存地址，通常和malloc配套使用。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>int main()
{//定义一个栈变量指向堆内存地址,堆内存大小10个字节char *s = malloc(10);//拷贝abcd字符串到s变量分配的内存中strcpy(s,"abcd");printf("%s\n",s);//释放堆内存中的内存,注意并不是把s变量释放了,而是释放了s指向的那块堆内存,//s变量是在栈内的,他是自动变量,不需要我们维护.free(s);//int a[1000000000000];//在栈中定义一个数组,由于栈内存空间有限,不适合定义大数据,会栈溢出//大数据适合在堆内存中创建int *p = malloc(10000000000000*sizeof(int));free(p);return 0;
}

3.3 思考:解决函数返回值是指针的问题

当函数的返回值是指针类型时, 如果函数内返回的地址是一个自变量的地址，那么编译是会报警告的，这个问题是因为函数内定义的自变量出了作用域就会消失，因为它存在栈内存中，由系统自动管理。
如下代码就是一个错误的示范

#include<stdio.h>int *test1()
{	int a = 10; //函数内定义的变量,出了作用域就会消失,因为它存在栈内存中,由系统自动管理return &a;
}int main()
{int *p = test1(); //编译时会警告,因为p指向的内存是在栈中分配给a变量的,test1函数执行完就释放了a,a不存在了.printf("%d\n",*p);return 0;
}

编译器会自动检测并报错提示

解决方案有2种:

方案一: 返回一个在堆内存分配的地址指针变量

在函数内使用malloc分配堆内存给栈的指针变量，这样当栈变量离开函数作用域被回收后，但是分配的堆内存空间还是有效的，里面存放的值也是可以访问的，在调用这个函数的时候拿到堆的内存地址就可以操作这块区域的数据，但是操作完后记得调用free来释放堆内存。

#include <stdio.h>
#include <stdlib.h>int *test2()
{// 任何变量类型包括数组如果要在函数外使用,都必须使用堆内存分配int *p = malloc(1 * sizeof(int));*p = 10;return p;
}int main()
{// 这样p变量指向的内存是在堆中分配的. 所以不会被自动回收.int *p = test2(); printf("%d\n", *p); // 10// 记得释放free(p);return 0;
}

方案二: 在函数调用处定义自变量

不要在函数内创建变量，而是在调用处创建变量，然后传递地址到目标函数处理，处理完成返回的地址其实和创建时指向的是一样的，都是在栈内存中。由于变量定义是在函数调用处定义的，只要调用处的作用域没有结束，就可以继续访问。

#include<stdio.h>int * test(int *a)
{*a = 10;return a;
}int main()
{int a; //在调用处定义变量int * p = test(&a);  //调用上面的方法,返回指针变量p , 此时指针变量p所指向的地址是存在栈内存中的. 因此不需要手动释放内存printf("%d,%d\n",a,*p);return 0;
}

注意:free函数释放的字节数是根据malloc申请的大小来释放的, 也就是说从指针变量当前位置往后多少个字节就释放多少, 因此特别需要注意指针变量++操作后, 会影响free的结果, 程序运行会异常, 因此free前需要做相应的–操作。

3.4 思考:局部静态变量和常量所指向的地址的值出了作用域还能访问吗?

可以，因为静态变量和常量都是在程序运行期间有效的,且不需要手动释放内存。

#include <stdio.h>char *test()
{static char a[100] = "hello"; //静态变量的地址是运行期有效的char *p = a;                  //定义一个指针变量指向a的地址p++;                          // 指针++后指向的就是e的位置了return p;
}const char *test1()
{// 定义了一个字符串常量, 由于常量是只读的,所以返回值类型最好加上constconst char *s = "hello1";return s;
}const char *test2()
{return "hello2"; //直接返回字符串常量, 效果和test1函数一样.
}int main()
{char *str = test();printf("%s\n", str); //可以正确输出ello ,因为str指向的地址是静态变量的地址,不会受函数作用域影响const char *str1 = test1();const char *str2 = test2();printf("str1=%s,str2=%s\n", str1, str2); //可以正确输出hello1和hello2,因为常量的地址也是不会变的//printf("%s\n",s); 虽然地址不会变,但是s还是栈的变量,只是指向了常量的地址而已. 所以出了函数体后,s变量就访问不了了.return 0;
}

3.5 案例:使用堆内存解决strcat追加字符串无法提前预知内存大小的申请问题

#include <stdio.h>
#include <stdlib.h>
#include <string.h>int main()
{char a[] = "hello";char b[] = "hhhhhhhhhhhhhhhhhhhhhhhh";//动态分配内存, 根据a和b的字符串长度动态申请堆内存大小char *p = malloc(strlen(a) + strlen(b) + 1);//拷贝strcpy(p, a);//追加strcat(p, b);printf("p=%s\n", p); // p=hellohhhhhhhhhhhhhhhhhhhhhhhhreturn 0;
}

3.6 calloc分配指定大小的堆内存

void * calloc(size_t _Count, size_t _Size);

与malloc类似，负责在堆中分配内存，参数1是所需内存单元数量，参数2是每个内存单元的大小(单位:字节)，calloc自动将分配的内存值0，因此不需要使用memset来清空。 而malloc分配的内存则需要使用memset来清空。

int *p = (int *)calloc(100, sizeof(int));//分配100个int
//等效于
int *p  = (int*)malloc(100 * sizeof(int))

3.7 realloc重新分配新的堆内存

重新分配用malloc或者calloc函数在堆内存中分配的空间大小。

void * realloc(void *p, size_t _NewSize);

参数1:p为之前用malloc或者calloc分配的内存地址,等于NULL,那么realloc等效于malloc
参数2:_NewSize为重新分配后的最终内存的大小(单位:字节).
返回值:
成功返回新分配的内存首地址, 失败则返回NULL , realloc内部会重新分配一个连续的内存空间, 如果源地址后面不够分配, 他就会新申请一块空间, 而且这中间会自动的完成拷贝旧区域的数据到新区域, 完成后会自动的把旧区域内存释放, 这个过程是不用我们关心, 我们只需要关注的是它返回的新地址, 需要我们手动释放的也是这个返回的新地址对应的内存空间.

使用场景:如果一个变量初始分配了10个字节的堆大小, 后面发现不够用来了,需要20个字节, 那么就可以使用realloc来增加到20个字节大小，例如：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>int main()
{char *s1 = calloc(10, sizeof(char));char *s2 = calloc(6, sizeof(char));strcpy(s1, "123456789");strcpy(s2, "adcde");//此时s1的申请的空间已经用完了, 如果还想把s2也追加到s1中,则需要对s1进行扩容s1 = realloc(s1, strlen(s1) + strlen(s2) + 1);//追加s2strcat(s1, s2);printf("s1=%s\n", s1); // s1=123456789adcdefree(s1);free(s2);return 0;
}

3.8 正确处理函数内分配堆内存的问题

注意:如果想给一个指针通过函数调用来分配堆内存,那么必须要将该指针的地址作为形参传入, 该函数的形参类型一定是二级指针. 否则无法实现这种需求。

先来看一段代码:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>void test(char *s)
{strcpy(s, "hello");
}int main()
{char *p = calloc(10, 1); //在堆中分配10个字节的内存大小test(p);                 //给p变量赋值printf("%s\n", p); // hellofree(p); //释放内存return 0;
}

接着将上面的代码修改下为下面这种后，你会发现输出结果还是null。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>void test(char *s)
{s = calloc(10, 1); //在这里申请堆内存strcpy(s, "hello");
}int main()
{char *p = NULL;test(p); //调用test函数,把p实参传递给函数的形参sprintf("p=%s\n", p); //p还是NULL, 因为test函数执行完成后,s变量就消失了free(p); //释放内存,直接报错,因为p变量执行的内存是在栈中return 0;
}

前面代码之所以可以是因为,变量p是在调用处分配了内存,然后调用test函数给形参s赋值,此时s栈变量指向的堆地址还是在main函数申请的, 所以离开了test函数后, main操作的变量p并不影响,并且指向的堆内存地址对应的值也是可以正常查看修改后的值的。

那么如何解决在调用处没有申请堆内存却能正常使用的问题呢?
将p变量的地址传递给test函数, 函数参数改为二级指针, 然后函数体内操作一级指针的值即可。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>void test(char **s)
{//给1级指针分配堆内存地址*s = calloc(10, 1);//赋值strcpy(*s, "hello");
}int main()
{char *p = NULL;test(&p); //传入一级指针的地址printf("%s\n", p); // hello//释放free(p);return 0;
}