Làm thế nào để xáo trộn một vector std ::?

Tôi đang tìm kiếm một cách chung, có thể sử dụng lại để xáo trộn một std::vectortrong C ++. Đây là cách tôi hiện đang làm, nhưng tôi nghĩ nó không hiệu quả lắm vì nó cần một mảng trung gian và nó cần biết loại mục (DeckCard trong ví dụ này):

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

Từ C ++ 11 trở đi, bạn nên:

#include <algorithm>
#include <random>

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

Live example on Coliru

Đảm bảo sử dụng lại cùng một phiên bản của rngnhiều lần gọi std::shufflenếu bạn định tạo các hoán vị khác nhau mọi lúc!

Hơn nữa, nếu bạn muốn chương trình của mình tạo ra các chuỗi xáo trộn khác nhau mỗi khi nó được chạy, bạn có thể khởi tạo hàm tạo của công cụ ngẫu nhiên với đầu ra là std::random_device:

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

Đối với C ++ 98, bạn có thể sử dụng:

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

Ngoài những gì @Cicada đã nói, bạn có thể nên gieo hạt trước,

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

Theo bình luận của @ FredLarson:

nguồn ngẫu nhiên cho phiên bản này của random_shuffle () được xác định thực thi, vì vậy nó có thể không sử dụng rand (). Sau đó, srand () sẽ không có hiệu lực.

Vì vậy, YMMV.

Nếu bạn đang sử dụng boost, bạn có thể sử dụng lớp này ( debug_modeđược đặt thành false, nếu bạn muốn việc ngẫu nhiên hóa có thể dự đoán được giữa quá trình thực thi, bạn phải đặt nó thành 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_));
    }
};

Hơn bạn có thể kiểm tra nó với mã này:

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

Nó thậm chí có thể đơn giản hơn, có thể tránh hoàn toàn việc gieo hạt:

#include <algorithm>
#include <random>

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

Điều này sẽ tạo ra một lần trộn mới mỗi khi chương trình được chạy. Tôi cũng thích cách tiếp cận này do sự đơn giản của mã.

Điều này hoạt động bởi vì tất cả những gì chúng ta cần std::shufflelà một UniformRandomBitGenerator, có các yêu cầu std::random_deviceđáp ứng.

Lưu ý: nếu xáo trộn nhiều lần, có thể tốt hơn nên lưu trữ random_devicetrong một biến cục bộ:

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

Tùy thuộc vào tiêu chuẩn bạn phải tuân theo (C ++ 11 / C ++ 14 / C ++ 17) trang "cppreference" này cung cấp các ví dụ khá hay: https://en.cppreference.com/w/cpp/algorithm/ random_shuffle .