Extern and extern "C" analysis

Extern

Extern is a keyword in C/C ++ that indicates the range (visibility) of functions and global variables. it tells the compiler that the declared functions and variables can be used in this module or other modules.

1. For the extern variable, it is just a declaration of the variable, instead of defining the allocation of memory space. If the variable is defined multiple times, a connection error occurs.

2. In general, the function and global variables referenced by this module to other modules are declared with the keyword extern in the module header file. That is to say, the C file defines that if the function or variable is open to the outside, it will be declared with extern in the H file. Therefore, only include the H file for external files. In addition, this function cannot be found outside of the compilation stage, but no error is reported. The link stage will generate the target from the definition moduleCodeFind this function.

3. The keyword corresponding to extern is static. The global variables and functions modified by it can only be used in this module.

1 problem:It is often seen that extern is placed before the function to become part of the function declaration. So, what is the role of the C language keyword extern in the function declaration?

Answer and analysis:

If the function declaration contains the keyword extern, it only implies that the function may be defined in other source files and has no other function. There is no obvious difference between the following two function declarations: extern int fun () and INT fun ();
Of course, such use is still available, that isProgramIn some complex projects, I prefer to add the extern modifier before all function declarations.

2 problem: extern variable

An array is defined in a source file:
Char A [6];
In another file, the statement is declared using the following statement:
Extern char *;

Can this be done?

Answer and analysis:

1) No. Illegal access will be reported during the program running. The reason is that the pointer to type T is not equivalent to the array of type T. Extern char * A declares a pointer variable instead of a character array. Therefore, it is different from the actual definition, resulting in invalid access during runtime. Change the Declaration to extern char a [].

2) The example analysis is as follows. If a [] = "ABCD", the external variable a = 0x61626364 (the ASCII code value of ABCD), * A is obviously meaningless, for example:

Obviously, the space (0x61626364) that a points to is meaningless and prone to illegal memory access.

3) This reminds us that we must strictly match the declared format when using extern. In actual programming, such errors are not uncommon.

4) extern is often used in variable declaration *. the C file declares a global variable. If the global variable is to be referenced, it is placed in *. H and use extern to declare.

3 problem: extern function 1

It is often seen that extern is placed before the function to become part of the function declaration. So, what is the role of the C language keyword extern in the function declaration?

Answer and analysis:

If the function declaration contains the keyword extern, it only implies that the function may be defined in other source files and has no other function. There is no obvious difference between the following two function declarations:

Extern int F (); and int f ();

Of course, such use is still available, that is, replacing include "*. h "to declare the function. In some complicated projects, I prefer to add the extern modifier before all the function declarations.

4 problem: extern function 2

When the function provider unilaterally modifies the function prototype, if the user does not know to continue to use the original extern statement, the compiler will not report an error during compilation. However, during the running process, a system error is often caused by missing or missing input parameters. How can this problem be solved?

Answer and analysis:

Currently, the industry does not have a perfect solution to deal with this situation. The common practice is that the provider provides external interface declarations in its own xxx_pub.h, and then the caller includes the header file, in this way, the extern step is omitted. To avoid such errors.

Baojian has a dual front. For the application of extern, different practices should be selected for different occasions.

Extern "C"

An enterprise once gave the following interview questions:

Interview Questions

Why do standard header files have a structure similar to the following?

# Ifndef _ incvxworksh

# DEFINE _ incvxworksh

# Ifdef _ cplusplus

Extern "C "{

# Endif

/*...*/

# Ifdef _ cplusplus

}

# Endif

# Endif/* _ incvxworksh */

Analysis

Obviously, the compilation macro "# ifndef _ incvxworksh, # DEFINE _ incvxworksh, and # endif" in the header file is used to prevent the header file from being repeatedly referenced.

So

# Ifdef _ cplusplus

Extern "C "{

# Endif

# Ifdef _ cplusplus

}

# Endif

What is the role?

Extern "C" contains a double meaning, which can be obtained literally: first, the target is "extern", and second, the target is "C. Let's explain these two meanings in detail.

(1) The function or variable specified by extern "C" is of the extern type;

Extern is a keyword in C/C ++ that indicates the range (visibility) of functions and global variables. This keyword tells the compiler, the declared functions and variables can be used in this module or other modules. Remember, the following statements:

Extern int;

It is just a declaration of a variable. It does not define variable A and does not allocate memory space for variable. Variable A can only be defined once as a global variable in all modules. Otherwise, a connection error occurs.

In general, the function and global variables referenced by this module to other modules are declared with the keyword extern in the module header file. For example, if Module B wants to reference the global variables and functions defined in module A, it only needs to include the header file of module. In this way, when Module B calls a function in module A, although Module B cannot find the function in the compilation phase, no error is reported; it will find this function from the target Code Compiled by module A in the connection phase.

The keyword corresponding to extern is static. The global variables and functions modified by it can only be used in this module. Therefore, a function or variable can only be used by this module and cannot be modified by extern "C.

(2) variables and functions modified by extern "C" are compiled and connected in C language;

Compilation Method without the extern "C" declaration

First, let's take a look at how C-like functions are compiled in C ++.

