如何通過字符串名稱訪問結構屬性？

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語句，就可以做到。

不過我會質疑設計。

您可以部分使用基於標簽的成員變量。 示例工作示例：

#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++ 不支持此功能。 你可以檢查一些 3rd-party 庫來為你做反射（但仍然需要大量的手動工作）。

或者另一種選擇是（如您所提到的）使用std::map （或者更確切地說是std::unordered_map因為它會表現得更好）將名稱映射到類中字段的 id 或偏移量（指針），然后通過 switch 語句（在前一種情況下）或直接使用指針（在后一種情況下）修改字段值。

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 來簡化。 要了解有關重載 lambda 的更多信息，請參閱此博客文章

原始代碼取自該答案： C++ JSON Serialization

有一個提議可以讓這樣的事情變得更容易。 這由P0255r0涵蓋

Answer 4

老實說，我認為使用重載的operator[]和if-else語句是您真正需要的。 給定任何一個班級，他們的成員真的有那么多嗎？ 在我看來，其他解決方案為這樣一個簡單的任務提供了太多的開銷。 我只會做這樣的事情：

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