c++ - 针对不同的编译时结果，使用枚举专门化 operator()

Question

我想知道是否可以专门化 operator():我希望能够在编译时调用 operator() 的不同变体。下面的代码提供了一个预期的示例。

#include <vector>
#include <iostream>
#include <string>
#include <numeric>
#include <array>

enum OpSelector {stdOp, Op1, Op2};
typedef std::array<double, 3> vec;

template<class T, OpSelector S = stdOp>
class classA
{
public:

    classA() {}

    double operator()(const double& a, const T& b) const
    {
        return (a & b);
    }
};

// Default function
template<class T>
double operator&( const double& a, const T& b )
{
    std::cout << "Operation 0" << std::endl;
    return 0;
}

// Specialized function
template<>
double classA<vec, Op1>::operator()(const double& a, const vec& b) const
{
    std::cout << "Operation 1" << std::endl;
    return 1;
}

// Specialized function
template<>
double classA<vec, Op2>::operator()(const double& a, const vec& b) const
{
    std::cout << "Operation 2" << std::endl;
    return 2;
}

int main(int argc, char** argv)
{
    classA<vec> obj;
    vec v {1,2,3};
    obj(1.2, v); // works
    obj<Op1>(1.2, v); // Does not work

   return 0;
}

是否可以通过特化/其他方式实现这一目标？

Answer 1

为了让你的例子工作，你必须移动OpSelector从类模板到 operator() 的模板参数函数(需要模板化):

#include <vector>
#include <iostream>
#include <string>
#include <numeric>
#include <array>

enum OpSelector {stdOp, Op1, Op2};
typedef std::array<double, 3> vec;

template<class T>
class classA
{
public:
    classA() {}

    template <OpSelector S = stdOp>
    double operator()(const double& a, const T& b) const;
};

// Specialized function
template<>
template<>
double classA<vec>::operator()<stdOp>(const double& a, const vec& b) const
{
    std::cout << "Operation 0" << std::endl;
    return 1;
}

template<>
template<>
double classA<vec>::operator()<Op1>(const double& a, const vec& b) const
{
    std::cout << "Operation 1" << std::endl;
    return 1;
}

// Specialized function
template<>
template<>
double classA<vec>::operator()<Op2>(const double& a, const vec& b) const
{
    std::cout << "Operation 2" << std::endl;
    return 2;
}

int main(int argc, char** argv)
{
    classA<vec> obj;
    vec v {1,2,3};
    obj(1.2, v); // works
    obj.template operator()<Op1>(1.2, v);

    // prints
    // Operation 0
    // Operation 1

   return 0;
}

此解决方案的缺点是如何专门化 operator()必须调用函数 ( .template operator()<Op1> )。

(你可以在这里玩这个:https://godbolt.org/z/rvGTWhjx1)

如果您决定使用命名函数而不是 operator() ，调用语法更接近您的预期:

template<class T>
class classA
{
public:
    classA() {}
    template <OpSelector S = stdOp>
    double func(const double& a, const T& b) const;
};

template<>
template<>
double classA<vec>::func<stdOp>(const double& a, const vec& b) const
{
    std::cout << "Operation 0" << std::endl;
    return 1;
}

/* ... further specializations ... */

void test()
{
    classA<vec> obj;
    vec v {1,2,3};
    obj.func(1.2, v);
    obj.func<Op1>(1.2, v);
}