【C++】C++26 Static Reflection完全ガイド：コンパイル時リフレクションでコードを自動生成する

#include <meta>
#include <print>

struct Point
{
    int   x;
    int   y;
    float z;
};

int main()
{
    // 全てのメンバ情報をコンパイル時に取得
    constexpr auto members = std::meta::nonstatic_data_members_of(^^Point);

    std::println("Point has {} members", members.size());

    // template for でメンバ名を列挙
    template for (constexpr auto m : members)
    {
        std::println("  - {}", std::meta::identifier_of(m));
    }
}

Point has 3 members
  - x
  - y
  - z

#include <meta>

struct Person
{
    std::string name;
    int         age;
};

// 型のリフレクション
constexpr auto person_info = ^^Person;

// メンバのリフレクション
constexpr auto name_info = ^^Person::name;
constexpr auto age_info  = ^^Person::age;

// 式のリフレクション
int global_var = 42;
constexpr auto var_info = ^^global_var;

// 型情報をコードに戻す
using MyType = [:^^Person:];  // Person と同じ意味

// メンバアクセスに使う
Person p{"Alice", 30};
int val = p.[:^^Person::age:];  // p.age と同じ（30になる）

// 条件付きで型を選ぶこともできる
using Bigger = [: sizeof(long) > sizeof(int) ? ^^long : ^^int :];

template<typename T>
std::string to_json(const T& obj)
{
    std::ostringstream oss;
    oss << "{";

    bool first = true;

    template for (constexpr auto member : std::meta::nonstatic_data_members_of(^^T))
    {
        if (!first)
        {
            oss << ", ";
        }
        first = false;

        // キー：メンバ名
        oss << "\"" << std::meta::identifier_of(member) << "\": ";

        // 値：型に応じて出力を変える
        using MemberType = decltype(obj.[:member:]);

        if constexpr (std::is_same_v<MemberType, std::string>)
        {
            oss << "\"" << obj.[:member:] << "\"";
        }
        else
        {
            oss << obj.[:member:];
        }
    }

    oss << "}";
    return oss.str();
}

// 実際に使ってみる
struct Config
{
    std::string host;
    int         port;
    bool        use_tls;
};

int main()
{
    Config cfg{"localhost", 8080, true};

    std::println("{}", to_json(cfg));
    // 出力: {"host": "localhost", "port": 8080, "use_tls": 1}
}

template<typename T>
std::string generate_insert(const T& obj)
{
    std::string table  = std::meta::identifier_of(^^T);
    std::string cols   = "";
    std::string values = "";

    bool first = true;

    template for (constexpr auto m : std::meta::nonstatic_data_members_of(^^T))
    {
        if (!first)
        {
            cols   += ", ";
            values += ", ";
        }
        first = false;

        cols   += std::meta::identifier_of(m);
        values += std::format("'{}'", obj.[:m:]);
    }

    return std::format("INSERT INTO {} ({}) VALUES ({})", table, cols, values);
}

struct Product
{
    int         id;
    std::string name;
    double      price;
};

int main()
{
    Product p{1, "Laptop", 999.99};

    std::println("{}", generate_insert(p));
    // INSERT INTO Product (id, name, price) VALUES ('1', 'Laptop', '999.99')
}

template<typename T>
    requires std::is_enum_v<T>
consteval auto make_enum_table() noexcept
{
    constexpr auto enumerators = std::meta::enumerators_of(^^T);
    std::array<std::pair<T, std::string_view>, enumerators.size()> table{};

    std::size_t i = 0;

    template for (constexpr auto item : enumerators)
    {
        table[i] = { [:item:], std::meta::identifier_of(item) };
        i++;
    }

    return table;
}

template<typename T>
    requires std::is_enum_v<T>
constexpr std::string_view enum_to_string(T value) noexcept
{
    constexpr auto table = make_enum_table<T>();

    template for (constexpr auto [v, name] : table)
    {
        if (v == value)
        {
            return name;
        }
    }

    return "unknown";
}

enum class Color { Red, Green, Blue };

int main()
{
    auto c = Color::Green;

    std::println("{}", enum_to_string(c));  // Green
}

int divide(int dividend, int divisor)
    [[pre: divisor != 0]]
    [[post r: r * divisor == dividend]]
{
    return dividend / divisor;
}

void set_volume(int level)
    [[pre: 0 <= level && level <= 100]]
    [[post: get_volume() == level]]
{
    volume_ = level;
}