Disabling operators overloads if a given template is not specialized for the operator parameters type

Question

I'm writting a metaprogramming library which includes a set of compile-time arithmetic types and functions. For example:

metafunctions.hpp

template<typename T>
struct function
{
    using result = T;
};

template<typename LHS , typename RHS>
struct add_t;

//Add metafunction
template<typename LHS , typename RHS>
using add = typename add_t<LHS,RHS>::result;

fixed_point.hpp:

#include "metafunctions.hpp"

template<long long int BITS , unsigned int PRECISSION>
struct fixed_point
{
    operator float()
    {
        return (float)BITS * std::pow(10.0f,-(float)PRECISION); //Its implemented as decimal fixed_point, not binary.
    };
};

//An alias which provides a convenient way to create numbers: scientific notation
template<int mantissa , int exponent = 0 , fbcount PRECISSION = mpl::DEFAULT_FRACTIONAL_PRECISION> // MANTISSA x 10^EXPONENT
using decimal = mpl::fixed_point<decimal_shift<mantissa , PRECISSION + exponent>::value , PRECISSION>; 

//add specialization:
template<long long int BITS1 , long long int BITS2 , unsigned int PRECISSION>
struct add_t<mpl::fixed_point<BITS1,PRECISION> , mpl::fixed_point<BITS2,PRECISION>> : public mpl::function<fixed_point<BITS1+BITS2 , PRECISION>> {};

A few days ago I have noticed that I could take advantage of decltype keyword and implement expression templates to simplify the syntax of complex expressions:

expressions.hpp

template<typename LHS , typename RHS>
mpl::add<LHS,RHS> operator+(const LHS& , const RHS&);

template<typename LHS , typename RHS>
mpl::sub<LHS,RHS> operator-(const LHS& , const RHS&);

template<typename LHS , typename RHS>
mpl::mul<LHS,RHS> operator*(const LHS& , const RHS&);

template<typename LHS , typename RHS>
mpl::div<LHS,RHS> operator/(const LHS& , const RHS&);

An example of its usage:

using pi = mpl::decimal<3141592,-6>; //3141592x10⁻-6 (3,141592)
using r  = mpl::decimal<2,-2>; //0,002
using a  = mpl::decimal<1>; // 1,0 

using x = decltype( pi() * r() + ( r() / a() ) ); //pi*r + (r/a)

But this has a downside: That overloads are defined for any type, so expressions like "a string" + "other string" fits in the expressions.hpp operator+ overload. Of course that overload resolution results in a compilation error, because the compiler is trying to fit std::string as type parameters of mpl::add_t.

My question is: Is there any way to disable/enable the overloads (with std::enable_if or something like that) based on the existence of a specialization of an specific template (mpl::add_t in the example) for the parameters of the functions/operators?.

So if the result type of the expression has an specialization for the types of the parameters, the operator will be enabled, and disabled in other case.

Daniel Frey · Accepted Answer · 2013-09-08T21:24:02.987

1

Something like this might work:

template<typename LHS , typename RHS>
typename std::enable_if<
   !std::is_same<
       void,
       typename mpl::add_t<LHS,RHS>::result
    >::value,
    mpl::add<LHS,RHS>
>::type
operator+(const LHS& , const RHS&)
{
    // ...
}

relying on the fact that if and only if there is a specialization, a typedef add_t<LHS,RHS>::result exists (and which is not void).

edited Sep 08 '13 at 21:24

answered Sep 08 '13 at 21:16

Daniel Frey

55,810
13
122
180

And what about using that with the template alias, `mpl::add = typename mpl::add_t::result`, that would work? Or the compiler rejects it when instantiates the alias? – Manu343726 Sep 08 '13 at 21:20
@Manu343726: Frankly, I don't know. Try it out, you have code ready to test it :) – Daniel Frey Sep 08 '13 at 21:22
Ok, I will try it later. Even if that case doesn't work, that looks like the correct answer. Thanks for your help. – Manu343726 Sep 08 '13 at 21:29
note that an empty default `template` can make SFINAE work better. Otherwise it is not found, instead of empty. – Yakk - Adam Nevraumont Sep 09 '13 at 00:48

Disabling operators overloads if a given template is not specialized for the operator parameters type

1 Answers1

Linked