c语言中include

① include是什么意思在c语言中

C语言作为高级语言，其基本特征就是用简单的助记符等等来代替以前的低级汇编语言，
对汇编语言的一些指令进行深度包装，用一批批的 #include<>头文件，将各特定的功能包装起来，

#include <>头文件引用，其中主要是一些基本变量，和其相应的函数定义声明。

希望对你有帮助

② c语言一个最最基础的问题——include的用法。

1、C语言预处理器指令#include用于在编译期间把制定文件的内容包含进当前文件中，又称文件包含指令。
在源文件中，任何形如
#include "文件名"
或
#include <文件名>
的行都被替换为由文件名指定的文件的内容。如果文件名用引号引起来，则在源文件所在位置查找该文件；如果在该位置没有找到文件，或者如果文件名是用<>括起来的，则将根据相应的规则查找该文件，这个规则同具体的实现有关。
2、被包含的文件本身也可以包含#include指令。如果某个被包含文件的内容发生了变化，那么所有依赖于该包含文件的源文件都必须重新编译。

③ 在C语言中，include,printf是什么意思

include是把后面的文件复制到你所写的源码文件，比如你在hello.c中写下了
#include <stdio.h>编译器会将stdio.h文件中的代码复制到hello.c中，这个过程有预处理器完成．

printf()是CI/O系统中的一个函数，用于输出相就的信息，它在stdio.h头文件中生成，关注0x30网络贴吧，关注C/C++

④ C语言中各种Include的文件及作用是什么

1. #include <assert.h>//设定插入点

2. #include <ctype.h> //字符处理

3. #include <errno.h> //定义错误码

4. #include <float.h> //浮点数处理

5. #include <fstream.h> //文件输入／输出

6. #include <iomanip.h> //参数化输入／输出

7. #include <iostream.h>//数据流输入／输出

8. #include <limits.h>//定义各种数据类型最值常量

9. #include <locale.h>//定义本地化函数

10. #include <math.h>//定义数学函数

11. #include <stdio.h> //定义输入／输出函数

12. #include <stdlib.h>//定义杂项函数及内存分配函数

13. #include <string.h>//字符串处理

14. #include <strstrea.h>//基于数组的输入／输出

15. #include <time.h>//定义关于时间的函数

16. #include <wchar.h> //宽字符处理及输入／输出

17. #include <wctype.h>//宽字符分类
    

⑤ C语言中各种Include的文件及作用

#include
//设定插入点
#include
//字符处理
#include
//定义错误码
#include
//浮点数处理
#include
//文件输入／输出
#include
//参数化输入／输出
#include
//数据流输入／输出
#include
//定义各种数据类型最值常量
#include
//定义本地化函数
#include
//定义数学函数
#include
//定义输入／输出函数
#include
//定义杂项函数及内存分配函数
#include
//字符串处理
#include
//基于数组的输入／输出
#include
//定义关于时间的函数
#include
//宽字符处理及输入／输出
#include
//宽字符分类
标准
c
（同上的不再注释）
#include
//stl
通用算法
#include
//stl
位集容器
#include
#include
#include
#include
#include
//复数类
#include
#include
#include
#include
#include
//stl
双端队列容器
#include
//异常处理类

⑥ C语言中#include什么意思

楼下说错了，所有的非标准头文件均必须使用""，比如#include<conio.h>会报错：无法找到该文件。
#include就是包含头文件
最基础的stdio.h是标准的输入输出文件，printf和scanf函数等在这当中。
同样的，自己也可以写头文件。
""可以直接指定头文件目录

⑦ C语言中，include是什么意思

include是一个计算机专业术语，C/C++中包含头文件命令，用于将指定头文件嵌入源文件中。

⑧ C语言中include是什么

#include "stdio.h"
#include "math.h"
main()
{
double x,s;
printf("input number:\n");
scanf("%lf",&x);
s=sin(x);
printf("sine of %lf is %lf\n",x,s);
}
预处理命令还有其它几种，这里的include 称为文件包含命令，其意义是把尖括号""或引号<>内指定的文件包含到本程序来，成为本程序的一部分。被包含的文件通常是由系统提供的，其扩展名为.h。因此也称为头文件或首部文件。C语言的头文件中包括了各个标准库函数的函数原型。因此，凡是在程序中调用一个库函数时，都必须包含该函数原型所在的头文件。在本例中，使用了三个库函数：输入函数scanf，正弦函数sin,输出函数printf。sin函数是数学函数，其头文件为math.h文件，因此在程序的主函数前用include命令包含了math.h。scanf和printf是标准输入输出函数，其头文件为stdio.h，在主函数前也用include命令包含了stdio.h文件。

⑨ c语言include的用法是什么

我整理了c语言 include的用法。希望对你有帮助哦!

其实这个只要了解了文件包含的基本处理方法就可以对文件包含有一个很好的理解与应用了，下来我们一起来看一下：

文件包含的处理方法：

