Question

请考虑以下事项。类A有一个函数指针作为成员，并在其构造函数中接受一个函数以传递给该成员。在一个单独的文件中，我有一个类B，它包含一个指向类A的指针作为成员，而类B也有一个成员，我想要传递给类{{ {1}}。

以下是我收到的一个示例和错误。做这样的事情的标准方法是什么？

A.H：

B.h：

class A {
 private:
  int (*func)(int);

 public:
  A(int (*func_)(int));
};

A::A(int (*func_)(int)) : func(func_) {}

main.cpp中：

#include "A.h"  // Why can't I forward declare A instead?

class B {
 private:
  A *A_ptr;
  int function(int);  // some function

 public:
  B();
  ~B();
};

int B::function(int n) {
  return n+2;  // some return value
}

B::B() {
  A_ptr = new A(function);
}

B::~B() {
  delete A_ptr;
}

我得到的错误：

#include "B.h"

int main() {
  B b;
}

Answer 1

要回答你关于“做这样的事情的标准方法是什么”的问题，我假设你的意思是传递成员函数和/或一般函数指针并用一些数据执行它们。一些提供此功能的流行实现是：

FastDelegate
std::function
boost::function

这真的归结为偏好和图书馆选择。就个人而言，我大部分时间都使用过FastDelegate，然后是std :: function。

我发布的所有链接都应该有教程信息，以帮助您启动并运行，并向您展示如何正确地传递和存储成员函数和/或一般函数指针。

以下是使用FastDelegate的示例：

class A 
{
public:
    // [1] This creates a delegate type. Can used for any function, 
    // class function, static function, that takes one int 
    // and has a return type of an int.
    typedef FastDelegate1< int, int > Delegate;

    // [2] Pass the delegate into 'A' and save a copy of it.
    A( const Delegate& delegate ) : _delegate( delegate ) { };

    void execute()
    {
        // [7]
        // Result should be 10!
        int result = _delegate( 8 ); 
    }

private:
    // [3] Storage to save the Delegate in A.
    Delegate _delegate;
};

class B
{
public:
    B() 
    {
        // [4] Create the delegate
        A::Delegate bDelegate;
        bDelegate.bind( this, &B::function );

        // [5] Create 'A' passing in the delegate.            
        _aPtr = new A( bDelegate );

        // [6] Test it out!! :) 
        // This causes `A` to execute the Delegate which calls B::function. 
        _aPtr->execute();
    }

    ~B() 
    {
        delete _aPtr; 
    }

    int function( int n )
    {
        return n+2;
    }

private:
    A* _aPtr;
};

使用函数指针在另一个类中初始化对象指针

1 个答案: