Program environment and pretreatment

First look at what happened to the file , as follows ：

This article is mainly about the translation environment .

Program translation environment and execution environment

stay ANSI C In any implementation of , There are two different environments .

The first 1 One is the translation environment , In this environment, source code is converted into executable machine instructions . The first 2 One is the execution environment , It's used to actually execute code .

Detailed compilation + link

Each source file constituting a program is converted into object code through the compilation process （object code）.

Each target file is linked by a linker （linker） Tied together , Form a single and complete executable program .

Linkers also introduce standards C Any function in the function library used by the program , And it can search the programmer's personal library , Link the functions it needs to the program .

Take an example ： Different .c In the document , Want to reference a function , Make a statement like this .

It is mainly divided into the following parts ： 

 （ps: To view the header file information, you can find the installation directory ）

 

Precompile phase  

compile  

assembly  

.o Is in linux Generated under the system ,.obj Is in Windows Generated under the system . 

About the travel symbol table ： Different symbols have addresses .

The function of the linker is to merge segment tables ; 

The process of running a program ： 

1. The program must be loaded into memory . In an operating system environment ： This is usually done by the operating system . In an independent environment , The program must be loaded

Arranged by hand , It can also be done by putting executable code into read-only memory .

2. The execution of the procedure begins . And then I call main function .

3. Start executing program code . At this point, the program will use a runtime stack （stack）, Store function local variables and return address . The sequence is the same

You can also use static （static） Memory , Variables stored in static memory retain their values throughout the execution of the program .

4. To terminate the program . Normal termination main function ; It could be an accidental termination .

Predefined symbols

__STDC__    // If the compiler follows ANSI C, Its value is 1, Otherwise, it is not defined

Write a log file

#defifine

#defifine Define identifier

put questions to ：

stay defifine When defining identifiers , Do you want to add... At the end ; ?

If you don't add a semicolon ,return 0 Will be taken as for The following statement . Running successfully . （ A special case ）

It is better not to add a semicolon ： Examples are as follows

#define MAX 1000;

#define MAX 1000

if(condition)
 max = MAX;
else
 max = 0;

There will be syntax errors .IF Only one statement can be followed .

#defifine Defining macro

#defifine The mechanism includes a provision , Allow parameters to be replaced with text , This implementation is often called a macro （macro） Or define macro （defifine macro）.

The above code is risky

The solution is to add parentheses

Is the above code safe , Let's do another example

#define DOUBLE(x) (x) + (x)
int a = 5; 
printf("%d\n" ,10 * DOUBLE(a));
printf ("%d\n",10 * (5) + (5));
 This problem , The solution is to add a pair of parentheses around the macro definition expression .
#define DOUBLE( x) ( ( x ) + ( x ) )

#defifine Replacement rules

Extend... In a program #defifine When defining symbols and macros , There are several steps involved .

1. When calling a macro , First, check the parameters , See if it contains any information from #defifine Defined symbols . If it is , They are 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 #defifine Defined symbols . If it is , Repeat the above process .

Be careful ：

1. Macro parameters and #defifine Other... Can appear in the definition #defifine Variables defined . But for macros , No recursion .

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

What is in the string will not be replaced .

# and ##

At present, I want to realize such a function ：

When you want to enter different numbers ,a Is different .

Let's look at an example ：  Strings are naturally concatenated . The following three results are the same .

Use # , Change a macro parameter into the corresponding string .

## The role of

## You can combine the symbols on both sides of it into one symbol . It allows macro definitions to create identifiers from detached pieces of text .

 

notes ：

Such a connection must produce a legal identifier . Otherwise the result is undefined .

Macro parameters with side effects

When macro parameters appear more than once in the macro definition , If the parameter has side effects , Then you may be in danger when using this macro , guide

To unpredictable consequences . The side effect is the permanent effect of expression evaluation . for example ：

x+1;// No side effects 
x++;// With side effects 

 

The result of this code is the same , But the second will change a Value .

The front is false , So execute b++.10>11 For false . after a Increase to 11,b Increase to 12, First use 12 after , add 1, Turn into 13.

The difference between functions and macros . 

 

Then why not use functions to accomplish this task ？

There are two reasons ：

1. The code used to call and return from the function may take more time than actually performing this small computation . So the macro ratio function in the program In terms of scale and speed .

2. More importantly, the parameters of a function must be declared as specific types . So functions can only be used on expressions of the right type . On the contrary, how can this macro To be suitable for shaping 、 Long integer 、 Floating point type can be used for > To compare the types of . Macros are type independent .

Of course, compared with macros, functions also have disadvantages ：

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 .

Macros can sometimes do things that functions can't do . such as ： Macro parameters can appear type , But functions can't do it .

The macro passes a type . 

Naming conventions

Generally speaking, the syntax of function macro is very similar . So language itself can't help us distinguish the two . Well, one of our usual habits is ：

Capitalize all macro names Do not capitalize all function names

#undef

This instruction is used to remove a macro definition .

Command line definition

many C Our compiler provides a capability , Allows symbols to be defined on the command line . Used to start the compilation process . for example ： When we want to... According to the same source file When compiling different versions of a program , This feature is useful .（ Suppose an array of a certain length is declared in a program , If Machine memory is limited , We need a very small array , But the other machine's memory is uppercase , We need an array that can be capitalized .）

Conditional compilation

When compiling a program, if we want to translate a statement （ A set of statements ） It's convenient to compile or discard . Because we have conditional compilation instructions .

for instance ：

Debugging code , It's a pity , Reservation is in the way , So we can selectively compile

#include <stdio.h> 
#define __DEBUG__ 
int main() 
{ 
 int i = 0; 
 int arr[10] = {0}; 
 for(i=0; i<10; i++) 
 { 
 arr[i] = i; 
 #ifdef __DEBUG__ 
 printf("%d\n", arr[i]);// To see if the array assignment is successful . 
 #endif //__DEBUG__ 
 }
 return 0; 
}

See if it defines . Once defined, this statement will be executed .

  Common conditional compilation instructions ：

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

 

 

How header files are included ：

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 for headers in standard locations just as it looks for library function header files

file . 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 .

Is it possible to say , For library files, you can also use “” The form of includes ？

The answer is yes , Sure .

But this is less efficient , Of course, it is not easy to distinguish between library files and local files .

The beginning of each header file is written ：

#ifndef __TEST_H__

#define __TEST_H__

// Content of header file

#endif //__TEST_H__

perhaps ：

#pragma once

You can avoid the repeated introduction of header files .

Look at the offset ：

Use macro definitions to implement