std :: bindを関数ポインターに変換します
私は、最初のパラメーターとして関数ポインターをとるメソッドを持つサードパーティのライブラリを持っています：
int third_party_method(void (*func)(double*, double*, int, int, double*), ...);
次のように宣言されているクラスのメソッドにポインタを渡します。
class TestClass
{
public:
void myFunction (double*, double*, int, int, void*);
この関数を次のように渡そうとしました：
TestClass* tc = new TestClass();
using namespace std::placeholders;
third_party_method(std::bind(&TestClass::myFunction, tc, _1, _2, _3, _4, _5), ...);
ただし、これはコンパイルしません：
Conversion of parameter 1 from 'std::tr1::_Bind<_Result_type,_Ret,_BindN>' to 'void (__cdecl *)(double *,double *,int,int,void *)' is not possible
with
[
_Result_type=void,
_Ret=void,
_BindN=std::tr1::_Bind6<std::tr1::_Callable_pmf<void (__thiscall TestClass::* const )(double *,double *,int,int,void *),TestClass,false>,TestClass *,std::tr1::_Ph<1>,std::tr1::_Ph<2>,std::tr1::_Ph<3>,std::tr1::_Ph<4>,std::tr1::_Ph<5>>
]
メンバーを関数に渡す方法はありますか？
メンバーを関数に渡す方法はありますか？
クラスオブジェクトが何らかのグローバルオブジェクトでない限り、不可能です。オブジェクトにはデータが含まれている可能性があるため、関数ポインターは関数へのポインターにすぎません。ランタイムコンテキストは含まれず、コンパイル時コンテキストのみが含まれます。
コールバックの受け渡しごとにコンパイル時に一意のIDを持つことを受け入れる場合、次の一般化されたアプローチを使用できます。
使用法：
void test(void (*fptr)())
{
fptr();
}
struct SomeStruct
{
int data;
void some_method()
{
cout << data << endl;
}
void another_method()
{
cout << -data << endl;
}
};
int main()
{
SomeStruct local[] = { {11}, {22}, {33} };
test(get_wrapper<0>( boost::bind(&SomeStruct::some_method,local[0]) ));
test(get_wrapper<1>( boost::bind(&SomeStruct::another_method,local[0]) ));
test(get_wrapper<2>( boost::bind(&SomeStruct::some_method,local[1]) ));
test(get_wrapper<3>( boost::bind(&SomeStruct::another_method,local[1]) ));
test(get_wrapper<4>( boost::bind(&SomeStruct::some_method,local[2]) ));
test(get_wrapper<5>( boost::bind(&SomeStruct::another_method,local[2]) ));
}
Functorはすでに異なるタイプを持っているか、使用のランタイムスコープが重複しないため、たとえば、呼び出しごとに一意のIDを必要としない場合があります。ただし、毎回一意のIDを使用する方が安全です。
実装：
#include <boost/optional.hpp>
#include <boost/bind.hpp>
#include <iostream>
#include <ostream>
using namespace std;
template<unsigned ID,typename Functor>
boost::optional<Functor> &get_local()
{
static boost::optional<Functor> local;
return local;
}
template<unsigned ID,typename Functor>
typename Functor::result_type wrapper()
{
return get_local<ID,Functor>().get()();
}
template<typename ReturnType>
struct Func
{
typedef ReturnType (*type)();
};
template<unsigned ID,typename Functor>
typename Func<typename Functor::result_type>::type get_wrapper(Functor f)
{
(get_local<ID,Functor>()) = f;
return wrapper<ID,Functor>;
}
// ----------------------------------------------------------------------
void test(void (*fptr)())
{
fptr();
}
struct SomeStruct
{
int data;
void some_method()
{
cout << data << endl;
}
void another_method()
{
cout << -data << endl;
}
};
int main()
{
SomeStruct local[] = { {11}, {22}, {33} };
test(get_wrapper<0>( boost::bind(&SomeStruct::some_method,local[0]) ));
test(get_wrapper<1>( boost::bind(&SomeStruct::another_method,local[0]) ));
test(get_wrapper<2>( boost::bind(&SomeStruct::some_method,local[1]) ));
test(get_wrapper<3>( boost::bind(&SomeStruct::another_method,local[1]) ));
test(get_wrapper<4>( boost::bind(&SomeStruct::some_method,local[2]) ));
test(get_wrapper<5>( boost::bind(&SomeStruct::another_method,local[2]) ));
}
追伸マルチスレッドアクセスに注意-このような場合、何らかの種類の スレッドローカルストレージ データを使用する必要があります。
他の人が述べたように、グローバルまたは静的データを使用してバインド呼び出しコンテキストを生の関数として提供する以外に選択肢はありません。しかし、提供された解決策が一般的ではなく、ファンクターの空のパラメーターリストが残っています。バインドするさまざまな関数シグネチャごとにwrapper、get_wrapper、およびFuncを手動で記述し、異なる名前を付ける必要があります。
生バインドのより一般的なソリューションを提案したいと思います。
#include <iostream>
#include <memory>
#include <functional>
#include <cassert>
// Raw Bind - simulating auto storage behavior for static storage data
template <typename BindFunctor, typename FuncWrapper> class scoped_raw_bind
{
public:
typedef scoped_raw_bind<BindFunctor, FuncWrapper> this_type;
// Make it Move-Constructible only
scoped_raw_bind(const this_type&) = delete;
this_type& operator=(const this_type&) = delete;
this_type& operator=(this_type&& rhs) = delete;
scoped_raw_bind(this_type&& rhs): m_owning(rhs.m_owning)
{
rhs.m_owning = false;
}
scoped_raw_bind(BindFunctor b): m_owning(false)
{
// Precondition - check that we don't override static data for another raw bind instance
if(get_bind_ptr() != nullptr)
{
assert(false);
return;
}
// Smart pointer is required because bind expression is copy-constructible but not copy-assignable
get_bind_ptr().reset(new BindFunctor(b));
m_owning = true;
}
~scoped_raw_bind()
{
if(m_owning)
{
assert(get_bind_ptr() != nullptr);
get_bind_ptr().reset();
}
}
decltype(&FuncWrapper::call) get_raw_ptr()
{
return &FuncWrapper::call;
}
static BindFunctor& get_bind()
{
return *get_bind_ptr();
}
private:
bool m_owning;
static std::unique_ptr<BindFunctor>& get_bind_ptr()
{
static std::unique_ptr<BindFunctor> s_funcPtr;
return s_funcPtr;
}
};
// Handy macro for creating raw bind object
// W is target function wrapper, B is source bind expression
#define RAW_BIND(W,B) std::move(scoped_raw_bind<decltype(B), W<decltype(B), __COUNTER__>>(B));
// Usage
///////////////////////////////////////////////////////////////////////////
// Target raw function signature
typedef void (*TargetFuncPtr)(double, int, const char*);
// Function that need to be called via bind
void f(double d, int i, const char* s1, const char* s2)
{
std::cout << "f(" << d << ", " << i << ", " << s1 << ", " << s2 << ")" << std::endl;
}
// Wrapper for bound function
// id is required to generate unique type with static data for
// each raw bind instantiation.
// THE ONLY THING THAT YOU NEED TO WRITE MANUALLY!
template <typename BindFunc, int id = 0> struct fWrapper
{
static void call(double d, int i, const char* s)
{
scoped_raw_bind<BindFunc, fWrapper<BindFunc, id>>::get_bind()(d, i, s);
}
};
int main()
{
using namespace std::placeholders;
auto rf1 = RAW_BIND(fWrapper, std::bind(&f, _1, _2, _3, "This is f trail - 1"));
TargetFuncPtr f1 = rf1.get_raw_ptr();
f1(1.2345, 42, "f1: Bind! Bind!");
auto rf2 = RAW_BIND(fWrapper, std::bind(&f, _1, _2, _3, "This is f trail - 2"));
TargetFuncPtr f2 = rf2.get_raw_ptr();
f2(10.2345, 420, "f2: Bind! Bind!");
auto rf3 = RAW_BIND(fWrapper, std::bind(&f, _1, _2, _3, "This is f trail - 3"));
TargetFuncPtr f3 = rf3.get_raw_ptr();
f3(100.2345, 4200, "f3: Bind! Bind!");
}
テストされました-参照してください ここで実写
サードパーティ関数が関数へのポインターを予期しているためコンパイルされませんが、ポインターへのポインターを渡そうとしていますmember-関数。 2つのタイプは 基本的に異なる であり、交換できません。実際、メンバー関数へのポインターは非常に頻繁に 奇妙な動物 です。
[〜＃〜] sscce [〜＃〜] は、あなたが抱えている問題を示しています：
#include <iostream>
#include <iomanip>
using namespace std;
typedef void(*SpeakFn)(void);
void Bark()
{
cout << "WOOF" << endl;
}
void Meow()
{
cout << "meeow" << endl;
}
void SpeakUsing(SpeakFn fn)
{
fn();
}
class Alligator
{
public:
void Speak()
{
cout << "YAWWW" << endl;
}
typedef void(Alligator::*AlligatorSpeakFn)(void);
void SpeakUsing(AlligatorSpeakFn fn)
{
(this->*fn)();
}
};
int main()
{
SpeakUsing(&Bark); // OK
Alligator a;
Alligator::AlligatorSpeakFn mem_fn = &Alligator::Speak;
a.SpeakUsing(mem_fn); // OK
SpeakUsing(mem_fn); // NOT OK -- can't cvt from fn-ptr to mem-fn-ptr
}
関数へのポインターに変換できないため、メンバー関数へのポインターでSpeakUsingを呼び出すことはできません。
代わりに、次のような静的メンバー関数を使用します。
class Alligator
{
public:
static void Speak()
{
cout << "YAWWW" << endl;
}
typedef void(*AlligatorSpeakFn)(void);
void SpeakUsing(AlligatorSpeakFn fn)
{
fn();
}
};
いいえ、簡単ではありません。問題は、関数ポインターに情報のチャンクが1つあることです-関数のアドレスです。メソッドには、オブジェクトのアドレスとアドレスの両方が必要です。あるいは、オブジェクトのアドレスをパラメーターとして渡すこともできます。
これを行うには非常にハッキーな方法がありますが、それらはプラットフォーム固有のものになります。そして非常にハッキー。そのため、グローバル変数を使用する代わりに推奨します。
クラスの単一のグローバルインスタンスがある場合、これを行う方法を知っていますか？