模板类中的动态模板方法选择

Question

我想创建一个模板随机数生成器类，它可以是整数类型，也可以是浮点类型。为什么？对于赋值，我编写了一个累积函数（本质上与std:：acculate相同），我想制作一个可以是任意整数或浮点类型的测试工具（例如，无符号| short | long | long long int、float、double）。我们一直在研究模板，我试图通过使用模板编程来做出动态编译时决策。我可能用了错误的方法来处理这个问题-非常感谢任何建议/参考。

下面是我的测试函数：

void testdrive() {
    std::vector<int> vint(ELEMENTS);
    std::vector<double> vflt(ELEMENTS);
    RNG<int> intrng;
    RNG<double> fltrng;

    std::generate(vint.begin(), vint.end(), intrng)
    std::generate(vflt.begin(), vflt.end(), fltrng)

    std::cout << "Sum of " << printvec(vint) << "is " accum(vint) << "\n\n";
    std::cout << "Sum of " << printvec(vflt) << "is " accum(vflt) << '\n';
}

我不知道如何为我的类使用模板编程。我想做的是，如果类型是int类型，使用统一的int分布，如果是float | double使用统一的实分布。我意识到这两者并不是完全可以互换的，但就我所尝试的来说，这很好。这是我的班级：

template<typename T>
class RNG {
    public:
        RNG(T low=std::numeric_limits<T>::min(),
            T high=std::numeric_limits<T>::max())
            : rng_engine{rng_seed()}, rng_dist{low, high}, rng_low{low},
              rng_high{high} { }
        RNG(const RNG& r): rng_engine{rng_seed()}, rng_dist{r.rng_low,
            r.rng_high}, rng_low{r.rng_low}, rng_high{r.rng_high} { }
        T operator()() { return rng_dist(rng_engine); }
    private:
        std::random_device rng_seed;
        std::mt19937 rng_engine;
        template<typename U, typename=std::enable_if_t<std::is_integral<T>::value>>
            std::uniform_int_distribution<T> rng_dist;
        template<typename U, typename=std::enable_if_t<std::is_floating_point<T>::value>>
            std::uniform_real_distribution<T> rng_dist;
        T rng_low, rng_high;
};

此外，对于任何阅读这篇文章的人，我发现这本书对深入研究C模板非常有帮助： C模板-完整指南第2版（http://www.tmplbook.com/）

Answer 1

以下是我的想法，但我更喜欢@fifoforlifo的答案：

template<typename T>                                                      
class RNG {                                                               
    static_assert(std::is_arithmetic<T>::value,                           
                  "Only primitive numeric types supported.");             
    public:                                                               
        RNG(T low=std::numeric_limits<T>::min(),                          
            T high=std::numeric_limits<T>::max())                         
            : rng_engine{rng_seed()}, rng_dist{low, high}, rng_low{low},  
              rng_high{high} { }                                          
        RNG(const RNG& r): rng_engine{rng_seed()}, rng_dist{r.rng_low,    
            r.rng_high}, rng_low{r.rng_low}, rng_high{r.rng_high} { }     
        T max() { return rng_dist.max(); }                                
        T min() { return rng_dist.min(); }                                
        T operator()() { return rng_dist(rng_engine); }                   
    private:                                                              
        std::random_device rng_seed;                                      
        std::mt19937 rng_engine;                                          
        std::uniform_int_distribution<T> rng_dist;                        
        T rng_low, rng_high;                                              
};                                                                        

// Specialize RNG                                                         
// Really want a generic way to support any floating point type           
// e.g., float, double, long double                                       
// And ideally this would all be in one template class...                 
template<>                                                                
class RNG<double> {                                                       
    public:                                                               
        RNG(double low=std::numeric_limits<double>::min(),                
            double high=std::numeric_limits<double>::max())               
            : rng_engine{rng_seed()}, rng_dist{low, high}, rng_low{low},  
              rng_high{high} { }                                          
        RNG(const RNG& r): rng_engine{rng_seed()}, rng_dist{r.rng_low,    
            r.rng_high}, rng_low{r.rng_low}, rng_high{r.rng_high} { }     
        double max() { return rng_dist.max(); }                           
        double min() { return rng_dist.min(); }                           
        double operator()() { return rng_dist(rng_engine); }              
    private:                                                              
        std::random_device rng_seed;                                      
        std::mt19937 rng_engine;                                          
                std::uniform_real_distribution<double> rng_dist;          
        double rng_low, rng_high;                                         
};                                                                        

Answer 2

看看模板专业化。在下面的代码中，私有的结构分布选择要使用的std::uniform_*_distribution。

#include <stdio.h>
#include <vector>
#include <algorithm>
#include <random>
#include <iostream>

template <class T>
class RNG
{
    // primary template is designed for integers
    template <class U>
    struct Distribution
    {
        typedef std::uniform_int_distribution<U> Type;
    };
    // explicit specialization for float
    template <>
    struct Distribution<float>
    {
        typedef std::uniform_real_distribution<float> Type;
    };
    // explicit specialization for double
    template <>
    struct Distribution<double>
    {
        typedef std::uniform_real_distribution<double> Type;
    };

    std::random_device rng_source;
    typename Distribution<T>::Type rng_dist;

public:
    RNG(
        T low = std::numeric_limits<T>::min(),
        T high = std::numeric_limits<T>::max())
        : rng_source{}
        , rng_dist(low, high)
    {
    }
    RNG(const RNG& rhs)
        : rng_source{}
        , rng_dist(rhs.rng_dist)
    {
    }

    T operator()()
    {
        return rng_dist(rng_source);
    }
};

int main()
{
    const size_t ELEMENTS = 10;
    std::vector<int> vint(ELEMENTS);
    std::vector<double> vflt(ELEMENTS);
    RNG<int> intrng(0, 100);
    RNG<double> fltrng(0.0, 1.0);

    std::generate(vint.begin(), vint.end(), intrng);
    std::generate(vflt.begin(), vflt.end(), fltrng);

    return 0;  <-- set a breakpoint here to see both vectors
}