Remplissage d'un tableau avec des nombres aléatoires

Question

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

1: Ecrire une fonction (* createdata) qui alloue un tableau dynamique de num double valeurs, en initialisant les valeurs à 0.0.

2: Ecrivez une fonction différente qui remplira un tableau de valeurs doubles avec des valeurs aléatoires générées à l'aide de la fonction rand().

Voici ma tentative d'écrire la façon dont les fonctions fonctionnent (hors 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 ya quelque chose certainement mal avec ce qui précède.

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

Answer 1

Vous devez transmettre le pointeur attribué à la fonction gendata, car dans sa forme actuelle, ptr est inconnu. Est-ce que cela compile même?

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(); 
     } 
    } 
} 

Notez également Je vérifie pour le retour NULLà nouveau de malloc.

Autres conseils d'autres pourraient dire ici:

• Don't cast the return of malloc. N'oubliez pas de free le pointeur après l'avoir entièrement utilisé. Vous ne renvoyez rien dans votre fonction gendata, mais vous l'avez déclaré comme double. Utilisez void à la place si vous ne retournez rien.

Mais vous aurez probablement besoin de renvoyer 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 cela, à titre d'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; 
} 

Answer 2

Vous devez retourner le tableau alloué dans la fonction createdata(), sinon vous ne pouvez pas l'utiliser dans gendata(), ou ailleurs.

Je ne sais pas pourquoi gendata() est déclaré comme renvoyant un double non plus.

Answer 3

Eh bien, je ne suis pas assez familier avec la façon dont malloc fonctionne, bien qu'il semble que cela fonctionne bien, donc je ne peux pas évaluer cela, mais les seuls problèmes que je peux voir ici sont les suivants:

ne retourne pas ptr dans votre createdata fonction. Ainsi, lorsque vous essayez d'accéder à ptr dans votre fonction gendata, il n'y a pas de tableau ptr dans la portée. Cela vous donnera une erreur. En outre, la fonction gendata ne renvoie même rien.

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]); 
    } 
} 

Answer 4

En createdata(), vous avez oublié de revenir en fait le pointeur vers le tableau nouvellement alloué à la fin:

return ptr; 

De plus, votre fonction gendata() doit fonctionner sur un tableau déjà existant, ne génère pas le sien. Vous devriez l'ajouter comme argument. En outre, il n'a pas besoin de retourner quoi que ce soit. Alors:

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 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(); 
    } 
} 

Notez que double ptr[] signifie en fait la même chose que double* ptr, mais la syntaxe [] rend plus évident que ce que le function veut est un pointeur vers un tableau de doubles plutôt qu'un pointeur vers un seul double.

Alors maintenant, afin de créer un tableau, puis il randomiser, vous feriez:

double* array = createdata(N); // Create an array of N doubles. 
gendata(array, N); // Randomize it.