Risolto Errore nella generazione casuale di numeri di tipo double

[enk17]

Salve sto scrivendo un codice in cui devo riempire un array di numeri double,il problema sta che il rand mi genera sempre 0 oppure il numero -842150451.

#include <iostream>
#include <ctime>
#include <cstdlib>

using namespace std;
double* generatore(int n[],int totale);
void stampa(int n[],int totale);

int main()
{
    int* numeri;
    int totale;
    cout << "quanti numeri vuoi generare? ";
    cin >> totale;
    numeri = new int[totale];
    generatore(numeri,totale);
    stampa(numeri,totale);
    return 0;

}

double* generatore(int n[],int totale)
{
    srand(time(NULL));
    double* array=new double[totale];

    for (int j = 0; j < totale;j++)
    {
        double f = (double)rand() / 100.0;
        array[j] = f;
    }
    return array;
}

void stampa(int n[],int totale)
{
    for (int j = 0; j < totale;j++)
    {
        cout << n[j] << endl;
    }
}

 

[--- Ra ---]

Salve sto scrivendo un codice in cui devo riempire un array di numeri double,il problema sta che il rand mi genera sempre 0 oppure il numero -842150451.

#include <iostream>
#include <ctime>
#include <cstdlib>

using namespace std;
double* generatore(int n[],int totale);
void stampa(int n[],int totale);

int main()
{
    int* numeri;
    int totale;
    cout << "quanti numeri vuoi generare? ";
    cin >> totale;
    numeri = new int[totale];
    generatore(numeri,totale);
    stampa(numeri,totale);
    return 0;

}

double* generatore(int n[],int totale)
{
    srand(time(NULL));
    double* array=new double[totale];

    for (int j = 0; j < totale;j++)
    {
        double f = (double)rand() / 100.0;
        array[j] = f;
    }
    return array;
}

void stampa(int n[],int totale)
{
    for (int j = 0; j < totale;j++)
    {
        cout << n[j] << endl;
    }
}

Qualche consiglio...innanzitutto bisogna inizializzare nel main il seme per avviare la generazione dei numeri casuali:

double seme = time(NULL);
srand(seme);
//Poi utilizzi la funzione rand() ogni volta che vuoi generare un numero casuale.

Inoltre, gli array, in C++ hanno una dimensione fissa che va dichiarata a tempo di compilazione (una costante) perciò ti conviene usare un vettore perché tu vuoi stabilire una dimensione della struttura dati a partire da una variabile acquisita da standard input. In questo modo avrai più flessibilità.

L'idea per riempire il vettore (devi usare la libreria "<vector>" è qualcosa di questo tipo:

vector <double> vettore;
int numeri;

cout << "Quanti numeri vuoi generare? \n";
cin >> numeri;

for (int i = 0; i < numeri; i++){
    vettore.push_back(rand());
}

 

[enk17]

perciò ti conviene usare un vettore

li volevo usare ma purtroppo sono vincolato nel rispettare la consegna,sono riuscito a risolvere in questo modo.

#include <iostream>
#include <ctime>
#include <cstdlib>

using namespace std;
double* generatore(int n);
void stampa(double* n,int totale);

int main()
{
    double* numeri;
    int totale;
    cout << "quanti numeri vuoi generare? ";
    cin >> totale;
    numeri = new double[totale];
    numeri=generatore(totale);
    stampa(numeri,totale);
    return 0;

}

double* generatore(int n)
{
    srand(time(NULL));
    double* array=new double[n];
    double r;
    for (int j = 0; j < n;j++)
    {
        r=((double)rand() * (100.0 - 0) / (double)RAND_MAX - 0);
        array[j] = r;
    }
    return array;
}

void stampa(double* n,int totale)
{
    for (int j = 0; j < totale;j++)
    {
        cout << n[j] << endl;
    }
}

 

[--- Ra ---]

li volevo usare ma purtroppo sono vincolato nel rispettare la consegna,sono riuscito a risolvere in questo modo.

#include <iostream>
#include <ctime>
#include <cstdlib>

using namespace std;
double* generatore(int n);
void stampa(double* n,int totale);

