Remplissage d'un tableau avec des nombres aléatoires

Actuellement, je suis en train de remplir un tableau de taille num avec des valeurs aléatoires. Pour ce faire, j'ai besoin de créer deux fonctions:

1: Écrire une fonction (*createdata) qui alloue un tableau dynamique de num double des valeurs, de l'initialisation des valeurs à 0,0.

2: Écrire un différents fonction (gendata) qui permettra de remplir un tableau de valeurs doubles avec des valeurs aléatoires générées à l'aide de la fonction rand ().

Voici ma tentative d'écriture de la façon dont les fonctions opèrent (en dehors de la fonction main() ):

double *createdata(int num)
  {
         int i = 0;

         double *ptr;

         ptr = (double *)malloc(sizeof(double)*num);     

         if(ptr != NULL)
         {
           for(i = 0; i < num; i++)
           {
                 ptr[i] = 0.0;       
           }
         } 
  }  

double gendata(int num)
  {

         createdata(num); 

         int j = 0;

         for(j = 0; j < num; j++)
           {
                 ptr[j] = rand();       
           }               
  }

Cependant, je sais qu'il y a certainement quelque chose de mal avec l'au-delà.

Ce que je voudrais, c'est qu'une fois que j'ai appelé deux fonctions principales, je vais avoir généré un tableau de taille num qui est rempli avec des nombres aléatoires.

Un petit indice: il n'y a pas de return dans l'un de vos fonctions.
Si j'ajoute de retour(ptr) à la fin de mon *createdata fonction que faire l'affaire?
Votre gendata() fonction ne correspond pas à la spécification de remplir un tableau de double avec des valeurs aléatoires; il correspond à la spécification de générer et de remplir un tableau de double avec des valeurs aléatoires. Vous pouvez réviser le cahier des charges ou le code; dans l'ensemble, la révision du code sera plus utile à la fonction. Ensuite, vous n'avez pas besoin renvoyer rien de void gendata(double *array, int num).

InformationsquelleAutor | 2012-12-08

arrays c function pointers

2

Vous devez passer le pointeur alloué à la gendata fonction, parce que dans sa forme actuelle, ptr est inconnue. Est-ce que même le compiler?

Exemple:
```
double *createdata(int num)
{
    int i = 0;
    double *ptr;

    ptr = (double *)malloc(sizeof(double)*num);

    if(ptr != NULL)
    {
        for(i = 0; i < num; i++)
        {
            ptr[i] = 0.0;
        }
    }
    return ptr;
}
```
Et:
```
double gendata(int num)
{
    double *ptr = createdata(num);
    int j = 0;

    if(ptr != NULL)
    {
        for(j = 0; j < num; j++)
        {
            ptr[j] = rand();
        }
    }
}
```
A noter également que je suis vérification pour le retour NULL nouveau de malloc.

D'autres astuces autres pourraient dire ici:
- Ne jette pas le retour de malloc.
- N'oubliez pas de free le pointeur après vous l'utiliser entièrement.
- Vous n'êtes pas retourner quelque chose dans votre fonction gendata, mais vous avez déclaré comme double. Utilisation void au lieu de cela, si vous n'allez pas retourner quoi que ce soit.
Mais vous êtes probablement va avoir besoin de retourner le pointeur de toute façon, de sorte que vous pouvez l'utiliser plus tard dans d'autres fonctions, telles que main.

