如何通过字符串名称访问struct属性？

Question

我有一个结构：

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并增加我的内存需求。

Answer 1

有没有办法做到这一点，而不使用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 

Answer 2

你正在寻找被称为反射的功能。本地C++不支持此功能。您可以检查一些第三方库来为您做反射（但仍需要大量的手动工作）。

或者使用std::map（或者更确切地说std::unordered_map，因为它会表现得更好）或者其他选项将名称映射到类中字段的id或offset（指针），然后通过switch语句（in前一种情况）或直接使用指针（在后一种情况下）修改字段值。

Answer 3

您可以使用编译时可用的元数据来完成此操作。但是，我们必须手动完成：

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简化。要了解更多关于超载拉姆达，看到这个blog post

原始代码从答案被采取：C++ JSON Serialization

有做这样的事情更简单的建议。 这覆盖P0255r0

Answer 4

老实说，我认为使用超载operator[]和if-else声明是你真正需要的。鉴于任何阶级，他们真的是那么多成员？在我看来，其他解决方案为这么简单的任务提供了太多的开销。我只想做这样的事情：

template <typename T> 
T& operator[](const std::string& key) 
{ 
    if (key == ...) 
     // do something 
}