4

这是我正在尝试做的一个示例（这是一个“测试”案例，只是为了说明问题）：

#include <iostream>
#include <type_traits>
#include <ratio>

template<int Int, typename Type> 
constexpr Type f(const Type x)
{
    return Int*x;
}

template<class Ratio, typename Type, 
         class = typename std::enable_if<Ratio::den != 0>::type>
constexpr Type f(const Type x)
{
    return (x*Ratio::num)/Ratio::den;
}

template</*An int OR a type*/ Something, typename Type>
constexpr Type g(const Type x)
{
    return f<Something, Type>(x);
}

int main()
{
    std::cout<<f<1>(42.)<<std::endl;
    std::cout<<f<std::kilo>(42.)<<std::endl;
}

如您所见，该f()函数有两个版本：第一个将 anint作为模板参数，第二个将 a 作为模板参数std::ratio。问题如下：

我想“包装”这个函数，通过g()它可以将intOR astd::ratio作为第一个模板参数并调用f().

如何在不编写两个g()函数的情况下做到这一点？换句话说，我必须写什么而不是/*An int OR a type*/？

4

3 回答 3

2

我会这样做，但我稍微改变了你的界面：

#include <iostream>
#include <type_traits>
#include <ratio>

template <typename Type>
constexpr
Type
f(int Int, Type x)
{
    return Int*x;
}

template <std::intmax_t N, std::intmax_t D, typename Type>
constexpr
Type
f(std::ratio<N, D> r, Type x)
{
    // Note use of r.num and r.den instead of N and D leads to
    //   less probability of overflow.  For example if N == 8 
    //   and D == 12, then r.num == 2 and r.den == 3 because
    //   ratio reduces the fraction to lowest terms.
    return x*r.num/r.den;
}

template <class T, class U>
constexpr
typename std::remove_reference<U>::type
g(T&& t, U&& u)
{
    return f(static_cast<T&&>(t), static_cast<U&&>(u));
}

int main()
{
    constexpr auto h = g(1, 42.);
    constexpr auto i = g(std::kilo(), 42.);
    std::cout<< h << std::endl;
    std::cout<< i << std::endl;
}

42
42000

笔记：

  1. 我已经利用constexpr不通过模板参数传递编译时常量（这就是constexpr目的）。

  2. g现在只是一个完美的货运代理。但是我无法使用std::forward，因为它没有标记constexpr（可以说是 C++11 中的一个缺陷）。所以我放弃使用static_cast<T&&>。完美转发在这里有点矫枉过正。但是完全熟悉它是一个很好的成语。

于 2012-11-04T18:01:14.553 回答
1

如何在不编写两个 g() 函数的情况下做到这一点？

你没有。在 C++ 中，除了通过重载之外，没有办法获取某种类型的类型或值。

于 2012-11-04T17:22:13.917 回答
0

模板参数不可能同时采用类型和非类型值。

解决方案1：

重载的功能。

解决方案2：

您可以将值存储在类型中。前任：

template<int n>
struct store_int
{
    static const int num = n;
    static const int den = 1;
};

template<class Ratio, typename Type, 
         class = typename std::enable_if<Ratio::den != 0>::type>
constexpr Type f(const Type x)
{
    return (x*Ratio::num)/Ratio::den;
}

template<typename Something, typename Type>
constexpr Type g(const Type x)
{
    return f<Something, Type>(x);
}

但是使用此解决方案，您将不得不指定g<store_int<42> >(...)而不是g<42>(...)

如果函数很小，我建议你使用重载。

于 2012-11-04T17:27:46.850 回答