1

可変個引数テンプレートを使用してDelegateクラスを実装しようとしているときに、解決できない問題に遭遇しました。

/// --------------------------------------
/// @thanks     God
///             Steve Reinalter
/// @author     Henri Korpela aka Helixirr
/// --------------------------------------
#include <cstdio>

template<typename>
class Delegate;

template<typename Return, typename Param, typename... ParamsOther>
class Delegate<Return (Param, ParamsOther...)>{
public:

    /// Constructors & destructors:
    Delegate(void) = default;
    Delegate(Delegate const& delegate_) = default;
    Delegate(Delegate&& delegate_) = default;

    /// Member functions:
    Delegate& bind(Return (*function_)(Param, ParamsOther...));
    template<class C>
    Delegate& bind(C& c_, Return (C::*function_)(Param, ParamsOther...));

    /// Member functions (overloaded operators, assignment):
    Delegate& operator=(Delegate const& delegate_) = default;
    Delegate& operator=(Delegate&& delegate_) = default;

    /// Member functions (overloaded operators, function call):
    inline Return operator()(Param param_, ParamsOther... params_other_) const;

private:
    /// Member data:
    Return (*_m_opFunction)(Param, ParamsOther...) = nullptr;
    void* _m_opInstance = nullptr;
    /// Static member functions:
    template<class C, Return (C::*Function)(Param, ParamsOther...)>
    static inline Return _wrap_function_member(void* instance_, Param param_, ParamsOther... params_other_);
    template<Return (*Function)(Param, ParamsOther...)>
    static inline Return _wrap_function_static(void*, Param param_, ParamsOther... params_other_);
};

/// Member functions:
template<typename Return, typename Param, typename... ParamsOther>
Delegate<Return (Param, ParamsOther...)>& Delegate<Return (Param, ParamsOther...)>::bind(Return (*function_)(Param, ParamsOther...)){
    _m_opFunction = &_wrap_function_static<decltype(function_)>;
    _m_opInstance = nullptr;
    return *this;
}
template<typename Return, typename Param, typename... ParamsOther>
template<class C>
Delegate<Return (Param, ParamsOther...)>& Delegate<Return (Param, ParamsOther...)>::bind(C& c_, Return (C::*function_)(Param, ParamsOther...)){
    _m_opFunction = &_wrap_function_member<C, decltype(function_)>;
    _m_opInstance = &c_;
    return *this;
}
/// Member functions (overloaded operators, function call):
template<typename Return, typename Param, typename... ParamsOther>
Return Delegate<Return (Param, ParamsOther...)>::operator()(Param param_, ParamsOther... params_other_) const{
    return _m_opFunction(_m_opInstance, param_, params_other_...);
}
/// Static member functions:
template<typename Return, typename Param, typename... ParamsOther>
template<class C, Return (C::*Function)(Param, ParamsOther...)>
Return Delegate<Return (Param, ParamsOther...)>::_wrap_function_member(void* instance_, Param param_, ParamsOther... params_other_){
    return (static_cast<C*>(instance_)->*Function)(param_, params_other_...);
}
template<typename Return, typename Param, typename... ParamsOther>
template<Return (*Function)(Param, ParamsOther...)>
Return Delegate<Return (Param, ParamsOther...)>::_wrap_function_static(void*, Param param_, ParamsOther... params_other_){
    return (Function)(param_, params_other_...);
}

int f(int i_){
    return i_ * 2;
}

int main(void){
    Delegate<int (int)> delegate__;
    delegate__.bind(&f);
    printf("Result: %i\n", delegate__(8));
    return 0;
}

これをIdeoneで C++11 コンパイラ ( GCC 4.7.2 ) でコンパイルしようとしましたが、失敗したようです:

prog.cpp: 'Delegate& Delegate::bind(Return (*)(Param, ParamsOther ...)) のインスタンス化で [with Return = int; パラメータ = int; ParamsOther = {}]': prog.cpp:79:23: ここから必要 prog.cpp:45:5: エラー: 関数 '_wrap_function_static' をタイプ 'int (*)(int)' に変換する一致はありません prog.cpp: 39:26: エラー: 候補は: テンプレート static Return Delegate::_wrap_function_static(void*, Param, ParamsOther ...) [with Return (* Function)(Param, ParamsOther ...) = Function; 戻り値 = int; パラメータ = int; ParamsOther = {}] prog.cpp: 'Return Delegate::operator()(Param, ParamsOther ...) のインスタンス化で const [with Return = int; パラメータ = int; ParamsOther = {}]': prog.cpp:80:40: ここから必要 prog.cpp:59:65: エラー: 'void*' から 'int' への無効な変換 [-fpermissive] prog.cpp:59:65 : エラー: 機能する引数が多すぎます

私が理解できることから、decltypeと関数ポインターはこちら

template<typename Return, typename Param, typename... ParamsOther>
Delegate<Return (Param, ParamsOther...)>& Delegate<Return (Param, ParamsOther...)>::bind(Return (*function_)(Param, ParamsOther...)){
    _m_opFunction = &_wrap_function_static<decltype(function_)>;
    _m_opInstance = nullptr;
    return *this;
}

問題を引き起こしているようです。メンバー関数をデリゲートにバインドしようとすると、同じことが起こります。これはなぜですか？私は何を間違っていますか？関数ポインターの型を取得し、その型をテンプレート引数として使用するのはごく自然なことのように思えますが、何らかの理由で、ここでは機能しません。この decltype と関数ポインターのシナリオの何が問題になっていますか?

4

1 に答える 1

3

これは、clang++ 3.2 からのエラー メッセージの最初の部分です。

temp.cpp:41:19: error: assigning to 'int (*)(int)' from incompatible type
      '<overloaded function type>'
    _m_opFunction = &_wrap_function_static<decltype(function_)>;
                  ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
temp.cpp:75:16: note: in instantiation of member function 'Delegate<int
      (int)>::bind' requested here
    delegate__.bind(&f);
               ^
