C语言之内存讲解
1 内存讲解
1.1 作用域
C语言变量的作用域分为：代码块、函数、文件作用域：
1.1.1 局部变量
局部变量（自动变量）：一般情况代码块{}内部定义的变量；
特点：一个函数内定义，只在该函数范围内有效；在复合语句中定义，只在复合语句中有效，随着函数调用的结束或复合语句的结束局部变量的声明周期也结束；
若没有赋初值，内容为随机值；
#include <stdio.h>
void test()
{
//auto写不写是一样的
//auto只能出现在{}内部
auto int b = 10;
}
int main(void)
{
//b = 100; //err， 在main作用域中没有b
if (1)
{
//在复合语句中定义，只在复合语句中有效
int a = 10;
printf("a = %d\n", a);
}
//a = 10; //err离开if()的复合语句，a已经不存在
return 0;
}
1.1.2 静态static局部变量
static局部变量的作用域在定义函数内有效；其生命周期和程序运行周期一样，static局部变量的值只初始化一次，但可以赋值多次；static局部变量若未赋初值，则由系统自动赋值，数值型变量自动赋初值0，字符型变量赋空字符。
#include <stdio.h>
void fun1()
{
int i = 0;
i++;
printf("i = %d\n", i);
}
void fun2()
{
//静态局部变量，没有赋值，系统赋值为0，而且只会初始化一次
static int a;
a++;
static char s;
printf("a = %d\n", a);
printf("s=%c",s);
}
int main(void)
{
fun1();//i=1
fun2();//a=1,s=
return 0;
}
/*
i = 1
a = 1
s=
--------------------------------
Process exited after 0.09426 seconds with return value 0
请按任意键继续. . .
*/
1.1.3 全局变量
在函数外定义，可被本文件及其他文件中的函数所共用，若其他文件中函数调用此变量，需用extern声明,全局变量的生命周期和程序运行周期一样；不同文件的全局变量不可重名。
- 静态全局变量
在函数外定义，作用范围被限制在所定义的文件中，不同文件静态全局变量可以重名但作用域不能冲突，静态全局变量的生命周期和程序运行周期一样，同时静态全局变量的值初始化一次。 - extern全局变量声明
extern int a;，声明一个变量，该变量在别的文件已定义，这里只是声明 - 全局函数和静态函数
C语言中函数默认都是全局，使用关键字static可以将函数声明为静态，意味着该函数只能在定义这个函数的文件中使用，在其他文件中不能调用。即使声明该函数也没用，对于不同文件中的static函数名字可以相同。
注意：
允许在不同的函数中使用相同的变量名，它们代表不同的对象，分配不同的单元，互不干扰。
同一源文件中,允许全局变量和局部变量同名，在局部变量的作用域内，全局变量不起作用。
所有的函数默认都是全局的，意味着所有的函数都不能重名，但如果是staitc函数，那么作用域是文件级的，所以不同的文件static函数名是可以相同的。
| 类型 | 作用域 | 生命周期 |
|---|---|---|
| auto变量 | 一对{}内 | 当前函数 |
| static局部变量 | 一对{}内 | 整个程序运行期 |
| extern变量 | 整个程序 | 整个程序运行期 |
| static全局变量 | 当前文件 | 整个程序运行期 |
| extern函数 | 整个程序 | 整个程序运行期 |
| static函数 | 当前文件 | 整个程序运行期 |
| register变量 | 一对{}内 | 当前函数 |
1.2 内存布局
1.2.1 内存分区
C代码经过预处理、编译、汇编、链接4步后生成一个可执行程序。
在 Linux 下，程序是一个普通的可执行文件，以下列出一个二进制可执行文件的基本情况：
通过上图可以得知，在没有运行程序前，也就是说程序没有加载到内存前，可执行程序内部已经分好3段信息，分别为代码区（text）、数据区（data）和未初始化数据区（bss）3 个部分（有些人直接把data和bss合起来叫做静态区或全局区）
程序在加载到内存前，代码区和全局区(data和bss)的大小就是固定的，程序运行期间不能改变。然后，运行可执行程序，系统把程序加载到内存，除了根据可执行程序的信息分出代码区（text）、数据区（data）和未初始化数据区（bss）之外，还额外增加了栈区、堆区。
1.2.2 代码区（text segment）
存放 CPU 执行的机器指令。通常代码区是可共享的（即另外的执行程序可以调用它），使其可共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可。代码区通常是只读的，使其只读的原因是防止程序意外地修改了它的指令。另外，代码区还规划了局部变量的相关信息
代码区 加载的是可执行文件代码段，所有的可执行代码都加载到代码区，这块内存是不可以在运行期间修改的
1.2.3 全局初始化数据区/静态数据区（data段）
该区包含了在程序中明确被初始化的全局变量、已经初始化的静态变量（包括全局静态变量和局部静态变量）和常量数据（如字符串常量）
加载的是可执行文件数据段，存储于数据段（全局初始化，静态初始化数据，文字常量(只读)）的数据的生存周期为整个程序运行过程
1.2.4 未初始化数据区（又叫 bss 区）
存入的是全局未初始化变量和未初始化静态变量。未初始化数据区的数据在程序开始执行之前被内核初始化为 0 或者空（NULL）。
1.2.5 栈区（stack）
栈是一种先进后出的内存结构，由编译器自动分配释放，存放函数的参数值、返回值、局部变量等。在程序运行过程中实时加载和释放，因此，局部变量的生存周期为申请到释放该段栈空间
1.2.6 堆区（heap）
堆是一个大容器，它的容量要远远大于栈，但没有栈那样先进后出的顺序。用于动态内存分配。堆在内存中位于BSS区和栈区之间。一般由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。
1.2.7 存储类型总结
| 类型 | 作用域 | 生命周期 | 存储位置 |
|---|---|---|---|
| auto变量 | 一对{}内 | 当前函数 | 栈区 |
| static局部变量 | 一对{}内 | 整个程序运行期 | 初始化在data段，未初始化在BSS段 |
| extern变量 | 整个程序 | 整个程序运行期 | 初始化在data段，未初始化在BSS段 |
| static全局变量 | 当前文件 | 整个程序运行期 | 初始化在data段，未初始化在BSS段 |
| extern函数 | 整个程序 | 整个程序运行期 | 代码区 |
| static函数 | 当前文件 | 整个程序运行期 | 代码区 |
| register变量 | 一对{}内 | 当前函数 | 运行时存储在CPU寄存器 |
| 字符串常量 | 当前文件 | 整个程序运行期 | data段 |
/*#include<stdio.h>
int compare(int x, int y); //函数声明，分号不能省略
int main(){
int a=1,b=2,c;
c = compare(a,b); //函数调用
printf("max: %d\n", c);
return 0;
}
int compare(int x, int y){
return x>y?x:y;
}*/
#include <stdio.h>
#include <stdlib.h>
int e;
static int f;
int g = 10;
static int h = 10;
int main()
{
int a;
int b = 10;
static int c;
static int d = 10;
char *i = "test";
char *k = NULL;
printf("&a\t %p\t //局部未初始化变量\n", &a);
printf("&b\t %p\t //局部初始化变量\n", &b);
printf("&c\t %p\t //静态局部未初始化变量\n", &c);
printf("&d\t %p\t //静态局部初始化变量\n", &d);
printf("&e\t %p\t //全局未初始化变量\n", &e);
printf("&f\t %p\t //全局静态未初始化变量\n", &f);
printf("&g\t %p\t //全局初始化变量\n", &g);
printf("&h\t %p\t //全局静态初始化变量\n", &h);
printf("i\t %p\t //只读数据(文字常量区)\n", i);
k = (char *)malloc(10);
printf("k\t %p\t //动态分配的内存\n", k);
return 0;
}
/*
&a 000000000062FE3C //局部未初始化变量
&b 000000000062FE38 //局部初始化变量
&c 0000000000407034 //静态局部未初始化变量
&d 0000000000403018 //静态局部初始化变量
&e 0000000000407A20 //全局未初始化变量
&f 0000000000407030 //全局静态未初始化变量
&g 0000000000403010 //全局初始化变量
&h 0000000000403014 //全局静态初始化变量
i 0000000000404000 //只读数据(文字常量区)
k 0000000000BF13C0 //动态分配的内存
*/
1.3 存储类型内存操作函数
1.3.1 memset()
#include <string.h>
void *memset(void *s, int c, size_t n);
功能：将s的内存区域的前n个字节以参数c填入
参数：
s：需要操作内存s的首地址c：填充的字符，c虽然参数为int，但必须是unsigned char , 范围为0~255n：指定需要设置的大小
返回值：s的首地址
#include <stdio.h>
#include <string.h>
int main()
{
int a[10];
memset(a, 0, sizeof(a));//初始化数组
memset(a, 97, sizeof(a));//给数组赋值
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%c", a[i]); //aaaaaaaaaa
}
return 0;
}
1.3.2 memcpy()
#include <string.h>
void *memcpy(void *dest, const void *src, size_t n);
功能：拷贝src所指的内存内容的前n个字节到dest所值的内存地址上。
参数：
dest：目的内存首地址src：源内存首地址，注意：dest和src所指的内存空间不可重叠n：需要拷贝的字节数
返回值：dest的首地址
#include <stdio.h>
#include <string.h>
int main()
{
int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int b[10];
memcpy(b, a, sizeof(a));//b:目标内容首地址；a:源数组首地址；数据长度
//memcpy(&a[3], a, 5 * sizeof(int)); //err0, 内存重叠
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d, ", b[i]);
}
return 0;
}
1.3.3 memmove()
memmove()功能用法和memcpy()一样，区别在于：dest和src所指的内存空间重叠时，memmove()仍然能处理，不过执行效率比memcpy()低些。
1.3.4 memcmp()
#include <string.h>
int memcmp(const void *s1, const void *s2, size_t n);
功能：比较s1和s2所指向内存区域的前n个字节
参数：
s1：内存首地址1s2：内存首地址2n：需比较的前n个字节
返回值：
- 相等：=0
- 大于：>0
- 小于：<0
#include <stdio.h>
#include <string.h>
int main()
{
int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int b[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 10, 10 };
int flag = memcmp(a, b, sizeof(a));
printf("flag = %d\n", flag);//a<b时返回flag = -1
return 0;
}
1.4 堆区内存分配和释放
| 序号 | 函数 | 描述 |
|---|---|---|
| 1 | void *calloc(int num,int size) | 在内存中动态地分配num 个长度为 size的连续空间，并将每一个字节都初始化为0。所以它的结果是分配了num*size个字节长度的内存空间，并且每个字节的值都是0。 |
| 2 | void free(void *address) | 该函数释放address 所指向的内存块,释放的是动态分配的内存空间。 |
| 3 | void *malloc(int num) | 在堆区分配一块指定大小的内存空间，用来存放数据。这块内存空间在函数执行完成后不会被初始化，它们的值是未知的。 |
| 4 | void *realloc(void *address,int newsize) | 该函数重新分配内存，把内存扩展到newsize |
注意：void * 类型表示未确定类型的指针。C、C++ 规定 void * 类型可以通过类型转换强制转换为任何其它类型的指针。
1.4.1 malloc()
#include<stdlib.h>
void *malloc(size_t size);
功能： 在内存的动态堆区中分配一块长度为size字节的连续区域，用来存放类型说明符指定的类型。分配的内存空间内容不确定，一般使用memset初始化。
参数：size：需要分配内存大小（单位：字节）
返回值：成功：分配空间的起始地址
失败：NULL
#include <stdio.h>
#include <string.h>
#include<stdlib.h>
int main()
{
int count,*array,n;
printf("please input number of array:\n");
scanf("%d",&n);
array=(int *)malloc(n*sizeof(int));
if(array==NULL){
printf("failed!\n");
return -1;
}
//将申请空间清0
memset(array,0,sizeof(int)*n);
for(count=0;count<n;count++){
array[count]=count;
printf("%2d",array[count]);
}
free(array);
return 0;
}
1.4.2 free()
#include <stdlib.h>
void free(void *ptr);
功能：释放ptr所指向的一块内存空间，ptr是一个任意类型的指针变量，指向被释放区域的首地址。对同一内存空间多次释放会出错。
参数：
ptr：需要释放空间的首地址，被释放区应是由malloc函数所分配的区域
返回值：无
1.5 内存分区代码分析
1.5.1 返回栈去地址
#include <stdio.h>
#include <string.h>
#include<stdlib.h>
int *fun(){
int a=10; //局部变量，由栈区分配内容
return &a;//函数调用完毕，a释放
}
int main(int argc, char *argv[]){
int *p=NULL;
p=fun();
*p=100;
printf("*p = %d\n", p);
return 0;
}
1.5.2 返回data去区地址
#include <stdio.h>
int *fun()
{
static int a = 10;
return &a; //函数调用完毕，a不释放
}
int main(int argc, char *argv[])
{
int *p = NULL;
p = fun();
*p = 100; //ok
printf("*p = %d\n", *p);
return 0;
}
1.5.3 值传递1
#include <stdio.h>
#include <stdlib.h>
void fun(int *tmp)
{
tmp = (int *)malloc(sizeof(int));
*tmp = 100;
}
int main(int argc, char *argv[])
{
int *p = NULL;
fun(p); //值传递，形参tmp修改不会影响实参p
printf("*p = %d\n", *p);//err，操作空指针指向的内存
return 0;
}
1.5.4 值传递2
#include <stdio.h>
#include <stdlib.h>
void fun(int *tmp)
{
*tmp = 100;
}
int main(int argc, char *argv[])
{
int *p = NULL;
p = (int *)malloc(sizeof(int));
fun(p); //值传递
printf("*p = %d\n", *p); //ok，*p为100
return 0;
}
1.5.5 返回堆区地址
#include <stdio.h>
#include <stdlib.h>
int *fun()
{
int *tmp = NULL;
tmp = (int *)malloc(sizeof(int));
*tmp = 100;
return tmp;//返回堆区地址，函数调用完毕，不释放
}
int main(int argc, char *argv[])
{
int *p = NULL;
p = fun();
printf("*p = %d\n", *p);//ok
//堆区空间，使用完毕，手动释放
if (p != NULL)
{
free(p);
p = NULL;
}
