C++ C++；使用模板对象进行操作

我有一节课

class BarBase {

};

以及派生模板类，该类存储指向成员函数的指针和指向同一类的对象的指针

template<typename TypeName> class Bar: public BarBase
{
    void ( TypeName::*action ) ( void );
    TypeName* object;
};

现在来回答问题。Foo有一个模板函数

template <typename TypeName>
void Foo::foo( TypeName* object , void ( TypeName::*action ) ( void ) )

模板
void Foo：：Foo（类型名*对象，void（类型名：：*操作）（void））

在此函数中，如何在

mybar

元素中找到字段

object

和

action

等于此函数参数的元素？如您所见，我不能直接访问像

this->mybar[I]>action

这样的字段，因为这些字段不是（也不能是）巴巴多斯的成员

编辑

---

我可以比较

对象

。我添加了一个

virtualsize\u t getObject（）{}

到

BarBase

并在

Bar

中覆盖它，如

virtual size\u t getObject（）{return（size\t）this->object；}。然后我比较了两个
size\u t
，但我不知道如何将
action
转换为数字…
最简单的解决方案是使基类多态，并使用
dynamic\u cast
确定它是否具有预期的类型：

class BarBase {
public:
    virtual ~BarBase() {}  // virtual function required for polymorphism
};

Bar<TypeName>* bar = dynamic_cast<Bar<TypeName>*>(myBars[i]);
if (bar && bar->object == object && bar->action == action) {
    // it's a match
}

class巴巴多斯{
公众：
virtual~BarBase（）{}//多态性所需的虚拟函数
};
Bar*Bar=动态_铸造（myBars[i]）；
如果（条和条->对象==对象和条->操作==操作）{
//这是一场比赛
}

这确实增加了一些支持RTTI的开销；在我的脑海中，我想不出任何一种定义明确的方法来做到这一点，而不增加开销。
如果你不想使用Mike variant（我更喜欢他的变体），你可以使用类似的方法

这个问题没有正确而简单的解决方案。您可以在循环中使用dynamic_cast并检查dynamic_cast是否返回NOTNULLvalue@ForEveR添加了问题的更新。您可以使用reinterpret_cast将函数指针强制转换为void*，但这不是正确的方法。@永久：指向成员函数的指针不是函数指针。@永久，这可能会导致未定义的行为，空PTR和成员FN指针是不同的，这将永远不会考虑<代码> Bar <代码>和<代码> bar >代码>，即使它们包含指向同一个最派生对象和同一个成员的指针。@ MikeSeymour，谢谢您的回答，很好的解决方案。请问，为什么需要虚拟析构函数，这个概念是如何工作的？谢谢@Kolyunya:
dynamic\u cast
通过使用运行时类型信息（RTTI）询问对象的动态类型是否为
Bar
。只有当类型是多态的（这意味着它至少有一个虚函数）时，这才是可能的。如果您不需要任何虚拟函数，那么实现这一点的一个简单方法是使析构函数成为虚拟函数。
class BarBase {
public:
    virtual ~BarBase() {}  // virtual function required for polymorphism
};

Bar<TypeName>* bar = dynamic_cast<Bar<TypeName>*>(myBars[i]);
if (bar && bar->object == object && bar->action == action) {
    // it's a match
}

class BarBase 
{
public:
   virtual ~BarBase() { }
   virtual void* getObject() { return 0; }
   virtual const char* getFunctionName() { return 0; }
};

template<typename T>
class Bar : public BarBase
{
public:
   Bar(T* obj, void (T::*func) (void)):object(obj), action(func)
   {
   }
   virtual void* getObject() { return object; }
   virtual const char* getFunctionName() { return typeid(action).name(); }
   T* object;
   void (T::*action)(void);
};

class BarBase 
{
public:
   virtual ~BarBase() { }
   virtual void* getObject() const { return 0; }
};

template<typename T>
class Bar : public BarBase
{
public:
   Bar(T* obj, void (T::*func) (void)):object(obj), action(func)
   {
   }
   virtual void* getObject() const { return object; }
   T* object;
   void (T::*action)(void);
};

for (auto pos = objects.begin(); pos != objects.end(); ++pos)
{
      if ((*pos)->getObject() == &p)
      {
         auto bar = static_cast<Bar<S>*>(*pos);
         if (bar->action == act)
         {
            // right object founded.
         }
      }
   }