我正在尝试实现有限的 reflection在 C++ 中，这样我就可以调用 getter和 setter在存储的对象上。这是我到目前为止所做的

主要代码

#ifndef REFLECTION_MANAGER_HPP_
#define REFLECTION_MANAGER_HPP_

#include <iostream>
#include <string>


template <class Owner, class IOType> 
class SingleProperty {
public:
  typedef IOType    (Owner::*get_func_t)(); 
  typedef void    (Owner::*set_func_t)( IOType Value );

  inline SingleProperty(get_func_t Getter, set_func_t Setter ): m_Getter(Getter), m_Setter(Setter) {
  }
  get_func_t        m_Getter;
  set_func_t        m_Setter;
};

class ReflectionManager {
public:
  static ReflectionManager& Instance() {
    static ReflectionManager instance;
    return instance;
  }

  template <class Owner, class IOType> 
  void RegisterProperty(  std::string class_name, 
                          std::string property_name, 
                          typename SingleProperty<Owner, IOType>::get_func_t GetFn, 
                          typename SingleProperty<Owner, IOType>::set_func_t SetFn)  {
    SingleProperty<Owner, IOType>* pProperty = new SingleProperty<Owner, IOType>(GetFn, SetFn );
    m_class_memeber_map[class_name][property_name] = pProperty;
  }

  template <class Owner> void put(std::string key, void *value, std::string class_name = NULL ) {
    Owner *ptr = reinterpret_cast<Owner*>(value);
    std::map<std::string, std::map< std::string, void*> >::iterator pos = m_class_memeber_map.find(class_name);
    if ( pos == m_class_memeber_map.end()) {
      return; // handle the error
    }
    for ( std::map< std::string, void*>::iterator itr = pos->second.begin(); itr != pos->second.end(); ++itr ) {
      SingleProperty<Owner,std::string> *ptr = (SingleProperty<Owner,std::string> *)itr->second;
      (ptr->*m_Getter)();
    }
  }
private:
  ReflectionManager() {
  }
  ReflectionManager(ReflectionManager const&); 
  void operator=(ReflectionManager const&);

  std::map<std::string, std::map< std::string, void*> > m_class_memeber_map;

};

#endif

调用代码

这将被调用如下

ReflectionManager::Instance().RegisterProperty<Person, std::string>("Person", "m_name", &Person::GetName, &Person::SetName);
  ReflectionManager::Instance().RegisterProperty<Person, std::string>("Person", "m_dept", &Person::GetDept, &Person::SetDept);
  ReflectionManager::Instance().RegisterProperty<Person, int>("Person", "m_age", &Person::GetAge, &Person::SetAge);

  Person p1;
  p1.SetName("Avinash");
  p1.SetDept("Gemfire Native Client");
  p1.SetAge(34);

  ReflectionManager::Instance().put<Person>( "key1", &p1, "Person");

我已经存储了 getter和 setter在map , 但在 put函数我无法调用它，因为我不知道类型。

问题

基本上我现在如何实现 for 循环 for ( std::map< std::string, void*>::iterator itr = pos->second.begin(); itr != pos->second.end(); ++itr )我想在其中遍历每个元素并调用相应的 getter和 setter方法。

我试过了，但没有用。

(ptr->*((itr->second).m_Getter))();

我发现的另一种方法将不胜感激

  template <class Owner, class IOType> 
  void RegisterProperty(  std::string class_name, 
    std::string property_name, 
    typename SingleProperty<Owner, IOType>::get_func_t GetFn, 
    typename SingleProperty<Owner, IOType>::set_func_t SetFn)  {

      SingleProperty<Owner, IOType>* pProperty = new SingleProperty<Owner, IOType>(GetFn, SetFn );
      m_class_memeber_map[class_name][property_name] = pProperty;
      m_property_type_map[class_name].push_back(std::make_pair(property_name, TypeName<IOType>::get()));

  }

  template <class Owner> void put(std::string key, void *value, std::string class_name = NULL ) {
    Owner *pOwner  = reinterpret_cast<Owner*>(value);
    std::map<std::string, std::map< std::string, void*> >::iterator pos = m_class_memeber_map.find(class_name);

    std::vector<std::pair<std::string, std::string> > vector_property_map = m_property_type_map.find(class_name)->second;
    for ( std::vector<std::pair<std::string, std::string> >::iterator itr = vector_property_map.begin();itr != vector_property_map.end(); ++itr ) {
        std::map< std::string, void*>::iterator pos_getter_setter_fn = pos->second.find(itr->first);
        if ( itr->second == "int" ) {
          SingleProperty<Owner,int> *ptr = (SingleProperty<Owner, int> *)pos_getter_setter_fn->second;
          (pOwner->*(ptr->m_Getter))();
        } else if ( itr->second == "string" ) {
          SingleProperty<Owner,std::string> *ptr = (SingleProperty<Owner, std::string> *)pos_getter_setter_fn->second;
          (pOwner->*(ptr->m_Getter))();
        } 
    }
  }

最佳答案

这些指针是指向函数成员的指针 Owner输入:

get_func_t m_Getter;
set_func_t m_Setter;

为什么你试着调用他们给予 SingleProperty<>指针作为对象？

Owner *ptr = reinterpret_cast<Owner*>(value);
for ( std::map< std::string, void*>::iterator itr = pos->second.begin();
   itr != pos->second.end(); ++itr )
{
  SingleProperty<Owner,std::string> *ptr = 
      (SingleProperty<Owner,std::string> *)itr->second;
  // Here is the flaw, you are trying to call m_Getter from SingleProperty object
  // pointer, but it must be Owner pointer!
  (ptr->*m_Getter)();
}

此外，您还必须将属性类型作为模板参数正确传递 IOType . 我不确定你想用这个函数做什么，用丢弃的返回类型调用 getter 的效果是什么，但从抽象语法的角度来看，它应该是这样的:

template <class Owner, class IOType> void put(const std::string& key, Owner* value,
    const std::string& class_name = "")
{
    std::map<std::string, std::map<std::string, void*> >::iterator pos =
        m_class_memeber_map.find(class_name);

    if(pos == m_class_memeber_map.end())
    {
       return; // handle the error
    }

    for(std::map<std::string, void*>::iterator itr = pos->second.begin();
       itr != pos->second.end(); ++itr)
    {

        SingleProperty<Owner,IOType> *ptr = 
          static_cast<SingleProperty<Owner, IOType>*>(itr->second);
        (value->*(ptr->m_Getter))(); // return IOType discarded?!?!
    }
}

关于c++ - C++中的一种反射，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/13174999/