Perché le distribuzioni casuali di C++ 11 sono modificabili?

Question

Ho pensato che il valore generato dalla distribuzione casuale di C++ 11 (uniform_int_distribution, ad esempio), dipende solo dallo stato del generatore che viene passato allo operator(). Tuttavia, per qualche ragione non esiste uno specificatore const nella firma di operator(). Che cosa significa e come devo passare la distribuzione come parametro di funzione? Ho pensato di doverlo passare come parametro non reciproco: per riferimento const, ma ora non ne sono sicuro.

Answer 1

Ho frainteso la domanda in un primo momento, tuttavia, ora che ho capito, è una buona domanda. Alcuni scavare nella fonte dell'attuazione <random> per g ++ dà la seguente (con alcuni bit tralasciato per chiarezza):

template<typename _IntType = int> 
    class uniform_int_distribution 
    { 

    struct param_type 
    { 
    typedef uniform_int_distribution<_IntType> distribution_type; 

    explicit 
    param_type(_IntType __a = 0, 
     _IntType __b = std::numeric_limits<_IntType>::max()) 
    : _M_a(__a), _M_b(__b) 
    { 
     _GLIBCXX_DEBUG_ASSERT(_M_a <= _M_b); 
    } 

    private: 
    _IntType _M_a; 
    _IntType _M_b; 
}; 

public: 
    /** 
    * @brief Constructs a uniform distribution object. 
    */ 
    explicit 
    uniform_int_distribution(_IntType __a = 0, 
      _IntType __b = std::numeric_limits<_IntType>::max()) 
    : _M_param(__a, __b) 
    { } 

    explicit 
    uniform_int_distribution(const param_type& __p) 
    : _M_param(__p) 
    { } 

    template<typename _UniformRandomNumberGenerator> 
result_type 
operator()(_UniformRandomNumberGenerator& __urng) 
    { return this->operator()(__urng, this->param()); } 

    template<typename _UniformRandomNumberGenerator> 
result_type 
operator()(_UniformRandomNumberGenerator& __urng, 
     const param_type& __p); 

    param_type _M_param; 
}; 

Se strabismo passato tutta la _, possiamo vedere che ha solo un singolo parametro membro, param_type _M_param, che a sua volta è semplicemente una struttura nidificata che contiene 2 valori interi, in effetti un intervallo. operator() è dichiarato solo qui, non definito. Qualche altro scavo ci porta alla definizione. Invece di postare tutto il codice qui, che è piuttosto brutto (e piuttosto lungo), è sufficiente dire che nulla è mutato all'interno di questa funzione. Infatti, aggiungendo const alla definizione e alla dichiarazione si compileranno felicemente.

La domanda diventa, è vero per ogni altra distribuzione? La risposta è no. Se guardiamo alla realizzazione per std::normal_distribution, troviamo:

template<typename _RealType> 
template<typename _UniformRandomNumberGenerator> 
    typename normal_distribution<_RealType>::result_type 
    normal_distribution<_RealType>:: 
    operator()(_UniformRandomNumberGenerator& __urng, 
    const param_type& __param) 
    { 
result_type __ret; 
__detail::_Adaptor<_UniformRandomNumberGenerator, result_type> 
    __aurng(__urng); 

    //Mutation! 
if (_M_saved_available) 
    { 
    _M_saved_available = false; 
    __ret = _M_saved; 
    } 
    //Mutation! 

tutto questo è solo teorizzare, ma immagino la ragione per cui non è limitato a const è quello di consentire gli esecutori di mutare la loro attuazione, se necessario. Inoltre, mantiene un'interfaccia più uniforme - se alcuni operator() sono const e alcuni non sono const, tutto diventa un po 'disordinato.

Tuttavia, perché non li hanno semplicemente resi costanti e consentono agli implementatori di utilizzare mutable Non ne sono sicuro. Probabilmente, a meno che qualcuno non sia coinvolto in questa parte dello sforzo di standardizzazione, potresti non ottenere una buona risposta a questo.

Modifica: come sottolineato da MattieuM, mutable e più thread non funzionano bene insieme.

Altrettanto poco interessante, std::normal_distribution genera due valori contemporaneamente, memorizzandone uno uno (da cui lo _M_saved). Il operator<< che definisce permette effettivamente di vedere questo valore prima della prossima chiamata a operator():

#include <random> 
#include <iostream> 
#include <chrono> 

std::default_random_engine eng(std::chrono::system_clock::now().time_since_epoch().count()); 
std::normal_distribution<> d(0, 1); 

int main() 
{ 
    auto k = d(eng); 
    std::cout << k << "\n"; 
    std::cout << d << "\n"; 
    std::cout << d(eng) << "\n"; 
} 

Qui, il formato di output è mu sigma nextval.