how to create and use/include a DLL in Visual C++ and deployment?

how to create DLL in Visual C++?

1. Walkthrough: Create and use your own Dynamic Link Library (C++)
2. Is there a Visual Studio Project Configuration Macro which defines DEBUG or RELEASE regardless of the Project Configuration Name?
3. Deployment in Visual C++
4. Universal CRT deployment
5. How do I setup visual studio to register some #defines globally?
6. Identify current configuration using preprocessor directives on visual studio?
7. “Debug only” code that should run only when “turned on”
8. Dynamic-Link Library Search Order
9. Working with Import Libraries and Export Files
10. Link an executable to a DLL
11. DLL Frequently Asked Questions

it includes two steps:

DLL produce:1) Create a DLL project in Visual Studio. 2)Add exported functions and variables to the DLL.

consumer: 1)Create a console app project in Visual Studio. 2)Use the functions and variables imported from the DLL in the console app. 3)Run the completed app.

in this DLL demo, I did not create the same project as this post, so macro MATHLIBRARY_EXPORTS is not defined as it specifies. so I created a macro in the C/C++ preprocessor -> define my own MATHLIBRARY_EXPORTS.

12. Link an executable to a DLL

An executable file links to (or loads) a DLL in one of two ways:

1. Implicit linking, where the operating system loads the DLL at the same time as the executable that uses it. The client executable calls the exported functions of the DLL the same way as if the functions were statically linked and contained within the executable. Implicit linking is sometimes referred to as static load or load-time dynamic linking.
2. Explicit linking, where the operating system loads the DLL on demand at runtime. An executable that uses a DLL by explicit linking must explicitly load and unload the DLL. It must also set up a function pointer to access each function it uses from the DLL. Unlike calls to functions in a statically linked library or an implicitly linked DLL, the client executable must call the exported functions in an explicitly linked DLL through function pointers. Explicit linking is sometimes referred to as dynamic load or run-time dynamic linking.

An executable can use either linking method to link to the same DLL. Furthermore, these methods aren't mutually exclusive; one executable may implicitly link to a DLL, and another might attach to it explicitly.

Implicit Linking, what is it? and when it happens?

Implicit linking occurs when an application's code calls an exported DLL function. When the source code for the calling executable is compiled or assembled, the DLL function call generates an external function reference in the object code. To resolve this external reference, the application must link with the import library (.lib file) provided by the maker of the DLL.

The import library only contains code to load the DLL and to implement calls to functions in the DLL. Finding an external function in an import library informs the linker that the code for that function is in a DLL. To resolve external references to DLLs, the linker simply adds information to the executable file that tells the system where to find the DLL code when the process starts up.

When the system starts a program that contains dynamically linked references, it uses the information in the program's executable file to locate the required DLLs. If it can't locate the DLL, the system terminates the process, and displays a dialog box that reports the error. Otherwise, the system maps the DLL modules into the process address space.

If any of the DLLs has an entry-point function for initialization and termination code such as DllMain, the operating system calls the function. One of the parameters passed to the entry-point function specifies a code that indicates the DLL is attaching to the process. If the entry-point function doesn't return TRUE, the system terminates the process and reports the error.

Finally, the system modifies the executable code of the process to provide starting addresses for the DLL functions. Like the rest of a program's code, the loader maps DLL code into the address space of the process when the process starts up. The operating system loads it into memory only when needed. As a result, the PRELOAD and LOADONCALL code attributes used by .def files to control loading in previous versions of Windows no longer have meaning.

How to use implicit linking?

To use a DLL by implicit linking, client executables must obtain these files from the provider of the DLL:

• One or more header files (.h files) that contain the declarations of the exported data, functions, and C++ classes in the DLL. The classes, functions, and data exported by the DLL must all be marked __declspec(dllimport) in the header file. For more information, see dllexport, dllimport.
• An import library to link into your executable. The linker creates the import library when the DLL is built. For more information, see LIB files as linker input.
• The actual DLL file.

To use the data, functions, and classes in a DLL by implicit linking, any client source file must include the header files that declare them. From a coding perspective, calls to the exported functions are just like any other function call.

To build the client executable file, you must link with the DLL's import library. If you use an external makefile or build system, specify the import library together with the other object files or libraries that you link.

The operating system must be able to locate the DLL file when it loads the calling executable. That means you must either deploy or verify the existence of the DLL when you install your application.

13. Kinds of DLLs

it explains all kinds of DLLs clearly.

14. Determining Which DLLs to Redistribute

it tells which DLL to distribute.

15. Visual Studio 2017 compiles in 32bit on 64 bit system?
16. Build 32-bit DLL on 64-bit Windows® Platform Using MSVC Toolchain
17. Back to Basics: 32-bit and 64-bit confusion around x86 and x64 and the .NET Framework and CLR
18. How to create a 64-bit C DLL with MSVC 2017 and IDL 8.7 for Windows 10
19. 4.5 Compiling in Windows with MSVC
20. How do I use a third-party DLL file in Visual Studio C++?
21. Link an executable to a DLL
22. C++ toolkit installation on Windows
23. How to create and use DLL (Dynamic Link Library) in (C+
24. Configuring Your Project's Build Settings
25. C++ - Windows - Creating a dynamic-link library (DLL)
26. Dynamic-link library
27. Projects in Visual C++ 2010 – Part 1: Creating a DLL project
28. Module 16: C++, MFC & Dynamic Link Libraries - DLL 1
29. Module 16a: Windows Dynamic Link Libraries - DLL 2
30. Module 16b: Windows Dynamic Link Libraries - DLL 3
31. Module 16c: Windows Dynamic Link Libraries - DLL 4
32. MODULE BB DYNAMIC LINK LIBRARY - DLL Part 1: STORY
33. MODULE CC DYNAMIC LINK LIBRARY - DLL Part 2: PROGRAM EXAMPLES
34. MODULE CC1 DYNAMIC LINK LIBRARY - DLL Part 3: PROGRAM EXAMPLES
35. Creating and Using a Dynamic Link Library(DLL) in VC++

it has three related papers in the bottom sections.

36. Setting up the Boost C++ library