1

テンプレート クラスのテンプレート パラメーターとして、クラスのメンバー関数の署名と実際のポインターの両方を渡しています。演算子のオーバーロード用にそのようなクラスを異なる特殊化する方法はありますか? を調べてtype_traitsからヒントを得ようとしましたstd::is_copy_assignableが、g++ はビルトインを使用しているようです (__has_trivial_copyたとえば)。

4

1 に答える 1

0

さて、私はこの質問に取り組みました。

結果を取得することは可能だと思いますが、自分のテンプレート引数の 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 スタックに何かをプッシュすることはできないからです。

于 2012-04-18T17:01:36.680 に答える