我有一个结构:
typedef struct Tick {
double open;
double high;
double low;
double close;
double ema100;
} Tick;
我想访问一个给定密钥的属性:
Tick currentTick = {44.5, 45.1, 44.2, 44.6, 44.255};
std::string key = "ema100";
std::cout << currentTick[key];
有没有办法在不使用std::map
的情况下执行此操作?我想答案是否定的,但我只想在修改所有内容之前确定使用std::map
并增加内存需求。
答案 0 :(得分:4)
有没有办法在不使用std :: map的情况下执行此操作?
只要你愿意接受一系列级联if-else
陈述,你就可以做到。
我会质疑设计。
您可以使用基于标签的成员变量部分到达那里。 Sample working example:
#include <iostream>
struct OpenTag {};
struct HighTag {};
struct LowTag {};
struct CloseTag {};
struct Ema100Tag {};
struct Tick {
template <typename Tag> struct Member
{
double val;
operator double () const { return val; }
operator double& () { return val; }
};
struct AllMembers : Member<OpenTag>,
Member<HighTag>,
Member<LowTag>,
Member<CloseTag>,
Member<Ema100Tag> {};
AllMembers data;
template <typename Tag>
double operator[](Tag t) const
{
return (Member<Tag> const&)(data);
}
template <typename Tag>
double& operator[](Tag t)
{
return (Member<Tag>&)(data);
}
};
int main()
{
Tick t;
t[OpenTag()] = 12.345;
std::cout << t[OpenTag()] << std::endl;
}
输出:
12.345
答案 1 :(得分:2)
您正在寻找的功能称为反射。本机C ++不支持此功能。你可以检查一些第三方库来为你做反射(但仍然需要大量的手动工作)。
或者另一个选项是(如你所提到的)使用std::map
(或更确切地说std::unordered_map
,因为它表现更好)将名称映射到类中字段的id或offset(指针)然后通过switch语句(在前一种情况下)或直接使用指针(在后一种情况下)修改字段值。
答案 2 :(得分:2)
您可以使用编译时可用的元数据来执行此操作。但是,我们必须手动完成:
template<typename Class, typename T>
struct Property {
constexpr Property(T Class::*aMember, const char* aName) : member{aMember}, name{aName} {}
using Type = T;
T Class::*member;
const char* name;
};
template<typename Class, typename T>
constexpr auto makeProperty(T Class::*member, const char* name) {
return Property<Class, T>{member, name};
}
现在我们有一个可以保存所需元数据的类。以下是如何使用它:
struct Dog {
constexpr static auto properties = std::make_tuple(
makeProperty(&Dog::barkType, "barkType"),
makeProperty(&Dog::color, "color")
);
private:
std::string barkType;
std::string color;
};
现在我们可以通过递归对它进行迭代:
template<std::size_t iteration, typename T, typename U>
void accessGetByString(T&& object, std::string name, U&& access) {
// get the property
constexpr auto property = std::get<iteration>(std::decay_t<T>::properties);
if (name == property.name) {
std::forward<U>(access)(std::forward<T>(object).*(property.member));
}
}
template<std::size_t iteration, typename T, typename U>
std::enable_if_t<(iteration > 0)>
getByStringIteration(T&& object, std::string name, U&& access) {
accessGetByString<iteration>(std::forward<T>(object), name, std::forward<U>(access));
// next iteration
getByStringIteration<iteration - 1>(std::forward<T>(object), name, std::forward<U>(access));
}
template<std::size_t iteration, typename T, typename U>
std::enable_if_t<(iteration == 0)>
getByStringIteration(T&& object, std::string name, U&& access) {
accessGetByString<iteration>(std::forward<T>(object), name, std::forward<U>(access));
}
template<typename T, typename U>
void getByString(T&& object, std::string name, U&& access) {
getByStringIteration<std::tuple_size<decltype(std::decay_t<T>::properties)>::value - 1>(
std::forward<T>(object),
name,
std::forward<U>(access)
);
}
最后,您可以使用此工具,如:
struct MyAccess {
void operator()(int i) { cout << "got int " << i << endl; }
void operator()(double f) { cout << "got double " << f << endl; }
void operator()(std::string s) { cout << "got string " << s << endl; }
}
Dog myDog;
getByString(myDog, "color", MyAccess{});
这肯定可以通过重载lambda来简化。要了解有关重载的lambda的更多信息,请参阅此blog post
原始代码取自该答案:C++ JSON Serialization
有一个建议让这样的事情变得更容易。 这由P0255r0
涵盖答案 3 :(得分:0)
老实说,我认为使用重载operator[]
和if-else
语句就是你真正需要的。鉴于任何一个班级,他们真的是那么多成员吗?在我看来,其他解决方案为这么简单的任务提供了太多的开销。我会做这样的事情:
template <typename T>
T& operator[](const std::string& key)
{
if (key == ...)
// do something
}