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

Question

我正在寻找一种方法来存储一小部分多维数据，这些数据在编译时已知并且永远不会改变。此结构的目的是充当存储在单个命名空间中的全局常量，但无需实例化对象即可全局访问。

如果我们只需要一层数据，有很多方法可以做到这一点。您可以将 anenum或 a classorstruct与静态/常量变量一起使用：

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()地图。如果我设置为非静态，它可以找到地图，但如果没有 的实例，我就无法调用它，而且我不想要它的实例。GetBytesRequired()MidiEventTypes

同样，这个问题不是关于如何修复编译错误，问题是关于存储不仅仅是键/值对的静态/常量数据的适当结构和设计模式是什么。

这些是目标：

• 数据和大小在编译时已知并且永远不会改变。

• 通过每组数据的人类可读密钥来访问一小组数据。键应映射到特定的非线性整数。

• 每个数据集包含相同的成员数据集。IE。每个人MidiEventType都有NumBytes财产。

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

• 有了键（或代表键值的变量），我们应该能够读取与键指向的常量项关联的额外数据，并使用另一个命名键来获取额外数据。

• 我们不需要实例化一个类来读取这些数据，因为没有任何变化，并且数据集的副本不应该超过一个。

• 事实上，除了 include 指令之外，不需要任何东西来访问数据，因为它的行为应该像常量。

• 我们在运行时不需要这个对象。目标是通过使用命名标签结构存储数据组，而不是到处使用（不明确的）整数文字，使代码更有条理且更易于阅读。

• 它是一个可以深入研究的常量……就像 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;
}