ЕМ>У Вас получается скомпилировать это с consteval? Мой прошлогодний VC++ отказывается.

struct Rec {
    enum Type { RT_End, RT_Int, RT_Cstr, RT_Rec, RT_Enter, RT_Leave };
    int type, id;
    union {
        int v_int;
        const char* v_cstr;
        struct Rec *v_rec;
    };
    constexpr Rec() : type(RT_End),id(0),v_int(0) {}
    constexpr Rec(int id,int v) : type(RT_Int),id(id),v_int(v) {}
    constexpr Rec(int id,const char* v) : type(RT_Cstr),id(id),v_cstr(v) {}
    constexpr Rec(int id,Rec *v) : type(RT_Rec),id(id),v_rec(v) {}
    struct Enter{}; constexpr Rec(Enter,int id) : type(RT_Enter),id(id),v_int(0) {}
    struct Leave{}; constexpr Rec(Leave) : type(RT_Leave),id(0),v_int(0) {}
};

#define R_ENTER(id)      { Rec::Enter(),id },
#define R_LEAVE()        { Rec::Leave() },

enum ParameterType { PT_MaxNumberOfLines, PT_AllowedLineTypes, PT_UniqueKey, PT_LineConfig };
enum LineParameterType { LPT_Id,LPT_Name,LPT_Dir };
enum LT { LT_Mic=1,LT_DigitalOutput=2,LT_Speakers=4 };
enum LD { LD_Input,LD_Output };

const Rec ParameterList[]={
    { PT_UniqueKey,"12345-67890" },
    { PT_AllowedLineTypes,LT_Mic | LT_DigitalOutput | LT_Speakers },
    R_ENTER(PT_LineConfig)
        { LPT_Name,"line3" },
        { LPT_Id,12 },
        { LPT_Dir,LD_Input },
    R_LEAVE()    
    R_ENTER(PT_LineConfig)
        { LPT_Name,"line4" },
        { LPT_Id,7 },
        { LPT_Dir,LD_Output },
    R_LEAVE()
    { PT_MaxNumberOfLines,5 },
    {}
};

ЕМ>Лень набрасывать код только ради примера. Одно из типичных применений — параметризуемые программы, настраиваемые на конкретного заказчика. Поначалу хватает набора простейших #define или констант, потом софт постепенно усложняется, добавляются новые параметры и их группы, которые уже замучишься перечислять в виде имен вида Node7_Channel3_TempMax, и вдобавок легко перепутать номера/индексы. А главное — в этой куче с ходу не видно структуры, ибо она делается в некотором роде подобно реляционным БД, где иерархия и группировка достигаются гибкими, но неочевидными способами.

#include <array>
#include <cstdint>
#include <iostream>
#include <string>

struct
{
    struct {
        bool Value_A = true;
        int Value_B = 42;
        double Value_C = 3.14;
        std::string Value_D = "Hello";
        std::array<uint8_t, 16> Value_E {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F};
    } Key_A;

    struct {
        struct {
            bool Value_A = true;
            int Value_B = 42;
            double Value_C = 3.14;
            std::string Value_D = "Hello";
            std::array<uint8_t, 16> Value_E {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F};
        } Key_X;

        bool Value_A = true;
        int Value_B = 42;
        double Value_C = 3.14;
        std::string Value_D = "Hello";
        std::array<uint8_t, 16> Value_E {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F};
    } Key_B;

    struct {
        bool Value_A = true;
        int Value_B = 42;
        double Value_C = 3.14;
        std::string Value_D = "Hello";
        std::array<uint8_t, 16> Value_E {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F};
    } Key_C;

    
} inline constexpr Config;

int main()
{
    std::cout << Config.Key_B.Key_X.Value_C << std::endl;
}

#include <string>
#include <iostream>

// где-то по коду
static const int z[]={1,2};
static const double x=10;
static const int y[]={1,2,3,4,5,6,7,8,9,10};

// собираем всех кого нужно в древовидную структуру в отдельной единице трансляции маркер имя namespace-а
namespace Consts {
    auto &z=::z;
    namespace Nested {
        auto &x=::x;
        auto &y=::y;
    }
}

// decl
typedef decltype(typeid(0)) ti;
#define DECL(name) decl(ctx,(void*)&name,sizeof(name),#name,typeid(name));
void enum_vars( void (*decl)(void *ctx,void *ptr,size_t size,const char* name,ti t),void *ctx) {
    #include "consts.inc" // что-бы вручную не писать используем готовый код. готовим отдельно
}
#undef DECL

// utils
#include <cxxabi.h>
#include <stdlib.h>
std::string getTypeName(ti t) {
    std::string res; int err=0;
    char* name=abi::__cxa_demangle(t.name(),0,0,&err);
    if (name) { res=name; free(name); }
    return res;
}
void print_var(void *ctx,void *ptr,size_t size,const char* name,ti t) {
    std::cout<<size<<"\t"<<name<<"\t"<<getTypeName(t)<<"\n";
}

int main() {
    enum_vars(print_var,0); // пробегаем по линейному списку (можем делать всё что хотим, например выводим на печать)
    return 0;
}

#!/bin/sh

echo > consts.inc
g++ -c test.cpp && \
objdump -x test.o | c++filt | lua filter.lua > consts.inc && \
rm test.o && \
g++ -o test test.cpp && \
./test

