Question

我尝试过使用std::random_shuffle和std::shuffle，但是他们只是将第一个和第一个元素和第一个元素和最后一个元素混合在一起，但不是最后一个。有没有办法改组包含最后一个元素的数组（向量）？

//NumberGenerator.h
#ifndef __NUMBERGENERATOR_H__
#define __NUMBERGENERATOR_H__
#pragma once
#include "Number.h" //regular numbers
#include "MegaNumber.h" //mega numbers
#include <vector> //<vector>
#include <string> //strings 
using std::to_string; //convert int to strings
#include <algorithm> //shuffle
//#include <random> //std::default_random_engine
#define NON_MEGA_COMBINATIONS 5
#define MEGA_COMBINATIONS 1

using std::vector; //<vectors>
using std::string; //string
using std::random_shuffle; //shuffles arrays

class NumberGenerator
{
public:
    NumberGenerator(vector<Number> numbers, vector<MegaNumber> megaNumbers); //constructor
    ~NumberGenerator();
    string pickNumbers(); //function that randomizes regularDraws and megaDraws
protected: 
    vector<Number> regularDraws; //contains number information
    vector<MegaNumber> megaDraws; //contains mega number information
};

#endif


//NumberGenerator.cpp
#include "NumberGenerator.h"


//constructor
NumberGenerator::NumberGenerator(vector<Number> numbers, vector<MegaNumber> megaNumbers)
{
    regularDraws = numbers;
    megaDraws = megaNumbers;
}

//destructor
NumberGenerator::~NumberGenerator()
{
}


string NumberGenerator::pickNumbers()
{
    srand(rand());
    random_shuffle(&regularDraws[1], &regularDraws[regularDraws.size() - 1]);
    random_shuffle(&megaDraws[1], &megaDraws[megaDraws.size() - 1]);
    string regular;
    string mega;
    string last = to_string(regularDraws[regularDraws.size() - 1].getID());

    for (int i = 1; i <= NON_MEGA_COMBINATIONS; i++)
    {
        regular = regular + " " + to_string(regularDraws[i].getID());
    }

    for (int i = 1; i <= MEGA_COMBINATIONS; i++)
    {
        mega = mega + " " + to_string(megaDraws[i].getID());
    }

    return regular + " " + mega + " " + last;
}



//Number.h
#ifndef __NUMBER_H_
#define __NUMBER_H__
#pragma once


class Number
{
public:
    Number(int id); //constructor
    ~Number(); //destructor


    int getID(); //returns the number ID



protected:
    int ID; //This is the number 
};

#endif 

//Number.cpp
#include "Number.h"


//constructor
Number::Number(int id)
{
    occurence = 0;
    occurencePct = 0;
    ID = id;
}

//destructor
Number::~Number()
{
}

//returns the number ID
int Number::getID() 
{
    return ID; 
}


//MegaNumber.h
#ifndef __MEGANUMBER_H__
#define __MEGANUMBER_H__
#pragma once
#include "Number.h"

//Subclass of Number
class MegaNumber :
    public Number
{
public:
    MegaNumber(int id); //Will be inheriting Number superclass
    ~MegaNumber();
};

#endif

//MegaNumber.cpp
#include "MegaNumber.h"


//constructor
MegaNumber::MegaNumber(int id) : Number::Number(id) //inherits the super class Number
{

}

//destructor
MegaNumber::~MegaNumber()
{
}

//Source.cpp
#include <iostream>
#include "NumberGenerator.h"
int main()
{
vector<Number> arg1 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
vector<MegaNumber> arg2 = {0, 1, 2, 3, 4, 5, 6, 7 , 8, 9};
NumberGenerator game(arg1, arg2);
  for (int i = 0; i < 10; i++)
  {
      cout << game.pickNumbers() << endl;
  }
}

这是我的代码的精简版本，因为它包含10个文件，我认为这对于我正在做的事情是有意义的。无论如何，每次运行pickNumbers（）时，最后一个元素都不会被洗牌。

Answer 1

采用一对迭代器的所有标准库算法（和其他函数）都在半开放范围end()上运行。但是，这根本不是问题 - 所有标准库容器的设计都是为了使std::vector<int> v = whatever(); std::random_shuffle(v.begin(), v.end());（和变体）返回的迭代器是 past-the-end 迭代器：它指向< em>一个超过容器中最后一个真实元素。所以这个调用：

int

实际上将所有向量中的last s洗牌。

鉴于此，您可以看到您正确使用该功能。对于&regularDraws[regularDraws.size() - 1]参数，您传递random_shuffle(std::next(regularDraws.begin()), regularDraws.end());（和类似的） - 向量中最后一个实际元素的地址。由于间隔是半开放的，如上所述，最后一个元素不是随机播放的一部分。

你不应该在所有^（1）中使用指向向量的指针，而是使用迭代器：

std::next

[1]是因为你最初传递first（向量中的第二个元素）作为random_shuffle(regularDraws.begin(), regularDraws.end());参数，所以我保留了（记住数组索引是0-基于C ++）。如果这不是您的意图，只需将整个矢量洗牌：

begin == end

在任何地方使用半开放范围实际上非常有利：

它允许简单表达空范围：begin
如果我们在元素指向之前将迭代器表示为＆＃34;，则可以使用迭代器指定所有插入点。＆＃34; end表示＆＃34;在第一个元素之前插入，＆＃34;并且auto b = rng.begin(); auto e = rng.end(); auto m = std::next(b, std::distance(b, e) / 2); processHalf(b, m); processHalf(m, e);转换为＆＃34;在一个过去的最后一个元素之前插入，＆＃34;即＆＃34;在最后一个元素之后插入。＆＃34;
它允许轻松连接/拆分：
```
std::vector
```

^（1）您的代码只能起作用，因为"jean": { "color": "red", "cost": 15000, "size": 28 }将其元素连续存储在内存中。使用迭代器，它可以与任何容器一起使用。

如何改组包含最后一个元素的数组？

1 个答案: