4

有没有办法将字符串或字符转换为类成员/成员函数以动态访问它们？

例如。这个特定的代码，

 #include <iostream>
 #include <map>

 using namespace std;

 class agnt {
 public:
 int x, y;
 agnt(int a=0, int b=0) : x(a), y(b) {}
 };


 int main() {
      map<int,agnt> agntID;
      agnt temp;
      temp.x=1;
      temp.y=5;

      agntID[1]=temp;

      for(char tmp='x'; tmp<'z'; tmp++) {
         cout<<agntID[1].tmp<<'\n';     //Here I get the following error: tmp is
         }                              //not a member of class agnt
 }

有没有办法转换字符'tmp'，使其被识别为类成员？任何提示或解决方案将不胜感激。

4

4 回答 4

3

C++ 没有任何内省，所以不，这是不可能的。

但是，您可以通过另一个std::map包含名称作为键的名称来“破解”它，并且值是对变量的引用：

agnt temp;

std::unordered_map<char, int&> variable_map = {
    { 'x', temp.x },
    { 'y', temp.y }
};

variable_map['x'] = 123;
std::cout << variable_map['y'] << '\n';

不过，这通常不值得，因为它的工作量更大。特别是如果您想对多个变量执行此操作（因为每个结构变量都需要自己的映射）。

于 2013-10-24T05:52:28.873 回答
1

不

C++ 没有自省和反射能力。您必须自己编写这种动态访问的代码。

在某些情况下，手动编码的合理替代方案可以使用外部模式文件来描述您的 C++ 类，然后自动生成类以及内省和反射代码。你不能使用模板来做到这一点，因为在这个领域甚至完全没有 C++ 的元编程能力。

由于 C++ 语法的复杂性，通过直接解析生成代码.h通常要困难得多（即使是编译器制造商也花了好几年的时间才在相当程度上同意什么是有效的 C++ 代码，什么不是）。

您可以使用模板来简化发布，但仍需手动操作：

template<typename T, typename C>
std::map<std::string, T C::*>& attribute_map() {
    static std::map<std::string, T C::*> m;
    return m;
}

template<typename C>
struct Published {
    template<typename T>
    T& attribute(const std::string& name) {
        std::map<std::string, T C::*>& m = attribute_map<T, C>();
        typename std::map<std::string, T C::*>::const_iterator i=m.find(name);
        if (i == m.end()) {
            throw std::runtime_error("Attribute not present");
        } else {
            return static_cast<C *>(this)->*i->second;
        }
    }
};

对于每个属性，您需要明确“发布”它

template<typename T, typename C>
void publish(const std::string& name, T C::*mp) {
    attribute_map<T, C>()[name] = mp;
}

鉴于上述样板代码，您可以创建一个类并通过派生以下方式发布其一些成员Published<Class>：

struct MyClass : Published<MyClass> {
    int a;
    double b;
    std::string c;

    MyClass(int a, double b, const std::string& c)
        : a(a), b(b), c(c)
    {
    }
};

然后，您将需要publish在程序开始时只调用一次该函数，以便能够动态访问属性：

int main(int argc, const char *argv[]) {
    publish("a", &MyClass::a);
    publish("b", &MyClass::b);
    publish("c", &MyClass::c);

    MyClass m1(3, 4.5, "This is a test");
    MyClass m2(6, 7.8, "This is another test");

    std::cout << m1.attribute<int>("a") << "\n";
    std::cout << m2.attribute<std::string>("c") << "\n";
    return 0;
}
于 2013-10-24T05:53:19.283 回答
1

您不能在 C++ 中执行此操作，因为它是一种静态类型语言。获得这种行为的一种方法是提供访问包装器：

template <char c>
struct getter {
};


template <>
struct getter<'x'> { 
   static int get(const agnt &theAgnt) {
      return theAgnt.x;
   }
};


template <>
struct getter<'y'> { 
   static int get(const agnt &theAgnt) {
      return theAgnt.y;
   }
};

template <char c>
int get(const agnt &theAgnt) {
    return getter<c>::get(theAgnt);
}

并调用：

agnt temp;
//... set members
std::cout << get<'x'>(temp) << std::endl;

但是，for循环不会按您期望的方式工作，因为模板参数需要在编译时确定。此外，您不能只请求任何旧的东西，除非您get在 unspecialisedgetter中定义一个返回某种 NULL 指示符的函数，例如INT_MIN.

然而，这实际上是一种获得与动态语言模糊相似的东西的技巧。但这与仅仅引用并没有什么不同temp.x。相反，您应该尝试遵守 C++ 约定并享受静态类型！

于 2013-10-24T05:54:26.340 回答
1

虽然回答“否”的每个人都是正确的……但这并不能说明全部情况。语言中没有任何内容允许您这样做，但这并不意味着环境不允许这样做。

例如，在 vxworks 上，您可以调用symFindByName()来查找函数、变量或任何其他符号，然后您可以通过它提供的指针调用该函数。但这依赖于 OS API，并且可能是 vxworks 链接器工作方式的副作用

其他操作系统可能具有类似的功能。

于 2013-10-24T07:45:59.870 回答