1

我将类的成员函数的签名和实际指针作为模板类的模板参数传递。有没有办法为运算符重载对此类进行不同的专门化？我试图查看type_traits并从中获得提示std::is_copy_assignable，但似乎 g++ 使用了内置函数（__has_trivial_copy例如）。

4

1 回答 1

0

好吧，我研究了这个问题。

我认为有可能得到结果，但这相当复杂，因为类 A 想知道它自己的模板参数之一是否是类 B 的运算符，它必须首先检查 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 回答