我正在寻找一种方法来存储一个小 多维在编译时已知且永远不会更改的数据集。此结构的目的是充当存储在单个命名空间中的全局常量,否则无需实例化对象即可全局访问。
如果我们只需要一个级别的数据,有很多方法可以做到这一点。您可以使用 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
的实例,我就无法调用它我不想要它的实例。同样,这个问题不是关于如何修复编译错误,问题是关于存储超过键/值对的静态/常量数据的适当结构和设计模式是什么。
这些是目标:
映射到特定的非线性整数。
MidiEventType
有一个 NumBytes
属性(property)。能够读取与键的常量项关联的额外数据
指向,为额外数据使用另一个命名键。
没有任何变化,并且不应有多个拷贝
数据集。
NOTE_ON = 9
, 字面量 9
不应出现在其他任何地方。标签NOTE_ON
应改为使用,以便只能在一处更改该值。使用与常量相同的用例来存储在编译时已知的小型、固定大小、分层(多维)静态数据集的最佳方法是什么?
最佳答案
这是我的看法,一个完整的 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;
}
关于c++ - 存储小型、固定大小、分层静态数据集的好方法是什么?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/69072204/