Скачать или смотреть Creating Windows C++ Libraries Without Runtime Dependencies

Learn how to build self-contained Windows C++ libraries without the hassle of distributing multiple runtimes. Simplify your library creation process with these expert tips and best practices!
---
This video is based on the question https://stackoverflow.com/q/190059/ asked by the user 'tfinniga' ( https://stackoverflow.com/u/9042/ ) and on the answer https://stackoverflow.com/a/190163/ provided by the user 'Nick' ( https://stackoverflow.com/u/26240/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, comments, revision history etc. For example, the original title of the Question was: Building windows c++ libraries without a runtime?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 2.5' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 2.5' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Creating Windows C++ Libraries Without Runtime Dependencies

Building a C++ library for use on Windows/MSVC can often feel like a daunting task, especially when you consider the need to manage multiple runtime versions. In this guide, we will explore a common challenge faced by developers: setting up a library in a way that minimizes runtime dependencies, and how you can distribute just two versions of your library—32-bit and 64-bit.

The Problem: Runtime Dependency Management

When creating a C++ library, you may run into the issue of needing to link against different versions of Microsoft's C++ runtimes. This can lead to several complications:

Multiple Versions: You may need to provide different versions of your library, specifically linked against various runtime libraries (debug, release, multi-threaded, etc.)

Distribution Complexity: It can become cumbersome and complex to distribute these versions, especially to users who may not have all the requisite versions of the runtime installed.

Potential Compatibility Issues: Linking to unversioned DLLs can lead to applications that do not work across different Windows versions.

To combat these challenges, many developers are looking for ways to build libraries that require no runtime dependencies or at least limit them significantly.

The Solution: Static Linking

The key to simplifying the distribution of your library lies in static linking. Here's how you can achieve this:

1. Use Custom Memory Management

Consider implementing your own new operator (e.g., mynew) and custom allocators for your Standard Template Library (STL) types. This will allow you to avoid linking against the default memory management functions provided by the C++ runtime. Here’s what you need to consider:

Override Operators: Implement your own versions of new, delete, and other memory functions. This allows you to control memory allocation without the standard runtime's overhead.

Create Custom Allocators: For STL containers, make sure they use your custom allocator instead of the standard one.

2. Disable Default Libraries

When building your library, compile it with the /nodefaultlib flag. This will prevent the linker from automatically linking to the standard libraries that may introduce unwanted runtime dependencies.

3. Provide Thunking Mechanism

When a parent project links with your library, require it to map your mynew operator back to the standard new operator. This way, the parent project can integrate with your library while maintaining its own memory management strategy.

Include an Example: Offer an example implementation of how to do this linking in your library documentation. This can be invaluable for other developers and help ensure seamless adoption of your library.

4. Avoid Unversioned DLL Links

Make sure not to link to msvcrt.dll, the unversioned runtime. Linking to the versioned DLLs (i.e., msvcrt##.dll) is crucial for ensuring compatibility across different Windows versions.

Best Practices: Stick to linking with specific versioned runtime libraries to avoid hard-to-debug issues down the road.

Conclusion

By implementing these strategies, you can build Windows C++ libraries that simplify distribution and minimize the potential for runtime issues. Utilizing static linking, custom memory operations, and proper library management will allow you to focus on what really matters: developing a robust library that your users will love.

Remember, building libraries is both an art and a science. Following these best practices will help set you on the right path for effective library creation and distribution on Windows.