程序设计进阶——C语言（翁凯版）第五周-CSDN博客

本文链接：https://blog.csdn.net/qq_44845100/article/details/136039349

5.1 全局变量

5.1.1 全局变量：定义在函数之外的变量，全局的生存期和作用域

全局变量

定义在函数外面的变量是全局变量；
全局变量具有全局的生存期和作用域；
它们与任何函数都无关，在任何函数内部都可以使用它们。

代码如下

#include <stdio.h>

int f(void); 

int gAll=12;

int main(int argc,char const argv[])
{
	printf("in %s gAll=%d\n",__func__,gAll);
	f();
	printf("agn in %s gAll=%d\n",__func__,gAll);
	return 0;
	
}

int f(void)
{
	printf("in %s gAll=%d\n",__func__,gAll);
	gAll+=2;
	printf("agn in %s gAll=%d\n",__func__,gAll);
	return gAll;
}

输出

in main gAll=12
in f gAll=12
agn in f gAll=14
agn in main gAll=14

全局变量初始化

没有做初始化的全局变量会得到0值；
指针会得到NULL；
只能用编译时刻已知的值初始化全局变量；
它们的初始化发生在main函数之前。

代码如下

#include <stdio.h>

int f(void); 

int gAll;

int main(int argc,char const argv[])
{
	printf("in %s gAll=%d\n",__func__,gAll);
	f();
	printf("agn in %s gAll=%d\n",__func__,gAll);
	return 0;
	
}

int f(void)
{
	printf("in %s gAll=%d\n",__func__,gAll);
	gAll+=2;
	printf("agn in %s gAll=%d\n",__func__,gAll);
	return gAll;
}

输出

in main gAll=0
in f gAll=0
agn in f gAll=2
agn in main gAll=2

被隐藏的全局变量

如果函数内部存在与全局变量同名的变量，则全局变量被隐藏

#include <stdio.h>

int f(void); 

int gAll=12;

int main(int argc,char const argv[])
{
	printf("in %s gAll=%d\n",__func__,gAll);
	f();
	printf("agn in %s gAll=%d\n",__func__,gAll);
	return 0;
	
}

int f(void)
{
	int gAll=1;
	printf("in %s gAll=%d\n",__func__,gAll);
	gAll+=2;
	printf("agn in %s gAll=%d\n",__func__,gAll);
	return gAll;
}

输出

in main gAll=12
in f gAll=1
agn in f gAll=3
agn in main gAll=12

5.1.2 静态本地变量

静态本地变量

在本地变量定义时加上static修饰符就成为静态本地变量；
当函数离开时，静态本地变量会继续存在并保持其值；
静态本地变量的初始化只会在第一次进入这个函数时做，以后进入函数会保持上次离开时的值

代码如下

#include <stdio.h>

int f(void); 


int main(int argc,char const argv[])
{
	f(); 
	f();
	f();
	return 0;
	
}

int f(void)
{
	int All=1;
	printf("in %s All=%d\n",__func__,All);
	All+=2;
	printf("agn in %s All=%d\n",__func__,All);
	return All;
}

输出

in f All=1
agn in f All=3
in f All=1
agn in f All=3
in f All=1
agn in f All=3

加上static修饰符之后代码如下

#include <stdio.h>

int f(void); 


int main(int argc,char const argv[])
{
	f(); 
	f();
	f();
	return 0;
	
}

int f(void)
{
	static int All=1;
	printf("in %s All=%d\n",__func__,All);
	All+=2;
	printf("agn in %s All=%d\n",__func__,All);
	return All;
}

输出

in f All=1
agn in f All=3
in f All=3
agn in f All=5
in f All=5
agn in f All=7

静态本地变量实际上是特殊的全局变量；
它们位于相同的内存区域；
静态本地变量具有全局的生存期，函数内的局部作用域；
static在这里的意思是局部作用域（本地可访问）

5.1.3 后记：返回指针的函数，使用全局变量的贴士

返回指针的函数

返回本地变量的地址是危险的；
返回全局变量或静态本地变量的地址是安全的；
返回在函数内malloc的内存是安全的，但是容易造成问题；
最好的做法是返回传入的指针；

tips

不要使用全局变量在函数间传递参数和结果；
尽量避免使用全局变量；
使用全局变量和静态本地变量的函数是线程不安全的

5.2 编译预处理和宏

5.2.1 宏定义

编译预处理指令

#开头的是编译预处理指令；
它们不是C语言的成分，但是C语言程序离不开它们；
#define用来定义一个宏

#include <stdio.h>

#define PI 3.14159
#define FORMAT "%f\n"

int main(int argc,char const argv[])
{
	printf(FORMATdefine,2*PI*3.0);
	return 0;
}

输出

18.849540

#define

#define <名字> <值>；
注意没有结尾的分号，因为不是C的语句；
名字必须是一个单词，值可以是各种东西；
在C语言的编译器开始编译之前，编译预处理程序（cpp）会把程序中的名字换成值；
完全的文本替换；

宏

