Handling Third-Party Libraries

Handling third-party libraries that do not use C++20 modules involves a few strategies to ensure compatibility and maintainability. Here's how you can integrate these libraries into your C++20 project effectively.

Using Traditional #include Directives

The simplest approach is to continue using traditional #include directives for third-party libraries. This method requires no modification to the libraries and ensures they work as intended. Here’s an example:

1#include <iostream>
2
3// Traditional include
4#include "third_party_library.h"
5
6int main() {
7  // Function from third-party library
8  third_party_function();
9}

Creating Header Units

You can convert third-party headers into header units using the import statement. This allows you to gradually transition to modules while still using existing headers. Here’s an example:

1// third_party_library.h
2#pragma once
3void third_party_function();

1// main.cpp
2// Creating a header unit
3import "third_party_library.h";
4
5int main() {
6  third_party_function();
7}

Wrapping Third-Party Libraries in Modules

Another approach is to create a module that wraps the third-party library. This module can expose the necessary functionality while hiding the implementation details. Here’s an example:

1// third_party_wrapper.cppm
2export module ThirdPartyWrapper;
3#include "third_party_library.h"
4
5export void wrapped_function() {
6  third_party_function();
7}

1// main.cpp
2import ThirdPartyWrapper;
3
4int main() {
5  wrapped_function();
6}

Using Global Module Fragment

For headers that need to be included before the module declaration, use the global module fragment. This ensures preprocessor directives and macros are handled correctly. For example:

1module; // Global module fragment
2#include "third_party_library.h"
3
4export module MyModule;
5import <iostream>;
6
7export void myFunction() {
8  third_party_function();
9}

Managing Dependencies

When integrating third-party libraries, ensure your build system correctly handles the dependencies. Use package managers or build systems like CMake to manage and configure the inclusion of these libraries.

Example: CMake Integration

Here's an example of how you might configure a CMake project to use a third-party library with modules.

1cmake_minimum_required(VERSION 3.20)
2project(MyProject)
3
4# Add third-party library
5add_library(
6  third_party_library STATIC third_party_library.cpp
7)
8
9# Create module
10add_library(MyModule STATIC my_module.cppm)
11target_link_libraries(
12  MyModule PRIVATE third_party_library
13)
14
15# Set target properties
16set_target_properties(MyModule PROPERTIES
17  CXX_STANDARD 20
18  CXX_STANDARD_REQUIRED YES
19  CXX_EXTENSIONS NO
20)
21
22# Main executable
23add_executable(MyApp main.cpp)
24target_link_libraries(MyApp PRIVATE MyModule)

Summary

Integrating third-party libraries that do not use C++20 modules can be done using traditional #include directives, creating header units, or wrapping them in modules.

Each method has its benefits and can be chosen based on the specific needs and constraints of your project.