c++ - 存储小型、固定大小、分层静态数据集的好方法是什么？

Question

我正在寻找一种方法来存储一个小 多维在编译时已知且永远不会更改的数据集。此结构的目的是充当存储在单个命名空间中的全局常量，否则无需实例化对象即可全局访问。
如果我们只需要一个级别的数据，有很多方法可以做到这一点。您可以使用 enum或 class或 struct使用静态/常量变量:

class MidiEventTypes{
   public:
   static const char NOTE_OFF = 8;
   static const char NOTE_ON = 9;
   static const char KEY_AFTERTOUCH = 10;
   static const char CONTROL_CHANGE = 11;
   static const char PROGRAM_CHANGE = 12;
   static const char CHANNEL_AFTERTOUCH = 13;
   static const char PITCH_WHEEL_CHANGE = 14;
};

通过使用此类及其成员，我们可以轻松地比较程序中任何位置的数值变量:

char nTestValue = 8;
if(nTestValue == MidiEventTypes::NOTE_OFF){} // do something...

但是如果我们想要存储的不仅仅是一个名称和值对呢？如果我们还想用 存储一些额外的数据怎么办？每个持续的？在上面的示例中，假设我们还想存储每种事件类型必须读取的字节数。
下面是一些伪代码的用法:

char nTestValue = 8;
if(nTestValue == MidiEventTypes::NOTE_OFF){
   std::cout << "We now need to read " << MidiEventTypes::NOTE_OFF::NUM_BYTES << " more bytes...." << std::endl;
}

我们也应该能够做这样的事情:

char nTestValue = 8;
// Get the number of read bytes required for a MIDI event with a type equal to the value of nTestValue.
char nBytesNeeded = MidiEventTypes::[nTestValue]::NUM_BYTES; 

或者:

char nTestValue = 8;    
char nBytesNeeded = MidiEventTypes::GetRequiredBytesByEventType(nTestValue);

和:

char nBytesNeeded = MidiEventTypes::GetRequiredBytesByEventType(NOTE_OFF);

这个问题不是关于如何让实例化的类做到这一点。我已经可以做到了。问题是关于如何存储和访问与常量相关/附加的“额外”常量(不变)数据。 (运行时不需要这个结构!)或者如何创建一个多维常量。看起来这可以用静态类来完成，但我已经尝试了下面代码的几种变体，每次编译器发现一些不同的提示:

static class MidiEventTypes{
   
   public:
   static const char NOTE_OFF = 8;
   static const char NOTE_ON = 9;
   static const char KEY_AFTERTOUCH = 10; // Contains Key Data
   static const char CONTROL_CHANGE = 11; // Also: Channel Mode Messages, when special controller ID is used.
   static const char PROGRAM_CHANGE = 12;
   static const char CHANNEL_AFTERTOUCH = 13;
   static const char PITCH_WHEEL_CHANGE = 14;
   
   // Store the number of bytes required to be read for each event type.
   static std::unordered_map<char, char> BytesRequired = {
      {MidiEventTypes::NOTE_OFF,2},
      {MidiEventTypes::NOTE_ON,2},
      {MidiEventTypes::KEY_AFTERTOUCH,2},
      {MidiEventTypes::CONTROL_CHANGE,2},
      {MidiEventTypes::PROGRAM_CHANGE,1},
      {MidiEventTypes::CHANNEL_AFTERTOUCH,1},
      {MidiEventTypes::PITCH_WHEEL_CHANGE,2},
   };
   
   static char GetBytesRequired(char Type){
      return MidiEventTypes::BytesRequired.at(Type);
   }
   
};

这个特定的例子不起作用，因为它不会让我创建 static unordered_map .如果我不做 unordered_map static , 然后它编译但是 GetBytesRequired()找不到 map 。如果我做 GetBytesRequired()非静态，它可以找到 map ，但是如果没有 MidiEventTypes 的实例，我就无法调用它我不想要它的实例。
同样，这个问题不是关于如何修复编译错误，问题是关于存储超过键/值对的静态/常量数据的适当结构和设计模式是什么。
这些是目标:

数据和大小在编译时是已知的，永远不会改变。

使用每个数据集的人类可读 key 访问一小组数据。关键应该
映射到特定的非线性整数。

每个数据集包含相同的成员数据集。 IE。每个MidiEventType有一个 NumBytes属性(property)。

可以使用命名键或函数访问子项。

使用键(或表示键值的变量)，我们应该
能够读取与键的常量项关联的额外数据
指向，为额外数据使用另一个命名键。

我们不需要实例化一个类来读取这些数据，因为
没有任何变化，并且不应有多个拷贝
数据集。

事实上，除了包含指令，访问数据不需要任何东西，因为它应该表现得像一个常量。

我们在运行时不需要这个对象。目标是通过使用命名标签结构存储数据组，而不是在任何地方使用(模棱两可的)整数文字，从而使代码更有条理且更易于阅读。

它是一个常量，您可以深入研究……就像 JSON。

