C语言进阶 12. 程序结构

12.1. 全局变量定义

• 全局变量:

  • 定义在函数外面的变量

  • 全局变量具有全局的生存期和作用域

    • 它们与任何函数都无关
    • 在任何函数内部都可以使用它们

• __func__:

  • printf(“%s\n”, func);

  • 表示在哪个函数内, 返回值为字符串, 所以是%s

  • func两边都有两个下划线

• 全局变量初始化:

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

• 被隐藏的全局变量:

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

#include <stdio.h>

int f(void);

int gAll = 12;
char* p;

int main(int argc, char const* argv[]) {
	printf("%s\n", p);
	printf("in %s gAll = %d\n", __func__, gAll);//__func__表示在哪个函数内
	f();
	printf("again %s gAll = %d\n", __func__, gAll);
	return 0;
}

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

12.2. 静态本地变量

• 静态本地变量:

  • 在本地变量定义时加上static修饰符就成为静态本地变量

  • 当函数离开的时候, 静态本地变量会继续存在并保持其值

  • 静态本地变量的初始化只会在第一次进入这个函数时做, 以后进入函数时会保持上次离开时的值

  • 静态本地变量实际上是特殊的全局变量

  • 它们位于相同的内存区域

  • 静态本地变量具有全局的生存期, 函数内的局部作用域

    • static在这里的意思是局部作用域(本地可访问)

#include <stdio.h>

int f(void);

int gAll = 12;

int main(int argc, char const* argv[]) {
	f();
	f();
	f();
	return 0;
}
int f(void) {
	static int all = 1;
	static int i = 1;
	
	printf("gAll = %p\n", &gAll);
	printf("all = %p\n", &all);
	printf("i = %p\n", &i);
	

	printf("in %s all = %d\n", __func__, all);
	all += 2;
	printf("again %s all = %d\n", __func__, all);
	return all;
}

12.3. 返回指针的函数

• 没听懂

• 返回指针的函数:

  • 返回本地变量的地址是危险的

  • 返回全局变量或静态本地变量的地址是安全的

  • 返回在函数内malloc的内存是安全的, 但是容易造成问题

  • 最好的做法是返回传入的指针

• tips:

  • 不要使用全局变量来在函数间传递参数和结果

  • 尽量避免使用全局变量

    • 丰田汽车的案子

  • *用全局变量和静态本地变量的函数是线程不安全的

#include <stdio.h>

int* f(void);
void g(void);

int main(int argc, char const* argv[]) {
	int* p = f();
	printf("*p = %d\n", *p);
	g();
	printf("*p = %d\n", *p);
	return 0;
}

int* f(void) {
	int i = 12;
	return &i;
}

void g(void) {
	int k = 24;
	printf("k = %d\n", k);
}

12.4. 宏定义

• 编译预处理指令:

  • #开头的是编译预处理指令

  • 它们不是C语言的成分, 但是C语言程序离不开它们

  • #define 用来定义一个宏

  • C语言在编译之前, 会先做一次编译预处理, 预处理会把PAI替换成3.14159

    • #define PAI 3.14159

• #define:

  • #define <名字> <值>

  • 注意: 没有结尾的分号, 也没有中间的赋值符号, 因为不是C的语句

  • 名字必须是一个单词, 值可以是各种东西

  • 在C语言的编译器开始编译之前, 编译预处理程序(cpp)会把程序中的名字换成值

    • 完全的文本替换

• 宏:

  • 如果一个宏的值中有其他的宏的名字, 也是会被替换的

    • #define PAI 3.14159
    • #define PAI2 2 * PAI

  • 如果一个宏的值超过了一行, 最后一行之前的行末需要加\

  • 宏的值后面出现的注释不会被当作宏的值的一部分

• 没有值的宏:

  • #define _DEBUG

  • #define _CRT_SECURE_NO_WARNINGS

  • 这类宏是用来条件编译的, 后面有其他的编译预处理指令来检查这个宏是否一i纪念馆被定义过了

• 预定义的宏:

  • __LINE__ 行号

  • __FILE__ 文件名

  • __DATE__ 日期

  • __TIME__ 时间

  • 这些宏是用来表达一些特殊的东西, 让编译器替你插入一些特殊的值

