c语言adds什么用法,C语言中，#include的用法：#include "" 和 #include<>区别

采用 "

"：依次搜索当前目录、包括/I编译开关的路径、包括INCLUDE环境变量的路径  采用<>：依次搜索包括/I编译开关的路径、包括INCLUDE环境变量的路径

The #include Directive

The #include directive tells the preprocessor to treat the contents

of a specified file as if those contents had appeared in the source

program at the point where the directive appears. You can organize

constant and macro definitions into include files and then use

#include directives to add these definitions to any source file.

Include files are also useful for incorporating declarations of

external variables and complex data types. You only need to define

and name the types once in an include file created for that

purpose.

Syntax

#include "path-spec"

#include

The path-spec is a filename optionally preceded by a directory

specification. The filename must name an existing file. The syntax

of the path-spec depends on the operating system on which the

program is compiled.

Both syntax forms cause replacement of that directive by the entire

contents of the specified include file. The difference between the

two forms is the order in which the preprocessor searches for

header files when the path is incompletely specified.

Syntax Form Action Quoted form This form instructs the preprocessor to look for

include files in the same directory of the file that contains the

#include statement, and then in the directories of whatever files

that include (#include) that file. The preprocessor then searches

along the path specified by the /I compiler option, then along

paths specified by the INCLUDE environment

variable. Angle-bracket form This form instructs the preprocessor to search

for include files first along the path specified by the /I compiler

option, then along the path specified by the INCLUDE environment

variable. The preprocessor stops searching as soon as it finds a file with

the given name. If you specify a complete, unambiguous path

specification for the include file between two sets of double

quotation marks (" "), the preprocessor searches only that path

specification and ignores the standard directories.

If the filename enclosed in double quotation marks is an incomplete

path specification, the preprocessor first searches the “parent”

file’s directory. A parent file is the file containing the #include

directive. For example, if you include a file named file2 within a

file named file1, file1 is the parent file.

Include files can be “nested”; that is, an #include directive can

appear in a file named by another #include directive. For example,

file2, above, could include file3. In this case, file1 would still

be the parent of file2 but would be the “grandparent” of

file3.

When include files are nested, directory searching begins with the

directories of the parent file and then proceeds through the

directories of any grandparent files. Thus, searching begins

relative to the directory containing the source currently being

processed. If the file is not found, the search moves to

directories specified by the /I compiler option. Finally, the

directories specified by the INCLUDE environment variable are

searched. The following example shows file inclusion using angle

brackets:

#include

This example adds the contents of the file named STDIO.H to the

source program. The angle brackets cause the preprocessor to search

the directories specified by the INCLUDE environment variable for

STDIO.H, after searching directories specified by the /I compiler

option.

The following example shows file inclusion using the quoted

form:

#include "defs.h"

This example adds the contents of the file specified by DEFS.H to

the source program. The double quotation marks mean that the

preprocessor searches the directory containing the parent source

file first.

Nesting of include files can continue up to 10 levels. Once the

nested #include is processed, the preprocessor continues to insert

the enclosing include file into the original source file.

Microsoft Specific To locate includable source files, the preprocessor first searches

the directories specified by the /I compiler option. If the /I

option is not present or fails, the preprocessor uses the INCLUDE

environment variable to find any include files within angle

brackets. The INCLUDE environment variable and /I compiler option

can contain multiple paths separated by semicolons (;). If more

than one directory appears as part of the /I option or within the

INCLUDE environment variable, the preprocessor searches them in the

order in which they appear.

For example, the command

CL /ID:\MSVC\INCLUDE MYPROG.C

causes the preprocessor to search the directory D:\MSVC\INCLUDE for

include files such as STDIO.H. The commands

SET INCLUDE=D:\MSVC\INCLUDE

CL MYPROG.C

have the same effect. If both sets of searches fail, a fatal

compiler error is generated.

If the filename is fully specified for an include file with a path

that includes a colon (for example, F:\MSVC\SPECIAL\INCL\TEST.H),

the preprocessor follows the path.

For include files specified as #include "path-spec", directory

searching begins with the directory of the parent file and then

proceeds through the directories of any grandparent files. Thus,

searching begins relative to the directory containing the source

file containing the #include directive being processed. If there is

no grandparent file and the file has not been found, the search

continues as if the filename were enclosed in angle brackets.

END Microsoft Specific