tableau de pointeurs

Bonjour,
dans le cadre d'un traitement temps réel j'ai besoin d'avoir la réponse à un problème simple :
j'ai un tableau de données par ex ArrayA = { 1 , 10 , 2 , 11 , 3 , 12} (taille 6 en int)
j'ai 2 tableaux : ArrayB et ArrayC (taille 3 en int)
et je voudrais que mon tableau ArrayB aille pointer sur le tableau ArrayA pour récupérer les valeur {1,2,3} et que ArrayC aille pointer sur les valeur {10,11,12}

j'aurais aimé faire un truc du genre au final
ArraB[0] = &ArrayA[0];
ArraB[1] = &ArrayA[2];
ArraB[2] = &ArrayA[4];
ArraC[0] = &ArrayA[1];
ArraC[1] = &ArrayA[3];
ArraC[2] = &ArrayA[5];

De cette facon je construis 2 tableaux (ArrayB et ArrayC) juste en remplissant un tableau (ArrayA)
le code que j'ai écris ne fonctionne pas, savez vous comme faire ca en c ?

J'ai bien cherché mais Google ne sait pas

Ce qui est étonnant c'est que tu sois obligé de faire quelque chose comme ça.

Je ne sais pas quelles sont tes contraintes mais pourquoi ne pas utiliser un tableau et démarrer les indices à 0 et à 3 ?

Tu aurais :

Code:

---

1 2	int pos_tab_b = 0 ; int pos_tab_c = 3 ;

---

Dans le cas où tu veux vraiment faire comme dans ton exemple :

Code:

---

1 2 3

int a[6] = {1,2,3,4,5,6}; int* b = &n[0] ; int *c = &n[3];

---

De toute évidence, tu ne peux pas limiter b à 3 cases, si tu fais b[4] ça marchera. Si tu veux éviter ça tu dois recopier le tableau dans un autre :

Code:

---

1 2 3 4 5

int a[6] = {1,2,3,4,5,6}; int i; int b[3] ; for(i=0; i<3; ++i) b[i] = a[i] ;

---

Mais réfléchis bien à ton objectif final.

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

#include <stdio.h> #include <stdlib.h> int main(void) { //initialisation de arrayA pour l'exemple int* arrayA = malloc(6*sizeof(int)); int i; for(i=0;i<6;i++){ arrayA[i]=i; } int** arrayB = malloc(3*sizeof(int*)); int** arrayC = malloc(3*sizeof(int*)); //La partie intéressante, on recopie les adresses dans les deux tableaux for(i=0;i<3;i++){ arrayB[i]=arrayA+i; arrayC[i]=arrayA+(i+3); } //Affichage avec les premieres valeurs for(i=0;i<3;i++){ printf("arrayB[%d] : %d\narrayC[%d] : %d\n\n",i,*arrayB[i],i,*arrayC[i]); } //On modifie arrayA arrayA[0]=3; arrayA[4]=40; //Repercution sur B et C for(i=0;i<3;i++){ printf("arrayB[%d] : %d\narrayC[%d] : %d\n\n",i,*arrayB[i],i,*arrayC[i]); } return 0; }

---

C'est sans doute pas très propre, mais ca fait ce que tu veux. On récupère les pointeurs des cases dans les tableau B et C.
Note bien qu'il est impératif d'utiliser l'* lors de l'appel de arrayB/arrayC.

Citation:

---

De toute évidence, tu ne peux pas limiter b à 3 cases, si tu fais b[4] ça marchera. Si tu veux éviter ça tu dois recopier le tableau dans un autre :

---

Il n'évitera rien du tout. Au mieux il se retrouvera avec un b[4] completement incohérent au lieu d'être un truc qui peut "sembler" juste. Mais il peut aussi bien se retrouver avec un truc qui "pourrait" coller. On en sait rien, on ne connait pas l'état de la mémoire autour.
D'autre part, il ne faut pas recopier le tableau dans deux autres tableau pour son problème initial.
Si tu modifies arrayA apres, il se passe quoi ? arrayB et arrayC sont tels qu'ils étaient quand t'as recopié arrayA, ca ne répond donc plus au probleme.

Effectivement ça ne limite pas. Mais je voulais dire que il est sur que b[4] marchera avec la première technique tandis que avec la 2ème il pourra avoir une segfault. Mais ça ne répond plus à l'exercice, tu as tout à fait raison.

Je pense que c'est quand même étrange d'être obligé de faire quelque chose comme ça...

Citation:

---

Je pense que c'est quand même étrange d'être obligé de faire quelque chose comme ça...

---

Plus qu'étrange, c'est dangereux aussi.

Tant que ton ensemble arrayB + arrayC reste plus petit que arrayA, et qu'il est inclus dans arrayA, y'a pas de soucis, tout tes éléments de arrayB/C seront des éléments connus.

Mais que se passe-t il au moment ou tu vas faire un free de ton arrayA ? arrayB et arrayC vont pointer sur une zone non connue, ou il peut y avoir n'importe quoi.
Je ne suis pas un pro de sécurité, mais il me semble que si une personne connait l'endroit ou pointe arrayB[X], sait que c'est une zone vide, et décide d'y mettre un code malicieux, ca peut plutot mal se passer :aie:

Ce que tu as commencé à faire est correct, à supposer que tu a bien déclaré ArrayB et ArrayC comme ceci :

Code:

---

1 2	int *ArrayB[3]; int *ArrayC[3];

---

Et que tu y accèdes comme celà :

Code:

---

1 2	printf("%i %i %i\n", *ArrayB[0], *ArrayB[1], *ArrayB[2]); printf("%i %i %i\n", *ArrayC[0], *ArrayC[1], *ArrayC[2]);

---

Je ne vois aucun problème avec ce code. Ce n'est pas particulièrement dangereux, comme toujours avec le C il faut faire attention à ce qu'on fait.

Qia,

Bien essayé pour qu'on fasse tes exercices à ta place. :)

Citation:

---

Ce n'est pas particulièrement dangereux, comme toujours avec le C il faut faire attention à ce qu'on fait.

---

Rien n'est vraiment dangereux quand on sait ce qu'on fait. Mais il faut quand même à mon avis redoubler de prudence quand on fait de la manipulation de pointeurs, et ca ne coute rien de le dire (surtout sur un forum "débutant")

Merci à tous, parfait pour cette réponse c'est ce que j'attendais.
Je savais pas que c'était possible.
Je vous explique l'intérêt de cette méthode pour mon application.
Je récupérer un buffer de données à partir d'un driver qui vient récupérer des signaux issues du FPGA (connecté sur un pci). Ce buffer représente 6 tableaux de nombres complexes. Sur ce grand buffer je dois réordonner les données sur 6 tableaux pour effectuer des FFT complexe.
Grâce à l'utilisation de pointeur l'ordinateur n'effectue donc aucun calcul pour réordonner ces tableaux.
Encore merci pour vos réponses rapide et merci à Al_th
Grâce à ca je gagne qq micro seconde dans mon calcul

Citation:

---

Envoyé par Al_th

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

#include <stdio.h> #include <stdlib.h> int main(void) { //initialisation de arrayA pour l'exemple int* arrayA = malloc(6*sizeof(int)); int i; for(i=0;i<6;i++){ arrayA[i]=i; } int** arrayB = malloc(3*sizeof(int*)); int** arrayC = malloc(3*sizeof(int*)); //La partie intéressante, on recopie les adresses dans les deux tableaux for(i=0;i<3;i++){ arrayB[i]=arrayA+i; arrayC[i]=arrayA+(i+3); } //Affichage avec les premieres valeurs for(i=0;i<3;i++){ printf("arrayB[%d] : %d\narrayC[%d] : %d\n\n",i,*arrayB[i],i,*arrayC[i]); } //On modifie arrayA arrayA[0]=3; arrayA[4]=40; //Repercution sur B et C for(i=0;i<3;i++){ printf("arrayB[%d] : %d\narrayC[%d] : %d\n\n",i,*arrayB[i],i,*arrayC[i]); } return 0; }

---

C'est sans doute pas très propre, mais ca fait ce que tu veux. On récupère les pointeurs des cases dans les tableau B et C.
Note bien qu'il est impératif d'utiliser l'* lors de l'appel de arrayB/arrayC.

Il n'évitera rien du tout. Au mieux il se retrouvera avec un b[4] completement incohérent au lieu d'être un truc qui peut "sembler" juste. Mais il peut aussi bien se retrouver avec un truc qui "pourrait" coller. On en sait rien, on ne connait pas l'état de la mémoire autour.
D'autre part, il ne faut pas recopier le tableau dans deux autres tableau pour son problème initial.
Si tu modifies arrayA apres, il se passe quoi ? arrayB et arrayC sont tels qu'ils étaient quand t'as recopié arrayA, ca ne répond donc plus au probleme.

---

Citation:

---

Envoyé par mattox37

Grâce à l'utilisation de pointeur l'ordinateur n'effectue donc aucun calcul pour réordonner ces tableaux.
Grâce à ca je gagne qq micro seconde dans mon calcul

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#include <stdio.h> #include <stdlib.h> int main(void) { //initialisation de arrayA pour l'exemple int* arrayA = malloc(6*sizeof(int)); int i; for(i=0;i<6;i++){ arrayA[i]=i; } int** arrayB = malloc(3*sizeof(int*)); int** arrayC = malloc(3*sizeof(int*)); //La partie intéressante, on recopie les adresses dans les deux tableaux for(i=0;i<3;i++){ arrayB[i]=arrayA+i; arrayC[i]=arrayA+(i+3); } //Affichage avec les premieres valeurs for(i=0;i<3;i++){ printf("arrayB[%d] : %d\narrayC[%d] : %d\n\n",i,*arrayB[i],i,*arrayC[i]); }

---

---

Salut
Effectivement, dans le code que tu nous présentes il n'y a aucun calcul pour réordonner le tableau mais c'est parce que le tableau "arrayA" est déjà trié vu que tu l'as rempli avec les entiers naturels !!!

