C language - program compilation

C Program translation environment and execution environment .

Translation environment refers to the environment that converts source files into executable machine instructions , The execution environment is used to actually execute code .

In the translation environment , Each source file is converted into object code through compilation (obj), The target files are bound together by linkers

, Form a single executable program , The linker also links the functions in the function library to the program .

Compilation is divided into precompile ( Preprocessing ), compile , Assemble three stages .

In the precompile phase , Put the included header code into the source file , Conduct define Substitution of defined symbols , And the deletion of comments .

In the compilation phase , Through grammatical analysis , Semantic analysis , Lexical analysis , Symbol summary C Language code is translated into assembly language code .

In the assembly phase , Translate assembly language code into machine language .

Preprocessing instruction

// These predefined symbols are built into the language .
__FILE__      // Source files to compile 
__LINE__     // The current line number of the file 
__DATE__    // The date the file was compiled 
__TIME__    // When the file was compiled 
__STDC__    // If the compiler follows ANSI C, Its value is 1, Otherwise, it is not defined 

#define

Use define Define the indicator

#define name stuff

#define When defining an identifier , Better not add ;

Use #define Allow parameters to be replaced with text , This definition is called macro definition .

for example

#define SQUARE( x ) x * x

However, macro definitions used to evaluate numeric expressions should be properly bracketed , Avoid using macros due to operations in parameters

Unpredictable interactions between operators or adjacent operators .

#define The replacement rule of

1. When calling a macro , First, check the parameters , See if it contains any information from #define Defined symbols . If it is , Their head

Replaced first .

2. The replacement text is then inserted into the program at the location of the original text . For macros , Parameter names are replaced by their values .

3. Last , Scan the result file again , See if it contains any information from #define Defined symbols . If it is , Repeat the above process .

Be careful ：

1. Macro parameters and #define Other... Can appear in the definition #define Defined symbols . But for macros , No recursion .

2. When the preprocessor searches #define When defining symbols , The contents of string constants are not searched .

Advantages and disadvantages of macros ：

1. The code used to call and return from the function may take more time than actually performing this small computation .

So macros are better than functions in terms of program size and speed .

2. The parameters of a function must be declared as a specific type . So functions can only be used on expressions of the right type . On the contrary, how can macro

It can be applied to plastic surgery 、 Long integer 、 Floating point type, etc , The type used to compare . Macros are type independent .

The disadvantages of macro ：

1. Every time you use a macro , A macro defined code will be inserted into the program . Unless the macro is short , Otherwise, the length of the program may be greatly increased .

2. Macros can't be debugged .

3. Macro is type independent , It's not rigorous enough .

4. Macros can cause operator priority problems , It is easy for Cheng to make mistakes .

Conditional compilation

1.
#if  Constant expression 
 //
#endif
// Constant expressions are evaluated by the preprocessor .
 Such as ：
#define __DEBUG__ 1
#if __DEBUG__
 //..
#endif
2. Conditional compilation of multiple branches 
#if  Constant expression 
 //...
#elif  Constant expression 
 //...
#else
 //...
#endif
3. Judge whether it is defined 
#if defined(symbol)
#ifdef symbol
#if !defined(symbol)
#ifndef symbol
4. Nested instruction 
#if defined(OS_UNIX)
 #ifdef OPTION1
 unix_version_option1();
 #endif
 #ifdef OPTION2
 unix_version_option2();
 #endif
#elif defined(OS_MSDOS)
 #ifdef OPTION2
 msdos_version_option2();
 #endif
#endif

The header file contains

The local file contains :

#include "filename"

Search strategy ： First, find the source file in the directory , If the header file is not found , The compiler looks like a library function header file

Find header files in standard locations . If no compilation error is found .

The library file contains ：

#include <filename.h>

Look up the header file and go directly to the standard path , If no compilation error is found .

How to use Conditional compilation Avoid nesting repeated references that contain header files , Improve the efficiency of program execution .

Each header file begins with

#ifndef __TEST_H__
#define __TEST_H__
// Content of header file 
#endif   //__TEST_H__

perhaps

#pragma once