problèmes de vector de pointeur vers des tableaux de structure

Bonjour à tous, j'ai un petit problème qui m'empêche d'avancer...

J'ai une structure :

Code:

---

1 2 3 4 5

typedef struct CelluleElement { float afPos[3]; //coordonnées x,y,z float fVal; //niveau de gris du voxel }celluleElement;

---

Cette structure représente un voxel du volume

Pour mon programme, j'ai besoin de manipuler des tableaux de CelluleElement de taille constante (CelluleElement[8]) , que je veux insérer dans mon vecteur au travers une fonction récursive.

J'ai déclaré mon vecteur comme ceci, mais ce n'est pas la bonne méthode...

vector<CelluleElement*> voCell;

et je fais un passage par référence à ma fonction.

Le problème c'est que quand je fais un push_back() toutes les valeurs de mon vecteur prennent la valeur du dernier élément insérer.

Je devine que mes pointeurs pointent tous vers la même zone mémoire, mais alors comment déclarer mon vecteur pour palier à ce problème?

Salut, et bienvenue sur le forum.

Pour commencer, je voudrais attirer ton attention sur le fait que, contrairement au C, une définition de type (qu'il s'agisse d'une énumération, d'une union, d'une structure ou d'une classe) sert de manière automatique à la définition de ce type.

Il est donc totalement inutile d'utiliser typedef truc{contenu} untype, et tu peux te contenter d'un

Code:

---

1 2 3 4 5

struct CelluleElement { float afPos[3]; //coordonnées x,y,z float fVal; //niveau de gris du voxel };

---

Ensuite, je voudrais attirer ton attention sur le fait que l'utilisation de pointeur devrait être réservée aux seuls cas où il n'y a pas moyens de faire autrement, c'est à dire, à des cas tout à fait particuliers, ne serait-ce que parce qu'ils sont souvent associés à la gestion dynamique de la mémoire et aux problèmes qu'elle sous entend.

Y a-t-il donc la moindre raison pour que tu veuille gérer tes éléments sous la forme de pointeurs :question:

J'aurais, à titre personnel, tendance à dire que non:

1. Ta structure ne semble pas être destinée à être utilisée de manière polymorphe
2. L'objet est parfaitement copiable
3. L'utilisation de copies (s'il est réellement impossible de les éviter) ne semble pas particulièrement handicapante au vu des performances actuelles du matériel, ni en terme d'utilisation de la mémoire (il n'y a que quatre float par élément), ni en terme de temps (la copie de quatre float est finalement très rapide :D)
4. les inconvénients liés à la gestion dynamique de la mémoire sont, à mon sens, très largement supérieurs aux éventuels gains que tu pourrais espérer en terme de performance lors de la copie

Cependant, tu ne nous donne malheureusement pas assez d'information pour nous permettre de t'aider à résoudre ton problème.

Pourrais tu donc nous donner le code des différentes fonctions que tu as créées voir, idéalement, un code minimum compilable d'exemple qui reproduise le problème :question:

En effet, la première règle des forums est "aide nous à t'aider", car les boules de crystal de la plus part des membres sont, malheureusement, en réparation :aie: ;)

Tout d'abord merci de m'avoir répondu si vite...

En fait, je développe un algorithme de marching cube récursif pour la modélisation de surface, j'ai déjà un algorithme qui marche, mais j'essaie de l'optimiser, et pour effectuer cela je veux enregistrer mes cellules récursivement.

Mes cellules sont des tableaux de 8 CelluleElement représentant les 8 sommets du cube

Citation:

---

Envoyé par koala01

Salut, et bienvenue sur le forum.

Ensuite, je voudrais attirer ton attention sur le fait que l'utilisation de pointeur devrait être réservée aux seuls cas où il n'y a pas moyens de faire autrement, c'est à dire, à des cas tout à fait particuliers, ne serait-ce que parce qu'ils sont souvent associés à la gestion dynamique de la mémoire et aux problèmes qu'elle sous entend.

