参考级别第 2 部分

Question

扩展这个问题，看起来像我没有提供足够的细节。

我有一个名为 CallbackObject 的对象，该对象旨在包含对象实例、要调用的函数的信息以及在调用时传递的参数。

template <typename objectType,
          typename memberFunctionPtrType,
          typename memberFcnArg1Type>
struct CallbackObject1
{
  objectType obj ;
  memberFunctionPtrType fcnPtr ;
  memberFcnArg1Type arg1 ;

  CallbackObject1(objectType iObj,
                  memberFunctionPtrType iFcnPtr,
                  memberFcnArg1Type iArg1 )
  {
    obj = iObj ;
    fcnPtr = iFcnPtr ;
    arg1 = iArg1 ;
  }

  void exec()
  {
    (obj.*fcnPtr)( arg1 ) ;
  }
} ;

使用示例：

struct Point
{
  float x,y ;
  void print( int numTimes )
  {
    for( int i = 0 ; i < numTimes ; i++ )
      printf( "%f %f\n", x, y ) ;
  }
} ;

typedef void (Point::* PointPrintFcnType)( int ) ;

int main()
{
  Point p ;
  p.x=p.y=1;

  CallbackObject1<Point, PointPrintFcnType, int> ocall( p, &Point::print, 5 );
  ocall.exec() ;
}

我遇到的唯一问题是如果 objectType 是指针类型，则 (obj.*fcnPtr) 失败，因为它实际上应该读取 ( (*obj).*fcnPtr) 或 (obj->*fcnPtr) 如果 obj 是指针。

现在我有一个解决方案，我定义 另一个 CallbackObject 类，如下所示：

template <typename pObjectType,
          typename memberFunctionPtrType,
          typename memberFcnArg1Type>
struct CallbackPObject1
{
  pObjectType obj ;
  memberFunctionPtrType fcnPtr ;
  memberFcnArg1Type arg1 ;

  CallbackPObject1(pObjectType iObj,
                  memberFunctionPtrType iFcnPtr,
                  memberFcnArg1Type iArg1 )
  {
    obj = iObj ;
    fcnPtr = iFcnPtr ;
    arg1 = iArg1 ;
  }

  void exec()
  {
    (obj->*fcnPtr)( arg1 ) ;
  }
} ;

但这充其量是很粗糙，最坏的是难以使用，如果其他人正在使用此代码，他们将不得不创建一个如果使用的对象类型实际上是指针，则不同类型的回调对象。

有什么办法解决这个问题吗？

Answer 1

下面是一个辅助函数示例，假设 void 返回、一个参数，并且无需处理多于一层的间接：

template <typename T, typename F, typename A>
inline void invoke(T& obj, F func, const A& arg)
{
    (obj.*func)(arg);
}

template <typename T, typename F, typename A>
inline void invoke(T* obj, F func, const A& arg)
{
    (obj->*func)(arg);
}

如果您需要处理多于一层的间接，您可以用此替换第二个函数：

template <typename T, typename F, typename A>
inline void invoke(T* obj, F func, const A& arg)
{
    invoke(*obj, func, arg);
}

这将递归地剥离关闭间接级别，直到最终得到可以调用成员函数的东西。

然后您可以像这样编写 exec() 函数：

void exec()
{
    invoke(obj, fcnPtr, arg1);
}

Answer 2

将多态函数对象（例如 boost::function）与函子生成函数（例如 boost::bind）结合使用。这是一个远远优越的解决方案——天才发生在函子生成时，而不是调用它时，并且可以调用任何可以使用正确签名调用的函数对象。

Answer 3

好的，对 上一个问题应用“重载”方法 我得到

template <typename objectType,
          typename memberFunctionPtrType,
          typename memberFcnArg1Type>
struct CallbackObject1 : public Callback
{
  objectType obj ;
  objectType *pObj ;
  memberFunctionPtrType fcnPtr ;
  memberFcnArg1Type arg1 ;

  CallbackObject1(objectType iObj,
                  memberFunctionPtrType iFcnPtr,
                  memberFcnArg1Type iArg1 )
  {
    obj = iObj ;
    pObj = 0 ;
    fcnPtr = iFcnPtr ;
    arg1 = iArg1 ;
  }

  CallbackObject1(objectType *iObj,
                  memberFunctionPtrType iFcnPtr,
                  memberFcnArg1Type iArg1 )
  {
    pObj = iObj ;
    fcnPtr = iFcnPtr ;
    arg1 = iArg1 ;
  }

  void exec()
  {
    if( pObj )
      (pObj->*fcnPtr)( arg1 ) ;
    else
      (obj.*fcnPtr)( arg1 ) ;
  }
} ;

使用

  typedef void (Point::* PointPrintFcnType)( int ) ;

  Point p ;
  p.x=p.y=1;

  CallbackObject1<Point, PointPrintFcnType, int> ocall( p, &Point::print, 5 );
  ocall.exec() ;

  CallbackPObject1<Point*, PointPrintFcnType, int> ocallP( &p, &Point::print, 2 );
  ocallP.exec() ;

它工作相当不错，但它的内部并不像我想要的那么干净。