int main()
{
    double* numeri;
    int totale;
    cout << "quanti numeri vuoi generare? ";
    cin >> totale;
    numeri = new double[totale];
    numeri=generatore(totale);
    stampa(numeri,totale);
    return 0;

}

double* generatore(int n)
{
    srand(time(NULL));
    double* array=new double[n];
    double r;
    for (int j = 0; j < n;j++)
    {
        r=((double)rand() * (100.0 - 0) / (double)RAND_MAX - 0);
        array[j] = r;
    }
    return array;
}

void stampa(double* n,int totale)
{
    for (int j = 0; j < totale;j++)
    {
        cout << n[j] << endl;
    }
}

L'ho provato solo a compilare e sembra tutto OK.

 

[Super Squirrel]

sono riuscito a risolvere in questo modo.

Mi sono permesso di ripulire un po' il codice e di aggiustare alcune cose che non andavano bene:

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

double* generatore(int dim)
{
    double *v = new double[dim];
    for(int i = 0; i < dim ; ++i)
    {
        v[i] = rand() / (double)RAND_MAX * 100;
    }
    return v;
}

void stampa(double *v, int dim)
{
    for(int i = 0; i < dim; ++i)
    {
        cout << v[i] << endl;
    }
}

int main()
{
    srand(time(0));
    int dim;
    cout << "quanti numeri vuoi generare? ";
    cin >> dim;
    double *v = generatore(dim);
    stampa(v, dim);
    delete[] v;
}

 

[--- Ra ---]

Mi sono permesso di ripulire un po' il codice e di aggiustare alcune cose che non andavano bene:

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

double* generatore(int dim)
{
    double *v = new double[dim];
    for(int i = 0; i < dim ; ++i)
    {
        v[i] = rand() / (double)RAND_MAX * 100;
    }
    return v;
}

void stampa(double *v, int dim)
{
    for(int i = 0; i < dim; ++i)
    {
        cout << v[i] << endl;
    }
}

int main()
{
    srand(time(0));
    int dim;
    cout << "quanti numeri vuoi generare? ";
    cin >> dim;
    double *v = generatore(dim);
    stampa(v, dim);
    delete[] v;
}

Posso chiederti perché nei cicli chiusi utilizzi il pre-incremento piuttosto che il post-incremento della variabile iterativa?

 

[Super Squirrel]

Posso chiederti perché nei cicli chiusi utilizzi il pre-incremento piuttosto che il post-incremento della variabile iterativa?

Fondamentalmente per una questione di abitudine.
Abitudine che però nasce dal fatto che il pre-incremento è in linea di massima più efficiente del post-incremento (anche se probabilmente i moderni compilatori provvederanno a certe ottimizzazioni in modo automatico), oltre ad una questione di esplicitare in modo chiaro i propri intenti (nel senso che il post-incremento sta ad indicare la necessità di utilizzare il valore della variabile prima della modifica).

 

[--- Ra ---]

Fondamentalmente per una questione di abitudine.
Abitudine che però nasce dal fatto che il pre-incremento è in linea di massima più efficiente del post-incremento (anche se probabilmente i moderni compilatori provvederanno a certe ottimizzazioni in modo automatico), oltre ad una questione di esplicitare in modo chiaro i propri intenti (nel senso che il post-incremento sta ad indicare la necessità di utilizzare il valore della variabile prima della modifica).

Utilizzando il pre-incremento, però, si salta il primo elemento dell'array, cioè quello in posizione [0] o sbaglio?

 

[Super Squirrel]

Utilizzando il pre-incremento, però, si salta il primo elemento dell'array, cioè quello in posizione [0] o sbaglio?

No, non cambia nulla da quel punto di vista.

In pratica puoi vedere gli operatori di incremento pre-fisso e post-fisso come delle chiamate a funzioni.
Mi spiego meglio: sia i una variabile intera, l'istruzione

++i

equivale alla chiamata a funzione

incremento_prefisso(i);

CON
int incremento_prefisso(int &i)
{
    i += 1;
    return i;
}

mentre l'istruzione

i++

equivale alla chiamata a funzione

incremento_postfisso(i);

CON
int incremento_postfisso(int &i)
{
    int temp = i;
    i += 1;
    return temp;
}

Spero di essere stato chiaro.