15.变量的存储类别

变量的存储类别

内存的分区

1.内存：物理内存，虚拟内存。
虚拟内存：操作系统虚拟出来的的内存。

操作系统会再物理内存和虚拟内存之间做映射。
在32位系统下，每个进程的寻址范围是4G：0x00 00 00 00 ~ 0xff ff ff ff
在写应用程序时，看到的都是虚拟内存。

2.在运行程序的时候，操作系统会将虚拟内存进行分区。

1）堆
在动态申请内存的时候，在堆里开辟内存。

2）栈
主要存放局部变量。

3）静态全局区
a. 未初始化的静态全局区
静态变量（定义变量的时候，前面加 static 修饰）, 或全局变量，没有初始化的，存在此区。
b. 初始化的静态全局区
全局变量、静态变量、赋过初值的放在此区。

4）代码区
存放程序代码

5）文字常量区
存放常量

普通全局变量

概念：
在函数外部定义的变量

int num = 100; //全局变量
int main()
{
return 0;
}

作用范围：
普通全局变量的作用范围，是程序的所有地方。
只不过用之前需要声明。声明方法：extern int num;
注意声明的时候，不要赋值。
生命周期：
程序运行的整个过程，一直存在，直到程序结束。

注意：定义普通的全局变量的时候，如果不赋初值，它的默认值为0。

#include
int num;
void fun(void); 
int main()
{
	printf("in main num=%d\n", num);
	num = 100;
	fun();
	return;
}
void fun(void)
{
	printf("in fun num=%d\n", num);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

静态全局变量

概念：
定义全局变量的时候，前面用static修饰。

static int num = 100; //num 就是一个静态全局变量
int main()
{
return = 0;
}

作用范围：
static 限定了静态全局变量的作用范围只能在它定义的.c（源文件）中有效。

生命周期：
在程序运行的整个过程中，一直存在。

注意：
定义静态全局变量的时候，如果不赋初值，它的默认值为0。

普通局部变量

概念：
在函数内部定义的，或者复合语句中定义的变量。

int main()
{
int num; //普通局部变量
{
int a;//复合语句局部变量
}
}

作用范围：
在函数定义的变量，在它的函数中有效。
在复合语句中定义的，在它的复合语句中有效。
被调函数的形参是被调函数的局部变量。

生命周期：
在函数调用之前，局部变量不占用空间，调用函数的时候
才为局部变量开辟空间，函数结束，局部变量释放。

#include
void fun(void)
{
	int num = 3;
	num++;
	printf("num=%d\n", num);
}
int main()
{
	fun();
	fun();
	fun();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

静态局部变量

概念：
定义局部变量的时候，前面加static修饰。

作用范围：
在它定义的函数和复合语句中有效。

生命周期：
第一次调用函数的时候，开辟空间赋值，函数结束后，不释放。
以后再调用函数的时候，就不再为其开辟空间，也不赋初值。
用的还是以前那个变量。

#include
void fun(void)
{
	static int num = 3;
	num++;
	printf("num=%d\n", num);
}
int main()
{
	fun();
	fun();
	fun();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意：
1.定义普通局部变量，如果不赋初值，它的值是随机的，打印会报错。
定义静态局部变量，如果不赋初值，它的值是0。
2.普通全局变量和静态全局变量如果不赋初值，它的值为0。

变量重名问题

在同一作用范围内，不允许变量重名。
作用范围不同的可以重名。
局部范围内，重名的全局变量不起作用。（就近原则）

#include
int num = 100;
void fun(void)
{
	printf("in fun num =%d\n", num);
}
int main()
{
	int num = 10;
	printf("in main num=%d\n", num);
	fun();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

外部函数和内部函数

外部函数

自己定义的普通函数，都是外部函数。
即函数可以在程序的任何一个文件中调用。

内部函数

在定义函数的时候，在返回值类型前面加static修饰，被称为内部函数。
static 限定了函数的作用范围，在定义的.c中有效。

内部函数和外部函数的区别：
外部函数：所有地方都可以调用
内部函数：只能在所定义的.c中的函数调用

#include
#include"4.h"
int main()
{
	fun();
	return 0;
}
1
2
3
4
5
6
7

#include
static void fun2(void);
void fun(void)
{
	printf("in fun\n");
	fun2();
}
static void fun2(void)
{
	printf("in fun2\n");
}
1
2
3
4
5
6
7
8
9
10
11

4.h：

extern void fun(void);
1

static函数的例子：

42.c

#include
extern int funB(void);
extern int funA(void);
int num = 3;
int main()
{
	int num = 5;
	printf("num=%d\n", num);
	printf("funA=%d\n", funA());
	printf("funB=%d\n", funB());
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

42_fun.c:

static int num = 11;
int funA(void)
{
	return num;
}
static int funB(void)
{
	return 7;
}
1
2
3
4
5
6
7
8
9

42_fun2.c:

int funB(void)
{
	return 8;
}

1
2
3
4
5