Модули и организация крупного проекта

export module math;

export int add(int a, int b);

int hidden_helper(int value) {
    return value * 2;
}

export module geometry;

export {
    struct Point { double x, y; };
    double distance(Point a, Point b);
}

int internal_counter = 0;

// math.cppm — interface unit
export module math;
export int add(int, int);

// math.cpp — implementation unit
module math;
int add(int a, int b) { return a + b; }

// math-detail.cppm
export module math:detail;
export int normalize(int);

// math.cppm
export module math;
import :detail;
export int calculate(int value);

export module reports;
import formatting;          // только внутренняя зависимость
export import report_types; // доступна импортирующему коду
export Report build_report();

// Текстовое включение зависит от макросов места включения.
#define VALUE_TYPE long
#include "configurable.hpp"

// Импорт получает уже собранный интерфейс модуля.
import configuration;

module;
#include <windows.h>
#include "legacy_c_api.h"

export module platform;
export Handle open_handle();

import <vector>;
import <string>;
// стандартные заголовки используются как header units,
// если это поддерживает toolchain и конфигурация сборки

// legacy_config.hpp
#if FEATURE_LEVEL >= 2
using Payload = RichPayload;
#else
using Payload = CompactPayload;
#endif

// разные TU раньше задавали FEATURE_LEVEL перед #include

export module geometry;
export struct Point {
    double x;
    double y;
};

// a.cpp
int calculate() { return 1; }
// b.cpp
int calculate() { return 2; }
// обе функции имеют внешнее связывание

// math.hpp
inline int clamp_positive(int x) {
    return x < 0 ? 0 : x;
}
// одинаковое определение встречается в нескольких TU

export module parser;
export int parse(std::string_view text);

module parser;
int parse(std::string_view text) {
    return implementation(text);
}

// a.cpp
#pragma pack(push, 1)
#include "packet.hpp"
#pragma pack(pop)

// b.cpp
#include "packet.hpp"

static_assert(sizeof(Packet) /* различается */);

export module containers;
export template<class T>
class Box {
public:
    explicit Box(T value) : value_(std::move(value)) {}
private:
    T value_;
};

export module catalog;

class InternalType;
export std::vector<InternalType> load_items();
// Клиенту нужен layout и операции vector<InternalType>.

export module storage;
export class Storage {
public:
    Storage();
    ~Storage();
    void save(Record);
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};

// contracts module
export struct EventSink {
    virtual void on_event(const Event&) = 0;
    virtual ~EventSink() = default;
};
// A и B зависят от EventSink, но не друг от друга