C语言-内存管理
作用域
C语言变量的作用域分:
- 局部变量也叫auto自动变量(auto可写可不写)
- 代码块作用域(代码块是{}之间的一段代码)
- 函数作用域
- 文件作用域
局部变量
- 在一个函数内定义,只在函数范围内有效
- 在复合语句中定义,只在复合语句中有效
- 随着函数调用的结束或复合语句的结束局部变量的声明,声明周期结束
- 如果没有赋初始值,内容为随机
#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;
}
静态(static)局部变量
- 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++;
printf("a = %d\n", a);
}
int main(void)
{
fun1();
fun1();
fun2();
fun2();
return 0;
}
全局变量
- 在函数外定义,可被本文件及其它的文件中的函数所共用,若其它文件中的函数调用此变量,需要用extern声明
- 全局变量的生命周期和程序运行周期一样
- 不同文件的全局变量不可重名
静态(static)全局变量
- 在函数外定义,作用范围被限制在所定义的文件中
- 不同文件静态全局变量可以重名,但是作用域不冲突
- static全局变量的生命周期和程序的运行周期一样,同时static全局变量的值只初始化一次
extern全局变量声明
extern int a;声明一个变量,这个全局变量在别的文件中已经定义了,这里只是声明,而不是定义。
全局函数和静态函数
- 在C语言中函数默认都是全局的,使用关键字static可以将函数声明为静态,函数定义为static就意味着这个函数只能再定义的文件中使用,在其他文件中不能调用,即使在其他文件中声明这个函数也没用。
- 对于不同文件中的static函数名字可以相同
注意:
- 允许在不同的函数中使用相同的变量名,它们代表不同的对象,分配不同的单元,互不干扰。
- 在同一源文件中,允许全局变量和局部变量同名,在局部变量的作用域内,全局变量不起作用。
- 所有的函数默认都是全局的,意味着所有的函数都不能重名,但是如果是static函数,那么作用域是文件级的,所以不同文件的文件static函数名可以相同
总结
类型 | 作用域 | 生命周期 |
---|---|---|
auto变量 | 一对{} | 内当前函数 |
static局部变量 | 一对{}内 | 整个程序运行期 |
extern变量 | 整个程序 | 整个程序运行期 |
static全局变量 | 当前文件 | 整个程序运行期 |
extern函数 | 整个程序 | 整个程序运行期 |
static函数 | 当前文件 | 整个程序运行期 |
register变量 | 一对{}内 | 当前函数 |
全局变量 | 整个程序 | 整个程序运行期 |
内存分区
- C代码经过预处理、编译、汇编、链接4步后生成一个可执行程序。
- 在没有运行程序前,也就是说程序没有加载到内存前,可执行内部已经分好3段信息,分为代码区(text)、数据区(data)和未初始化数据区(bss)3个部分(data和bss合起来叫做静态区或全局区)
- 代码区(text),存放 CPU 执行的机器指令,通常是只读的。
- 程序在加载到内存前,代码区和全局区(data区和bss区)的大小就是固定的
- 运行可执行程序,系统把程序加载到内存,除了根据可执行程序的信息分出代码区(text)、数据区(data)、和未初始化数据区(bss)之外,还额外增加了栈区、堆区。
图片示意图
存储类型总结
类型 | 作用域 | 生命周期 | 存储位置 |
---|---|---|---|
auto变量 | 一对{}内 | 当前函数 | 栈区 |
static局部变量 | 一对{}内 | 整个程序运行期 | 初始化在data段,未初始化在bss段 |
extern变量 | 整个程序 | 整个程序运行期 | 初始化在data段,未初始化在bss段 |
static全局变量 | 当前文件 | 整个程序运行期 | 初始化在data段,未初始化在bss段 |
extern函数 | 整个程序 | 整个程序运行期 | 代码区 |
static函数 | 当前文件 | 整个程序运行期 | 代码区 |
register变量 | 一对{}内 | 当前函数 | 运行时存储在CPU寄存器 |
字符串常量 | 当前文件 | 整个程序运行期 | data段 |
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;
}
内存操作函数
1.memcpy()
#include <string.h>
void *memcpy(void *dest, const void *src, size_t n);
功能:拷贝src所指的内存内容的前n个字节到dest所值的内存地址上。
参数:
dest:目的内存首地址
src:源内存首地址,注意:dest和src所指的内存空间不可重叠,可能会导致程序报错
n:需要拷贝的字节数
返回值:dest的首地址
2.memset()
#include <string.h>
void *memset(void *s, int c, size_t n);
功能:将s的内存区域的前n个字节以参数c填入
参数:
s:需要操作内存s的首地址
c:填充的字符,c虽然参数为int,但必须是unsigned char , 范围为0~255
n:指定需要设置的大小
返回值:s的首地址
3.memmove()
memmove()功能用法和memcpy()一样,
区别在于:dest和src所指的内存空间重叠时,
memmove()仍然能处理,不过执行效率比memcpy()低些。
4.memcmp()
#include <string.h>
int memcmp(const void *s1, const void *s2, size_t n);
功能:比较s1和s2所指向内存区域的前n个字节
参数:
s1:内存首地址1
s2:内存首地址2
n:需比较的前n个字节
返回值:
相等:=0
大于:>0
小于:<0
堆区内存分配和释放
1.malloc()
#include <stdlib.h>
void *malloc(size_t size);
功能:在内存的动态存储区(堆区)中分配一块长度为size字节的连续区域,用来存放类型说明符指定的类型。分配的内存空间内容不确定,一般使用memset初始化。
参数:
size:需要分配内存大小(单位:字节)
返回值:
成功:分配空间的起始地址
失败:NULL
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int main()
{
int count, *array, n;
printf("请输入要申请数组的个数:\n");
scanf("%d", &n);
array = (int *)malloc(n * sizeof (int));
if (array == NULL)
{
printf("申请空间失败!\n");
return -1;
}
//将申请到空间清0
memset(array, 0, sizeof(int)*n);
for (count = 0; count < n; count++) /*给数组赋值*/
array[count] = count;
for (count = 0; count < n; count++) /*打印数组元素*/
printf("%2d", array[count]);
free(array);
return 0;
}
2.free()
#include <stdlib.h>
void free(void *ptr);
功能:释放ptr所指向的一块内存空间,ptr是一个任意类型的指针变量,指向被释放区域的首地址。对同一内存空间多次释放会出错。
参数:
ptr:需要释放空间的首地址,被释放区应是由malloc函数所分配的区域。
返回值:无
内存分区代码分析
1.返回栈区地址
#include <stdio.h>
int *fun()
{
int a = 10;
return &a;//函数调用完毕,a释放
}
int main(int argc, char *argv[])
{
int *p = NULL;
p = fun();
*p = 100; //操作野指针指向的内存,err
return 0;
}
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;
}
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); //值传递,形参修改不会影响实参
printf("*p = %d\n", *p);//err,操作空指针指向的内存
return 0;
}
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;
}
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;
}
return 0;
}