Question

我将类的成员函数的签名和实际指针作为模板类的模板参数传递。有没有办法让这类运算符重载具有不同的专业性？我试着查看type_traits并提供std::is_copy_assignable的提示，但似乎g ++使用内置插件（例如__has_trivial_copy）。

Answer 1

好吧，我处理过这个问题。

我认为有可能获得结果，但它相当复杂，因为A类想要知道它自己的模板参数之一是否是B类的运算符，它必须首先检查B ::运算符是否存在，然后检查它是否等于模板参数。这很快增加了任务的难度。

此外，我在测试时发现，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堆栈上。

如果成员函数是运算符，我可以在编译时检查吗？

1 个答案: