¿Cómo mezclar un std :: vector?

Estoy buscando una forma genérica y reutilizable de barajar un std::vectoren C ++. Así es como lo hago actualmente, pero creo que no es muy eficiente porque necesita una matriz intermedia y necesita saber el tipo de elemento (DeckCard en este ejemplo):

srand(time(NULL));

cards_.clear();

while (temp.size() > 0) {
    int idx = rand() % temp.size();
    DeckCard* card = temp[idx];
    cards_.push_back(card);
    temp.erase(temp.begin() + idx);
}

Desde C ++ 11 en adelante, debería preferir:

#include <algorithm>
#include <random>

auto rng = std::default_random_engine {};
std::shuffle(std::begin(cards_), std::end(cards_), rng);

Live example on Coliru

¡Asegúrese de reutilizar la misma instancia de a lo rnglargo de múltiples llamadas a std::shufflesi tiene la intención de generar diferentes permutaciones cada vez!

Además, si desea que su programa cree diferentes secuencias de mezcla cada vez que se ejecuta, puede sembrar el constructor del motor aleatorio con la salida de std::random_device:

auto rd = std::random_device {}; 
auto rng = std::default_random_engine { rd() };
std::shuffle(std::begin(cards_), std::end(cards_), rng);

Para C ++ 98 puede usar:

#include <algorithm>

std::random_shuffle(cards_.begin(), cards_.end());

http://www.cplusplus.com/reference/algorithm/shuffle/

// shuffle algorithm example
#include <iostream>     // std::cout
#include <algorithm>    // std::shuffle
#include <vector>       // std::vector
#include <random>       // std::default_random_engine
#include <chrono>       // std::chrono::system_clock

int main () 
{
    // obtain a time-based seed:
    unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
    std::default_random_engine e(seed);

    while(true)
    {
      std::vector<int> foo{1,2,3,4,5};

      std::shuffle(foo.begin(), foo.end(), e);

      std::cout << "shuffled elements:";
      for (int& x: foo) std::cout << ' ' << x;
      std::cout << '\n';
    }

    return 0;
}

Además de lo que dijo @Cicada, probablemente deberías sembrar primero,

srand(unsigned(time(NULL)));
std::random_shuffle(cards_.begin(), cards_.end());

Según el comentario de @ FredLarson:

la fuente de aleatoriedad para esta versión de random_shuffle () está definida por la implementación, por lo que no puede usar rand () en absoluto. Entonces srand () no tendría ningún efecto.

Entonces YMMV.

Si está usando boost , puede usar esta clase ( debug_modeestá configurada en false, si desea que la aleatorización sea predecible entre la ejecución, debe configurarla en true):

#include <iostream>
#include <ctime>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/random/uniform_int_distribution.hpp>
#include <boost/random/variate_generator.hpp>
#include <algorithm> // std::random_shuffle

using namespace std;
using namespace boost;

class Randomizer {
private:
    static const bool debug_mode = false;
    random::mt19937 rng_;

    // The private constructor so that the user can not directly instantiate
    Randomizer() {
        if(debug_mode==true){
            this->rng_ = random::mt19937();
        }else{
            this->rng_ = random::mt19937(current_time_nanoseconds());
        }
    };

    int current_time_nanoseconds(){
        struct timespec tm;
        clock_gettime(CLOCK_REALTIME, &tm);
        return tm.tv_nsec;
    }

    // C++ 03
    // ========
    // Dont forget to declare these two. You want to make sure they
    // are unacceptable otherwise you may accidentally get copies of
    // your singleton appearing.
    Randomizer(Randomizer const&);     // Don't Implement
    void operator=(Randomizer const&); // Don't implement

public:
    static Randomizer& get_instance(){
        // The only instance of the class is created at the first call get_instance ()
        // and will be destroyed only when the program exits
        static Randomizer instance;
        return instance;
    }

    template<typename RandomAccessIterator>
    void random_shuffle(RandomAccessIterator first, RandomAccessIterator last){
        boost::variate_generator<boost::mt19937&, boost::uniform_int<> > random_number_shuffler(rng_, boost::uniform_int<>());
        std::random_shuffle(first, last, random_number_shuffler);
    }

    int rand(unsigned int floor, unsigned int ceil){
        random::uniform_int_distribution<> rand_ = random::uniform_int_distribution<> (floor,ceil);
        return (rand_(rng_));
    }
};

Entonces puedes probarlo con este código:

#include "Randomizer.h"
#include <iostream>
using namespace std;

int main (int argc, char* argv[]) {
    vector<int> v;
    v.push_back(1);v.push_back(2);v.push_back(3);v.push_back(4);v.push_back(5);
    v.push_back(6);v.push_back(7);v.push_back(8);v.push_back(9);v.push_back(10);

    Randomizer::get_instance().random_shuffle(v.begin(), v.end());
    for(unsigned int i=0; i<v.size(); i++){
        cout << v[i] << ", ";
    }
    return 0;
}

Puede ser incluso más simple, la siembra se puede evitar por completo:

#include <algorithm>
#include <random>

// Given some container `container`...
std::shuffle(container.begin(), container.end(), std::random_device());

Esto producirá una nueva reproducción aleatoria cada vez que se ejecute el programa. También me gusta este enfoque debido a la simplicidad del código.

Esto funciona porque todo lo que necesitamos std::shufflees un UniformRandomBitGenerator, cuyos requisitos std::random_devicecumplen.

Nota: si baraja repetidamente, puede ser mejor almacenar el random_deviceen una variable local:

std::random_device rd;
std::shuffle(container.begin(), container.end(), rd);

Dependiendo del estándar que tenga que seguir (C ++ 11 / C ++ 14 / C ++ 17), esta página "cppreference" proporciona ejemplos bastante buenos: https://en.cppreference.com/w/cpp/algorithm/ random_shuffle .