specialize operator() with enums for different compile time results

Question

I would like to know if it is possible to specialize the operator(): I would like to be able to call different variants of operator() at compile time. The code bellow provides an example of what is expected.

#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;
}

Is it possible to achieve this through specialization/ some other means?

`S` is a template parameter of the class not the operator so definitely wont work — Alan Birtles, Apr 21 '22 at 17:52
Noted. If, for example, I put the template parameter on the `operator()` will I be able to call the specialized `()`? `template` `double operator()(const double& a, const T& b) const{` `return (a & b); } ` `template<>` `double classA::operator()( const double& a, const vec& b ) const{` `std::cout << "Operation 1" << std::endl;` `return 1;}` ... This is not good for putting chunks of code in the comments. :| — mysticSnake, Apr 21 '22 at 18:08
What do you want the runtime code to look like, that specifies which overload to use? Why not *just use named member functions*? — Karl Knechtel, Apr 21 '22 at 18:12

Quxflux · Answer 1 · 2022-04-21T18:11:16.790

To make your example work, you have to move OpSelector template argument from the class template to the operator() function (which needs to be templated):

#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;
}

The downside to this solution is how the specialized operator() function has to be called (.template operator()<Op1>).

(You can play with this here: https://godbolt.org/z/rvGTWhjx1)

If you decide to use a named function instead of operator(), the calling syntax is closer to what you seem to have intended:

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);
}

Thanks! Apart from the slightly different syntax, they should do the same thing. A follow-up question, if possible. I am relatively new to C++, but this code will know what to do at compile, right? — mysticSnake, Apr 21 '22 at 18:15
@mysticSnake Yes. You can verify this by putting the (simplified) into [godbolt](https://godbolt.org/z/GM9nPPfno). The assembly output on the right side shows that different instructions are generated for the three specialized functions. — Quxflux, Apr 21 '22 at 18:22

score 0 · Answer 2 · answered Apr 21 '22 at 18:12

S is a template parameter of the class not the operator so wont do what you want. Even if you do make the operator templated the syntax to call it would be really awkward: obj.template operator()<Op1>(1.2, v);, you'd be better of making a named function instead which you can then call how you want to, e.g: bj.foo<Op1>(1.2, v);:

#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 foo(const double& a, const T& b) const;
};

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

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

// Specialized function
template<>
template<>
double classA<vec>::foo<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.foo(1.2, v); // works
    obj.foo<Op1>(1.2, v); // Does not work

   return 0;
}

Note that unfortunately you can't specialise a member function of a templated class so you'd have to add explicit specialisations for each type T for stdOp.

Hello Mr. Alan. Thanks for the reply! It is equivalent to one from @Quxflux. Thanks for the additional input on having to specify both template parameters! — mysticSnake, Apr 21 '22 at 18:29

specialize operator() with enums for different compile time results

2 Answers2