Y a-t-il donc la moindre raison pour que tu veuille gérer tes éléments sous la forme de pointeurs :question:

J'aurais, à titre personnel, tendance à dire que non:

1. Ta structure ne semble pas être destinée à être utilisée de manière polymorphe
2. L'objet est parfaitement copiable
3. L'utilisation de copies (s'il est réellement impossible de les éviter) ne semble pas particulièrement handicapante au vu des performances actuelles du matériel, ni en terme d'utilisation de la mémoire (il n'y a que quatre float par élément), ni en terme de temps (la copie de quatre float est finalement très rapide :D)
4. les inconvénients liés à la gestion dynamique de la mémoire sont, à mon sens, très largement supérieurs aux éventuels gains que tu pourrais espérer en terme de performance lors de la copie

Cependant, tu ne nous donne malheureusement pas assez d'information pour nous permettre de t'aider à résoudre ton problème.

---

Le problème c'est que je traite des volumes de 512*512*512 voxels c'est pour ça que j'avais l'idée d'utiliser des pointeurs et un vecteur pour n'ajouter que les cellules à traiter et limiter l'occupation mémoire...

Sachant qu'à la fin de mon algorithme le vecteur à approximativement une taille de 1500000 cellules de 8 CelluleElement

Donc 4*4*8*1500000=192000000 octets

En effet l'utilisation des pointeurs est discutable car toutes les cellules sont différentes, et je n'y accède que deux fois chacune dans mon programme...

En fait, j'utilise un vecteur de pointeur car je n'ai pas réussi à faire un vecteur de tableau de structure.

Merci de votre aide, je reste connecter pour répondre aux questions si tout n'est pas clair

Bonjour à tous,

Citation:

---

J'ai déclaré mon vecteur comme ceci, mais ce n'est pas la bonne méthode...
vector<CelluleElement*> voCell;

---

Si, c'est comme ça que j'ai toujours déclaré mes vecteurs.

Citation:

---

et je fais un passage par référence à ma fonction.

Le problème c'est que quand je fais un push_back() toutes les valeurs de mon vecteur prennent la valeur du dernier élément insérer.

---

Peux tu poster un exemple de ton code, qui peut nous expliquer comment tu fais ton passage par référence a ta fonction (et quelle fonction ?). Et comment tu définis les pointeurs que tu ajoutes à ton vecteur ?

pour mehdi :

l'intitulé de la fonction :

Code:

---

1 2 3 4 5 6 7 8 9

void MarchingCube( const int *aiDim, const float *fPosBegin, const CROI &poRoi, const float *afNewPHYO, const int *aiDDO, unsigned char *aucCellSetting, vector<CelluleElement*> &voCell, unsigned int *aiPosCorres)

---

et ce que j'insère dans le vecteur :

déclaration :

Code:

---

CelluleElement aoCell[8];

---

insertion :

Code:

---

voCell.push_back(*aoCell);

---

peut-être serait-ce plus simple d'avoir un vecteur de ce type :

Code:

---

vector<CelluleElement[8]> voCell

---

Si j'ai bien compris tu veux insérer les 8 éléments de ton tableau aoCell dans un vecteur.
A ta place j'essayerais ça :

Code:

---

1 2 3 4 5

vector<CelluleElement*> voCell; CelluleElement aoCell[8]; for(i=0; i<8;i++) voCell.push_back(&aoCell[i]);

---

Cela ne résout pas le problème, les éléments sont identiques 8 à 8...

En fait, je veux construire mes cellules récursivement, et arrivé à un certain niveau de récursivité je veux enregistrer ma cellule dans le vecteur.

La question est pourquoi les pointeurs de mon vecteur pointent sur la même cellule?

résolution du problème :

déclaration :

Code:

---

CelluleElement *aoCell;

---

initialisation :

Code:

---

aoCell=new CelluleElement[8];

