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;
}