Remplissez un vecteur avec des nombres aléatoires c ++

J'ai un vecteur que je suis en train de remplir avec des nombres aléatoires. - Je continuer à courir dans un problème, cependant, que les vecteur pour la plupart des sorties 0 à chaque fois que je suis à court (il ne devrait pas sortie 0 jamais). Ce que j'ai fait une erreur dans mon code ci-dessous pour faire une sortie 0 (sorties de 0, plus que n'importe quel autre numéro):

vector<int> myVector;
srand((unsigned)time(NULL));
int a = rand() % 20 + 1; //1 to 20    
for (int i =0; i < a; i++){
        int b = rand() % 20 + 1;
        myVector.push_back(b);
        cout << myVector[b] << endl;
    }

Je suis un débutant et n'ai pas fait beaucoup de programmation C++ dans un temps long, donc je ne suis pas sûr de ce qui est fait de mon code de dysfonctionnement. Si quelqu'un peut expliquer ce que j'ai fait de mal, il serait grandement apprécié.

source d'informationauteur Valrok | 2014-02-02

c++random srand vector

6

Vous appelez le mauvais index dans votre vecteur

Essayer de faire:
```
cout << myVector[i] << endl;
```
sinon vous risquez de manquer la fin de votre vertex pour les 20 premières itérations.

Vous pouvez également appeler .back() sur votre vecteur pour obtenir le dernier élément du vecteur.

Vous pouvez utiliser std::générer de l'algorithme de remplir un vecteur de n éléments avec des nombres aléatoires.

En C++ moderne, il est recommandé de ne pas utiliser tout le temps à base de graines et de std::rand, mais au lieu d'utiliser random_device pour générer une graine. Pour un logiciel basé sur le moteur, vous devez toujours spécifier le moteur et la distribution. Lire Plus..

#include <random>
#include <algorithm>
#include <iterator>
#include <iostream>
#include <functional>

using namespace std;

int main()
{
    //First create an instance of an engine.
    random_device rnd_device;
    //Specify the engine and distribution.
    mt19937 mersenne_engine {rnd_device()};  //Generates random integers
    uniform_int_distribution<int> dist {1, 52};

    auto gen = [&dist, &mersenne_engine](){
                   return dist(mersenne_engine);
               };

    vector<int> vec(10);
    generate(begin(vec), end(vec), gen);

    //Optional
    for (auto i : vec) {
        cout << i << " ";
    }


}

Si vous voulez réorganiser les éléments d'une plage dans un ordre aléatoire:

  std::shuffle(begin(vec), end(vec), mersenne_engine);

Juste ajouter mes 2 cents... Cette réponse est similaire à celui donné par Marko Tunjicmais il n'utilise pas std::rand à partir de C, mais le C++11 caractéristiques de la place.
Il vous permet d'utiliser la distribution de votre choix, uniform_int_distribution dans l'exemple ci-dessous.

#include <algorithm>
#include <iostream>
#include <limits>
#include <random>
#include <vector>

static std::vector<int> generate_data(size_t size)
{
    using value_type = int;
    //We use static in order to instantiate the random engine
    //and the distribution once only.
    //It may provoke some thread-safety issues.
    static std::uniform_int_distribution<value_type> distribution(
        std::numeric_limits<value_type>::min(),
        std::numeric_limits<value_type>::max());
    static std::default_random_engine generator;

    std::vector<value_type> data(size);
    std::generate(data.begin(), data.end(), []() { return distribution(generator); });
    return data;
}

int main()
{
    for (auto i = 0u; i < 5; ++i)
    {
        std::vector<int> myVector = generate_data(10);
        myVector = generate_data(10);

        std::cout << "myVector (iteration " << i << "): ";
        for (auto v: myVector)
        {
            std::cout << v << ",";
        }
        std::cout << "\n";
    }
}

2

Vous appelez le mauvais index dans votre vecteur
```
cout << myVector[i] << endl;
```
2

Il n'est pas clair ce que vous essayez de faire avec la boucle, le code est la création d'un vecteur aléatoire de taille, rempli avec des nombres aléatoires.

Sortie "myVector[b]", mais " b " est la valeur aléatoire, pas l'indice de venez d'ajouter le numéro. Vous pourriez tout simplement :
```
cout << b << endl;
```
Mais vraiment, vous devriez la taille du vecteur, et simplement l'accès par index.
```
int vec_size = rand() % 20 + 1;
vec<int> myvec(vec_size);
for( int i = 0; i < vec_size; ++i ) {
    vec[i] = rand() % 20 + 1;
}

/* output the list after you made it */
std::copy(myvec.begin(), myvec.end(),
        std::ostream_iterator<int>(cout, "\n"));
```

//here I generate a vector that contains random vectors
//for example, after this code, vec = { {1,4,8}, {1,3,6,7,9}, {2,5,6} }

#include <vector>
#include <time.h>

void generate_random_vectors(const int num_of_rand_vectors, vector<vector<int>> &vec) {
    for (int j = 0; j < num_of_rand_vectors; ++j) {
        //the vector size will be randomal: between 0 to 19
        int vec_size = (rand() % 20);
        vector<int> rand_vec(vec_size);
        for (int k = 0; k < vec_size; ++k) {
            //each vec element will be randomal: between 1 to 20
            rand_vec[k] = 1 + (rand() % 20);
        }
        //each vector will be sorted if you want to
        sort(rand_vec.begin(), rand_vec.end());
        //push each of the 'num_of_rand_vectors'-th vectors into vec
        vec.push_back(rand_vec);
    }
}

void main() {

    srand(static_cast<unsigned int>(time(NULL)));

    //input vector containing random sorted vectors
    vector<vector<int>> vec;
    generate_random_vectors(3, vec);
}

Qu'en est simple:

std::vector<int> v(1000);
std::generate(v.begin(), v.end(), std::rand);

-1
```
cout << myVector[b] ?!
```
il devrait être : cout << myVector[i];

Vous devez vous connecter pour publier un commentaire.