#include <stdio.h>

//const double PAI = 3.14159;//这个是C99版本才使用的

#define PAI 3.14159	//但是在老版本里面都是用的这种方式

#define FORMAT "%f\n"

#define PAI2 2 * PAI	//PAI * 2

#define PRT printf("%f\n", PAI);\
			printf("%f\n", PAI2)

int main(int argc, char const* argv[]) {
	printf("%f\n", 2 * PAI * 3.0);

	printf(FORMAT, 2 * PAI * 3.0);//这里的FORMAT被替换成了"%f\n"

	printf(FORMAT, PAI2 * 3.0);

	PRT;

	printf("%s : %d\n", __FILE__, __LINE__);
	printf("%s, %s\n", __DATE__, __TIME__);
	
	return 0;
}

12.5. 带参数的宏

• 像函数的宏:

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

• 错误定义的宏:

  • #define RADTODEG(x) (x * 57.29578) //5+2*57

  • #define RADTODEG(x) (x) * 57.29578 //180/1*57

  • printf(“%f\n”, RADTODEG1(5 + 2));//119.591560

  • printf(“%f\n”, 180 / RADTODEG2(1));//10313.240400

• 带参数的宏的原则:

  • 一切都要括号
    • 整个值要括号
    • 参数出现的每个地方都要括号
  • #define RADTODEG(x) ((x) * 57.29578)
  • 上面的宏应该写成这个样子

• 多个参数:

  • 可以带多个参数
    • #define MIN(a, b) ((a) > (b) ? (b) : (a))
  • 也可以组合(嵌套)使用其他宏

• 分号?

  • 不要在定义宏的时候在它后面加分号

• 特点:

  • 在大型程序的代码中使用非常普遍
  • 可以非常复杂, 如"产生"函数, 它的效率要比函数高, 但是占据的内存空间也要高于函数, 这样会牺牲空间来提高效率
    • 在#和##这个两个运算符的帮助下
      • 不讲, 自己看资料
  • 存在中西方文化差异
  • 部分宏会被inline函数替代
    • 不讲, 自己看资料

• 其他编译预处理指令:

  • 条件编译
  • error
  • …

#include <stdio.h>

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

#define RADTODEG1(x) (x * 57.29578)
#define RADTODEG2(x) (x) * 57.29578

#define MIN(a, b) ((a) > (b) ? (b) : (a))

int main(int argc, char const* argv[]) {
	int i;
	scanf("%d", &i);
	printf("%d\n", cube(i + 2));

	printf("%f\n", RADTODEG1(5 + 2));//119.591560
	printf("%f\n", 180 / RADTODEG2(1));//10313.240400

	printf("%d\n", MIN(3, 2));
	return 0;
}

12.6. 多个源代码文件

• 多个.c文件:

  • main()里的代码太长了适合分成几个函数
  • 一个源代码文件太长了适合分成几个文件
    • 把多个函数分到多个.c文件当中
  • 两个独立的源代码文件不能编译形成可执行的程序
    • 如何将多个.c文件组合成一个有效的程序

• 项目:

  • 在VS当中, 创建源文件(.c文件)之前, 必须先创建一个项目, 在一个项目中, 可以创建多个源文件, 而这些源文件VS会自动的链接到一起. 而对于Dev C++, 它可以直接创建源文件, 但是如果想要把多个源文件链接到一起时, 就必须创建一个项目, 然后把这些源文件都拉到项目当中.

  • 有的IDE有分开的编译(compile)和构建(build)两个按钮, 前者是对单个源代码文件编译, 后者是对整个项目做链接

• 编译单元:

  • 一个.c文件是一个编译单元

  • 编译器每次编译只处理一个编译单元, 编译完成后, 会生成.o文件, 目标代码文件, 然后由链接器(link)把它们链接在一起

  • compile生成文件, build链接文件

• File1.c

#include <stdio.h>

int max(int a, int b);

int main(int argc, char const* argv[]) {
	int a = 5;
	int b = 6;
	printf("%d\n", max(a, b));
	return 0;
}