理想情况下，不应该要求强制转换来使用常量的值。

我们应该避免重复数据并且可能不同步的冗余列表。例如，一旦我们定义了 NOTE_ON = 9 , 字面量 9不应出现在其他任何地方。标签NOTE_ON应改为使用，以便只能在一处更改该值。

这是一个通用问题，MIDI 仅用作示例。

常量应该能够拥有多个属性。

使用与常量相同的用例来存储在编译时已知的小型、固定大小、分层(多维)静态数据集的最佳方法是什么？

Answer 1

这是我的看法，一个完整的 constexpr 编译时解决方案。
为了您的使用，还将 MIDI 内容放在头文件中，您就可以开始使用了。
带头文件 https://www.onlinegdb.com/lGp7zMNB6

#include <iostream>
#include "const_string.h"
#include "const_map.h"

namespace midi
{
    using data_t = char;
    using string_t = const_string<32>; // 32 is big enough to hold strings in map

    namespace control
    {
        constexpr data_t NOTE_OFF = 8;
        constexpr data_t NOTE_ON = 9;
        constexpr data_t KEY_AFTERTOUCH = 10;
        constexpr data_t CONTROL_CHANGE = 11;
        constexpr data_t PROGRAM_CHANGE = 12;
        constexpr data_t CHANNEL_AFTERTOUCH = 13;
        constexpr data_t PITCH_WHEEL_CHANGE = 14;
    } /* namespace control */

    constexpr auto required_bytes = make_const_map<data_t, data_t>({
        {control::NOTE_OFF,2},
        {control::NOTE_ON,2},
        {control::KEY_AFTERTOUCH,2},
        {control::CONTROL_CHANGE,2},
        {control::PROGRAM_CHANGE,1},
        {control::CHANNEL_AFTERTOUCH,1},
        {control::PITCH_WHEEL_CHANGE,2}
    });

    constexpr auto str = make_const_map<data_t, string_t>({
        { control::NOTE_ON,"Note on" },
        { control::NOTE_OFF,"Note off" },
        { control::CONTROL_CHANGE, "Control change"},
        { control::CHANNEL_AFTERTOUCH, "Channel aftertouch"},
        { control::PITCH_WHEEL_CHANGE, "Pitch wheel change"}
    });

} /* namespace midi */

int main()
{
    static_assert(midi::control::NOTE_OFF == 8, "test failed");
    static_assert(midi::required_bytes[midi::control::NOTE_OFF] == 2, "test failed");
    static_assert(midi::required_bytes[13] == 1, "test failed");
    static_assert(midi::str[midi::control::NOTE_OFF] == "Note off", "test failed");

    return 0;
}

//接受后编辑:更简洁的语法

#include <iostream>
#include "const_string.h"
#include "const_map.h"

namespace midi_details
{
    using data_t = char;
    using string_t = const_string<32>;
}

constexpr midi_details::data_t MIDI_NOTE_OFF = 8;
constexpr midi_details::data_t MIDI_NOTE_ON = 9;
constexpr midi_details::data_t MIDI_KEY_AFTERTOUCH = 10;
constexpr midi_details::data_t MIDI_CONTROL_CHANGE = 11;
constexpr midi_details::data_t MIDI_PROGRAM_CHANGE = 12;
constexpr midi_details::data_t MIDI_CHANNEL_AFTERTOUCH = 13;
constexpr midi_details::data_t MIDI_PITCH_WHEEL_CHANGE = 14;

namespace midi_details
{
    constexpr auto required_bytes = make_const_map<data_t, data_t>({
        {MIDI_NOTE_OFF,2},
        {MIDI_NOTE_ON,2},
        {MIDI_KEY_AFTERTOUCH,2},
        {MIDI_CONTROL_CHANGE,2},
        {MIDI_PROGRAM_CHANGE,1},
        {MIDI_CHANNEL_AFTERTOUCH,1},
        {MIDI_PITCH_WHEEL_CHANGE,2}
        });

    constexpr auto str = make_const_map<data_t, string_t>({
            { MIDI_NOTE_ON,"Note on" },
            { MIDI_NOTE_OFF,"Note off" },
            { MIDI_CONTROL_CHANGE, "Control change"},
            { MIDI_CHANNEL_AFTERTOUCH, "Channel aftertouch"},
            { MIDI_PITCH_WHEEL_CHANGE, "Pitch wheel change"}
        });

    struct info_t
    {
        constexpr info_t(data_t r, string_t n) :
            required_bytes{ r },
            name{ n }
        {
        }

        data_t  required_bytes;
        string_t name;
    };

} /* namespace midi_details */

constexpr auto midi(midi_details::data_t value)
{
    return midi_details::info_t{ midi_details::required_bytes[value], midi_details::str[value] };
}

int main()
{
    static_assert(MIDI_NOTE_OFF == 8);
    static_assert(midi(MIDI_NOTE_OFF).required_bytes == 2, "test failed");
    static_assert(midi(MIDI_NOTE_OFF).name == "Note off", "test failed");

    return 0;
}