for line in io.lines() do
    local size,name=line:match"%.data%.rel%.ro%.local%s+(%x+)%s+(Consts::[%w%d:_]+)"
    if name then print("DECL("..name..")") end
end

8    Consts::z    int [2]
8    Consts::Nested::x    double
40    Consts::Nested::y    int [10]

static_assert(Config.Key_B.Key_X.Value_C == 3.14);
static_assert(Config.Key_B.Key_X.Value_D == "Hello");

Config.Key_B.Key_X.Value_C;
get<2>(get<0>(get<1>(Config)));

enum ParameterType {
  PT_MaxNumberOfLines,
  PT_AllowedLineTypes,
  PT_UniqueKey,
  PT_LineConfig,
};

enum LineParameterType {
  LPT_Id,
  LPT_Name,
  LPT_Dir,
};

...

MyMagicListType const ParameterList {
  { PT_UniqueKey, "12345-67890 },
  { PT_AllowedLineTypes, LT_Mic | LT_DigitalOutput | LT_Speakers },
  { PT_LineConfig,
    { LPT_Name, "line1" },
    { LPT_Id, 12 },
    { LPT_Dir, LD_Input },
  },
  { PT_LineConfig,
    { LPT_Name, "line2" },
    { LPT_Id, 7 },
    { LPT_Dir, LD_Output },
  },
  { PT_MaxNumberOfLines, 5 },
};

ЕМ>В родном синтаксисе почти все это есть, не хватает сущей мелочи — возможности размещения литеральных значений в "самоопределенном" виде, где каждый элемент снабжается заголовком "это элемент типа T", "это увеличение вложенности", "это уменьшение вложенности". А известные мне средства организации подобных описаний через шаблонную магию слишком громоздки и корявы, чтоб я мог заставить себя их терпеть.

struct Rec {
    enum Type { RT_End, RT_Int, RT_Cstr, RT_Rec, RT_Enter, RT_Leave };
    int type, id;
    union {
        int v_int;
        const char* v_cstr;
        struct Rec *v_rec;
    };
    Rec() : type(RT_End) {}
    Rec(int id,int v) : type(RT_Int), id(id), v_int(v) {}
    Rec(int id,const char* v) : type(RT_Cstr), id(id), v_cstr(v) {}
    Rec(int id,Rec *v) : type(RT_Rec), id(id), v_rec(v) {}
    struct Enter{}; Rec(Enter,int id) : type(RT_Enter), id(id) {}
    struct Leave{}; Rec(Leave) : type(RT_Leave) {}
};

#define STRUCT_BEGIN(id) { id,[](){static Rec _array[]={
#define STRUCT_END()     {}};return _array;}() },
#define R_ENTER(id)      { Rec::Enter(),id },
#define R_LEAVE()        { Rec::Leave() },

enum ParameterType { PT_MaxNumberOfLines, PT_AllowedLineTypes, PT_UniqueKey, PT_LineConfig };
enum LineParameterType { LPT_Id,LPT_Name,LPT_Dir };
enum LT { LT_Mic=1,LT_DigitalOutput=2,LT_Speakers=4 };
enum LD { LD_Input,LD_Output };

Rec ParameterList[]={
    { PT_UniqueKey,"12345-67890" },
    { PT_AllowedLineTypes,LT_Mic | LT_DigitalOutput | LT_Speakers },
    STRUCT_BEGIN(PT_LineConfig)
        { LPT_Name,"line1" },
        { LPT_Id,12 },
        { LPT_Dir,LD_Input },
    STRUCT_END()
    STRUCT_BEGIN(PT_LineConfig)
        { LPT_Name,"line2" },
        { LPT_Id,7 },
        { LPT_Dir,LD_Output },
    STRUCT_END()
    R_ENTER(PT_LineConfig)
        { LPT_Name,"line3" },
        { LPT_Id,12 },
        { LPT_Dir,LD_Input },
    R_LEAVE()    
    R_ENTER(PT_LineConfig)
        { LPT_Name,"line4" },
        { LPT_Id,7 },
        { LPT_Dir,LD_Output },
    R_LEAVE()
    { PT_MaxNumberOfLines,5 },
    {}
};

//---------------------------------------------------------------------------------
auto SomeOperation(Numeric auto&&) {/*. . .*/}
auto SomeOperation(String auto&&) {/*. . .*/}
auto SomeOperation(Range auto&&) {/*. . .*/}

auto SomeOperation(Aggregate auto&& t)
{
    return aggregates::Apply(t, [](auto&&...x){ return (SomeOperation(x) | ...); });
}
//---------------------------------------------------------------------------------
struct {
    constexpr auto operator()(Numeric auto&&) const {/*. . .*/}
    constexpr auto operator()(String auto&&) const {/*. . .*/}
    constexpr auto operator()(Range auto&&) const {/*. . .*/}
    constexpr auto operator()(auto&&...) const {/*. . .*/}

    constexpr auto operator()(Aggregate auto&& t) const { return aggregates::Apply(t, *this}); }

} inline constexpr AnotherOperation;
//---------------------------------------------------------------------------------
struct {
// . . .
} inline constexpr Config;

int main()
{
    SomeOperation(Config);
    AnotherOperation(Config);
}