Remplir contenue d'une structure aléatoirement

Version imprimable

05/11/2017, 16h59
delisiouz

Remplir contenue d'une structure aléatoirement
Bonjour j'ai une structure pers
Code:

1 2 3 4 5 6 struct per{ int id; /* On prendra l’indice du tableau, par exemple */ char *nom; char age; char telephone[10]; };
et je dois faire ca:
Définissez un tableau statique de struct per contenant un certain nombre d’entrées choisies aléatoirement, ainsi qu’une variable statique donnant le nombre d’entrées dans le tableau.

Mais je ne comprend pas cette partie "un tableau statique de struct per contenant un certain nombre d’entrées choisies aléatoirement" comment remplir le contenue aléatoirement.

Merci
05/11/2017, 18h10
Sve@r

Citation:

Envoyé par delisiouz

comment remplir le contenue aléatoirement.

Bonjour

Tu as plusieurs possibilités. Si t'es sur un Unix/Linux, tu peux aller lire le fichier /dev/random. Ce n'est pas un vrai fichier, c'est un point d'entrée vers le noyau mais on peut le lire via read/fread et la lecture récuoère des octets aléatoires.
Tu peux aussi utiliser la fonction random() qui te retourne un long aléatoire compris entre 0 et RAND_MAX. Mais il te faut d'abord initialiser le générateur de nombres aléatoires via la fonction srandom(). Et comme cette initialisation a besoin d'une graine différente (une même graine donnera la même séquence aléatoire), perso j'utilise comme graine le temps machine associé à mon pid de cette façon: srandom(time(NULL) ^ getpid()) (getpid() est une primitive Unix/Linux que tu peux shunter si t'es sous zindow).
05/11/2017, 18h44
delisiouz

Je ne comprend toujours pas comment je peut le remplir etant donné qu'on a aussi des char pour l'age, le nom et le telephone.
Sachant que a la fin je devrai:
le but est de manier des fichiers, et d’apprendre une méthode de sauvegarde de données, en utilisant un format de TLV (type, length, value). Un tel format permet d’encoder des données binaires, de manière modulaire et extensible.

Je ne sais pas si cette precision aide.
05/11/2017, 20h12
Sve@r

Une structure (ou même une simple variable) c'est avant tout une suite d'octets. Si j'écris par exemple int toto alors "toto" fait (à priori) 4 octets. Si ensuite j'écris memcpy((char*)&toto + 2, 0x12, 1) ça va placer l'octet de valeur "0x12" dans le 3° octet de toto. Ensuite, que l'octet soit 0x12 en dur ou bien un octet aléatoire issu de random() importe peu dans l'opération.
Et pour le "à priori", on s'en fout car tu as à ta disposition l'opérateur sizeof qui te donne la taille d'une variable en octets. Donc une boucle et ça devrait le faire...
05/11/2017, 20h52
delisiouz
Je ne sais pas si j'ai bien compris mais on va ca
Donc je fait ca
Code:

1 2 3 4 5 6 srand(time(NULL)); struct per *p; p=(struct per*)malloc(sizeof(struct per)); int n=rand()%(200-0+1)+0; p->nom=(char*)malloc(sizeof(n)); memcpy((char*)&n+2,0x12,1);
Je ne sais pas trop si c'est bien ca ce qu'il faut faire au depart je l'ai juste fait pour le char *nom pour savoir si je suis dans le bonne direction pour faire ensuite l'age et le telephone.

Merci
05/11/2017, 21h12
Sve@r

Citation:

Envoyé par delisiouz

Je ne sais pas trop si c'est bien ca ce qu'il faut faire au depart je l'ai juste fait pour le char *nom pour savoir si je suis dans le bonne direction pour faire ensuite l'age et le telephone.

Oui c'est ça. Mais pourquoi passer par les membres de p ??? Autant remplir directement p, p+1, p+2, p+3, ... Et attention, 0x12 n'était qu'un exemple de remplissage d'un octet (il me fallait bien trouver une valeur pour l'exemple donc j'ai choisi 0x12 comme j'aurais pu prendre 0xaa) mais toi, tu dois utiliser des nombres choisis aléatoirement...

Accessoirement, faire un malloc pour 1 c'est idiot. Tu écrirais directement struct pers p ça irait plus vite. Idem pour le nom qui pourrait être un tableau de n caractères en dur plutôt qu'alloué à chaque fois. D'ailleurs je ne pige pas trop le nom=malloc(sizeof(n)). Je pense que tu voulais plutôt faire nom=malloc(n * sizeof(char)) (surtout que n est une valeur aléatoire). Mais là encore, pourquoi le nom devrait avoir une taille aléatoire ??? Remplir une zone d'octets aléatoires ne signifie pas que la zone elle-même doit avoir une taille aléatoire...

Citation:

Envoyé par Sve@r

Mais pourquoi passer par les membres de p ??? Autant remplir directement p, p+1, p+2, p+3, ...

Voila ce que je pensais faire
Code:

1 2 3 4 5 6 srand(time(NULL)); struct pers *p[10]; int i; for(i=0;i<10;i++){ p[i]=init(i); }
J'ai crée le tableau de membre et faut bien allouer la mémoire donc je le fait dans init ce qui donne
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 struct per *init(int id){ srand(time(NULL)); struct per *p; p=(struct per*)malloc(sizeof(struct per)); int n=rand()%(200-0+1)+0; p->nom=(char*)malloc(n*sizeof(char)); int r=rand()%(12-1+1)+1; memcpy((char*)&n+2,r,1); int a=rand()%(100-0+1)+0; p->age=malloc(a*sizeof(char)); r=rand()%(12-1+1)+1; memcpy((char)&a+2,r,1); int t=rand()%(9-0+1);//par contre je sais si si c'est bien vu que c'est un tableau p->telephone=malloc(t*sizeof(char)); r=rand()%(12-1+1)+1; memcpy((char)&a+2,r,1); return p; }
Je ne sais pas si c'est bien comme ca qu'il faut d'apres la question. Par contre je ne suis pas convaincu pour le telephone qui est un tableau char[10].

Merci

Citation:

Envoyé par delisiouz

Voila ce que je pensais faire

Code:

1
2
3
4
5
6
 srand(time(NULL));
  struct pers *p[10];
  int i;
  for(i=0;i<10;i++){
    p[i]=init(i);
  }

Ok. Donc en fait, tu veux remplir 10 structures. Tu aurais pu faire aussi

Code:

1
2
3
4
5
6
 srand(time(NULL));
  struct pers p[10];
  int i;
  for(i=0;i<10;i++){
    init(&p[i]);
  }

Et pour la fonction init

Code:

1
2
3
void init(struct pers *p) {
    ... remplissage de toute la zone située à l'adresse "p" de façon aléatoire...
}

Citation:

Envoyé par delisiouz

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
struct per *init(int id /* A quoi sert ce "id" ??? parce qu'à priori je ne le vois pas réutilisé dans la fonction... */){
  srand(time(NULL));
 // Pas besoin de réinitialiser la graine - Le terme "initialisation" a un sens qui n'est pas très éloigné de "doit se faire une seule fois"...

  struct per *p;
  p=(struct per*)malloc(sizeof(struct per));

  int n=rand()%(200-0+1)+0;
  p->nom=(char*)malloc(n*sizeof(char));
 // Donc là, tu définis un nom avec une taille aléatoire comprise entre 0 et 200. Déjà un tableau ayant une taille alétaoire c'est difficile de comprendre son utilité... mais une taille à 0 !!!???

  int r=rand()%(12-1+1)+1;
  memcpy((char*)&n+2,r,1);
  /* Là tu places un nombre aléatoire (compris entre 1 et 12 ???) dans le troisième octet de "n". Là encore le but de cette opération m'échappe (n étant ici une variable de travail et ne faisant pas partie de la structure à remplir)
    Mais la vraie question c'est ce "+2". Dans mon exemple, je te montrais comment remplir un octet et donc j'avais pris le troisième (+2) pour l'exemple mais je m'attendais à ce que tu comprennes que
    toi, tu doives utiliser cet exemple pour en déduire comment remplir le premier, le second, le troisième, le quatrième et etc jusqu'à remplir au final les 150 octets de ta structure "pers" !!! */

  int a=rand()%(100-0+1)+0;
  p->age=malloc(a*sizeof(char));
  // Hum... p->age est un int non ???!!!???

  r=rand()%(12-1+1)+1;
  memcpy((char)&a+2,r,1);
  // Pareil. Pourquoi toucher au 3° octet de "a"...

  int t=rand()%(9-0+1);//par contre je sais si si c'est bien vu que c'est un tableau => Exact

  p->telephone=malloc(t*sizeof(char));
  r=rand()%(12-1+1)+1;
  memcpy((char)&a+2,r,1);
  return p;  
}

Mes remarques en rouge dans ton code. Je crains que tu ne piges pas ce que signifie "remplir quelque chose" parce que tu as rempli en fait tout le reste sauf le quelque chose lui-même. De même, je ne comprends pas pourquoi, chez-toi, le fait de devoir remplir "quelque chose" impose d'abord de devoir créer ce "quelque chose" avec une taille aléatoire. Si moi je dois remplir une bouteille vide, je pars du principe que la bouteille a déjà sa taille définie et invariante. De même si on me demande de remplir un tableau de char, je m'imagine que le tableau a sa taille bien définie et que je n'ai à me préoccuper que de son contenu...