4.3 作用域与可见域

局部变量与全局变量

1.在函数内部定义的变量(包括形参)叫局部变量

2.在函数外部定义的变量叫全局变量

3.局部变量在函数执行阶段期间有效，仅在函数内部可见

4.全局变量在程序运行期间有效，在所有函数中可见

5.在其它文件中访问全局变量需要使用外部声明

6.局部变量和全名变量同名，优先选择局部变量

---

静态变量与静态函数

静态局部变量不会因函数返回而被回收，程序退出才被回收，但其可见性仍然局限于函数内部

静态全局变量和静态函数的可见性，仅局限于定义该变量和函数的源文件，即使使用外部声明

---

生命周期和使用范围 （重要！！！）

局部变量：

使用范围：从定义的地方开始，直到所在的函数结束。

内存生命周期：从定义的地方开始操作系统为其分配内存，直到所在函数结束，操作系统立刻回收其内存

形参也是局部变量！

        仅限于函数内部使用

if语句内定义的也是局部变量！

        使用：从定义的地方开始到花括号结束

        生命：从定义的地方开始操作系统分配到所在花括号结束

---

全局变量：

使用范围：从定义的地方开始，依次向下所有的函数都可以访问

生命周期：从程序运行那一块开始操作系统已经为其分配好内存，直到程序结束，一次分配，终生使用

vim var1.c

//var1.c:只负责定义全局变量
int g_a = 520; //定义初始化全局变量

vim var2.c

//var2.c:只负责调用访问var1.c的全局变量
//编译命令:gcc -o var var1.c var2.c
#include <stdio.h>

void A(void) {
    //g_a++; //不可以
}

//声明var1.c定义的全局变量g_a
//使用范围:从声明的地方开始依次向下
//所有的函数都可以访问
extern int g_a;

int main(void) {
    printf("main函数:g_a=%d\n",g_a);//可以
    return 0;
}

---

静态局部变量

用static关键字修饰的局部变量又称静态局部变量，使用范围与局部变量一样。

生命周期：从运行程序那一刻操作系统就已经为其分配好内存，直到程序结束回收，一次分配，终生使用

#include <stdio.h>      //当第一次调用时系统已为其分配好内存，因此，当执行printf后，a = 10;
void B(void){			//存入内存，第二次调用B()时，不会再执行static int a = 520;语句去定义
    static int a = 520;		//并初始化分配内存，所以打印时，a = 10；
    printf("%d\n",a);			 
    a = 10;
}
int main(void){
    B();   //520
    B();   //10
}

---

局部变量，全局变量，静态局部变量演示

//局部变量,全局变量,静态局部变量演示
#include <stdio.h>

// 形参为局部变量
//使用范围:仅限于函数内部使用,一旦出了函数就无法在使用了
//内存生命周期:从定义的地方开始操作系统为其分配内存直到所在的函数结束,操作系统立刻
//回收其内存
int add(int x, int y) {//形参变量也是局部变量,仅限于函数内部使用
    //printf("add函数:g_a = %d\n", g_a); //不可以
    return x + y;
}

void A(int x) { //x = g_a = 520
    printf("A函数: x = %d\n", x);
}

//全局变量
//使用范围:从定义的地方开始依次向下所有的函数都可以访问
//内存生命周期:从运行程序那一刻(./var)操作系统就已经为其分配好内存,直到程序结束操作系统
//回收其内存,一次分配,终生使用
int g_a = 520; //定义初始化全局变量(建议全局变量名以"g_"开头(g=global=全局))

void B(void) {
    //静态局部变量
    //使用范围:从定义的地方开始直到所在的函数结束,跟局部变量使用范围一样一样的
    //内存生命周期:从运行程序那一刻(./var)操作系统就已经为其分配好内存,直到程序结束操作系统
    //回收其内存,一次分配,终生使用
    static int a = 520;//用static关键字修饰的局部变量又称静态局部变量
    printf("B函数:a = %d\n", a); //可以
    a = 10;
}

