c++ - 我可以在编译时检查成员函数是否是运算符吗？

Question

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

Answer 1

嗯，我研究过这个问题。

我认为可以得到结果，但它相当复杂，因为 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 堆栈。