C语言进阶 12. 程序结构

勇远热爱

于 2024-07-28 15:07:35 发布

阅读量554

点赞数 30

分类专栏： C语言文章标签： c语言

本文链接：https://blog.csdn.net/tzy18739738749/article/details/140736860

版权

C语言专栏收录该内容

21 篇文章 0 订阅

订阅专栏

C语言进阶 12. 程序结构

文章目录

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;
}