---

insertion :

Code:

---

voCell.push_back(aoCell);

---

en fait, il manquait l'initialisation...

En déclarant :

Code:

---

CelluleElement aoCell[8];

---

cela ne fonctionne pas...

Bonjour,

Citation:

---

Envoyé par julienmalin

La question est pourquoi les pointeurs de mon vecteur pointent sur la même cellule?

---

Non, la question serait plutôt : Mais qu'est-ce que tu essayes de faire à vrai dire ?

Tes messages sont difficile à décrypter. Après plusieurs relecture je n'ai toujours pas compris qui, comment et où sont crée tes CelluleElement, quel est le rôle de ce mystérieux vecteur, que doit-il contenir avant/après l'algo, etc..

En relisant, je crois avoir fini par comprendre le souci :P

Citation:

---

En fait, j'utilise un vecteur de pointeur car je n'ai pas réussi à faire un vecteur de tableau de structure.

---

Il n'est pas possible d'avoir un std::vector<T[]>.
Par contre on peut avoir :
1) Une structure qui contient le tableau.

Code:

---

1 2 3 4 5

struct Cellule { CelluleElement elements[8]; }; std::vector<Cellule> v;

---

C'est probablement la solution la plus simple.

2) Un tableau de type std::array, l'équivalent C++ des tableaux C "T[]", qui eux sont compatibles avec les std::vector

Code:

---

1 2	std::vector<std::array<CelluleElement, 8>> v;

---

Bien aussi, le problème c'est qu'il faut avoir un compilateur très récent pour supporter std::array.

3) Un pointeur vers un tableau dynamique

Code:

---

1 2	T* array = new T[8]; std::vector<T*> v;

---

Bon, perso, ça me crisperais de faire des centaines de millier d'alloc de petits tableaux dans le tas et de tout fragmenter. M'enfin si ça se trouve, c'est de la premature optimization, l'allocateur est peut être assez malin. Autre chose, il ne faut surtout pas oublier de faire des delete[] après utilisation sinon gare à la fuite mémoire géante :mouarf:

Citation:

---

Envoyé par Arzar

2) Un tableau de type std::array, l'équivalent C++ des tableaux C "T[]", qui eux sont compatibles avec les std::vector

Code:

---

1 2	std::vector<std::array<CelluleElement, 8>> v;

---

Bien aussi, le problème c'est qu'il faut avoir un compilateur très récent pour supporter std::array.

---

ou utilisez boost::array qui est l'inspiration de std::tr1::array

Bonjour, j'espère que vous avez passé un bon weekend...

Pour Arzar :

J'utilise un vecteur pour stocker mes cellules, afin d'éviter à avoir à les reconstruire ultérieurement dans mon programme.

Je stocke toutes les cellules intéressantes récursivement et parmi ces cellules intéressantes je ne fais des calculs que sur les cellules composant la plus grande surface

J'ai implémenté ta première méthode

Citation:

---

Envoyé par Arzar

Par contre on peut avoir :
1) Une structure qui contient le tableau.

Code:

---

1 2 3 4 5

struct Cellule { CelluleElement elements[8]; }; std::vector<Cellule> v;

---

C'est probablement la solution la plus simple.

---

Méthode qui fonctionne et qui simplifie mon code...

Aussi j'aimerais savoir si je peux gagner en temps de calcul et en occupation mémoire avec la deuxième méthode :

Citation:

---

Envoyé par Arzar

2) Un tableau de type std::array, l'équivalent C++ des tableaux C "T[]", qui eux sont compatibles avec les std::vector

Code:

---

1 2	std::vector<std::array<CelluleElement, 8>> v;

---

Bien aussi, le problème c'est qu'il faut avoir un compilateur très récent pour supporter std::array.

---

ou la méthode de Joel F

Citation:

---

Envoyé par Joel F

ou utilisez boost::array qui est l'inspiration de std::tr1::array

---

Bien à vous :)