EDIT: Donc, ce serait comme ça, comme un exemple:
```
double *gendata(int num)
{
    double *ptr = createdata(num);
    int j = 0;

    if(ptr != NULL)
    {
        for(j = 0; j < num; j++)
        {
            ptr[j] = rand();
        }
    }
    return ptr;
}
```
Et dans votre main:
```
int main(void)
{
    double *data;
    data = gendata(100);
    printf("%g\n", data[5]);

    //When you're done, call free
    free(data);
    return 0;
}
```
- Merci pour votre réponse. Ok, maintenant, je suis à l'intérieur de ma main(), et de tester mes fonctions, je veux imprimer une certaine valeur de la matrice que j'ai généré. Dans main(), j'ai appeler la fonction ( gendata(numvals); ) alors j'essaie d'imprimer la deuxième valeur de l'array ("printf( "%lf", ptr[1] ); ) mais ce n'est pas de travail. De quoi ai-je besoin de changer?
- Voir mon edit.
- Si vous savez que vous ne lancez pas le retour de malloc, pourquoi le faites-vous?
- Parce que c'est pas pertinente pour la question. C'est juste un soupçon, et je ne le supporte pas très bien.
InformationsquelleAutor Flavio Toribio
0

Vous avez besoin de retourner un tableau alloué dans le createdata fonction de (), sinon, vous ne pouvez pas l'utiliser dans gendata(), ou n'importe où ailleurs.

Je ne suis pas sûr pourquoi gendata() est déclarée comme retournant un double, soit.
- Salut Jason, comment pourrais-je modifier mon code pour que se produit? (Je suis le seul à se familiariser avec les pointeurs pour le moment!).
- Flávio Toribio de réponse montre ce que je veux dire, je suggère la lecture de ce livre.
InformationsquelleAutor JasonD
0

Dans createdata(), vous avez oublié de fait retourner le pointeur de la nouvellement allouée tableau à la fin:
```
return ptr;
```
Aussi, votre gendata() la fonction a besoin de travailler sur un tableau, de ne pas générer ses propres. Vous devez ajouter, comme un argument. Aussi, il n'a pas besoin de retourner quoi que ce soit. Donc:
```
void gendata(double ptr[], int num)
{
    int j = 0;
    if (ptr != NULL) {
        for(j = 0; j < num; j++) {
            ptr[j] = rand();
        }
    }
}
```
Cependant, vous pouvez simplifier le ci-dessus et de réduire le niveau d'imbrication:
```
void gendata(double ptr[], int num)
{
    int j = 0;
    if (ptr == NULL)
        return;

    for(j = 0; j < num; j++) {
        ptr[j] = rand();
    }
}
```
Noter que double ptr[] signifie en fait le même que double* ptr, mais le [] syntaxe rend plus évident que la fonction veut, c'est un pointeur vers un tableau de doubles plutôt qu'un pointeur à un seul double.

Maintenant afin de créer un tableau et ensuite aléatoire, vous feriez:
```
double* array = createdata(N); //Create an array of N doubles.
gendata(array, N); //Randomize it.
```
InformationsquelleAutor Nikos C.

Bien, je ne suis pas assez familier avec la façon malloc œuvres, bien qu'il ressemble à ça fonctionnera très bien, donc je ne peux pas l'évaluer, mais le seul problème que je peux voir ici ce sont:

Vous n'êtes pas de retour ptr dans votre createdata fonction. Ainsi, lorsque vous essayez d'accéder à ptr dans votre gendata fonction, il n'y a pas de ptr tableau dans la portée. Qui vous donnera une erreur. Aussi, gendata fonction n'est pas à même de retourner quoi que ce soit.

Regardez ce code, cela devrait fonctionner:

double *createdata(int num)
{
     int i = 0;

     double *ptr;

     ptr = (double *)malloc(sizeof(double)*num);     

     if(ptr != NULL)
     {
       for(i = 0; i < num; i++)
       {
             ptr[i] = 0.0;       
       }
     } 
     return ptr; //return the pointer
  }  

double *gendata(int num) //you forgot the '*' here
{

     double *ptr = createdata(num); 

     int j = 0;

     for(j = 0; j < num; j++)
       {
             ptr[j] = rand();       
       }     
     return ptr; //i added this so you obviously return the pointer 
  }

Je crois que cela fonctionne, voici un exemple d'utilisation:

int main()
{
    int c;
    double *data = gendata(8);
    for(c = 0; c < 8; c++)
    {
        printf("%f\n", data[c]);
    }
}

Juste une chose: la question est étiqueté comme C.
Désolé où ai-je fait de mal?
Vous utilisez les fonctions C++, comme cout, et aussi le mélange des déclarations avec le code...
Je pense que je l'ai corrigé.
Pas tout à fait... Vous êtes de passage un double comme une chaîne de format. Je vais essayer de le réparer.

InformationsquelleAutor Aaron

Vous devez vous connecter pour publier un commentaire.