remplir un tableau dans une boucle

J’ai une fonction qui s’appelle constamment. J’ai 3 tableaux plus petits que je dois emballer dans un tableau plus grand chaque boucle

float* a; float* b; float* c; float* abc; a = calloc(1, sizeof(float)*3); b = calloc(1, sizeof(float)*3); c = calloc(1, sizeof(float)*3); abc = calloc(1, sizeof(float)*9); void update() { for(int i = 0; i < 3; i++) { fill_a(a); fill_b(b) fill_c(c); abc[0] = a[0]; abc[1] = b[0]; abc[2] = c[0]; abc[0] = a[1]; abc[1] = b[1]; abc[2] = c[1]; abc[0] = a[2]; abc[1] = b[2]; abc[2] = c[2]; } } free(a); free(b); free(c); free(abc); 

l’implémentation ci-dessus présente des problèmes car les valeurs sont écrasées lors des boucles suivantes.

J’ai essayé d’append un décalage aux valeurs comme ceci:

  for(int i = 0; i < 3; i++) { fill_a(a); fill_b(b) fill_c(c); abc[(i*9)+0] = a[0]; abc[(i*9)+1] = b[0]; abc[(i*9)+2] = c[0]; 

et bien que cela semble fonctionner, si j’essaie d’append un par un, cela ne fonctionne pas non plus.

J’ai également essayé d’append des compensations via une valeur d’index, mais le décompte est infini.

 int idx = 0; void update() { for(int i = 0; i < 3; i++) { fill_a(a); fill_b(b) fill_c(c); abc[++idx] = a[0]; abc[++idx] = b[0]; abc[++idx] = c[0]; abc[++idx] = a[1]; abc[++idx] = b[1]; abc[++idx] = c[1]; 

J’ai également essayé de remplir les premiers tableaux en un pour la boucle. Puis plus tard dans la boucle de mise à jour, en plaçant ces valeurs dans un tableau plus grand.

 int idx; idx = 0; void update() { for(int i = 0; i < 3; i++) { fill_a(a); fill_b(b) fill_c(c); } int tidx = idx; abc[++tidx] a[0]; abc[++tidx] b[0]; abc[++tidx] c[0]; .... idx = tidx; } 

mais encore une fois l’idx s’en va à l’infini. Comment puis-je organiser cet algorithme de manière à pouvoir remplir le tableau le plus grand à l’intérieur de cette boucle avec les valeurs du tableau le plus petit tout en maintenant les décalages dans l’ordre?

Les valeurs du tableau le plus grand seront toujours écrasées chaque boucle. Une fois remplies, elles sont utilisées ailleurs, puis écrasées au prochain appel à mettre à jour.

J’ai essayé le débogage gdb en passant pas à pas dans le code, une variable à la fois.

La sortie attendue est quelque chose comme ceci:

 a = { 0, 1, 2 }; b = { -3, -2, -1 }; abc = { 0, -3, 11. 1, -2, 22 }; 

Voici un exemple entièrement fonctionnel du code actuel.

  int count = 3; float* v_buff; float* c_buff; size_t vs = sizeof(float) * 6); v_buff = calloc(1, (vs)); void update() { for(int i = 0; i < count; i++) { float a[3] = { 0, 1, 2}; //these will be new every update float b[3] = { -3, -2, -1}; int idx = 0; v_buff[++idx] = a[0]; v_buff[++idx] = a[1]; v_buff[++idx] = a[2]; v_buff[++idx] = b[0]; v_buff[++idx] = b[1]; v_buff[++idx] = b[2]; } } 

Cet exemple de code est compilé mais la même chose s’applique. essayer l’offset:

 v_buff[(i * 3) + (++idx)] = a[0]; 

provoque l’épuisement de mon compteur à l’infini ou remplace simplement le premier ensemble de valeurs dans v_buff.

Pour votre tableau abc , la première approche ne fonctionne pas car vous définissez les 3 premières entrées du tableau sur le contenu de a , puis vous les écrasez avec le contenu de b , puis à nouveau avec le contenu de c .

Votre deuxième approche est proche mais pas tout à fait parce que vous multipliez i par 9 au lieu de 3, donc l’indice sort des limites après la première itération.

Votre troisième approche est également proche, mais le problème est que vous utilisez un préincrément ( ++idx ) au lieu d’un postincrement ( idx++ ), vos index vont donc de 1 à 9 au lieu de 0 à 8.

En outre, votre fonction de update appelle fill_a , fill_b et fill_c dans une boucle. Sans voir ces fonctions, j’imagine que cela les remplit avec le même contenu à chaque fois, donc elles n’ont probablement pas besoin d’être en boucle.

Donc, en supposant que l’allocation et la désallocation pour chacun des 4 tableaux se produisent en dehors de la update , la fonction devrait ressembler à ceci:

 void update() { int i; fill_a(a); fill_b(b) fill_c(c); for(int i = 0; i < 3; i++) { abc[(i*3)+0] = a[i]; abc[(i*3)+1] = b[i]; abc[(i*3)+2] = c[i]; } } 

À la première itération de la boucle, i vaut 0; les trois lignes sont donc évaluées comme suit:

 abc[0] = a[0]; abc[1] = b[0]; abc[2] = c[0]; 

À la deuxième itération, i vaut 1 et le corps évalue:

 abc[3] = a[1]; abc[4] = b[1]; abc[5] = c[1]; 

À la troisième itération, i est i 2 et le corps évalue:

 abc[6] = a[2]; abc[7] = b[2]; abc[8] = c[2]; 

Vous pouvez aussi l'implémenter comme ceci:

 void update() { int i, idx; fill_a(a); fill_b(b) fill_c(c); for(int i = 0, idx = 0; i < 3; i++) { abc[idx++] = a[i]; abc[idx++] = b[i]; abc[idx++] = c[i]; } }