C语言学习笔记之程序结构

程序结构

全局变量

全局变量

1.定义在函数外部的变量就叫全局变量
2.全局变量具有全局的生存期和作用域
3.它们与任何函数都无关
4.在任何函数内部都可以使用它们

全局变量初始化

1.没有做初始化的全局变量会得到0值
2.指针会得到NULL值
3.只能用编译时刻已知的值来初始化全局变量
不能实现：

int a=10;
int b=a;
int main(){...

但可以：

const int a=10;
int b=a;
int main(){...

4.它们的初始化发生在main函数之前
5.如果在子函数内定义了一个与全局变量相同的变量，全局变量将被隐藏。

静态本地变量

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

补充：
1.静态本地变量实际上是特殊的全局变量
2.它们位于相同的内存区域
3.静态本地变量具有全局的生存期，函数内的局部作用
——static在这里的意思是局部作用域（本地可访问）
测试代码：

#include<stdio.h>
int a=2;
int main(){
	int k=0;
	static int b=1;
	printf("&a=%p\n",&a);
	printf("&b=%p\n",&b);
	printf("&k=%p\n",&k);
	return 0;
} 

结果：

&a=0000000000403010
&b=0000000000403014
&k=000000000062FE1C

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

*返回指针的函数

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

#include<stdio.h>
int* f(void);
void g(void);
int main(){
	int *p=f();
	printf("*p=%d\n",*p);
	g();
	printf("*p=%d\n",*p);
	return 0;
} 
int* f(void){
	int a=1;
	printf("&a=%d\n",&a);
	return &a;
}
void g(void){
	int b=2;
	printf("b=%d\n",b);
	printf("&b=%d\n",&b);
}

结果：

&a=6487516
*p=1
b=2
&b=6487516
*p=2

因为在函数结束后本地变量会消亡！！

tips

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

编译预处理和宏

宏定义

编译预处理指令

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

没有值的宏

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

预定义的宏

_LINE_//行号
_FILE_//文件名
_DATE_//定义的日期
_TIME_//定义的时间
_STDC_

带参数的宏

类似于函数

#include<stdio.h>
#define cube(x) ((x)*(x)*(x))
int main()
{
printf("%d\n",cube(5));
return 0;
}

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

错误定义的宏

#include<stdio.h>
#define RADTODEG1(x) (x*57.29578)
#define RADTODEG2(x) (x)*57.29578
int main()
{
	printf("%f\n",RADTODEG1(5+2));
	printf("%f\n",180/RADTODEG2(1));
	return 0;
}	

结果：

119.591560
10313.240400

带参数的宏的原则

1.一切都要括号
a.整个值要括号
b.参数出现的每个地方都要括号
2.#define RADTODEG(x) ((x)*57.29578)
3.宏定义的最后不要加分号！

总结：

1.在大型程序的代码中使用非常普遍
2.可以非常复杂，如“产生”函数
在#和##两个运算符帮助下
3.存在中西方文化差异
4.部分宏会被inline函数代替

其他编译预处理指令

1.条件编译
2.error
3.。。。

大程序结构

多个源代码文件

思路：
{
1.main（）里的代码太长了适合分成几个函数
2.一个源代码文件太长了适合分成几个文件
3.两个独立的源代码文件不能编译形成可执行的程序
}

项目

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

头文件

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

include

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

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

include的误区

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

不对外公开的函数

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

声明

标准头文件结构：

#ifndef __LIST_HEAD__
#define __LIST_HEAD__
#include "node.h"
typedef struct _list{
	Node* head;
	Node* tail;
	} List;
	#endif 

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