Alors que si tu prends ton tableau initial ArrayA = { 1 , 10 , 2 , 11 , 3 , 12}, que tu fasses une recopie des nombres ou que tu pointes les cases contenant leur adresse, tu es quand-même obligé de faire un algo pour les trier. Ou alors c'est que j'ai rien compris à cette phrase

Citation:

---

et je voudrais que mon tableau ArrayB aille pointer sur le tableau ArrayA pour récupérer les valeur {1,2,3} et que ArrayC aille pointer sur les valeur {10,11,12}

---

Citation:

---

Envoyé par mattox37

Code:

---

1 2 3 4 5 6 7 8 9 10

//On modifie arrayA arrayA[0]=3; arrayA[4]=40; //Repercution sur B et C for(i=0;i<3;i++){ printf("arrayB[%d] : %d\narrayC[%d] : %d\n\n",i,*arrayB[i],i,*arrayC[i]); } return 0; }

---

---

Effectivement, le seul avantage que tu auras à passer par des pointeurs c'est qu'il n'y a au final qu'un seul tableau de valeurs. Et donc la modification du contenu du tableau est répercutée quand on l'affiche par les pointeurs...

Accessoirement, dans ton exemple les malloc sont inutiles

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

#include <stdio.h> #include <stdlib.h> int main(void) { int arrayA[6]; int* arrayB[3]; int* arrayC[3]; int i;   //initialisation de arrayA pour l'exemple for(i=0;i<6;i++){ arrayA[i]=i; }   //La partie intéressante, on recopie les adresses dans les deux tableaux for(i=0;i<3;i++){ arrayB[i]=arrayA+i; arrayC[i]=arrayA+i+3; }   //Affichage avec les premieres valeurs for(i=0;i<3;i++){ printf("arrayB[%d] : %d\narrayC[%d] : %d\n\n",i,*arrayB[i],i,*arrayC[i]); } //On modifie arrayA arrayA[0]=3; arrayA[4]=40; //Repercution sur B et C for(i=0;i<3;i++){ printf("arrayB[%d] : %d\narrayC[%d] : %d\n\n",i,*arrayB[i],i,*arrayC[i]); } return 0; }

---

Le but n'était pas de trier les nombres mais de mettre les nombres dans les bons tableaux sans faire d'opérations (nombres pair dans un tableau, nombre impaire dans un autre tableau). désolé si je n'ai pas été clair dans l'exemple

Citation:

---

Envoyé par Sve@r

Salut
Effectivement, dans le code que tu nous présentes il n'y a aucun calcul pour réordonner le tableau mais c'est parce que le tableau "arrayA" est déjà trié vu que tu l'as rempli avec les entiers naturels !!!

Alors que si tu prends ton tableau initial ArrayA = { 1 , 10 , 2 , 11 , 3 , 12}, que tu fasses une recopie des nombres ou que tu pointes les cases contenant leur adresse, tu es quand-même obligé de faire un algo pour les trier. Ou alors c'est que j'ai rien compris à cette phrase


Effectivement, le seul avantage que tu auras à passer par des pointeurs c'est qu'il n'y a au final qu'un seul tableau de valeurs. Et donc la modification du contenu du tableau est répercutée quand on l'affiche par les pointeurs...

Accessoirement, dans ton exemple les malloc sont inutiles

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

#include <stdio.h> #include <stdlib.h> int main(void) { int arrayA[6]; int* arrayB[3]; int* arrayC[3]; int i;   //initialisation de arrayA pour l'exemple for(i=0;i<6;i++){ arrayA[i]=i; }   //La partie intéressante, on recopie les adresses dans les deux tableaux for(i=0;i<3;i++){ arrayB[i]=arrayA+i; arrayC[i]=arrayA+i+3; }   //Affichage avec les premieres valeurs for(i=0;i<3;i++){ printf("arrayB[%d] : %d\narrayC[%d] : %d\n\n",i,*arrayB[i],i,*arrayC[i]); } //On modifie arrayA arrayA[0]=3; arrayA[4]=40; //Repercution sur B et C for(i=0;i<3;i++){ printf("arrayB[%d] : %d\narrayC[%d] : %d\n\n",i,*arrayB[i],i,*arrayC[i]); } return 0; }

---

---

donc :resolu: ??

Citation:

---

Envoyé par souviron34

donc :resolu: ??

---

Donc Al_th m'a donné ma réponse.
Merci à tous pour vos réponses, ça fait plaisir un forum aussi dynamique :p

Citation:

---

Envoyé par mattox37

Donc Al_th m'a donné ma réponse.
Merci à tous pour vos réponses, ça fait plaisir un forum aussi dynamique :p

---

À ton service, mais je crois que ce que souviron34 voulait te dire, c'est que lorsque tu considères ton problème comme ayant reçu la réponse que tu attendais et donc est résolu, il faut cliquer sur le bouton :resolu: en bas de page pour marquer ta discussion comme telle.

Tu pourras éventuellement la faire repasser à l'état non résolu par la suite si tu as des choses à ajouter.