处理时间：文件包含也是以"#"开头来写的(#include ), 那么它就是写给预处理器来看了, 也就是说文件包含是会在编译预处理阶段进行处理的。

处理方法：在预处理阶段，系统自动对#include命令进行处理，具体做法是:将所包含文件的内容复制到包含语句(#include )处，得到新的文件，然后再对这个新的文件进行编译。

一般情况下文件包含分为两种：包含.h文件和包含.c文件

1. 当然对于这两情况也都是按照上面说的方法来处理的。呵呵，这个肯定是没得说的.

2. 包含.c文件和编译多文件程序是不同的。

多文件程序: 是在源文件编译时把多个文件进行编译、连接在一起生成一个可执行文件。

包含.c文件: 按照我们上边的说法则是把多个文件合并为一个文件进行编译。

接下来通过例子看一下：

(1)包含.c文件:

1: //file1: main.c

2: #include

3: #include "fun.c"

4: int main()

5: {

6: int a=5,b=19;

7: c = a;

8: sun(a,b);

9: printf("c=%d/n",c);

10: return 0;

11: }

12: //end of file1

1: //file2: fun.c

2: int c=0;

3: void sun(int a, int b)

4: {

5: printf("a+b=%d/n",a+b);

6: c=0;

7: printf("c=%d/n",c);

8: }

9: //end of file2

10:

这个例子是采用包含.c文件的方法实现的。

在编译时，直接去编译main.c文件，预处理器会先把fun.c文件中的内容复制到main.c中来，然后再对新的main.c进行编译。

编译命令：

gcc main.c -o main

可以看到，这里并没有对fun.c进行编译，但还是生成了最终的main可执行程序。

也可以通过命令来观察一下预处理的结果：

编译命令：

gcc -E main.c -o main.cpp

在main.cpp文件末尾可以看来下面一段代码：

1: //main.cpp文件中

2: 931 # 2 "main.c" 2

3: 932 # 1 "fun.c" 1

4: 933 //注意这里是fun.c里边的内容

5: 934 int c=0;

6: 935 void sun(int a, int b)

7: 936 {

8: 937 printf("a+b=%d/n",a+b);

9: 938 c=0;

10: 939 printf("c=%d/n",c);

11: 940 }

12: //这里是main函数

13: 941 # 3 "main.c" 2

14: 942 int main()

15: 943 {

16: 944 int a=5,b=19;

17: 945 c = a;

18: 946 printf("c=%d/n",c);

19: 947 sun(a,b);

20: 948 printf("c=%d/n",c);

21: 949 return 0;

22: 950 }

可见，其实就是将fun.c文件中的内容添加到了main函数之前，然后对新的文件进行编译，生成最终的可执行程序。

(2)编译多文件程序：

同样是上边的例子，把main.c中“ #include "fun.c" ”注释掉，加上一句：“extern int c;”因为 c 变量在另外一个文件(fun.c)中定义。

1: //file1: main.c

2: #include

3: //#include "fun.c" //注释掉

4: extern int c; //添加这一句

5: int main()

6: {

7: int a=5,b=19;

8: c = a;

9: sun(a,b);

10: printf("c=%d/n",c);

11: return 0;

12: }

13: //end of file1

14:

15:

16: //file2: fun.c

17: int c=0;

18: void sun(int a, int b)

19: {

20: printf("a+b=%d/n",a+b);

21: c=0;

22: printf("c=%d/n",c);

23: }

24: //end of file2

这次如果还是按照上面的方法只编译main.c的话就会出错，因为变量c和函数sun并没有在main.c中定义，所以编译时需要将fun.c一起编译：

编译命令：

gcc -c main.c -o main.o #编译main.c

gcc -c fun.c -o fun.o #编译fun.c

gcc main.o fun.o -o main #用main.o fun.o生成main

好了，大家不防想想这两种方法的优缺点，这里就只写不足之处了：

1. 包含.c文件的方法: 容易产生"重定义",大家想想如果一个工程中有多个文件都同时包含了某一个件，那么这个被包含文件的内容就会被复制到多个文件中去，也就相当于每个包含该文件的文件中都定义被包含文件中的变量和函数，这样在链接时就会产生"重定义"错误。

2. 多文件分开编译的方法: 这个比较好，不容易出现"重定义"之类的问题，这也是我们最常用的一种方法，但是并不是像上面这个例子中这样直接去用，而是使用"头文件"将各个.c文件联系起来。

上边这个例子大家会发现，在main.c中需要加上“extern int c;”这样一句声明，如果包含的文件较多?如果全局变量较多?...这个我们可以省掉吗?回答是肯定的!方法就是给它写上一个头文件。

接下来看一下使用头文件的来实现这个例子的方法：

1: //file1: main.c

2: #include

3: #include "fun.h" //fun.c修改为fun.h

4: //extern int c; //这行也不要了

5: int main()

6: {

7: int a=5,b=19;

8: c = a;

9: sun(a,b);

10: printf("c=%d/n",c);

11: return 0;

12: }

13: //end of file1

1:

2: //file2: fun.c

3: #include "fun.h"

4: int c=0; //变量c的定义

5: void sun(int a, int b) //函数sun()的定义

6: {

7: printf("a+b=%d/n",a+b);

8: c=0;

9: printf("c=%d/n",c);

10: }

11: //end of file2

1: //file3: fun.h

2: extern int c; //把c声明为外部可用的

3: void sun(int a, int b); //sun()函数的声明

4: //end of file3

这样再看一下，在要用到fun.c中定义的函数或变量的文件中只要包含fun.h文件就可以了，是不是这样???呵呵，当然是了。。。

预处理时会把fun.h中的内容复制到包含它的文件中去，而复制的这些内容只是声名，不是定义，所以它被复制再多份也不会出现"重定义"的错误。。。

把同一类功能写到一个.c文件中，这样可以把他们划为一个模块，另外再对应的写上一个.h文件做它的声明。这样以后再使用这个模块时只需要把这两个文件添加进工程，同时在要使用模块内函数或变量的文件中包含.h文件就可以了。