• File2.c

int max(int a, int b) {
	return (a > b ? a : b);
}

12.7. 头文件

• 如何保证在main这里对函数max的使用和在Max文件当中对max的定义是一致的呢?

  • 我们需要有一个中间的媒介

• 头文件:

  • 这个中间的媒介就是头文件, 它相当于一个桥梁, 一份合同

  • 把函数原型放到一个头文件(以.h结尾)中, 在需要调用这个函数的源文件(.c文件)中, #include 这个头文件, 就能让编译器在编译的时候知道函数的原型

  • #include “Max.h”: 头文件要用双引号引用

• #include:

  • #include是一个编译预处理指令, 和宏一样 , 在编译之前就处理了

  • 它把那个文件的全部文件内容原封不动的插入到它所在的地方

    • 所以也不是一定要在.c文件的最前面#include

• ""还是<>:

  • #include有两种形式来指出要插入的文件

    • ""要求编译器首先在当前目录(.c文件所在的目录)寻找这个文件, 如果没有, 到编译器指定的目录去找

    • <>让编译器只在指定的目录去找

  • 编译器自己知道自己的标准库的头文件在哪里

  • 环境变量和编译器命令行参数也可以指定寻找头文件的目录

  • 结论: 调用C语言标准库时用<>, 调用自己创建的头文件时用""

• #include的误区:

  • #include不是用来引入库的, 它只是把stdio.h当中的内容原封不动插入到了#include这一行

  • stdio.h里面只有printf的原型, printf的代码在另外的地方, 某个.lib(Windows)或.a(Unix)中

  • 现在的C语言编译器默认会引入所有的标准库

    • VS的标准库路径
      • D:\Windows Kits\10\Include\10.0.22000.0\ucrt\stdio.h

  • #include <stdio.h>只是为了让编译器知道printf函数的原型, 保证你调用时给出的参数值是正确的类型

• tips:

  • 在使用和定义这个函数的地方都应该#include这个头文件

  • 一般的做法就是任何.c都有对应的同名的.h, 把所有对外公开的函数的原型和全局变量的声明都放进去

• 不对外公开的函数:

  • 在函数前面加上static就使得它成为只能在所在的编译单元(所在的.c文件)中被使用的函数

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

#include <stdio.h>
#include "Max.h"

static int i = 1;

static int main(int argc, char const* argv[]) {
	int a = 5;
	int b = 6;
	printf("%d\n", max(a, b));
	return 0;
}

12.8. 声明

• 变量的声明:

  • int i;是变量的定义
  • extern int i;是变量的声明, 在声明的时候不能给变量初始化

• 声明和定义:

  • 声明是不产生代码的东西

    • 函数原型
    • 变量声明
    • 结构声明
    • 宏声明
    • 枚举声明
    • 类型声明
    • inline函数

  • 定义是产生代码的东西

• 头文件:

  • 只有声明可以被放在头文件中

    • 这是规范而不是规则

    • 如果将定义放在了头文件当中, 会造成一个项目中多个编译单元里有重名的实体

      • *某些编译器允许几个编译单元中存在同名的函数, 或者weak修饰来强调这种存在

• 重复声明:

  • 同一个编译单元里, 同名的结构不能被重复声明

  • 如果你的头文件里有结构的声明, 很难这个头文件不会在一个编译单元里被#include多次

  • 所以需要"标准头文件结构"

    • #ifndef _MAX_H_ //编译预处理指令, 意思是如果没有定义这个宏, 那么就定义这个宏, 如果已经定义了这个宏的话, 那么中间的它们中间的程序就不会出现在.i文件当中, 也就不会出现重复声明的情况

    • #define _MAX_H_ //那么就定义这个宏

    • #endif //结束

• 标准头文件结构:

	#ifndef _MAX_H_
	#define _MAX_H_

		struct Node {
			int value;
			char* name;
		};

		#endif

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

#include <stdio.h>
#include "Max.h"
#include "Min.h"

static int i = 1;

int main(int argc, char const* argv[]) {
	int a = 5;
	int b = 6;
	printf("%d\n", max(a, gAll));
	return 0;
}