C语言学习笔记（八）程序结构

一、全局变量

（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);	//_func_表示当前函数名称
	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;
}

• 全局变量初始化
  • 没有做初始化的全局变量会得到0值
    • 指针会得到NULL值
  • 只能用编译时刻已知的值来初始化全局变量
  • 它们的初始化发生在main函数之前
• 被隐藏的全局变量
  • 如果函数内部存在与全局变量同名的变量，则全局变量被隐藏

（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 gAll=%d\n",_func_,all);
	gAll+=2;
	printf("agn in %s gAll=%d\n",_func_,all);
	return all;
}
//静态的本地变量
#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 gAll=%d\n",_func_,all);
	gAll+=2;
	printf("agn in %s gAll=%d\n",_func_,all);
	return all;
}

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

//检验静态变量
#include<stdio.h>
int f(void);
int gAll=1;
int main(int argc,char const *argv[])
{
	f();
	return 0;
}
int f(void)
{
	int k=1;
	static int all=1;
	printf("&gAll=%p\n",&gAll);
	printf("&all =%p\n",&all);
	printf("&k   =%p\n",&k);
	return all;
}

（3）返回指针的函数

• 返回本地变量的地址是危险的
• 返回全局变量或静态本地变量的地址是安全的
• 返回在函数内malloc的内存是安全的，但是容易造成问题
• 最好的做法是返回传入的指针
• tips
  • 不要使用全局变量来在函数间传递参数和结果
  • 尽量避免使用全局变量
    • 丰田汽车的案子
  • *使用全局变量和静态本地变量的函数是线程不安全的

二、编译预处理和宏

（1）编译预处理指令

• #开头的是编译预处理指令
• 它们不是C语言的成分，但是C语言程序离不开它们
• #define用来定义一个宏
  • #define<名字><值>
  • 注意没有结尾的分号，因为不是C的语句
  • 名字必须是一个单词，值可以是各种东西
  • 在C语言的编译器开始编译之前，编译预处理程序(cpp)会把程序中的名字换成值
    • 完全的文本替换
  • gcc --save-temps

#include<stdio.h>
#definr PI 3.14159
int main(int argc,char const *argv[])
{
	printf("%f\n",2*PI*3.0);
	return 0;
}

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

#include<stdio.h>
#definr PI 3.14159
#definr PI2 2*PI
int main(int argc,char const *argv[])
{
	printf("%f\n",PI2*3.0);
	return 0;
}

• 没有值的宏
  • #define _DEBUG
  • 这类宏适用于条件编译的，后面有其他的编译预处理指令检查这个宏是否已经被定义过了
• 预定义的宏
• _LINE_
• _FILE_
• _DATE_
• _TIME_
• _STDC_

（2）带参数的宏

• 像函数的宏
  • #define cube(x) ((x)(x)(x))
  • 宏可以带参数

#include<stdio.h>
#define cube(x) ((x)*(x)*(x))
int main(int argc,char const *argv[])
{
	int i;
	scanf("%d",&i);
	printf("%d\n",cube(i));
	return 0;
}

• 错误定义的宏

#define dao(x) (x * 57.295)
#define dao2(x) (x) * 57.295

• 带参数的宏的原则
  • 一切都要带括号
    • 整个值要括号
    • 参数出现的每个地方都要括号
  • # define dao(x) ((x)*57.539)
• 可以带多个参数
  • #define MIN(a,b) ((a)>(b)?(b):(a))
• 也可以组合(嵌套)使用其他宏
• 大型程序的代码中使用非常普遍
• 可以非常复杂，如"产生"函数
  • 在#和##这两个运算符的帮组下
• 存在中西方文化差异
• 部分宏会被inline函数替代

三、大程序结构

（1）多个源代码文件

• 多个.c文件
  • main()里的代码太长了适合分成几个函数
  • 一个源代码文件太长了适合分成几个文件
  • 两个独立的源代码文件不能编译形成可执行的程序
• 项目
  • 在Dev C++中新建一个项目，然后把几个源代码文件加进去
  • 对于项目，Dev C++的编译会把一个项目中所有的源代码文件都编译后，链接起来
  • 有的IDE有分开的编译和构件两个按钮，前者是对单个源代码文件编译，后者是对整个项目做链接
• 编译单元
  • 一个.c文件是一个编译单元
  • 编译器每次编译只处理一个编译单元

（2）头文件

• 把函数原型放到一个头文件(以.h结尾)中，在需要调用这个函数的源代码文件(.c文件)中#include这个头文件，就能让编译器在编译的时候知道函数的原型
• #include
  • #include是一个编译预处理指令，和宏一样，在编译之前就处理了
  • 它把哪个文件的全部文本内容原封不动地插入到它所在的地方
  • 所以也不是一定要在.c文件的最前面#include
• ""还是<>
  • #include有两种形式来指出要插入的文件
    • ""要求编译器首先在当前目录(.c文件所在的目录)寻找这个文件，如果没有，到编译器指定的目录去寻找
    • <>让编译器只在指定的目录去找
  • 编译器自己知道自己的标准库的头文件在哪里
  • 环境变量和编译器命令行参数也可以指定寻找头文件的目录
• #include的误区
  • #include不是用来引入库的
  • stdio.h里只有printf的原型，printf的代码再另外的地方，某个.lib(Windows)或.a(Unix)中
  • 现在的C语言编译器默认会引入所有的标准库
  • #include<stdio.h>只是为了让编译器知道peintf函数的原型，保证你调用时给出的参数值是正确的类型
• 在使用和定义这个函数的地方都应该#include这个头文件
• 一般的做法就是任何.c都有对应的同名的.h，把所有对外公开的函数的原型和全局变量的声明都放进去
• 不对外公开的函数
  • 在函数前面加上static就使得它成为只能在所在的编译单元中被使用的函数
  • 在全局变量前面加上static就使得它成为只能在所在的编译单元中被使用的全局变量

（3）声明

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

//main.c文件内容
#include<stdio.h>
#include "min.h"
int main(int argc,char const *argv[])
{
	int a=5,b=6;
	printf("min is %d\n",min(a,gAll));
	return 0;
}

//min.h文件内容
int min(int,int);
extern int gAll;

//min.c文件内容
#include "min.h"
int gAll=10;
int min(int a,int b)
{
	return a>b? b:a;
}

• 声明和定义
  • 声明是不会产生代码的东西
  • 定义是产生代码的东西
• 头文件
  • 只有声明可以被放在头文件中
    • 是规则不是法律
  • 否则会造成一个项目中多个编译单元里有重名的实体
    • *某些编译器允许几个编译单元中存在同名的函数，或者用weak修饰符来强调这种关系

//标准头文件结构
#ifndef _MIN_H_
#define _MIN_H_
int min(int,int);
extern int gAll;
struct point{
	int x;
	int y;
};
#endif

• 标准头文件结构
  • 运用条件编译和宏，保证这个头文件在一个编译单元中只会被#include一次
  • #pragram once也能起到相同的作用，但是不是左右的编译器都支持