Resolve the internal connection and external connection in C ++

In IntroductionC ++Before the internal connection and external connection in, describe some concepts.

1. Statement

A declaration introduces a name into a scope;

In c ++, it is legal to repeat a declaration in a scope.

The following are declarations:

 
 

  
  
Int foo (int, int); // function pre-declaration
  
  
Typedef int Int; // typedef Declaration
  
  
Class bar; // class pre-declaration
  
  
Extern int g_var; // external reference Declaration
  
  
Class bar; // class pre-declaration
  
  
Typedef int Int; // typedef Declaration
  
  
Extern int g_var; // external reference Declaration
  
  
Friend test; // member statement
  
  
Using std: cout; // namespace reference Declaration
  
  
Friend test; // member statement
  
  
Using std: cout; // namespace reference Declaration
  
  
Int foo (int, int); // function pre-declaration
 
 

You can repeat these statements multiple times in the same scope.

There are two types of declarations that cannot be repeated. They are the declarations of class member functions and static data members.

 
 

  
  
Class foo
  
  
{
  
  
Static int I;
  
  
Static int I; // No
  
  
Public:
  
  
Int foo ();
  
  
Int foo (); // No
  
  
};
 
 

2. Definition

A definition provides a unique description of an object (type, instance, function) in a scope.

An object cannot be defined repeatedly in the same scope.

The following are definitions.

 
 

  
  
int y;  
  
  
class foo {...};  
  
  
struct bar {...};  
  
  
foo* p;  
  
  
static int i;  
  
  
enum Color{RED,GREEN,BLUE};  
  
  
const double PI = 3.1415;  
  
  
union Rep{...};  
  
  
void test(int p) {};  
  
  
foo a;  
  
  
bar b; 
 
 

3. compilation unit

When a c or cpp file is being compiled, the Preprocessor first recursively contains the header file to form a single source file containing all necessary information. This source file is a compilation unit. This compilation unit will be compiled into a target file (. o or. obj) with the same name as the cpp file name ). The Connection Program Associates the symbols generated in different compilation units to form an executable program.

4. Free Functions

If a function is a free function, it is neither a member function of the class nor a friend function.

The following describes the internal connection and external connection.

Internal Connection: If a name is partial for its compilation unit and does not conflict with the same name in other compilation units, the name has an internal connection (Note: Sometimes the declaration is considered as connectionless, and here we are regarded as an internal connection ).

Internal connections are available in the following cases:

A) All statements

B) definitions of static free functions, static friends functions, and static variables in the namespace (including the global namespace)

C) enum Definition

D) inline Function Definition (including free and non-free functions)

E) Class Definition

F) const constant definition in namespace

G) Definition of union

External Connection: In a multi-file program, if a name can interact with other compilation units during connection, this name has an external connection.

External connections are available in the following cases:

A) Class non-inline functions always have external connections. Including class member functions and class static member functions

B) static member variables always have external connections.

C) non-static free functions, non-static friends functions, and non-static variables in the namespace (including the global namespace)

The following is an example:

A) Declarations, enum definitions, and union definitions have internal connections.

All declarations, enum definitions, and union definitions do not generate connection symbols after compilation, that is to say, declarations with the same name and definitions of enum and union in different compilation units do not encounter errors with multiple symbols during connection.

 
 

  
  
// Main. cpp
  
  
Typedef int Int; // typedef declaration, internal connection
  
  
Enum Color {red}; // enum definition, internal connection
  
  
Union X // union definition, internal connection
  
  
{
  
  
Long;
  
  
Char B [10];
  
  
};
  
  
Int main (void)
  
  
{
  
  
Int I = red;
  
  
Return I;
  
  
}
  
  
// A. cpp
  
  
Typedef int Int; // declare an int type alias in a. cpp. No error will occur during connection.
  
  
Enum Color {blue}; // defines an enum Color in a. cpp. No error will occur during connection.
  
  
Const Int I = blue; // const constant definition, internal connection
  
  
Union X // union definition, internal connection
  
  
{
  
  
Long;
  
  
Char B [10];
  
  
};
 
 

B) The static free functions, static friends functions, static variables, and const constant definitions in the namespace have internal connections.

 
 

  
  
// Main. cpp
  
  
Namespace test
  
  
{
  
  
Int foo (); // function declaration, internal connection
  
  
Static int I = 0; // namespace static variable definition, internal connection
  
  
Static int foo () {return 0 ;}// namespace static function definition, internal connection
  
  
}
  
  
Static int I = 0; // Global static variable definition, internal connection
  
  
Static int foo () {return 1 ;}// Global static function definition, internal connection
  
  
Const int k = 0; // global const constant definition, internal connection
  
  
Int main (void)
  
  
{
  
  
Return 0;
  
  
}
  
  
// A. cpp
  
  
Namespace test
  
  
{
  
  
Int I = 0; // namespace variable definition, external connection
  
  
Int foo () {return 0;} // namespace Function Definition, external connection
  
  
}
  
  
Int I = 0; // global variable definition, external connection
  
  
Int k = 0; // global variable definition, external connection
  
  
Int foo () {return 2;} // global function definition, external connection
 
 

In the global namespace, main. cpp defines static variables I, constants k, AND STATIC FREE functions foo, which have internal connections. If you remove the static or const modifiers of these variables or functions, the multiply defined symbols error will occur during the connection. they conflict with the global variables and global functions in a. cpp.

C) class definitions always have internal connections, and non-inline class member functions always have external connections, whether the member functions are static, virtual, or general member functions, class static data member definitions always have external connections.

1. The class definition has an internal connection. If not, imagine that you have defined the class Base header file in the four cpp files, and all the class Base files in the four compilation units have external connections, an error occurs during connection.

See the following example:

 
 

  
  
// Main. cpp
  
  
Class B // class definition, internal connection
  
  
{
  
  
Static int s_ I; // static class member declaration, internal connection
  
  
Public:
  
  
Void foo () {++ s_ I;} // class inline function, internal connection
  
  
};
  
  
Struct D
  
  
{
  
  
Void foo (); // class member function declaration, internal connection
  
  
};
  
  
Int B: s_ I = 0; // class static data member definition, external connection
  
  
Void D: foo () // class member function definition, external connection
  
  
{
  
  
Cout <"D: foo in main. cpp" <endl;
  
  
}
  
  
Int main () // main function, global free function, external connection
  
  
{
  
  
B B;
  
  
D;
  
  
Return 0;
  
  
}
  
  
// A. cpp
  
  
Class B
  
  
{
  
  
Int k;
  
  
};
  
  
Struct D
  
  
{
  
  
Int d;
  
  
};
 
 

In this example, both main. cpp and a. cpp have definitions of class B and class D, but the link error does not occur when compiling the two cpp files.

2. non-inline member functions of a class (generally static or virtual) always have external connections. When you include a Class header file and use this class function, connect to the correct class member function. Continue with the above example. change struct D in cpp

 
 

  
  
Struct D // class definition
  
  
{
  
  
Int d;
  
  
Void foo (); // class member function declaration
  
  
};
  
  
Void D: foo () // class member function definition, external connection
  
  
{
  
  
Cout <"D: foo in a. cpp" <endl;
  
  
}
 
 

In this case, both main. cpp and D: foo in a. cpp have external connections, and the multiply defined symbols error will occur during the connection.

3. the static data member of the class has an external connection. In the example above, B: s_ I. cpp defines static data members. If other compilation units use B: s_ I, they are connected to main. cpp corresponds to s_ I of the compilation unit.

D) inline functions always have internal connections, no matter what function this function is.

 
 

  
  
// Main. cpp
  
  
Inline int foo () {return 1;} // inline global function, internal connection
  
  
Class Bar // class definition, internal connection
  
  
{
  
  
Public:
  
  
Static int f () {return 2;} // inline class static function, internal connection
  
  
Int g (int I) {return I;} // inline class member function, internal connection
  
  
};
  
  
Class Base
  
  
{
  
  
Public:
  
  
Inline int k (); // class member function declaration, internal connection
  
  
};
  
  
Inline int Base: k () {return 5;} // inline class member function, internal connection
  
  
Int main (void)
  
  
{
  
  
Return 0;
  
  
}
 
 

If your Base class is defined in Base. h, while the Base inline function is in Base. as defined in cpp. include "Base. h "compilation will not cause problems, but function k will not be found during connection, so the inline function of the class is best placed in the header file, so that every cpp containing the header file can find the inline function.

Now I have an understanding of the connection in c ++ and can clearly understand the cause of the connection error. When you create a connection error, it means that all compilation units do not have an external connection to the object. When you connect, multiple connected entities exist, this indicates that multiple compilation units provide external connected entities with the same name. At the same time, when designing a program, be sure not to allow external connections to functions, classes, variables, and other functions used by the current compilation unit to reduce connection conflicts with other compilation units.

However, the connectivity between the template function and the template class is not described here, and some special situations are not described (for example, the inline function cannot be called inline ).