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

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

采用一对迭代器的所有标准库算法(和其他函数)都在半开放范围内运行[first, last).但是,这根本不是问题 - 所有标准库容器的设计都是为了使end()(和变体)返回的迭代器是一个过去的迭代器:它指向一个超过容器中最后一个真实元素的容器.所以这个电话:

std::vector<int> v = whatever();
std::random_shuffle(v.begin(), v.end());

实际上洗牌所有的intS IN的矢量.

鉴于此,您可以看到您正在使用该功能.对于last参数,您传递&regularDraws[regularDraws.size() - 1](和类似) - 向量中最后一个实际元素的地址.由于间隔是半开的,正如我上面所概述的那样,最后一个元素不是shuffle的一部分.

您根本不应该使用指向vector的指针⁽¹⁾,而是使用迭代器:

random_shuffle(std::next(regularDraws.begin()), regularDraws.end());

那std::next是因为你最初传递[1](向量中的第二个元素)作为first参数,所以我保留了(请记住,数组索引在C++中是基于0的).如果这不是您的意图,只需将整个矢量洗牌:

random_shuffle(regularDraws.begin(), regularDraws.end());

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

• 它允许简单表达空范围: begin == end
• 如果我们将迭代器称为"在元素指向之前",则可以使用迭代器指定所有插入点.begin然后意味着"在第一个元素之前插入",并end转换为"在一个过去的最后一个元素之前插入",即"在最后一个元素之后插入".

• 它允许轻松连接/拆分:

  auto b = rng.begin();
  auto e = rng.end();
  auto m = std::next(b, std::distance(b, e) / 2);
  processHalf(b, m);
  processHalf(m, e);
  

⁽¹⁾您的代码只能工作,因为std::vector它的元素连续存储在内存中.使用迭代器,它将适用于任何容器.