テンプレート クラスのテンプレート パラメーターとして、クラスのメンバー関数の署名と実際のポインターの両方を渡しています。演算子のオーバーロード用にそのようなクラスを異なる特殊化する方法はありますか? を調べてtype_traits
からヒントを得ようとしましたstd::is_copy_assignable
が、g++ はビルトインを使用しているようです (__has_trivial_copy
たとえば)。
1 に答える
さて、私はこの質問に取り組みました。
結果を取得することは可能だと思いますが、自分のテンプレート引数の 1 つがクラス B の演算子であるかどうかを知りたいクラス A は、まず B::operator が存在することを確認してから、テンプレート引数と同じです。これにより、タスクの難易度が急速に高まります。
さらに、テスト中に、g++ は高度なテンプレートの使用に対するサポートがまだ非常に貧弱であることがわかりました。たとえば、次のコードはステップ 2 を実行します。これは、特定のメンバー関数が存在すると想定され、テンプレート引数が同じメンバー関数と等しいかどうかを確認します。
#include <iostream>
using namespace std;
struct Hello{
int helloworld(){
return 0;
}
int goodbyeworld(){
return 0;
}
};
template<typename T1, T1, typename T2, T2> struct is_same_method{
static constexpr bool value=false;
};
template<typename Return, typename Class, typename... Args, Return(Class::*member)(Args...)>
struct is_same_method<Return(Class::*)(Args...), member, Return(Class::*)(Args...), member>{
static constexpr bool value=true;
};
#define method_test(a, b) is_same_method<decltype(a), a, decltype(b), b>::value
template<typename T, T> struct what_am_I_passed;
template<typename Return, typename Class, typename... Args, Return(Class::*member)(Args...)>
struct what_am_I_passed<Return(Class::*)(Args...), member>{
static void so_what(){
/*
* error: ‘decltype (& Class:: helloworld)’ is not a valid type for a template constant parameter.
*/
cout<<"you passed me "<<(method_test(member, &Class::helloworld)?"helloworld":"something else")<<endl;
}
};
int main(){
what_am_I_passed<decltype(&Hello::helloworld), &Hello::helloworld>::so_what();
}
現在、このコードは g++ 4.4、4.5 で失敗し、4.6.1 でクラッシュし、4.6.2 以降で動作します。
これらすべての問題の後、実行時にいくつかのロジックを移植することにしました。これが私が最終的に得たものです。
#include <iostream>
#include <type_traits>
using namespace std;
template<typename mem_type, mem_type mem> struct operator_type{
enum types{
//complete me...
NONE=0, ADD, SUB, MUL, DIV, MOD, POW, UNM, EQ, NEQ, LT, LE, GT, GE, SUBSCRIPT, CALL
};
static types what(){ return NONE; }
};
typedef operator_type<int, 0>::types op_types;
template<typename Return, typename Class, typename... Args, Return(Class::*mem)(Args...)>
class operator_type<Return(Class::*)(Args...), mem>{
#define isOp(name, symbol, args)\
template<typename Class_,int=0> static bool is##name(float&&){ return false; }\
template<typename Class_, Return(Class_::*innermem)(Args...)=&Class_::operator symbol>\
static bool is##name(int&&){ return innermem==mem && (args<0 || sizeof...(Args)==args); }
#define testOp(name) if(is##name<Class>(0)) return op_types::name
//complete me...
isOp(ADD, +, 1)
isOp(SUB, -, 1)
isOp(MUL, *, 1)
isOp(DIV, /, 1)
isOp(MOD, %, 1)
isOp(POW, ^, 1)
isOp(UNM, -, 0)
isOp(EQ, ==, 1)
isOp(NEQ, !=, 1)
isOp(LT, <, 1)
isOp(LE, <=, 1)
isOp(GT, >, 1)
isOp(GE, >=, 1)
isOp(SUBSCRIPT, [], 1)
isOp(CALL, (), -1)
public:
static op_types what(){
//complete me...
testOp(ADD);
testOp(SUB);
testOp(MUL);
testOp(DIV);
testOp(MOD);
testOp(POW);
testOp(UNM);
testOp(EQ);
testOp(NEQ);
testOp(LT);
testOp(LE);
testOp(GT);
testOp(GE);
testOp(SUBSCRIPT);
testOp(CALL);
return op_types::NONE;
}
};
template<typename T, T> struct wants_to_know_operators;
template<typename Return, typename Class, typename... Args, Return(Class::*mem)(Args...)>
struct wants_to_know_operators<Return(Class::*)(Args...), mem>{
typedef operator_type<decltype(mem), mem> my_operator_type;
static void stuff(){
switch(my_operator_type::what()){
case op_types::NONE: cout<<"this is not an operator"<<endl; break;
case op_types::CALL: cout<<"this is operator()"<<endl; break;
case op_types::SUBSCRIPT: cout<<"this is operator[]"<<endl; break;
case op_types::SUB: cout<<"this is operator-"<<endl; break;
case op_types::UNM: cout<<"this is operator- (unary)"<<endl; break;
//complete me...
default: cout<<"something else..."<<endl; break;
}
}
};
struct Test{
void operator()(){
}
Test& operator-(){
return *this;
}
Test& operator-(int){
return *this;
}
int operator[](int){
return 0;
}
int operator[](iostream){
return 0;
}
int operator==(int){
return 0;
}
void f(){}
};
int main(){
wants_to_know_operators<decltype(&Test::f), &Test::f>::stuff();
wants_to_know_operators<int(Test::*)(int), &Test::operator[]>::stuff();
wants_to_know_operators<int(Test::*)(iostream), &Test::operator[]>::stuff();
wants_to_know_operators<decltype(&Test::operator()), &Test::operator()>::stuff();
wants_to_know_operators<decltype(&Test::operator==), &Test::operator==>::stuff();
wants_to_know_operators<Test&(Test::*)(), &Test::operator- >::stuff();
wants_to_know_operators<Test&(Test::*)(int), &Test::operator- >::stuff();
}
構文はやや面倒ですが、テンプレートで解決できる最善の方法です。同じ演算子の異なるオーバーロードを区別できることに注意してください。私の目標では、これで十分であり、おそらく望ましいことです。なぜなら、すべては C++ 関数を Lua にエクスポートすることであり、もちろん、コンパイル時に Lua スタックに何かをプッシュすることはできないからです。