如何通過字符串名稱訪問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 
}