Question

我有一个类，它会在某些情况下调用用户指定的函数。因此，该类有一个方法void setExternalPostPaintFunction(void(*function)(QPainter&));，可以用来注册＆＃34;一个功能。然后将在此时调用此函数：

class A {
    public:
        void setExternalPostPaintFunction(void(*function)(QPainter&));
    private:
        void (*_externalPostPaint)(QPainter&);
        bool _externalPostPaintFunctionAssigned;
};

函数指针保存在成员变量_externalPostPaint中。 setExternalPostPaintFunction的实现如下所示：

void A::setExternalPostPaintFunction(void(*function)(QPainter&)) {
    _externalPostPaint = function;
    _externalPostPaintFunctionAssigned = true;
}

现在，这适用于普通功能。但是，我希望能够将指针传递给对象的成员函数。据我所知，在这种情况下我还必须传递并存储指向对象的指针。但是，我不知道另一个对象将具有哪种类型。所以我想我不得不使用模板。我已经想过这样的事情：

class A {
    public:
        template <typename T>
        void setExternalPostPaintFunction(void(T::*function)(QPainter&), T* object);
    private:
        void (T::*_externalPostPaint)(QPainter&);       //<- This can't work!
        bool _externalPostPaintFunctionAssigned;
};

这样我可以将函数指针和对象指针传递给setExternalPostPaintFunction，并且可能能够调用该函数内对象的函数。但是我无法将其存储在变量_externalPostPaint中，因为T类型仅在调用函数setExternalPostPaintFunction时推断出来，因此我无法取决于此类型的成员变量，因为在创建对象时必须知道我的成员变量的类型，并且除了它不能更改之外，但是在分配可能可能的新函数时必须这样做不同类型对象的成员函数。

那么这样做的正确方法是什么，或者有没有？我不太适合模板和函数指针，所以我可能忽略了一些东西。

Anoter选项当然是创建一个带有虚拟成员函数的仿函数类，该函数可以在派生类中被覆盖，然后传递+存储该类型的对象指针而不是函数指针。但是如果某种可能的话，我会更喜欢我的方法。

编辑：解决方案

TartanLlama建议使用std::function让我走上正轨。以下是我解决它的方法：

class A {
    public:
        template <typename T>
        void setExternalPostPaintFunction(T* object, void(T::*function)(QPainter&)) {
            _externalPostPaint = std::bind(function, object, std::placeholders::_1);
            _externalPostPaintFunctionAssigned = true;
        }
        void setExternalPostPaintFunction(std::function<void(QPainter&)> const& function);
    private:
        std::function<void(QPainter&)> _externalPostPaint;
        bool _externalPostPaintFunctionAssigned;
};

如您所见，指向函数/成员函数的指针现在存储在std::function<void(QPainter&)>对象中。优点是，std::function基本上可以存储任何可调用目标。然后有两个重载：一个可用于任何std::function对象，也可以接受例如一个普通的函数指针（因为预期的std::function是从那个隐式构造的）和一个必须在一个对象上调用的成员函数（更方便）。后者作为模板实现。这使用std::bind来创建对象（用户传递）的成员函数（用户传递）的调用的std::function对象。

需要std::function的重载在源文件中实现，如下所示：

void ImageView::setExternalPostPaintFunction(std::function<void(QPainter&)> const& function) {
    _externalPostPaint = function;
    _externalPostPaintFunctionAssigned = true;
}

在类A的代码中调用存储的函数现在就像这样简单：

//canvas is a QPainter instance    
if (_externalPostPaintFunctionAssigned) _externalPostPaint(canvas);

想要将成员函数注册为回调函数的用户只需执行以下操作：

//_imageView is an instance of "A"
//"MainInterface" is the type of "this"
_imageView->setExternalPostPaintFunction(this, &MainInterface::infoPaintFunction);

或者，如果它不是成员函数而只是正常函数：

void someFunction(QPainter& painter) {
    //do stuff
}

_imageView->setExternalPostPaintFunction(&someFunction);

或者他可以显式创建一个std::function对象并传递它：

std::function<void(QPainter&)> function = [&](QPainter& painter){ this->infoPaintFunction(painter); };
_imageView->setExternalPostPaintFunction(function);

像魅力一样。

Answer 1

您可以使用std::function：

class A {
    public:
        //PostPaintFun can be anything which acts as a function taking a QPainter&
        //Could be a lambda, function pointer, functor, etc.
        using PostPaintFun = std::function<void(QPainter&)>;
        void setExternalPostPaintFunction(PostPaintFun fun);
    private:
        //Names beginning with an underscore are reserved, don't use them
        //Ending with an underscore is fine
        PostPaintFun fun_;
        bool externalPostPaintFunctionAssigned_;
};

现在您可以使用如下的成员函数：

struct B
{
    void exec(QPainter&) const;
};

void foo() {
    B b;
    a.setExternalPostPaintFunction(
        [b] (QPainter& p) {b.exec(p);}
    );
}

//or inside B
void B::foo() {
    a.setExternalPostPaintFunction(
        [this] (QPainter&p) {this->exec(p);}
    );
 }

Answer 2

我不得不说我更喜欢TartanLlama的答案，但在这里你可以找到适合你的东西。

这可能需要一些工作，但我相信你会明白这一点。

struct IFunctionHolder {};                      // Used for pointing to any FunctionHolder
typedef IFunctionHolder* functionHolder_ptr;    // Alias for IFunctionHolder* .

template<typename Function>                     // The template for the actual function holders.
struct FunctionHolder:  public IFunctionHolder
{
    Function function;
};


class A {
    public:
        template <typename T>
        void setExternalPostPaintFunction(void(T::*function)(QPainter&), T* object);
    private:
        functionHolder_ptr *function_holder;            // This memeber can hold eny instantiation of template<> FunctionHolder.
                                                        // Instantiate this member wen calling setExternalPostPaintFunction
        bool _externalPostPaintFunctionAssigned;
};

你可以有这样的代码：

A some_a;
void some_a.setExternalPostPaintFunction(&SomeInstance::some_fnunction);    // Here take place the instantiation of FunctionHolder.
some_a.function_holder.function(some_painter);

C ++：将指针存储到另一个对象

2 个答案: