A DLL is a library that contains code and data that can be used by multiple programs at the same time. For example: in Windows operating system In, the Comdlg32 DLL performs common functions related to dialog boxes. Therefore, each program can use the functions contained in the DLL to implement the open dialog box. This helps to promote code reuse and efficient memory use. The purpose of this article is to let you understand and master DLL at one time.

Why use DLL (Dynamic Link Library)?

    Code reuse is an important way to improve the efficiency of software development. Generally speaking, as long as a part of the code is universal, it can be constructed into a relatively independent functional module and reused in subsequent projects. Common examples are various application frameworks, which are published in the form of source code. Because this reuse is at the source code level and the source code is completely exposed to programmers, it is called "white box reuse". White box reuse has the following three disadvantages:

1. Exposure of source code and multiple copies, resulting in storage waste;
2. It is easy to have naming conflicts with the programmer's local code;
3. It is difficult to update the module function, which is not conducive to the modular implementation of the problem;

    In order to make up for these shortcomings, a "binary level" code reuse is proposed. The use of binary level code reuse hides the source code to a certain extent. There are more than DLL s for "black box reuse", static link libraries and even more advanced COM components.

Using DLL has the following advantages:

1. Use less resources; When multiple programs use the same function library, DLL s can reduce the amount of duplication of code loaded on disk and physical memory. This can greatly affect not only the programs running on the foreground, but also other programs running on the Windows operating system;
2. Promote modular architecture;
3. Simplify deployment and installation.

Create DLL    

    Open Visual Studio 2012 and create a project as shown in the following figure:

Enter the project name and click [OK];

Click [Finish] and the project is created. Now we can add our code to the project. Add two files: MyCode.h and MyCode.cpp; Enter the following code in MyCode.h:

1. #ifndef _MYCODE_H_  
2. #define _MYCODE_H_  
3. #ifdef DLLDEMO1_EXPORTS  
4. #define EXPORTS_DEMO _declspec( dllexport )  
5. #else  
6. #define EXPORTS_DEMO _declspec(dllimport)  
7. #endif  
8. extern "C" EXPORTS_DEMO int Add (int a , int b);  
9. #endif  

1. #include "stdafx.h"  
2. #include "MyCode.h"  
3. int Add ( int a , int b )  
4. {  
5.        return ( a + b );  
6. }  

Use DLL

    When our program needs to use DLL, we need to load DLL. There are two methods to load DLL in the program: load time dynamic link and run-time dynamic link.

1. In load time dynamic link, the application program calls the exported DLL function like a local function. To use load time dynamic links, you need to provide header files and import library files (. lib) when compiling and linking applications. When doing so, the linker will provide the system with the information required to load the DLL, and resolve the location of the exported DLL function during loading;
2. In runtime dynamic links, the application calls the LoadLibrary function or LoadLibraryEx function to load the DLL at runtime. After the DLL is successfully loaded, you can use the GetProcAddress function to obtain the address of the exported DLL function to be called. When using runtime dynamic links, you do not need to use import library files.

There are two ways to use DLL in actual programming, so which one should be used? During actual development, the following points are considered:

1. Startup performance if the initial startup performance of the application is important, run-time dynamic links should be used;
2. Ease of use in dynamic link during loading, the exported DLL functions are similar to local functions, and we can easily call these functions;
3. Application logic is dynamically linked at run time, and applications can branch to load different modules as needed.

Next, I will use two methods to call the DLL Dynamic link library.

Dynamic link on load:

1. #include <windows.h>  
2. #include <iostream>  
3. //#include "..\\DLLDemo1\\MyCode.h"  
4. using namespace std;  
5. #pragma comment(lib, "..\\debug\\DLLDemo1.lib")  
6. extern "C" _declspec(dllimport) int Add(int a, int b);  
7. int main(int argc, char *argv[])  
8. {  
9.       cout<<Add(2, 3)<<endl;  
10.       return 0;  
11. }  

1. #include <windows.h>  
2. #include <iostream>  
3. using namespace std;  
4. typedef int (*AddFunc)(int a, int b);  
5. int main(int argc, char *argv[])  
6. {  
7.       HMODULE hDll = LoadLibrary("DLLDemo1.dll");  
8.       if (hDll != NULL)  
9.       {  
10.             AddFunc add = (AddFunc)GetProcAddress(hDll, "Add");  
11.             if (add != NULL)  
12.             {  
13.                   cout<<add(2, 3)<<endl;  
14.             }  
15.             FreeLibrary(hDll);  
16.       }  
17. }  

The above codes are in DLLDemo1 project. ( Project Download).

DllMain function

The format of the module definition file (. DEF) file is as follows:

1. The LIBRARY statement describes the DLL corresponding to the. def file;
2. The names of the functions to be exported are listed after the EXPORTS statement. You can add @ n after the exported function name in the. def file to indicate that the sequence number of the function to be exported is n (this sequence number plays a certain role in function calls).

Using the def file, a DLL is generated, and the client calling code is as follows:

1. #include <windows.h>  
2. #include <iostream>  
3. using namespace std;  
4. typedef int (*AddFunc)(int a, int b);  
5. int main(int argc, char *argv[])  
6. {  
7.       HMODULE hDll = LoadLibrary("DLLDemo2.dll");  
8.       if (hDll != NULL)  
9.       {  
10.             AddFunc add = (AddFunc)GetProcAddress(hDll, MAKEINTRESOURCE(1));  
11.             if (add != NULL)  
12.             {  
13.                   cout<<add(2, 3)<<endl;  
14.             }  
15.             FreeLibrary(hDll);  
16.       }  
17. }  

extern "C"

Why use extern "C"? When designing C + +, the father of C + + considered that a large number of C code existed at that time. In order to support the original C code and the written C library, it is necessary to support C in C + + as much as possible, and extern "C" is one of the strategies. When declaring functions, I noticed that I also used extern "C". Here I want to talk about extern "C" in detail .

Extern "C" has two meanings. First, the target it modifies is "extern"; second, the target it modifies is "C". Let's talk about extern first. In C/C + +, extern is used to indicate the scope (visibility) of functions and variables Keyword that tells the compiler that the functions and variables it declares can be used in this module or other modules. The functions of extern are summarized as follows:

1. In a file, if an external variable is not defined at the beginning of the file, its valid range is only limited from the beginning of the definition to the end of the file. If you need to reference the variable before definition, you should make an "external variable declaration" on the variable with the keyword "external" before reference, indicating that the variable is a defined external variable. With this declaration, you can The variable has been used reasonably since the declaration, for example:

1. /* 
2. ** FileName     : Extern Demo 
3. ** Author       : Jelly Young 
4. ** Date         : 2013/11/18 
5. ** Description  : More information, please go to http://www.jellythink.com 
6. */  
7. #include <iostream>  
8. using namespace std;  
9. int main(int argc, char *argv[])  
10. {  
11.       extern int a;  
12.       cout<<a<<endl;  
13. }  
14. int a = 100;  

1. In a multi file program, if multiple files need to use the same external variable, you cannot define an external variable in each file, otherwise the error of "repeated definition" will appear. The correct way is to define an external variable in any file and make an "external variable declaration" on the variable in other files with extern When compiling and linking, the system will know that the variable is an external variable that has been defined elsewhere, and extend the scope of the external variable in another file to this file, so that the external variable can be used legally in this file. As everyone who has written MFC program knows, in the header file of CXXXApp class, a variable of this class is declared with extern, and The actual definition of variables is completed in the implementation file of CXXXApp class;
2. When defining an external function, if the keyword extern is added at the leftmost end, it means that the function is an external function. C language stipulates that if extern is omitted during definition, it is implied as an external function. The internal function must be preceded by the static keyword. In the file that needs to call this function, the function is declared with extern, indicating that the function is defined in other files External functions.

    We all know that C + + supports the overload mechanism through different types of function parameters, and the compiler generates different internal identifiers for each overloaded function according to the parameters. However, what should we do if a C + + program calls a compiled c function? For example, int Add (int a, int b) above Function. The name of the function in the library after being compiled by the C compiler is _Add, while the C + + compiler will generate names such as _Add _int _intto support function overloading and type safety. Due to different compiled names, C + + programs cannot directly call C functions, so c + + provides a C connection to exchange the specified symbol extern "C" To solve this problem; therefore, in the above DLL, the declaration format of the Add function is: extern "C" exports_demo int Add (int a, int b) This tells the C + + compiler that the function Add is a C-connected function. You should find the name _addin the library instead of _Add_int_int. when we remove the "C" in the DLL above, compile and generate a new DLL, and use the Dependency Walker tool to view the DLL, as shown in the figure:

1. #include <windows.h>  
2. #include <iostream>  
3. using namespace std;  
4. typedef int (*AddFunc)(int a, int b);  
5. int main(int argc, char *argv[])  
6. {  
7.      HMODULE hDll = LoadLibrary("DLLDemo1.dll");  
8.      if (hDll != NULL)  
9.      {  
10.           AddFunc add = (AddFunc)GetProcAddress(hDll, "?Add@@YAHHH@Z");  
11.           if (add != NULL)  
12.           {  
13.                cout<<add(2, 3)<<endl;  
14.           }  
15.           FreeLibrary(hDll);  
16.      }  
17. }  

Please note the second parameter of GetProcAddress function. The parameter name is the exported function name. Isn't it strange to write such a name when encoding. When we export using extern al "C", the screenshot is as follows:

Note that the export method is C, and the function name is now an ordinary Add. When we use GetProcAddress again, we can directly specify Add instead of adding a long list of strange names.

DLL export variables

DLL export class

Classes defined in DLL can also be exported. For detailed engineering code, see( Project Download)

summary

This is the end of the explanation of DLL. Since MFC is rarely used in the current environment, it will not be explained here. If I encounter MFC DLL related knowledge in future projects, I will make a summary. Finally, I hope you can put forward some pertinent suggestions to my blog.

******************************************************************************************************

Refer to the above content and work on the VS2010 development environment test The test steps are as follows:

1. Package the required functions into DLL

    First, create a DLL project named DllDemo, as shown in the following figure:       

2. Call DLL in dynamic link mode during loading

``

3. Call DLL in runtime dynamic link mode

4. Export functions in the form of. def files (module definition files) (functions are not exported in the form of _declspec(dllexport)):

Then create the header file (MyCode.h) and. cpp file (MyCode.cpp) and add the code respectively:

MyCode.h header file:

1. #ifndef _MYCODE_H_  
2. #define _MYCODE_H_  
3. extern "C" int Add (int a , int b);      
4. #endif  

MyCode.cpp file:

1. #include "MyCode.h"  
2. int Add ( int a , int b )  
3. {  
4.        return ( a + b );  
5. }  

Then add a module definition file (. def file):

Add code:

1. LIBRARY  "DllDemo"   //The string name here should be consistent with the project name   
2. EXPORTS  
3. Add @1;Export the Add function  

Compile the project and generate the DllDemo.dll file immediately.

Using the def file, a DLL is generated, and the client calling code is as follows:

1. //  DllTest2.cpp  :  Defines the entry point for the console application.   
2. //  
3. #include "stdafx.h"  
4. #include <windows.h>  
5. #include <iostream>  
6. using namespace std;  
7. typedef int (*AddFunc)(int a, int b);  
8. int _tmain(int argc, _TCHAR* argv[])  
9. {  
10.       HMODULE hDll = LoadLibrary("DllDemo.dll");  
11.       if (hDll != NULL)  
12.       {  
13.             AddFunc add = (AddFunc)GetProcAddress(hDll, MAKEINTRESOURCE(1));  
14.             if (add != NULL)  
15.             {  
16.                   cout<<add(2, 3)<<endl;  
17.             }  
18.             FreeLibrary(hDll);  
19.       }  
20.       while(1);  
21. }  

Project code download:

1. Generate dynamic link library (_declspec(dllexport) export function)

2. Generate dynamic link library (export functions in the form of. def file (module definition file))

3. Call DLL by dynamic link during loading

4. Call DLL in runtime dynamic link mode

5. Call of dynamic link library established by module definition (. def file)

Problems encountered:

1. There is a problem with the directory when importing the library. Corresponding to question 1 in the text, it is explained later.

2. The problem of character set (Unicode character set or multi byte set). There are two schemes: one is to modify the character set to multi byte set, and the other is to prefix the string   _ T(""), question 2 in the text

3. I don't know how to generate DLL through module definition file. I found the answer by looking at the code of reference blog, mainly modifying header file and adding module definition file.

4. The library file name in the module definition file shall be consistent with the project name.