temp.cpp:35:26: note: candidate function has different number of parameters
      (expected 1 but has 2)
    static inline Return _wrap_function_static(void*, Param param_,...
                         ^


temp.cpp:55:41: error: too many arguments to function call, expected 1, have 2
    return _m_opFunction(_m_opInstance, param_, params_other_...);
           ~~~~~~~~~~~~~                ^~~~~~
temp.cpp:76:38: note: in instantiation of member function 'Delegate<int
      (int)>::operator()' requested here
    printf("Result: %i\n", delegate__(8));

これは、次の宣言が原因で発生します_m_opFunction。

Return (*_m_opFunction)(Param, ParamsOther...) = nullptr;

template<Return (*Function)(Param, ParamsOther...)>
static inline Return _wrap_function_static(void*, Param param_, ParamsOther... params_other_);

つまり、は引数を関数呼び出しに転送することを期待しているのに対し、 は関数呼び出し_wrap_function_staticの引数のみを期待しています。void*_m_opFunction

標準ライブラリ ソリューション:

#include <iostream>
#include <functional>

int f(int i_){
    return i_ * 2;
}

struct foo
{
    int m;
    int f(int i) { return i * m; }
};

int main()
{
    std::function<int (int)> delegate__;

    delegate__ = f;
    std::cout << "Result: " << delegate__(8) << std::endl;

    foo o;
    o.m = 21;
    delegate__ = std::bind(&foo::f, std::ref(o), std::placeholders::_1);
    std::cout << "Result: " << delegate__(2) << std::endl;
}

アプローチを修正しようとしています：注：メンバー関数ポインターから「通常の」関数ポインターに変換することはできません（ユニオンを使用したり、生データをコピーしたりすることができます... UB）。より良いアプローチは、ポリモーフィズム (つまり、仮想関数と呼び出し元オブジェクトの動的割り当て) を使用することです。

#include <cstdio>

template<typename>
class Delegate;

template<typename Return, typename Param, typename... ParamsOther>
class Delegate<Return (Param, ParamsOther...)>{
public:

    /// Constructors & destructors:
    Delegate(void) = default;
    Delegate(Delegate const& delegate_) = default;
    Delegate(Delegate&& delegate_) = default;

    /// Member functions:
    Delegate& bind(Return (*function_)(Param, ParamsOther...));
    template<class C>
    Delegate& bind(C& c_, Return (C::*function_)(Param, ParamsOther...));

    /// Member functions (overloaded operators, assignment):
    Delegate& operator=(Delegate const& delegate_) = default;
    Delegate& operator=(Delegate&& delegate_) = default;

    /// Member functions (overloaded operators, function call):
    inline Return operator()(Param param_, ParamsOther... params_other_) const;

private:
    /// Member data:
    Return (*_m_opFunction)(Param, ParamsOther...) = nullptr;
    Return (Delegate::*_m_opMemFunction)(Param, ParamsOther...) = nullptr;
    void* _m_opInstance = nullptr;

    /// function wrappers:
    template<class C>
    static inline Return _wrap_member_function(Delegate const&, Param param_, ParamsOther... params_other_);
};

/// Member functions:
template<typename Return, typename Param, typename... ParamsOther>
Delegate<Return (Param, ParamsOther...)>& Delegate<Return (Param, ParamsOther...)>::bind(Return (*function_)(Param, ParamsOther...)){
    _m_opFunction = function_;
    _m_opMemFunction = nullptr;
    _m_opInstance = nullptr;
    return *this;
}
template<typename Return, typename Param, typename... ParamsOther>
template<class C>
Delegate<Return (Param, ParamsOther...)>& Delegate<Return (Param, ParamsOther...)>::bind(C& c_, Return (C::*function_)(Param, ParamsOther...)){
    _m_opFunction = reinterpret_cast<decltype(_m_opFunction)>( &_wrap_member_function<C> );
    _m_opMemFunction = reinterpret_cast<decltype(_m_opMemFunction)>( function_ );
    _m_opInstance = &c_;
    return *this;
}
/// Member functions (overloaded operators, function call):
template<typename Return, typename Param, typename... ParamsOther>
Return Delegate<Return (Param, ParamsOther...)>::operator()(Param param_, ParamsOther... params_other_) const{
    if(nullptr == _m_opMemFunction)
    {
        return _m_opFunction(param_, params_other_...);
    }else
    {
        auto f = reinterpret_cast<Return (*)(Delegate const&, Param, ParamsOther...)>( _m_opFunction );
        return f(*this, param_, params_other_...);
    }
}
/// function wrappers:
template<typename Return, typename Param, typename... ParamsOther>
template<class C>
Return Delegate<Return (Param, ParamsOther...)>::_wrap_member_function(Delegate<Return (Param, ParamsOther...)> const& instance_, Param param_, ParamsOther... params_other_){
    Return (C::*memFuncPtr)(Param, ParamsOther...) = reinterpret_cast<decltype(memFuncPtr)>( instance_._m_opMemFunction );
    return (reinterpret_cast<C*>(instance_._m_opInstance)->*memFuncPtr)(param_, params_other_...);
}

int f(int i_){
    return i_ * 2;
}

struct foo
{
    int m;
    int f(int i) { return i * m; }
};

int main(void){
    Delegate<int (int)> delegate__;
    delegate__.bind(&f);
    printf("Result: %i\n", delegate__(8));

    foo o;
    o.m = 21;
    delegate__.bind(o, &foo::f);
    printf("Resilt: %i\n", delegate__(2));
    return 0;
}

私が「間違いなくデザインに欠陥がある」と言った理由:

  • 標準ライブラリにはすでに「デリゲート」タイプが含まれています ( std::function)
    • StdLib バインド ( std::bind(&A::func, instance)vs delegate__.bind(instance, &A::func))のメンバー関数では、引数の順序が異なります。
    • StdLib バインドはインスタンスをコピーします。明示的にstd::ref(またはポインター) を使用して参照を渡す必要があります <- 関数が呼び出されるまでインスタンスを維持する必要があることは明らかであるため、エラーが発生しにくい
  • 関数呼び出しはパラメーターをコピーします (より良い: 完全な転送)
  • Paramパラメータをとで分割するのはなぜParamOthersですか?
  • ファンクタと互換性がない
于 2013-05-08T13:01:46.027 に答える