Discussion :

[mattox37]

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

[Trademark]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Al_th]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

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.

[Trademark]

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...

[Al_th]

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

[matafan]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Et que tu y accèdes comme celà :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[droggo]

Qia,

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

[Al_th]

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")

[mattox37]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Sve@r]

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 c :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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}

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

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 c :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[mattox37]

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

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 c :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[souviron34]

donc ??

[mattox37]

donc ??

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

[Obsidian]

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 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.