Module Interface vs Implementation

In C++20, a module can be separated into an interface file and an implementation file. This separation helps organize code and manage dependencies more effectively.

The module interface file defines the public-facing API of the module. It includes the declarations of functions, classes, variables, and any other entities that are intended to be accessible by other parts of the program.

The interface file uses the export keyword to make these declarations available outside the module. Here's an example:

1// Player.cppm
2export module Player;
3import <string>;
4
5export class Player {
6 public:
7  Player(std::string Name);
8  void SayHello();
9  std::string GetName();
10
11 private:
12  std::string Name;
13};

The module implementation file contains the actual definitions of the functions and other entities declared in the interface file.

It uses the module keyword without export, indicating that it provides the internal details of the module. Here's an example:

1// Player.cpp
2module Player;
3import <iostream>;
4
5Player::Player(std::string Name) : Name{Name} {}
6
7void Player::SayHello() {
8  std::cout << "Hello there! I am " << Name;
9}
10
11std::string Player::GetName() {
12  return Name;
13}

Visibility:

• The interface file defines what is visible outside the module.
• The implementation file contains internal details that are not exposed.

Keywords:

• The interface file uses export to make declarations public.
• The implementation file uses module without export.

Purpose:

• The interface file is for declarations.
• The implementation file is for definitions.

• Encapsulation: The implementation details are hidden, promoting better encapsulation and reducing the risk of accidental usage of internal details.
• Compile Times: Separating interface and implementation can lead to better compile times, as changes in the implementation file do not require recompiling code that depends on the module.

Here's how you might use these files in a project:

1// main.cpp
2import Player;
3#include <iostream>
4
5int main() {
6  Player player("John");
7  player.SayHello();
8  std::cout << "Player's name: "
9    << player.GetName();
10}

A module interface file in C++20 defines the public API using export, while an implementation file contains the actual definitions using module.

This separation enhances encapsulation, maintainability, and can improve compile times.