Deep understanding of the principles of include pre-Compilation

Do you know # What operations the compiler has done after a. h file is included? Do you know why static modification is required before the function is defined in the. h file? You know # ifndef ...... # Define ...... # Is endif the essence of preventing repeated header files? This article will discuss these issues and give my understanding and thoughts. You are welcome to leave a message.

1. # functions of the include command

1.1 when not to use include

 
 

  
  
// A. c file
  
  
 
  
  
Void test_a ()
  
  
{
  
  
Return;
  
  
}
  
  
 
  
  
 
  
  
// File B. c
  
  
 
  
  
Void test_a (); // function declaration
  
  
 
  
  
Void test_ B ()
  
  
{
  
  
Test_a (); // you can use
  
  
}
 
 

In fact, such a project does not need to use the include pre-compilation command.

1.2 When to use include

If there are a lot of functions in the project, follow the above practice, it must be in every. the beginning of file c lists the declarations of all functions called in this file, which is very inefficient. Once the form of a function changes, it must be changed one by one. function declaration starting with c.
Therefore, the # include pre-compiled command was created.

 
 

  
  
// A. c file
  
  
 
  
  
Void test_a ()
  
  
{
  
  
Return;
  
  
}
  
  
 
  
  
// A. H file
  
  
 
  
  
Void test_a ();
  
  
 
  
  
// File B. c
  
  
 
  
  
# Include "a. h" // contains the header file containing the test_a () function declaration
  
  
 
  
  
Void test_ B ()
  
  
{
  
  
Test_a ();
  
  
}
 
 

1.3 # What is the effect of include?

The above code encountered # include ". h ", the entire. h files are all copied to B. c. Therefore, B. before c, B. c has been modified to the following form:

 
 

  
  
// Temporary file after B. c pre-Compilation
  
  
 
  
  
Void test_a ();
  
  
 
  
  
Void test_ B ()
  
  
{
  
  
Test_a ();
  
  
}
 
 

It can be seen that the effect obtained is the same as that when test_a () function is manually added.

# Tips # in Linux, you can use gcc-E B. c to view the effect after pre-compiling B. c.

2. Use of static keywords

2.1 What is repeated function definition?

We often encounter errors, that is, repeated definitions of variables or functions. Here, I will give an example to illustrate what is the repeated definition of a function.

 
 

  
  
// A. c file
  
  
 
  
  
Void test ()
  
  
{
  
  
Return;
  
  
}
  
  
 
  
  
// File B. c
  
  
 
  
  
Void test ()
  
  
{
  
  
Return;
  
  
}
 
 

Therefore, no error will be reported during compilation, but an error will be reported during the link:

Multiple definition of 'test', because two test functions are defined in the same project.

2.2 write function implementation in. h

What will happen if function implementation is written in. h?

 
 

  
  
// A. H file
  
  
 
  
  
Void test_a ()
  
  
{
  
  
Return;
  
  
}
  
  
 
  
  
// File B. c
  
  
 
  
  
# Include "a. h"
  
  
 
  
  
Void test_ B ()
  
  
{
  
  
Test_a ();
  
  
}
 
 

After pre-compilation, you will find that B. c is modified to the following form:

 
 

  
  
// Temporary file after B. c pre-Compilation
  
  
 
  
  
Void test_a ()
  
  
{
  
  
Return;
  
  
}
  
  
 
  
  
Void test_ B ()
  
  
{
  
  
Test_a ();
  
  
}
 
 

Of course, there is no problem at present, and the link can be successfully compiled. However, what if there is a. h in c. c?

 
 

  
  
// C. c file
  
  
 
  
  
# Include "a. h"
  
  
 
  
  
Void test_c ()
  
  
{
  
  
Test_a ();
  
  
}
 
 

Same as above, c. c has formed the following code after pre-Compilation:

 
 

  
  
// Temporary file after c. c pre-Compilation
  
  
 
  
  
Void test_a ()
  
  
{
  
  
Return;
  
  
}
  
  
 
  
  
Void test_c ()
  
  
{
  
  
Test_a ();
  
  
}
 
 

Then, when the linker links), an error is reported:

Multiple definition of 'test _'

Therefore, the disadvantages of writing functions in. h are exposed. However, it is often necessary to set a function as an inline function and put it in the. h file. How can we prevent the above repeated definition errors?

2.3 static keywords

In response to the above situation, the static keyword solves this problem well.

If the static modifier is used, it indicates that the function can only be used in this file. Therefore, when the same function name in different files is modified by the static modifier, no repeated definition error is returned. For example:

 
 

  
  
// A. c file
  
  
 
  
  
Static void test ()
  
  
{
  
  
Return;
  
  
}
  
  
 
  
  
Void test_a ()
  
  
{
  
  
Test ();
  
  
}
  
  
 
  
  
