1

我正在编写一个元编程库，其中包括一组编译时算术类型和函数。例如：

元函数.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;

固定点.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>> {};

几天前我注意到我可以利用decltype关键字和实现表达式模板来简化复杂表达式的语法：

表达式.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&);

其用法示例：

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)

但这有一个缺点：重载是为任何类型定义的，所以像这样的表达式"a string" + "other string"适合expressions.hpp operator+重载。当然，重载决议会导致编译错误，因为编译器正试图std::string将mpl::add_t.

我的问题是：有没有办法根据函数/运算符参数的特定模板（在示例中）std::enable_if的专门化的存在来禁用/启用重载（使用或类似的东西） ？mpl::add_t.

因此，如果表达式的结果类型具有参数类型的特化，则运算符将被启用，而在其他情况下则被禁用。

4

1 回答 1

1

像这样的东西可能会起作用：

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&)
{
    // ...
}

依赖于这样一个事实，即当且仅当存在专业化时， typedefadd_t<LHS,RHS>::result存在（并且不存在void）。

于 2013-09-08T21:16:41.193 回答