c++：模板类 vs 两个类：效率

Question

我尝试了两件事：

class RandDouble{
    public:
        RandDouble(double const& min_inclusive, double const& max_exclusive):
              mt_(std::random_device()),
              dist_(min_inclusive,max_exclusive)
         {}
        ~RandDouble(){}
        double get(){ return dist_(mt_); }

    private:
        std::mt19937_64 mt_;
        std::uniform_real_distribution<double> dist_;
};

class RandUnsignedInt{
    public:
        RandUnsignedInt(unsigned int const& min_inclusive, unsigned int const& max_inclusive):
              mt_(std::random_device()),
              dist_(min_inclusive,max_exclusive)
         {}
       ~RandUnsignedInt(){}
        unsigned int get(){ return dist_(mt_); }

    private:
        std::mt19937_64 mt_;
        std::uniform_int_distribution<unsigned int> dist_;
};

和

template<typename Type>
class Rand{
    public:
        Rand(Type const& min_inclusive, Type const& max_exclusive);/
        ~Rand();
        Type get();

    private:
        std::mt19937_64 mt_;
        std::uniform_real_distribution<double>* dist_double_;
        std::uniform_int_distribution<unsigned int>* dist_u_int_;
};
template<typename Type>
Rand<Type>::~Rand(){
    if(dist_double_){ delete dist_double_; }
    if(dist_u_int_){ delete dist_u_int_; }
}

使用.cpp 文件：

template<>
Rand<double>::Rand(double const& min_inclusive, double const& max_exclusive):
    mt_(std::random_device()()),
    dist_double_(new std::uniform_real_distribution<double>(min_inclusive,max_exclusive)),
    dist_u_int_(NULL)
{}

template<>
Rand<unsigned int>::Rand(unsigned int const& min_inclusive, unsigned int const& max_exclusive):
    mt_(std::random_device()()),
    dist_double_(NULL),
    dist_u_int_(new std::uniform_int_distribution<unsigned int>(min_inclusive,max_exclusive))
{}

template<>
double Rand<double>::get(){ return (*dist_double_)(mt_); }

template<>
unsigned int Rand<unsigned int>::get(){ return (*dist_u_int_)(mt_); }

从实际的角度来看，模板解决方案与其他模板类更灵活，因为我可以执行以下操作：

template<typename Type>
classs C{
    /*some code*/
    private:
        Rand<Type> r;
};

所以我喜欢模板解决方案。但是当我检查调用Rand<double/unsigned int>::get() 方法所需的时间时，我意识到它所花费的时间是从RandDouble::get() 或RandUnisignedint::get() 调用的时间的两倍多。

有一种方法可以通过调用方法来保持模板方法的灵活性，该调用方法与使用两个不同类的调用方法一样有效。

Answer 1

问题可能是通过使用指向分布类的指针获得的间接性。尝试直接使用没有指针的类，或者最好做类似的事情

typename std::conditional<std::is_integral<Type>::value
                        , std::uniform_int_distribution<Type>
                        , std::uniform_real_distribution<Type> >::type _dist;

为了选择您需要的分发类型。 （这只是给你一个提示，类型检查肯定可以改进）。

---

解释： 上面的代码工作如下：std::conditional<(1),(2),(3)> 只是类型的静态 if 语句。如果第一个字段(1) 中的检查结果为真，则它采用第二个字段(2) 中的类型，否则它选择第三个字段(3) 中的类型。

如果模板参数Type 是整数类型，std::is_integral<Type>::value 将评估为true。因此，您的分发类型将是通常需要的std::uniform_int_distribution<Type>。

如果Type 不是整数类型（而是浮点类型，但此处未检查），则std::uniform_real_distribution<Type> 用于分发类型。

示例 (tested here)：

#include<random>
#include<iostream>

template<typename Type>
struct UniformDistribution
{
    std::mt19937_64 mt_;
    typename std::conditional<std::is_integral<Type>::value
                            , std::uniform_int_distribution<Type>
                            , std::uniform_real_distribution<Type> >::type dist_;    
    Type get()
    {
        return dist_(mt_);
    }
};

int main()
{
     //produces uniformly distributed integer number in [0, numeric_limist<int>::max()]
     std::cout<<UniformDistribution<int>().get()<<std::endl;

     //produces uniformly distributed double number in [0,1]
     std::cout<<UniformDistribution<double>().get()<<std::endl;
}

Answer 2

#include<random>

template< class T >
struct TDist{};

template<> struct TDist<double> { std::uniform_real_distribution<double> dist_; };
template<> struct TDist<unsigned int> { std::uniform_int_distribution<unsigned int> dist_; };


template<typename Type>
class Rand : private TDist<Type> {
public:
    Rand(Type min_inclusive, Type max_exclusive) :
        mt_(std::random_device()),
        dist_(min_inclusive,max_exclusive)
    {}

    Type get(){ return dist_(mt_); }

private:
    std::mt19937_64 mt_;
};