// File B. c
  
  
 
  
  
Static void test ()
  
  
{
  
  
Return;
  
  
}
  
  
 
  
  
Void test_ B ()
  
  
{
  
  
Test ();
  
  
}
 
 

No error is reported during project compilation, but the test () function can only be called by functions in a. c and B. c, and cannot be called by functions in other files such as c. c.

So what is the effect of modifying the function defined in the. h file using static?

 
 

  
  
// A. H file
  
  
 
  
  
Static void test ()
  
  
{
  
  
Return;
  
  
}
  
  
 
  
  
// File B. c
  
  
 
  
  
# Include "a. h"
  
  
 
  
  
Void test_ B ()
  
  
{
  
  
Test ();
  
  
}
  
  
 
  
  
// C. c file
  
  
 
  
  
# Include "a. h"
  
  
 
  
  
Void test_c ()
  
  
{
  
  
Test ();
  
  
}
 
 

In this case, after pre-compilation, B. c and c. in the c file, because # include ". h ", so the static void test () function is defined at the beginning of the two files. Therefore, both test_ B () and test_c () call the static void test () function in their own files () function.

Therefore, the conclusion is that if you define a function in the. h file, we recommend that you add the static keyword to it. In this way, when multiple files are included, no repeated definition errors will be generated.

3. Prevent Repeated inclusion of header files

People who often write programs know that when we write. h files, we usually add

 
 

  
  
#ifndef    XXX 
  
  
#define   XXX  
  
  
…… 
  
  
#endif 
 
 

This is intended to prevent repeated inclusion of header files. What does it mean?

It is not to prevent multiple files from containing a certain header file, but to prevent a header file from being contained multiple times by the same file. The details are as follows:

 
 

  
  
// A. H file
  
  
 
  
  
Static void test_a ()
  
  
{
  
  
Return;
  
  
}
  
  
 
  
  
// File B. c
  
  
 
  
  
# Include "a. h"
  
  
 
  
  
Void test_ B ()
  
  
{
  
  
Test_a ();
  
  
}
  
  
 
  
  
// C. c
  
  
 
  
  
# Include "a. h"
  
  
 
  
  
Void test_c ()
  
  
{
  
  
Test_a ();
  
  
}
 
 

There is no problem with this, but there will be problems in this case.

 
 

  
  
// A. H file
  
  
 
  
  
Static void test_a ()
  
  
{
  
  
Return;
  
  
}
  
  
 
  
  
// B. H file
  
  
 
  
  
# Include "a. h"
  
  
 
  
  
// C. H file
  
  
 
  
  
# Include "a. h"
  
  
 
  
  
// Main. c file
  
  
 
  
  
# Include "B. h"
  
  
# Include "c. h"
  
  
 
  
  
Void main ()
  
  
{
  
  
Test_a ();
  
  
}
 
 

In this way, the problem is "accidentally", because B. h and c. h contains. h, in the pre-compiled main. the c file is displayed as follows:

 
 

  
  
// Temporary file after main. c pre-Compilation
  
  
 
  
  
Static void test_a ()
  
  
{
  
  
Return;
  
  
}
  
  
 
  
  
Static void test_a ()
  
  
{
  
  
Return;
  
  
}
  
  
 
  
  
Void main ()
  
  
{
  
  
Test_a ();
  
  
}
 
 

In the same. c file, two definitions of test_a () are displayed. Therefore, an error is returned for repeated definitions.

However, if # ifndef… is added to a. h ...... # Define ...... # Endif.

For example, the above a. h is changed:

 
 

  
  
// A. h file
  
  
 
  
  
# Ifndef A_H
  
  
# Define A_H
  
  
 
  
  
Static void test_a ()
  
  
{
  
  
Return;
  
  
}
  
  
 
  
  
# Endif
 
 

Pre-compile to expand main. c, the following will appear:

 
 

  
  
// Temporary file pre-compiled by main. c
  
  
 
  
  
# Ifndef A_H
  
  
# Define A_H
  
  
 
  
  
Static void test_a ()
  
  
{
  
  
Return;
  
  
}
  
  
 
  
  
# Endif
  
  
 
  
  
# Ifndef A_H
  
  
# Define A_H
  
  
 
  
  
Static void test_a ()
  
  
{
  
  
Return;
  
  
}
  
  
 
  
  
# Endif
  
  
 
  
  
Void main ()
  
  
{
  
  
Test_a ();
  
  
}
 
 

When compiling main. c, when the second # ifndef A_H is encountered, the Section code is skipped and will not be compiled because A_H has been defined previously. Therefore, no repeated definition errors will be reported. This is # ifndef ...... # Define ...... # The essence of endif.

This article from the "three shadows" blog, please be sure to keep this source http://ticktick.blog.51cto.com/823160/596179