Bagaimana cara mengacak std :: vector?

Saya mencari cara umum yang dapat digunakan kembali untuk mengacak a std::vectordi C ++. Beginilah cara saya saat ini melakukannya, tetapi menurut saya itu tidak terlalu efisien karena memerlukan array perantara dan perlu mengetahui jenis itemnya (DeckCard dalam contoh ini):

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);
}

Mulai C ++ 11 dan seterusnya, Anda harus memilih:

#include <algorithm>
#include <random>

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

Live example on Coliru

Pastikan untuk menggunakan kembali contoh yang sama di rngseluruh beberapa panggilan ke std::shufflejika Anda berniat untuk menghasilkan permutasi yang berbeda setiap saat!

Selain itu, jika Anda ingin program Anda membuat urutan pengacakan yang berbeda setiap kali dijalankan, Anda dapat memasukkan konstruktor mesin acak dengan keluaran std::random_device :

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

Untuk C ++ 98 Anda dapat menggunakan:

#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;
}

Selain apa yang dikatakan @Cicada, Anda mungkin harus melakukan seed terlebih dahulu,

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

Per @ FredLarson komentar:

sumber keacakan untuk versi random_shuffle () ini ditentukan oleh implementasi, jadi mungkin tidak menggunakan rand () sama sekali. Maka srand () tidak akan berpengaruh.

Jadi YMMV.

Jika Anda menggunakan boost, Anda bisa menggunakan kelas ini ( debug_modedisetel ke false, jika Anda ingin pengacakan bisa diprediksi di antara eksekusi Anda harus menyetelnya ke 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_));
    }
};

Kemudian Anda dapat mengujinya dengan kode ini:

#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;
}

Bahkan bisa lebih sederhana, penyemaian dapat dihindari sepenuhnya:

#include <algorithm>
#include <random>

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

Ini akan menghasilkan pengocokan baru setiap kali program dijalankan. Saya juga menyukai pendekatan ini karena kesederhanaan kodenya.

Ini berfungsi karena yang kita butuhkan std::shufflehanyalah a UniformRandomBitGenerator, yang persyaratannya std::random_devicememenuhi.

Catatan: jika mengocok berulang kali, mungkin lebih baik menyimpannya random_devicedi variabel lokal:

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

Tergantung dari standar yang harus Anda ikuti (C ++ 11 / C ++ 14 / C ++ 17), halaman "cppreference" ini menyediakan contoh yang cukup bagus: https://en.cppreference.com/w/cpp/algorithm/ random_shuffle .