int main(void) {
    B();
    B();
    A(g_a); //调用A函数并且将全局变量g_a的值520传递给形参变量x
    printf("add函数的返回值:%d\n", add(10, 20));
    printf("main函数:g_a = %d\n", g_a); //可以
    //printf("a = %d\n", a); //不可以
    // 定义局部变量
    //使用范围:从定义的地方开始直到所在的函数结束
    //内存生命周期:从定义的地方开始操作系统为其分配内存直到所在的函数结束,操作系统立刻
                   //回收其内存
    int a = 520; //定义初始化局部变量
    printf("a = %d\n", a); //可以
    if(a == 521) {
        //使用范围:从定义的地方开始直到所在的花括号结束
        //内存生命周期:从定义的地方开始操作系统为其分配内存直到所在的花括号结束,操作系统立刻
        //回收其内存
        int b = 522;//定义初始化局部变量
        printf("b = %d\n", b); //可以
    }
    //printf("b = %d\n", b); //不可以
    return 0;
}

---

静态全局变量

使用范围：不能跨文件访问，只能在定义的文件内部访问，从定义的地方开始依次向下所有文件访问

生命周期：程序运行那一刻开始就已经分配内存，直到程序结束

vim var1.c:只负责定义全局变量，静态全局变量

//var1.c:只负责定义全局变量,静态全局变量,
//全局函数,静态全局函数
#include <stdio.h>
int g_a = 520; //定义初始化全局变量

//定义初始化静态全局变量
//使用范围:不能跨文件访问,只能在定义的文件
//内部访问,从定义的地方开始依次向下所有的
//函数都可以访问
//内存生命周期:跟全局变量一样一样的
static int g_b = 521;

//定义静态全局函数
//使用范围:跟静态全局函数一样
//内存生命周期:跟全局变量一样一样的
static void print1(void) {
    printf("print函数:g_a=%d\n", g_a);
    printf("print函数:g_b=%d\n", g_b);
}

//定义全局函数
//使用范围:整个程序
//内存生命周期:跟全局变量一样一样的
void print(void) {
    printf("print函数:g_a=%d\n", g_a);
    printf("print函数:g_b=%d\n", g_b);
    print1(); //可以
}

var2.c:只负责调用访问var1.c的全局变量

//var2.c:只负责调用访问var1.c的全局变量
//编译命令:gcc -o var var1.c var2.c
#include <stdio.h>
void A(void) {
    //g_a++; //不可以
}
//声明var1.c定义的全局变量g_a
//使用范围:从声明的地方开始依次向下
//所有的函数都可以访问
extern int g_a;
//extern int g_b;
//声明var1.c定义的全局函数
extern void print(void);
//extern void print1(void);
int main(void) {
    printf("main函数:g_a=%d\n",g_a);//可以
    //printf("main函数:g_b=%d\n",g_b);//不可以
    print();
    //print1(); //不可以
    return 0;
}

---

练习：

用全局数组实现一个内存栈，后进先出，要求提供如下函数：

压入：void push(int data);

弹出：int pop(void);

判空：int empty(void);

判满：int full(void);

//栈
#include <stdio.h>
static int g_arr[1024]; //定义静态全局数组,分配的内存用于栈,gcc默认全部初始化为0
static int g_top = 0; //记录栈顶的位置
//定义获取栈最大容量的函数
int cap(void) {
    return sizeof(g_arr)/sizeof(g_arr[0]);
}
//定义获取目前栈存储的有效数据的个数的函数
int size(void) {
    return g_top; 
}
//定义判断满的函数
int full(void) {
    return g_top >= cap(); //满返回1,否则返回0
}
//定义判断空的函数
int empty(void) {
    return g_top <= 0;//空返回1,否则返回0
}
//定义压栈函数
void push(int data) {
    g_arr[g_top++] = data;
}
//定义出栈函数
int pop(void) {
    return g_arr[--g_top];
}
int main(void) {
    int i;
    for(i = 0; i < 10; i++)  //循环压入10个数据:0,1,2,3,4,5,6,7,8,9,10
        if(!full()) //压之前先判断是否满了
            push(i); //如果有空位置,继续压
    while(!empty()) //循环出栈,先判断是否空了 
        printf("%d ", pop()); //有数据继续出
    printf("\n");
    return 0;
}