如果一个宏的值中有其他的宏的名字，也是会被替换的；
如果一个宏的值超过一行，最后一行之前的行末需要加\；
宏的值后面出现的注释不会被当做宏的值的一部分；

#include <stdio.h>

#define PI 3.14159
#define FORMAT "%f\n"
#define PI2 2*PI//pi*2
#define PRT printf("%f\n",PI);\
			printf("%f\n",PI2)
int main(int argc,char const argv[])
{
	printf(FORMAT,2*PI*3.0);
	PRT;
	return 0;
}

输出

18.849540
3.141590
6.283180

没有值的宏

#define _DUBUG;
这类宏是用于条件编译的，后面有其他的编译预处理指令来检查这个宏是否已经被定义过了；

预定义的宏

LINE;
FINE;
DATE;
TIME;
STDC;

#include <stdio.h>


int main(int argc,char const argv[])
{
	printf("%s:%d\n",__FILE__,__LINE__);
	printf("%s,%s\n",__DATE__,__TIME__);
	return 0;
}

输出

F:\C learning\upgrade\test.c:6
Feb  5 2024,16:09:40

5.2.2 带参数的宏

像函数的宏

#define cube(x) ((x)(x)(x))
宏可以带参数

#include <stdio.h>

#define cube(x) ((x)*(x)*(x))

int main(int argc,char const argv[])
{
	printf("%d\n",cube(5));
	return 0;
}

输出

带参数的宏的原则

一切都要括号；
整个值要括号；
参数出现的每个地方都要括号；

带参数的宏

可以带多个参数；
#define MIN(a,b) ((a)>(b)?(b):(a))；
也可以组合（嵌套）使用其他宏
要注意分号；
在大型程序的代码中非常常见；
可以非常复杂，如“产生”函数；
在#和##这两个运算符帮助下；
部分宏会被inline替代

5.3 大程序结构

5.3.1 多个源代码文件

多个.c文件

main()里的代码太长了适合分成几个函数；
一个源代码文件太长了适合分成几个文件；
两个独立的源代码文件不能编译形成可执行的程序；

项目

在Dev C++中新建一个项目，然后把几个源代码文件加入进去；
对于项目，Dev C++的编译会把一个项目中所有的源代码文件都编译后链接起来；
有的IDE有分开的编译和构建两个按钮，前者是对单个源代码文件编译，后者是对整个项目链接；

编译单元

一个.c文件是一个编译单元；
编译器每次编译只处理一个编译单元；

5.3.2 头文件

头文件

把函数原型放到一个头文件（以.h结尾）中，在需要调用这个函数的源代码文件（.c文件）中#include这个头文件，就能让编译器在编译的时候知道函数的原型。

#include

#include是一个预编译指令，和宏一样，在编译之前就处理了；
它把那个文件的全部文本内容原封不动地插入到它所在的地方；
所以也不是一定要在.c文件的最前面#include；

""还是<>

#include有两种形式来指出要插入的文件；
""要求编译器首先在当前目录（.c文件所在的目录）寻找这个文件，如果没有，到编译器指定的目录去找；
<>让编译器只在指定目录去找；
编译器自己知道自己的标准库的头文件在哪里；
环境变量和编译器命令行参数也可以指定寻找头文件的目录；

#include的误区

#include不是用来引入库的；
stdio.h里只有printf的原型，printf的代码在另外的地方，某个.lib(Windows)或.a(Unix)中；
现在的C语言编译器默认会引入所有的标准库；
#include <stdio.h>只是为了让编译器知道printf函数的原型，保证调用时给出的参数值是正确的类型；

头文件

在使用和定义这个函数的地方都应该#include这个头文件；
一般的做法就是任何.c都有对应的同名的.h，把所有对外公开的函数的原型和全局变量的声明都放进去；

不对外公开的函数

在函数前面加上static就使得它成为只能在所在的编译单元中被使用的函数；
在全局变量前面加上static就使得它成为只能在所在的编译单元中被使用的全局变量；

5.3.3 声明

变量的声明

int i;是变量的定义
extern int i;是变量的声明

声明和定义

声明时不产生代码的东西；
函数原型；
变量声明；
结构声明；
宏声明；
枚举声明；
类型声明；
inline声明；
定义是产生代码的东西；

头文件

只有声明被放在头文件中；
是规则不是法律；
否则会造成一个项目中多个编译单元有重复的实体；
*某些编译器允许几个编译单元中存在同名的函数，或者用weak修饰符来强调这种存在；

重复声明

同一个编译单元里，同名的结构不能被重复声明；
如果头文件里有结构的声明，很难这个头文件不会在一个编译单元里被#include多次；
所以需要“标准头文件结构”；

标准头文件结构

#ifndef __LIST_HEAD__
#define __LIST_HEAD__

#include "node.h"

typedef struct _list{
	Node* head;
	Node* tail;
}List;

#endif

运用条件编译和宏，保证这个头文件在一个编译单元中只会被#include一次；
#program once也能起到相同的作用，但是不是所有的编译器都支持。