生成T类型的随机数

Question

我正在编写一个程序，其中包含list<T>，其中T是int或double。我想要使​​用标题为<random>的组件生成一个函数，该函数生成T类型的数字。我无法找到以T作为模板参数的发行版。

的功能，然后会在通话中使用的generate功能：

generate(myList.begin(), myList.end(), RandomGenerator()) 

我如何去这样做呢？

我试图创建一个名为RandomGenerator的类，并为它重载operator()。 当我尝试通过一个参数超载operator()我得到一个错误。

函数调用，Random(b)是int参数b一个函数对象：

generate(rList.begin(), rList.end(), Random(b)); 

代码超载()，其中n是有点“伪” -variable只是告诉它是什么类型：

int operator()(int n) 
{ 
    std::uniform_int_distribution<int> dist(1000, 2000); 
    return dist(gen); 
} 

错误消息：

Error 2 error C2440: '<function-style-cast>' : cannot convert from 'int' to 'Random'  

Error 3 error C2780: 'void std::generate(_FwdIt,_FwdIt,_Fn0)' : expects 3 arguments - 2 provided  

Answer 1

除了乔伊的回答，以下应该与std::generate搭配很好。免责声明：我在元编程方面很糟糕，请指出任何错误或可能的改进。这是一个C++ 11解决方案，使用C++ 14它会稍微短一些。

Live demo on Coliru。

#include <algorithm> 
#include <iostream> 
#include <list> 
#include <random> 
#include <type_traits> 

template<typename T, 
     typename = typename std::enable_if<std::is_arithmetic<T>::value>::type> 
class random_generator { 
    using distribution_type = typename std::conditional< 
      std::is_integral<T>::value, 
      std::uniform_int_distribution<T>, 
      std::uniform_real_distribution<T> 
     >::type; 

    std::default_random_engine engine; 
    distribution_type distribution; 

public: 
    auto operator()() -> decltype(distribution(engine)) { 
     return distribution(engine); 
    } 
}; 

template<typename Container, typename T = typename Container::value_type> 
auto make_generator(Container const&) -> decltype(random_generator<T>()) { 
    return random_generator<T>(); 
} 

int main() { 
    auto l = std::list<double>(10); 

    std::generate(std::begin(l), std::end(l), make_generator(l));  

    for (auto i : l) { 
     std::cout << i << " ";  
    } 
} 

Answer 2

不是一个完美的解决方案，但你想要做什么：（修改代码，以便它可以被用来生成）

template <typename Distribution> 
class RandomGenerator 
{ 
    using Type = typename Distribution::result_type; 

    const Type getRandom(const Type& lower, const Type& upper) const 
    { 
     static std::default_random_engine generator; 
     static Distribution distribution(lower, upper); 

     return distribution(generator); 
    } 

public: 
    RandomGenerator(const Type& lowerBound, const Type& upperBound) : _lowerBound(lowerBound), _upperBound(upperBound) { } 

    const Type operator()() const 
    { 
     return getRandom(_lowerBound, _upperBound); 
    } 

private: 
    Type _lowerBound; 
    Type _upperBound; 
}; 

int main() 
{ 
    RandomGenerator<std::uniform_int_distribution<>> randomIntGenerator(1, 10); 
    RandomGenerator<std::uniform_real_distribution<>> randomDoubleGenerator(0.0, 10.0); 

    std::deque<int> intRandoms(10); 
    std::generate(intRandoms.begin(), intRandoms.end(), randomIntGenerator); 

    std::deque<double> doubleRandoms(5); 
    std::generate(doubleRandoms.begin(), doubleRandoms.end(), randomDoubleGenerator); 

    return 0; 
} 

当然，如果我们想要不同的号码，每次运行，我们可以设置种子default_random_engine像时间（0），但我会离开那一个。