C语言中.h和.c文件解析
程序设计基础C-题库-1
11、请简述printf（）函数的作用。 答案：
printf()printf()“Hello, world\n”“\n”
12、请简述C语言中main（）函数的作用。 答案： main函数是C程序的入口函数,即程序的执行是从main函数开始
程序设计基础C-题库
1、计算机语言按照高低级别可分为机器语言、 、 三大类。 答案： 汇编语言 ； 高级语言 ；
2、C语言中源文件的后缀名为 。 答案： *.c;.c ； 解析：
3、在程序中，如果使用printf()函数，应该包含 头文件。 答案： stdio.h ； 解析：
4、在main()函数中，用于返回函数执行结果的是 语句。 答案： return ；
15、下列关于主函数说法错误的是（ ）
A、 一个C程序中只能包含一个主函数 B、 主函数是C程序的入口 C、 C程序中可以包含多个主函数 D、 主函数只能包含输出语句 答案： CD
16、下列选项中，不属于C语言优点的是
A、 不依赖计算机硬件 B、 简洁、高效 C、 可移植 D、 面向对象 答案： D
5、C语言程序在Windows平台下经过编译、连接后生成的可执行文件后缀是 。 答案： .exe ；
6、C语言并不属于高级语言。 答案： 错误
7、计算机语言（Computer Language）是人与计算机之间通信的语言。 答案： 正确
8、C语言并不能实现汇编语言的大部分功能。 答案： 错误
9、Eclipse工具和Visual Studio工具都可以开发C语言。 答案： 正确
17、下列选项中，哪一个是多行注释？
A、 // B、 /**/ C、 \\ D、 以上均不属于 答案： B
c语言中.c文件与.h文件的关联
c语言中.c文件与.h文件的关联
一般一个C文件要搭配一个H文件，两者文件名相同，如 UART.c 对于UART.h ，其它函数通过#include"UART.h",来调用UART.c里面定义的函数和变量
H文件里面是对同名的C文件里面内容的声明，C文件必须include同名的头文件，一般C文件需要用到的其它头文件（比如stdio.h）,也在H文件里包含,见下面的例子
头文件一般要写成条件包含，这样在重复包含时，编译器自动把已经包含过的文件忽略掉
#ifndef __XXX_H
#define__XXX_H
#include
.....
#endif
C文件里面写好的函数，要在对于的H文件挂个名，叫其它包含这个H的C文件知道这个函数的存在
H文件就像一个销售部，C文件是生产部，客户了解一个公司的产品都是从销售部了解的，不会关注他是怎么生产的；另一方面，销售部挂的东西，都是根据生产部来的，两个文件的关系基本可以用这个来比喻
C文件里面定义的全局变量要在头文件里面加extern 声明，叫其它包含这个H的C文件知道这里还有个全局变量
H文件里面可以定义宏，什么是宏？看--> #define LEDBLINK() PORTA ^= (1<< LED) C文件直接使用LEDBLINK(); 编译之前会用PORTA ^= (1<< LED) 来进行替换
其它结构体也是要在H里面定义类型，但是必须在C文件里面例化。
C语言中.h和.c文件解析
C语言中.h和.c文件解析简单的说其实要理解C文件与头文件（即.h）有什么不同之处，首先需要弄明白编译器的工作过程，一般说来编译器会做以下几个过程：1.预处理阶段2.词法与语法分析阶段3.编译阶段，首先编译成纯汇编语句，再将之汇编成跟CPU相关的二进制码，生成各个目标文件(.obj文件)4.连接阶段，将各个目标文件中的各段代码进行绝对地址定位，生成跟特定平台相关的可执行文件，当然，最后还可以用objcopy生成纯二进制码，也就是去掉了文件格式信息。
（生成.exe文件）编译器在编译时是以C文件为单位进行的，也就是说如果你的项目中一个C文件都没有，那么你的项目将无法编译，连接器是以目标文件为单位，它将一个或多个目标文件进行函数与变量的重定位，生成最终的可执行文件，在PC上的程序开发，一般都有一个main函数，这是各个编译器的约定，当然，你如果自己写连接器脚本的话，可以不用main函数作为程序入口！！！！（main .c文件目标文件可执行文件）有了这些基础知识，再言归正传，为了生成一个最终的可执行文件，就需要一些目标文件，也就是需要C文件，而这些C文件中又需要一个main函数作为可执行程序的入口，那么我们就从一个C文件入手，假定这个C文件内容如下：#include#include "mytest.h"int main(int argc,char **argv){test = 25;printf("test.................%d\n",test);}头文件内容如下：int test;现在以这个例子来讲解编译器的工作：1.预处理阶段：编译器以C文件作为一个单元，首先读这个C文件，发现第一句与第二句是包含一个头文件，就会在所有搜索路径中寻找这两个文件，找到之后，就会将相应头文件中再去处理宏，变量，函数声明，嵌套的头文件包含等，检测依赖关系，进行宏替换，看是否有重复定义与声明的情况发生，最后将那些文件中所有的东东全部扫描进这个当前的C文件中，形成一个中间“C文件”2.编译阶段，在上一步中相当于将那个头文件中的test变量扫描进了一个中间C文件，那么test 变量就变成了这个文件中的一个全局变量，此时就将所有这个中间C文件的所有变量，函数分配空间，将各个函数编译成二进制码，按照特定目标文件格式生成目标文件，在这种格式的目标文件中进行各个全局变量，函数的符号描述，将这些二进制码按照一定的标准组织成一个目标文件3.连接阶段，将上一步成生的各个目标文件，根据一些参数，连接生成最终的可执行文件，主要的工作就是重定位各个目标文件的函数，变量等，相当于将个目标文件中的二进制码按一定的规范合到一个文件中再回到C文件与头文件各写什么内容的话题上：理论上来说C文件与头文件里的内容，只要是C语言所支持的，无论写什么都可以的，比如你在头文件中写函数体，只要在任何一个C文件包含此头文件就可以将这个函数编译成目标文件的一部分（编译是以C文件为单位的，如果不在任何C文件中包含此头文件的话，这段代码就形同虚设），你可以在C文件中进行函数声明，变量声明，结构体声明，这也不成问题！！！那为何一定要分成头文件与C文件呢？又为何一般都在头件中进行函数，变量声明，宏声明，结构体声明呢？而在C文件中去进行变量定义，函数实现呢？？原因如下：1.如果在头文件中实现一个函数体，那么如果在多个C文件中引用它，而且又同时编译多个C文件，将其生成的目标文件连接成一个可执行文件，在每个引用此头文件的C文件所生成的目标文件中，都有一份这个函数的代码，如果这段函数又没有定义成局部函数，那么在连接时，就会发现多个相同的函数，就会报错2.如果在头文件中定义全局变量，并且将此全局变量赋初值，那么在多个引用此头文件的C文件中同样存在相同变量名的拷贝，关键是此变量被赋了初值，所以编译器就会将此变量放入DATA段，最终在连接阶段，会在DATA段中存在多个相同的变量，它无法将这些变量统一成一个变量，也就是仅为此变量分配一个空间，而不是多份空间，假定这个变量在头文件没有赋初值，编译器就会将之放入 BSS段，连接器会对BSS段的多个同名变量仅分配一个存储空间3.如果在C文件中声明宏，结构体，函数等，那么我要在另一个C文件中引用相应的宏，结构体，就必须再做一次重复的工作，如果我改了一个C文件中的一个声明，那么又忘了改其它C文件中的声明，这不就出了大问题了，程序的逻辑就变成了你不可想象的了，如果把这些公共的东东放在一个头文件中，想用它的C文件就只需要引用一个就OK了！！！这样岂不方便，要改某个声明的时候，只需要动一下头文件就行了4.在头文件中声明结构体，函数等，当你需要将你的代码封装成一个库，让别人来用你的代码，你又不想公布源码，那么人家如何利用你的库呢？也就是如何利用你的库中的各个函数呢？？一种方法是公布源码，别人想怎么用就怎么用，另一种是提供头文件，别人从头文件中看你的函数原型，这样人家才知道如何调用你写的函数，就如同你调用printf函数一样，里面的参数是怎样的？？你是怎么知道的？？还不是看人家的头文件中的相关声明啊！！！当然这些东东都成了C标准，就算不看人家的头文件，你一样可以知道怎么使用c语言中.c和.h文件的困惑本质上没有任何区别。
c语言.h文件例子
c语言.h文件例子C语言中的.h文件通常是头文件，用于声明函数、变量和常量等。
它们通常包含在C源代码文件中，以便在多个文件中共享这些声明。
下面我将从不同角度给出关于C语言.h文件的例子。
1. 函数声明：一个.h文件中可以包含函数的声明。
例如，一个名为math.h的头文件可以包含数学函数的声明，如下所示：c.// math.h.#ifndef MATH_H.#define MATH_H.int add(int a, int b);float divide(float a, float b);#endif.这里，我们使用了#ifndef、#define和#endif来防止头文件被多次包含。
2. 变量声明：头文件还可以包含变量的声明。
例如，一个名为constants.h的头文件可以包含常量的声明，如下所示：c.// constants.h.#ifndef CONSTANTS_H.#define CONSTANTS_H.#define PI 3.14159。
extern int globalVar;#endif.这里，我们使用了#define来定义常量，使用extern关键字来声明全局变量，但不进行定义。
3. 结构体和类型声明：头文件还可以包含结构体和自定义类型的声明。
例如，一个名为structs.h的头文件可以包含结构体和类型的声明，如下所示：c.// structs.h.#ifndef STRUCTS_H.#define STRUCTS_H.typedef struct {。
int x;int y;} Point;typedef enum {。
RED,。
GREEN,。
BLUE.} Color;#endif.这里，我们使用了typedef关键字来定义新的数据类型。
4. 宏定义：头文件还可以包含宏定义，用于简化代码中的重复操作。
例如，一个名为macros.h的头文件可以包含宏定义，如下所示：c.// macros.h.#ifndef MACROS_H.#define MACROS_H.#define MAX(x, y) ((x) > (y) ? (x) : (y))。
c语言“h”和〈h〉
c语言“h”和〈h〉【最新版】目录1.C 语言中的"h"和"<h>"的含义2."h"和"<h>"的用途3.编写示例代码正文C 语言中的"h"和"<h>"是预处理指令，它们在编译过程中被处理，而不是在运行时被解释。
这两个预处理指令分别代表不同的功能，但它们都与头文件有关。
"h"指令用于声明一个头文件，它会在编译时将指定的头文件内容复制到当前源文件中。
这种方式可以避免头文件被重复包含，同时也可以提高编译效率。
例如，如果我们在源文件中使用"#include <stdio.h>"，那么编译器会在编译时将 stdio.h 文件的内容复制到源文件中，以便后续的编译工作。
而"<h>"指令则用于包含一个头文件，它会在编译时将指定的头文件内容直接插入到当前源文件中。
这种方式会导致头文件被重复包含，因此通常不推荐使用。
不过，在某些特定情况下，比如在使用某些第三方库时，可能需要使用"<h>"指令来包含头文件。
为了更好地理解这两个预处理指令，我们可以通过以下示例代码来说明：示例 1：使用"h"指令```c#include "example.h"int main() {printf("Hello, world!");return 0;}```在这个示例中，我们使用"#include"指令来包含 example.h 头文件。
在编译时，编译器会将 example.h 文件的内容复制到这个源文件中，然后进行编译。
示例 2：使用"<h>"指令```c#include <example.h>int main() {printf("Hello, world!");return 0;}```在这个示例中，我们使用"#include"指令来包含 example.h 头文件。
c语言中头文件书写格式
在C语言中，头文件（header files）通常包含函数声明和宏定义，它们为源文件（source files）提供信息。
头文件以`.h`为后缀，通常采用简单的文本格式进行编写。
下面是一个示例，展示了C语言头文件的基本书写格式：```c/* 这是注释，用于说明头文件的目的和内容*/#ifndef HEADER_FILE_NAME_H // 如果未定义HEADER_FILE_NAME_H#define HEADER_FILE_NAME_H // 定义HEADER_FILE_NAME_H/* 在这里声明函数和定义宏*/// 函数声明示例void function_name(parameter_type parameter_name);// 宏定义示例#define MACRO_NAME value#endif /* HEADER_FILE_NAME_H */```这是一个典型的C语言头文件模板。
下面是对各个部分的解释：1. **注释**：头文件的顶部通常包含注释，用于解释头文件的目的和内容。
2. **防止头文件重复包含的保护**：这一部分确保头文件不会被重复包含。
`#ifndef`、`#define` 和`#endif` 是预处理器指令，它们在头文件被包含时确保只有一次定义。
`HEADER_FILE_NAME_H` 是你自己定义的名称，通常采用大写字母和下划线命名法。
3. **函数声明**：函数声明在头文件中以原型形式出现，告诉编译器函数的名称、返回类型以及参数。
例如，`void function_name(parameter_type parameter_name);` 是一个函数声明的示例。
4. **宏定义**：使用`#define` 预处理器指令可以定义宏。
例如，`#define MACRO_NAME value` 定义了一个名为`MACRO_NAME` 的宏，其值为`value`。
5. **结束保护**：最后再次使用`#endif` 来结束防止重复包含的保护。
11.c语言中的h文件与c文件的理解、编写及使用
#include "alt_types.h"
#include "sys/alt_stdio.h"
#include <sys/alt_irq.h>
#include <stdio.h>
#include <string.h>
#include "altera_avalon_uart_regs.h"
4.在头文件中声明结构体，函数等，当你需要将你的代码封装成一个库，让别人来用你的代码，你又不想公布源码，那么人家如何利用你的库呢？也就是如何利用你的库中的各个函数呢？？一种方法是公布源码，别人想怎么用就怎么用，另一种是提供头文件，别人从头文件中看你的函数原型，这样人家才知道如何调用你写的函数，就如同你调用printf函数一样，里面的参数是怎样的？？你是怎么知道的？？还不是看人家的头文件中的相关声明啊！！！当然这些东东都成了C标准，就算不看人家的头文件，你一样可以知道怎么使用.
//还请高手能指点。warning: implicit declaration of function
//`alt_irq_register' test3 uart_zx.h，加上中断的头文件#include <sys/alt_irq.h>
c语言“h”和〈h〉
c语言“h”和〈h〉在C语言中，我们可以使用两种不同的方式引用头文件：使用引号（"")和尖括号（<>）。
下面将详细讨论这两种引用头文件的区别和使用方法。
1. 使用引号（""）引用头文件：以引号括起来的头文件引用表示该头文件是在当前目录或在用户指定的路径中查找。
通常，这种方式用于引用自己编写的头文件。
示例代码如下：```#include "file.h"```上述代码将在当前目录中查找名为 file.h 的头文件并引用它。
如果找不到该文件，则编译器会报错。
2. 使用尖括号（<>）引用头文件：以尖括号括起来的头文件引用表示该头文件是在系统路径中查找。
这种方式通常用于引用标准库或第三方库提供的头文件。
示例代码如下：``````上述代码将在系统路径中查找名为stdio.h 的头文件并引用它。
编译器会按照默认搜索路径来查找该头文件。
尖括号引用头文件时，编译器通常会搜索以下几个默认的系统路径（具体路径根据系统和编译器而定）：- 系统标准库路径- 环境变量中指定的路径- 编译器默认的路径在实际开发中，我们需要根据实际情况选择适合的引用方式。
下面列出了两种引用方式的一些适用场景：- 当我们编写的程序需要引用自己编写的头文件时，应该使用引号引用方式，这样可以确保编译器能够找到我们自己编写的头文件。
例如：```#include "utils.h"```- 当我们引用系统标准库或第三方库的头文件时，应该使用尖括号引用方式，因为这些头文件一般都被安装在系统指定路径下。
例如：```#include <stdlib.h>```在使用引号引用头文件时，我们还可以使用相对路径或绝对路径来指定头文件的位置。
例如，如果我们的头文件位于项目目录下的 include 文件夹中，我们可以像下面这样引用它：```#include "../include/utils.h"```这样，编译器会根据相对路径找到 utils.h 头文件并引用它。
C语言中的.h和.c文件
C语⾔中的.h和.c⽂件
1.h为头⽂件，.c为源⽂件，其实两者都是代码，没有实质性的区别，只是后缀不⼀样，是⼀种编程规范，主要是为了解决定义与调⽤之间的混乱。
2.h⽂件⼀般写⼀些函数声明、宏定义、结构体等内容；c⽂件是程序⽂件，内含程序的具体实现。
3.当⼀个.c⽂件需要使⽤另⼀个.c⽂件中的某个函数，此时只需要包含头⽂件，即可调⽤另⼀个.c⽂件中的函数
4.头⽂件和源⽂件区分开来有⼏点好处：⼀是头⽂件⽤于共享，只⽤⼀句#include就能包含；⼆是如果你要写库，⼜不想暴露你的源代码，可以把.c编译成.obj或是.lib发给别⼈⽤，然后把.h作为使⽤说明书。
c语言标准函数获取文件名 -回复
c语言标准函数获取文件名-回复C语言标准函数是一种用于编写C程序的工具。
它们由C语言标准库提供，并具有标准化的接口规范，以便程序员可以在不同的平台上轻松地编写可移植的代码。
其中，获取文件名的函数是一个非常常用的功能，因为它允许程序获取正在处理的文件的名称并进行相应的操作。
在本文中，我们将一步一步地回答有关如何在C语言中使用标准函数来获取文件名的问题。
第一步：包含头文件在C语言中，标准库函数通常定义在不同的头文件中。
如果我们想要使用获取文件名的函数，我们需要包含`<stdio.h>` 头文件。
这个头文件包含了一系列有关输入和输出的函数的声明，其中包括了一些获取文件名的函数的声明。
c#include <stdio.h>第二步：打开文件要获取文件名，我们首先需要打开文件。
这可以通过使用`fopen` 函数来实现。
`fopen` 函数的功能是打开指定路径的文件，并返回一个文件指针，供后续的文件操作使用。
以下是一个使用`fopen` 函数打开文件的例子：cFILE *file;file = fopen("filename.txt", "r");在上面的例子中，我们使用了`fopen` 函数打开了名为`filename.txt` 的文件，并赋值给了一个名为`file` 的文件指针。
第三步：获取文件名一旦我们打开了文件，我们可以使用其他标准函数来获取文件名。
C语言中，获取文件名的方法有很多种，这里我们介绍两种常用的方法。
# 方法一：使用`basename()`函数`basename()` 函数是C语言标准库中的一个函数，它允许我们获取一个文件路径的文件名部分。
`basename()` 函数的功能是去掉路径部分，只保留文件名。
以下是一个使用`basename()` 函数获取文件名的例子：c#include <libgen.h> basename函数的声明位于此头文件中char *filename = basename("path/to/filename.txt");printf("文件名是：s\n", filename);在上面的例子中，我们使用了`basename()` 函数获取了`path/to/filename.txt` 的文件名部分，并将其存储在一个名为`filename` 的字符指针中。
c语言 头文件互引用
c语言头文件互引用
C语言头文件互引用是指两个或多个头文件相互包含的情况。
在C语言中，头文件是扩展名为.h的文件，包含了C函数声明和宏定义，被多个源文件中引用共享。
一、头文件互引用会导致以下问题：
1．编译错误：如果两个头文件互相包含，会导致编译器无法确定哪个头文件应该先被包含，从而导致编译错误。
2．重复定义：如果两个头文件都定义了相同的宏或函数，会导致重复定义错误。
3．代码膨胀：头文件互引用会导致代码膨胀，降低代码可读性和可维护性。
二、为了避免头文件互引用问题，可以采取以下措施：
1．使用ifndef/endif宏：使用ifndef/endif宏可以防止重复定义。
2．使用pragma once：使用pragma once可以防止头文件被重复包含。
3．合理组织头文件：将相关的头文件组织在一起，可以减少头文件之间的依赖关系。
C语言头文件组织与包含原则
C语⾔头⽂件组织与包含原则说明本⽂假定读者已具备基本的C编译知识。
如⾮特殊说明，⽂中“源⽂件”指*.c⽂件，“头⽂件”指*.h⽂件，“引⽤”指包含头⽂件。
⼀、头⽂件作⽤C语⾔⾥，每个源⽂件是⼀个模块，头⽂件为使⽤该模块的⽤户提供接⼝。
接⼝指⼀个功能模块暴露给其他模块⽤以访问具体功能的⽅法。
使⽤源⽂件实现模块的功能，使⽤头⽂件暴露单元的接⼝。
⽤户只需包含相应的头⽂件就可使⽤该头⽂件中暴露的接⼝。
通过头⽂件包含的⽅法将程序中的各功能模块联系起来有利于模块化程序设计:1）通过头⽂件调⽤库功能。
在很多场合，源代码不便(或不准)向⽤户公布，只要向⽤户提供头⽂件和⼆进制库即可。
⽤户只需按照头⽂件中的接⼝声明来调⽤库功能，⽽不必关⼼接⼝如何实现。
编译器会从库中提取相应的代码。
2）头⽂件能加强类型安全检查。
若某个接⼝的实现或使⽤⽅式与头⽂件中的声明不⼀致，编译器就会指出错误。
这⼀简单的规则能⼤⼤减轻程序员调试、改错的负担。
在预处理阶段，编译器将源⽂件包含的头⽂件内容复制到包含语句(#include)处。
在源⽂件编译时，连同被包含进来的头⽂件内容⼀起编译，⽣成⽬标⽂件(.obj)。
如果所包含的头⽂件⾮常庞⼤，则会严重降低编译速度(使⽤GCC的-E选项可获得并查看最终预处理完的⽂件)。
因此，在源⽂件中应仅包含必需的头⽂件，且尽量不要在头⽂件中包含其它头⽂件。
⼆、头⽂件组织原则源⽂件中实现变量、函数的定义，并指定链接范围。
头⽂件中书写外部需要使⽤的全局变量、函数声明及数据类型和宏的定义。
建议组织头⽂件内容时遵循以下原则：1）头⽂件划分原则：类型定义、宏定义尽量与函数声明相分离，分别位于不同的头⽂件中。
内部函数声明头⽂件与外部函数声明头⽂件相分离，内部类型定义头⽂件与外部类型定义头⽂件相分离。
注意，类型和宏定义有时⽆法分拆为不同⽂件，⽐如结构体内数组成员的元素个数⽤常量宏表⽰时。
因此仅分离类型宏定义与函数声明，且分别置于*.th和*.fh⽂件(并⾮强制要求)。
c语言中timeh用法详解
c语言中time.h用法详解C语言中的time.h头文件是用于日期和时间处理的头文件，它包含了各种与时间相关的数据类型、函数和宏。
下面详细介绍time.h头文件的一些常见用法。
1.数据类型time.h头文件中定义了以下常见的时间相关数据类型：•time_t：时间类型，通常为长整型，用于表示时间。
•clock_t：时钟类型，通常为长整型，用于表示CPU时间。
•tm：时间结构体，用于表示时间。
2.函数time.h头文件中定义了很多与时间相关的函数，以下是一些常用的函数：•time(time_t *tloc)：获取当前的时间，并将时间值存储在tloc指向的time_t类型的变量中。
•clock(clock_t *clk)：获取当前程序执行的CPU时间，并将时间值存储在clk指向的clock_t类型的变量中。
•difftime(time_t time2, time_t time1)：计算两个时间之间的差值，返回值是两个时间相差的秒数。
•mktime(struct tm *timeptr)：将tm结构体中的时间转换为time_t类型的时间，并返回转换后的时间值。
•localtime(time_t *timeptr)：将time_t类型的时间转换为本地时间，并将本地时间存储在timeptr指向的tm结构体中。
•gmtime(time_t *timeptr)：将time_t类型的时间转换为协调世界时（UTC），并将转换后的时间存储在timeptr指向的tm结构体中。
3.宏time.h头文件中还定义了一些与时间相关的宏，以下是一些常用的宏：•CLOCKS_PER_SEC：表示每秒钟的CPU时钟数。
•TIME_UTC：表示协调世界时（UTC）的常量。
•asctime(const struct tm *timeptr)：将tm结构体中的时间转换为字符串形式，并返回一个指向该字符串的指针。
•strftime(char *s, size_t max, const char *format, const struct tm *timeptr)：按照指定的格式将时间转换为字符串，并将转换结果存储在s指向的字符数组中，最多存储max个字符。
C51资料-头文件
c51头文件的作用与c头文件的作用类似。
absacc。
h——-包含允许直接访问8051不同存储区的宏定义assert。
h-——文件定义assert宏，可以用来建立程序的测试条件ctype.h—--字符转换和分类程序intins。
h——-文件包含指示编译器产生嵌入式固有代码的程序的原型math.h—-—数学程序reg51.h--—51的特殊寄存器reg52。
h---52的特殊寄存器setjmp。
h—-—定义jmp_buf类型和setjmp和longjmp程序的原型stdarg.h—--可变长度参数列表程序stdlib.h—--存储器分配程序stdio。
h--—流输入和输出程序string。
h———字符转操作程序，缓冲区操作程序单片机中用c编程时头文件reg51。
h及reg52。
h解析我们在用c语言编程是往往第一行就是reg51.h或者其他的自定义头文件,我们怎么样来理解呢？1）“文件包含”处理。
程序的第一行是一个“文件包含”处理。
所谓“文件包含”是指一个文件将另外一个文件的内容全部包含进来。
程序中包含REG51.h文件的目的是为了要使用P1 （还有其他更多的符号）这个符号，即通知C 编译器，程序中所写的P1 是指80C51 单片机的P1 端口而不是其它变量。
这是如何做到的呢？打开reg51。
h 可以看到这样的一些内容：（此文件一般在C：\KEIL\C51\INC下,INC文件夹根目录里有不少头文件，并且里面还有很多以公司分类的文件夹，里面也都是相关产品的头文件.如果我们要使用自己写的头文件，使用的时候只需把对应头文件拷贝到INC文件夹里就可以了.) #ifndef __REG51_H__＃define __REG51_H__sfr P0 = 0x80；。
.。
.。
.。
.。
.。
..sbit TI = 0x99;sbit RI = 0x98；＃endif熟悉80C51 内部结构的读者不难看出，这里都是一些符号的定义,即规定符号名与地址的对应关系.注意其中有sfr P1 = 0x90；这样的一行，即定义P1 与地址0x90 对应，P1 口的地址就是0x90（0x90 是C 语言中十六进制数的写法，相当于汇编语言中写90H）。
c语言中头文件的作用和使用方法
c语言中头文件的作用和使用方法C语言中头文件的作用和使用1. 什么是头文件？在C语言中，头文件是包含一些预定义的常量、宏定义、函数声明或数据结构定义的文件。
头文件的扩展名通常为.h，它可以被包含在C语言源代码中，以便在编译时进行预处理。
2. 头文件的作用头文件的主要作用有以下几点：•提供函数和变量的声明：头文件中可以包含函数的声明，使得其他源代码文件可以调用声明在头文件中的函数，而不需要重复写函数的原型声明。
•定义常量和宏：头文件中可以包含常量和宏的定义，以便在不同的源代码文件中共享使用。
•实现模块化编程：通过将相关函数和变量的声明和定义放在同一个头文件中，可以实现代码的模块化，提高代码的可读性和可维护性。
•提高编译速度：由于头文件中的内容可以在编译前进行预处理，预处理器会将头文件的内容直接复制到源代码文件中，避免了重复代码的输入，也可以加快编译速度。
3. 头文件的使用3.1 包含头文件在C语言源代码中，通过使用#include指令可以包含头文件。
一般情况下，包含头文件的方式有两种：•使用尖括号<>包含系统提供的头文件：例如#include <stdio.h>，这种方式会在系统目录中查找相应的头文件。
•使用双引号""包含自定义的头文件：例如#include"myheader.h"，这种方式会首先在当前目录中查找相应的头文件，如果找不到再去系统目录中查找。
3.2 防止重复包含由于头文件的常见作用是提供声明和定义，为了防止多次包含同一个头文件引起的重定义错误，可以在头文件中使用预处理指令#ifndef、#define、#endif进行包含防护。
#ifndef MYHEADER_H#define MYHEADER_H// 头文件内容#endif这样，在多个源代码文件中包含同一个头文件时，只会包含一次，避免了重复定义的错误。
4. 常见的C标准库头文件C语言提供了一些常见的标准库头文件，包含了一些常用的函数和宏定义。
51单片机C语言中.c文件和.h文件的关联
1 方便开发:包含一些文件需要的共同的常量,结构,类型定义,函数,变量申明；
2 提供接口:对一个软件包来说可以提供一个给外界的接口(例如: stdio.h)。
2)h文件里应该有什么
常量,结构,类型定义,函数,变量申明。
3)h文件不应该有什么
变量定义, 函数定义。
{
unsigned int i,j;
for(j=n;j>0;j--)
for(i=112;i>0;i--);
}
在主程序main.c中
＃i nclude <delay.h> //在主程序包含.h文件，不能包含.c文件
模块划分的"划"是规划的意思，意指怎样合理的将一个很大的软件划分为一系列功能独立的部分合作完成系统的需求。C语言作为一种结构化的程序设计语言，在模块的划分上主要依据功能（依功能进行划分在面向对象设计中成为一个错误，牛顿定律遇到了相对论），C语言模块化程序设计需理解如下概念：
（1）模块即是一个.c文件和一个.h文件的结合，头文件(.h)中是对于该模块接口的声明；
5）C51包含头文件方法
/eleclike/52862/message.aspx
4）.c 和 .h文件的不同
/mfantastic/blog/item/d6fddd39793494f73a87ce0c.html
（2）某模块提供给其它模块调用的外部函数及数据需在.h中文件中冠以extern关键字声明；
（3）模块内的函数和全局变量需在.c文件开头冠以static关键字声明；
（4）永远不要在.h文件中定义变量！定义变量和声明变量的区别在于定义会产生内存分配的操作，是汇编阶段的概念；而声明则只是告诉包含该声明的模块在连接阶段从其料：
c语言中math.h的用法
c语言中math.h的用法
在C语言中，math.h是一个头文件，用于提供数学函数的声明。
这个头文件中包含了常见的数学函数，比如三角函数、指数函数、
对数函数、幂函数等。
通过包含math.h头文件，我们可以在程序中
使用这些数学函数来进行数学运算。
首先，我们需要在程序中包含math.h头文件，这样我们就可以
使用这个头文件中声明的数学函数了。
例如，我们可以这样包含math.h头文件：
#include <math.h>。
一些常见的数学函数包括：
三角函数，sin、cos、tan、asin、acos、atan等。
指数函数，exp、log、log10等。
幂函数，pow、sqrt等。
取整函数，ceil、floor等。
绝对值函数，fabs.
四舍五入函数，round.
这些函数可以帮助我们在C程序中进行各种复杂的数学运算，比如计算三角函数的值、求取对数、进行幂运算等等。
使用这些函数可以让我们的程序更加灵活和功能强大。
另外，math.h头文件中还定义了一些常量，比如π（M_PI）、自然对数的底（M_E）等，这些常量可以在程序中直接使用，方便我们进行数学计算。
总之，math.h头文件为C语言提供了丰富的数学函数和常量，可以帮助我们在程序中进行各种复杂的数学运算，是C语言中非常重要的一个头文件。
希望这些信息能够帮助你更好地理解math.h的用法。
C++——头文件的作用,C语言中的.h头文件到底有什么用？
C++——头文件的作用,C语言中的.h头文件到底有什么用？每个C++/C程序通常分为两个文件。
一个文件用于保存程序的声明（declaration），称为头文件。
另一个文件用于保存程序的实现（implementation），称为定义（definition）文件。
C++/C程序的头文件以“.h”为后缀，C程序的定义文件以“.c”为后缀，C++程序的定义文件通常以“.cpp”为后缀（也有一些系统以“.cc”或“.cxx”为后缀）。
1.1版权和版本的声明版权和版本的声明位于头文件和定义文件的开头（参见示例1-1），主要内容有：（1）版权信息。
（2）文件名称，标识符，摘要。
（3）当前版本号，作者/修改者，完成日期。
（4）版本历史信息。
/** Copyright (c) 2001,老妖工作室* All rights reserved.** 文件名称：filename.h* 文件标识：见配置管理计划书* 摘要：简要描述本文件的内容** 当前版本：1.1* 作者：输入作者（或修改者）名字* 完成日期：2001年7月20日** 取代版本：1.0* 原作者：输入原作者（或修改者）名字* 完成日期：2001年5月10日*/示例1-1 版权和版本的声明1.2 头文件的结构头文件由三部分内容组成：（1）头文件开头处的版权和版本声明（参见示例1-1）。
（2）预处理块。
（3）函数和类结构声明等。
假设头文件名称为 graphics.h，头文件的结构参见示例1-2。
【规则1-2-1】为了防止头文件被重复引用，应当用ifndef/define/endif结构产生预处理块。
【规则1-2-2】用 #include <filename.h>格式来引用标准库的头文件（编译器将从标准库目录开始搜索）。
【规则1-2-3】用 #include “filename.h”格式来引用非标准库的头文件（编译器将从用户的工作目录开始搜索）。
【建议1-2-1】头文件中只存放“声明”而不存放“定义”在C++ 语法中，类的成员函数可以在声明的同时被定义，并且自动成为内联函数。
C语言中.h与.c解析
(1)、混淆你的概念，让你无法分析出几个物理过程，或某个物理过程遵循的那条物理定律；
(2)、存在高次方程，列出方程也解不出。而后者已经是数学的范畴了，所以说，最难之处还在于掌握清晰的概念；
程序设计也是如此，如果概念很清晰，那基本上没什么难题(会难在数学上，比如算法的选择、时间空间与效率的取舍、稳定与资源的平衡上)。但是，要掌握清晰的概念也没那么容易。比如下面这个例子，看看你有没有很清晰透彻的认识。
2、答：1中已经回答过了。
3、答：不会。问这个问题的人绝对是概念不清，要不就是想混水摸鱼。非常讨厌的是中国的很多考试出的都是这种烂题，生怕别人有个清楚的概念了，绝对要把考生搞晕。
搞清楚语法和概念说易也易，说难也难。窍门有三点：
不要晕着头工作，要抽空多思考思考，多看看书；
看书要看好书，问人要问强人。烂书和烂人都会给你一个错误的概念，误导你；
int main(int argc,char **argv)
{
test = 25;
printf("test.................%d\n",test);
}
头文件内容如下：
int test;
现在以这个例子来讲解编译器的工作：
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
C语言中.h和.c文件解析20468104728 2010-1-9 15:32:30 收藏 | 打印 | 投票(1) | 评论(0) | 阅读(156) ◇字体：［大中小］---By xiaoxiaopig收集简单的说其实要理解C文件与头文件（即.h）有什么不同之处，首先需要弄明白编译器的工作过程，一般说来编译器会做以下几个过程：1.预处理阶段2.词法与语法分析阶段3.编译阶段，首先编译成纯汇编语句，再将之汇编成跟CPU相关的二进制码，生成各个目标文件 (.obj文件)4.连接阶段，将各个目标文件中的各段代码进行绝对地址定位，生成跟特定平台相关的可执行文件，当然，最后还可以用objcopy生成纯二进制码，也就是去掉了文件格式信息。
（生成.exe文件）编译器在编译时是以C文件为单位进行的，也就是说如果你的项目中一个C文件都没有，那么你的项目将无法编译，连接器是以目标文件为单位，它将一个或多个目标文件进行函数与变量的重定位，生成最终的可执行文件，在PC上的程序开发，一般都有一个main函数，这是各个编译器的约定，当然，你如果自己写连接器脚本的话，可以不用main函数作为程序入口！！！！（main .c文件目标文件可执行文件）有了这些基础知识，再言归正传，为了生成一个最终的可执行文件，就需要一些目标文件，也就是需要C文件，而这些C文件中又需要一个main函数作为可执行程序的入口，那么我们就从一个C文件入手，假定这个C文件内容如下：#include#include "mytest.h"int main(int argc,char **argv){test = 25;printf("test.................%d\n",test);}头文件内容如下：int test;现在以这个例子来讲解编译器的工作：1.预处理阶段：编译器以C文件作为一个单元，首先读这个C文件，发现第一句与第二句是包含一个头文件，就会在所有搜索路径中寻找这两个文件，找到之后，就会将相应头文件中再去处理宏，变量，函数声明，嵌套的头文件包含等，检测依赖关系，进行宏替换，看是否有重复定义与声明的情况发生，最后将那些文件中所有的东东全部扫描进这个当前的C文件中，形成一个中间“C文件”2.编译阶段，在上一步中相当于将那个头文件中的test变量扫描进了一个中间C文件，那么test变量就变成了这个文件中的一个全局变量，此时就将所有这个中间C文件的所有变量，函数分配空间，将各个函数编译成二进制码，按照特定目标文件格式生成目标文件，在这种格式的目标文件中进行各个全局变量，函数的符号描述，将这些二进制码按照一定的标准组织成一个目标文件3.连接阶段，将上一步成生的各个目标文件，根据一些参数，连接生成最终的可执行文件，主要的工作就是重定位各个目标文件的函数，变量等，相当于将个目标文件中的二进制码按一定的规范合到一个文件中再回到C文件与头文件各写什么内容的话题上：理论上来说C 文件与头文件里的内容，只要是C语言所支持的，无论写什么都可以的，比如你在头文件中写函数体，只要在任何一个C文件包含此头文件就可以将这个函数编译成目标文件的一部分（编译是以C文件为单位的，如果不在任何C文件中包含此头文件的话，这段代码就形同虚设），你可以在C文件中进行函数声明，变量声明，结构体声明，这也不成问题！！！那为何一定要分成头文件与C文件呢？又为何一般都在头件中进行函数，变量声明，宏声明，结构体声明呢？而在C文件中去进行变量定义，函数实现呢？？原因如下：1.如果在头文件中实现一个函数体，那么如果在多个C文件中引用它，而且又同时编译多个C文件，将其生成的目标文件连接成一个可执行文件，在每个引用此头文件的C文件所生成的目标文件中，都有一份这个函数的代码，如果这段函数又没有定义成局部函数，那么在连接时，就会发现多个相同的函数，就会报错2.如果在头文件中定义全局变量，并且将此全局变量赋初值，那么在多个引用此头文件的C 文件中同样存在相同变量名的拷贝，关键是此变量被赋了初值，所以编译器就会将此变量放入DATA段，最终在连接阶段，会在DATA段中存在多个相同的变量，它无法将这些变量统一成一个变量，也就是仅为此变量分配一个空间，而不是多份空间，假定这个变量在头文件没有赋初值，编译器就会将之放入 BSS段，连接器会对BSS段的多个同名变量仅分配一个存储空间3.如果在C文件中声明宏，结构体，函数等，那么我要在另一个C文件中引用相应的宏，结构体，就必须再做一次重复的工作，如果我改了一个C文件中的一个声明，那么又忘了改其它C文件中的声明，这不就出了大问题了，程序的逻辑就变成了你不可想象的了，如果把这些公共的东东放在一个头文件中，想用它的C文件就只需要引用一个就OK了！！！这样岂不方便，要改某个声明的时候，只需要动一下头文件就行了4.在头文件中声明结构体，函数等，当你需要将你的代码封装成一个库，让别人来用你的代码，你又不想公布源码，那么人家如何利用你的库呢？也就是如何利用你的库中的各个函数呢？？一种方法是公布源码，别人想怎么用就怎么用，另一种是提供头文件，别人从头文件中看你的函数原型，这样人家才知道如何调用你写的函数，就如同你调用printf函数一样，里面的参数是怎样的？？你是怎么知道的？？还不是看人家的头文件中的相关声明啊！！！当然这些东东都成了C标准，就算不看人家的头文件，你一样可以知道怎么使用c语言中.c和.h文件的困惑本质上没有任何区别。
只不过一般：.h文件是头文件，内含函数声明、宏定义、结构体定义等内容.c文件是程序文件，内含函数实现，变量定义等内容。
而且是什么后缀也没有关系，只不过编译器会默认对某些后缀的文件采取某些动作。
你可以强制编译器把任何后缀的文件都当作c文件来编。
这样分开写成两个文件是一个良好的编程风格。
而且，比方说我在aaa.h里定义了一个函数的声明，然后我在aaa.h的同一个目录下建立aaa.c ， aaa.c里定义了这个函数的实现，然后是在main函数所在.c文件里#include这个aaa.h 然后我就可以使用这个函数了。
main在运行时就会找到这个定义了这个函数的aaa.c文件。
这是因为：main函数为标准C/C++的程序入口，编译器会先找到该函数所在的文件。
假定编译程序编译myproj.c（其中含main()）时，发现它include了mylib.h（其中声明了函数void test()），那么此时编译器将按照事先设定的路径（Include路径列表及代码文件所在的路径）查找与之同名的实现文件（扩展名为.cpp或.c，此例中为mylib.c），如果找到该文件，并在其中找到该函数（此例中为void test()）的实现代码，则继续编译；如果在指定目录找不到实现文件，或者在该文件及后续的各include文件中未找到实现代码，则返回一个编译错误.其实include的过程完全可以“看成”是一个文件拼接的过程，将声明和实现分别写在头文件及C文件中，或者将二者同时写在头文件中，理论上没有本质的区别。
以上是所谓动态方式。
对于静态方式，基本所有的C/C++编译器都支持一种链接方式被称为Static Link，即所谓静态链接。
在这种方式下，我们所要做的，就是写出包含函数，类等等声明的头文件（a.h,b.h,...），以及他们对应的实现文件（a.cpp,b.cpp,...），编译程序会将其编译为静态的库文件（a.lib,b.lib,...）。
在随后的代码重用过程中，我们只需要提供相应的头文件（.h）和相应的库文件（.lib），就可以使用过去的代码了。
相对动态方式而言，静态方式的好处是实现代码的隐蔽性，即C++中提倡的“接口对外，实现代码不可见”。
有利于库文件的转发.c文件和.h文件的概念与联系如果说难题最难的部分是基本概念，可能很多人都会持反对意见，但实际上也确实如此。
我高中的时候学物理，老师抓的重点就是概念——概念一定要搞清，于是难题也成了容易题。
如果你能分析清楚一道物理难题存在着几个物理过程，每一个过程都遵守那一条物理定律(比如动量守恒、牛II定律、能量守恒)，那么就很轻松的根据定律列出这个过程的方程，N个过程必定是N个N元方程，难题也就迎刃而解。
即便是高中的物理竞赛难题，最难之处也不过在于：(1)、混淆你的概念，让你无法分析出几个物理过程，或某个物理过程遵循的那条物理定律；(2)、存在高次方程，列出方程也解不出。
而后者已经是数学的范畴了，所以说，最难之处还在于掌握清晰的概念；程序设计也是如此，如果概念很清晰，那基本上没什么难题(会难在数学上，比如算法的选择、时间空间与效率的取舍、稳定与资源的平衡上)。
但是，要掌握清晰的概念也没那么容易。
比如下面这个例子，看看你有没有很清晰透彻的认识。
//a.hvoid foo();//a.c#include "a.h" //我的问题出来了：这句话是要，还是不要？void foo(){return;}//main.c#include "a.h"int main(int argc, char *argv[]){foo();return 0;}针对上面的代码，请回答三个问题：a.c 中的 #include "a.h" 这句话是不是多余的？为什么经常见 xx.c 里面 include 对应的 xx.h？如果 a.c 中不写，那么编译器是不是会自动把 .h 文件里面的东西跟同名的 .c 文件绑定在一起？（请针对上面3道题仔细考虑10分钟，莫要着急看下面的解释。
:) 考虑的越多，下面理解的就越深。
）好了，时间到！请忘掉上面的3道题，以及对这三道题引发出的你的想法，然后再听我慢慢道来。
正确的概念是：从C编译器角度看，.h和.c皆是浮云，就是改名为.txt、.doc 也没有大的分别。
换句话说，就是.h和.c没啥必然联系。
.h中一般放的是同名.c文件中定义的变量、数组、函数的声明，需要让.c外部使用的声明。
这个声明有啥用？只是让需要用这些声明的地方方便引用。
因为 #include "xx.h" 这个宏其实际意思就是把当前这一行删掉，把 xx.h 中的内容原封不动的插入在当前行的位置。
由于想写这些函数声明的地方非常多（每一个调用 xx.c 中函数的地方，都要在使用前声明一下子），所以用 #include "xx.h" 这个宏就简化了许多行代码——让预处理器自己替换好了。
也就是说，xx.h 其实只是让需要写 xx.c 中函数声明的地方调用（可以少写几行字），至于 include 这个 .h 文件是谁，是 .h 还是 .c，还是与这个 .h 同名的 .c，都没有任何必然关系。