- Third, the use of attention
Description: This C language topic is the prelude to learning iOS development. And for programmers with an object-oriented language development experience, you can quickly get started with C language. If you don't have programming experience, or are not interested in C or iOS development, please ignore.
This is about the last preprocessing directive---file contains
First, the basic concept
Actually, we had a contact. The file contains this directive, which is # include, which can copy the entire contents of a file into another file.
Ii. General Form
1.1th form # include < file name >
Find files directly in the directory where the C-language library function header files are located
2.2nd form #include "file name"
The system will look in the current directory of the source program, if not found, and then to the operating system path path to find, and finally to the C library function header file in the same directory to find
Third, the use of attention
1. #include指令允许嵌套包含, for example, A.H contains b.h,b.h containing c.h, but does not allow recursive inclusion, such as A.H contains B.h,b.h.
The following procedure is wrong
2. Using the # include directive may result in a single header file being included multiple times, reducing compilation efficiency
For example, the following conditions:
A one function is declared in One.h, and One.h is included in the Two.h, by the way, a single function is declared. (This does not write the implementation of the function, that is, the definition of the function)
If I want to use one and two two functions in main.c, and sometimes we don't necessarily know that two.h contains one.h, we might do this:
The code for MAIN.C after the pre-processing of the compilation is this:
1 void One (), 2 void One (), 3 void (), 4 int main () 5 {6 7 return 0;8}
Line 1th is caused by the # include "One.h", and the 2nd, 3 lines are caused by the # include "Two.h" (because Two.h contains one.h). As you can see, the one function is declared 2 times and is not necessary at all, which reduces compilation efficiency.
In order to solve this problem of repeating the same header file, we usually write the contents of the header file:
To explain the meaning, take one.h for example: When we first include "one.h", because there is no definition of _one_h_, so the condition of the 9th line is established, and then the 10th line defines the _ONE_H_ this macro, and then declare the one function in line 13, Finally, the conditional compilation ends in line 15. When the second # include "One.h", because previously defined _ONE_H_ this macro, so the 9th line of the condition is not set, jump directly to the 15th line of #endif, end conditional compilation. This is the simple 3-sentence code that prevents one.h content from being repeatedly included.
In this case, the MAIN.C:
#include "one.h" #include "two.h"
It becomes:
1//#include "one.h" 2 #ifndef _one_h_ 3 #define _ONE_H_ 4 5 void One (), 6 7 #endif 8 9//#include "two.h" 10 #ifndef _two_h_11 #define _two_h_12//#include "one.h" #ifndef _one_h_15 #define _ONE_H_16 void One (); #end If20 (); #endif
The 7th line of section 2~ is caused by the # include "One.h", and the 23rd line of section 10~ is caused by the # include "Two.h". After the preprocessing of the compilation, it becomes:
1 void One (); 2 void ();
This is the result we want.
C language 17-preprocessing directive 3-file contains