As an object-oriented language, C ++ supports function overloading, while Procedural Language C does not. The name of the function in the symbol library after being compiled by C ++ is different from that in the C language. For example, assume that the prototype of a function is:

Void Foo (int x, int y );

After the function is compiled by the C compiler, its name in the symbol library is _ Foo, while the C ++ compiler generates names such as _ foo_int_int (different compilers may generate different names, but all adopt the same mechanism, and the new name is called "mangled name "). A name such as _ foo_int_int contains the function name, number of function parameters, and type information. c ++ relies on this mechanism to implement function overloading. For example, in C ++, the symbols generated by void Foo (int x, int y) and void Foo (int x, float y) are different, the latter is _ foo_int_float.

Similarly, variables in C ++ support both local variables and class member variables and global variables. The class member variables of the program written by the user may have the same name as the global variables, which are distinguished. In essence, when the compiler is compiling, it is similar to the function processing, and it also takes a unique name for the variables in the class, this name is different from the global variable name with the same name in the user program.

Connection method when extern "C" is not added

Suppose in C ++, the header file of module A is as follows:

// Module A header file modulea. h

# Ifndef module_a_h

# Define module_a_h

Int Foo (int x, int y );

# Endif

Reference this function in Module B:

// Module B implements the file moduleb. cpp

# I nclude "modulea. H"

Foo (2, 3 );

In fact, in the connection phase, the connector looks for symbols such as _ foo_int_int from the target file modulea. OBJ generated by module!

Compilation and Connection Methods After the extern "C" clause is added

After the extern "C" statement is added, the header file of module A is changed:

// Module A header file modulea. h

# Ifndef module_a_h

# Define module_a_h

Extern "C" int Foo (int x, int y );

# Endif

In Module B's implementation file, Foo (2, 3) is still called. The result is:

(1) When module A compiles and generates the foo target code, it does not perform special processing on its name and uses the C language;

(2) When the connector looks for the Foo (2, 3) call for the target code of Module B, it looks for the unmodified symbol name _ Foo.

If the function in module A declares that foo is of the extern "C" type, and Module B contains the extern int Foo (INT X, int y ), module B cannot find the function in module A, and vice versa.

Therefore, we can summarize the true purpose of the statement "extern" C "in one sentence (the birth of any syntax feature in any language is not random and comes from the needs of the real world. When thinking about a problem, we should not just focus on how the language is made, but also ask why it is doing so and what the motivation is, so that we can better understand many problems ):

Realize mixed programming of C ++, C and other languages.

Understand the motivation for setting up extern "C" in C ++. Next we will analyze the common usage skills of extern "C.

4. Usage of extern "C"

(1) To reference functions and variables in C language in C ++, the following processing must be performed when the C Language header file (assumed as cexample. h) is included:

Extern "C"

{

# I nclude "cexample. H"

}

In the header file of the C language, the external function can only be specified as the extern type. The C language does not support the extern "C" declaration. when the c file contains extern "C", a compilation syntax error occurs.

C ++ compiled by the author references the three files in the C function example projectSource codeAs follows:

/*C LanguageHeader file: cexample. H */

# Ifndef c_example_h

# Define c_example_h

Extern int add (int x, int y );

# Endif

/* C language implementation file: cexample. C */

# I nclude "cexample. H"

Int add (int x, int y)

{

Return X + Y;

}

// C ++ implementation file, call Add: cppfile. cpp

Extern "C"

{

# I nclude "cexample. H"

}

Int main (INT argc, char * argv [])

{

Add (2, 3 );

Return 0;

}

If C ++ calls a. dll written in C language, when it includes the header file of. dll or the declared interface function, it should add extern "C "{}.

(2) When referencing functions and variables in C ++ in C, the header file of C ++ needs to add extern "C ", however, you cannot directly reference this header file that declares extern "C" in C. You should only declare the extern "C" function defined in C ++ as the extern type.

The source code of the three files contained in the example project of C ++ is as follows:

// C ++ header file cppexample. h

# Ifndef cpp_example_h

# Define cpp_example_h

Extern "C" int add (int x, int y );

# Endif

// C ++ implementation file cppexample. cpp

# I nclude "cppexample. H"

Int add (int x, int y)

{

Return X + Y;

}

/* C implementation file cfile. c

/* Compilation errors: # I nclude "cexample. H "*/

Extern int add (int x, int y );

Int main (INT argc, char * argv [])

{

Add (2, 3 );

Return 0;

}

The following is a brief introduction:

After the function is translated into an assembly by the compilation system, the function name corresponds to the Assembly number. Because the C compiled function name is basically the same as the obtained assembly code, such as: Fun () => _ fun, main => _ main, but the number of letters in C ++ is quite different from the compiled code. For example, due to function overload, the function name is the same, but the Assembly Code cannot be the same. To distinguish between them, the compiler combines the function name and parameter type as the assembly code, which solves the overload problem. How to combine the function name and parameter type depends on the help of the compiler. In this way, if C ++ calls C, such as fun (), the call name is not the translation result of C _ fun, but a name with parameter information, therefore, fun () cannot be called. To solve this problem, the addition of extern "C" indicates that the function calling rule is C, then, the name with parameter information of the C ++ rule is not used, but _ fun, so as to call the C function.