Je suis en train d'impl=E9menter des carreaux de Bezier : =E0 peu de
chose pr=E8s, un entier n (le degr=E9) et un tableau de (n+1)*(n+2)/2
entr=E9es o=F9 stocker les "points de controle".
Bref, je me demandais s'il =E9tait pr=E9f=E9rable d'utiliser un type
vector ou un pointeur pour stocker mes points de controle... J'imagine
qu'il y a du plus comme du moins pour les deux solutions mais j'ai un
peu de mal =E0 =E9valuer tout =E7a. Pourrez vous m'aider ?
:) Oui, je suis d'accord dans le cas que j'ai évoqué c'est hors de propos. Simplement, intellectuelement parlant ce n'est pas satisfaisant... Et puis je suis certain de tomber un jour sur un cas où j'en aurai besoin. En fait ce qui m'a troublé c'est que mon cas (triangles de bezier ) est déjà un peu plus lourd que ce que j'ai ecrit. A peu de chose près ça ressemble à : ---------------- template <class _Point> class Bezier_patch { int degre; std::vector<_Point> carreau;
// A une coordonnée i,j,k du triangle faire correspondre // l'indice dans le tableau int map(int i,int j, int k) { //On oublie les tests sur i,j,k (tous positifs ou nuls et sommeÞgre) return ((deg-i)*(deg+1-i)/2 + k); };
public:
Bezier_patch(int degree=0):deg(degree){ init(); }; Bezier_patch(const Bezier_patch &Bp){deg=Bp.deg;init();carreau=Bp.carreau;}; ~Bezier_patch(){};/*Comment c'est y qu'on detruit un vector ?*/
Et comme par la suite je stocke mes patchs dans un tableau je me retrouve avec un : ---------------- std::vector<Bezier_patch<Point> > A(N,Bezier_patch(60)); ---------------- qui lance une grosse cascade de constructeurs : N fois - Bezier_patch(60) 30*61 fois construction + recopie de Point(0,0,0) - recopie de Bezier_patch ---------------- alors que juste derriere je remplis mes patchs à la main avec des 'set'... ---------------- B[index].set(i,j,k,Point(x,y,z)); ----------------
Alors je me fais peut-etre des noeuds au cerveau ( je confesse bien volontier cette tendance :/ ), et dans mon cas ça reste certainement modeste... N'empeche, ça m'a permis de prendre conscience qu'il y avait une floppée de code "inutile" qui était appellée "dans mon dos" pour faire les initialisations... Et je ne peux donc m'empecher de me demander s'il n'y a pas moyen de donner une taille à un tableau tout en lui interdisant l'initialisation des cases... Et puis après tout 'porky' pour 'porky' on a déjà bien le droit d'utiliser [] en dehors des bornes à nos risques et périls !
Bon, je vais déjà jeter un oeil aux boost::shared_ptr... et prendre une verveine ;) et arreter de me prendre la tete : sur mon cas concret y'a pas de lézard ;) Merci à tous
:)
Oui, je suis d'accord dans le cas que j'ai évoqué c'est hors de
propos. Simplement, intellectuelement parlant ce n'est pas
satisfaisant... Et puis je suis certain de tomber un jour sur un cas
où j'en aurai besoin. En fait ce qui m'a troublé c'est que mon cas
(triangles de bezier ) est déjà un peu plus lourd que ce que j'ai
ecrit. A peu de chose près ça ressemble à :
----------------
template <class _Point>
class Bezier_patch
{
int degre;
std::vector<_Point> carreau;
// A une coordonnée i,j,k du triangle faire correspondre
// l'indice dans le tableau
int map(int i,int j, int k) {
//On oublie les tests sur i,j,k (tous positifs ou nuls
et somme=degre)
return ((deg-i)*(deg+1-i)/2 + k);
};
public:
Bezier_patch(int degree=0):deg(degree){ init(); };
Bezier_patch(const Bezier_patch
&Bp){deg=Bp.deg;init();carreau=Bp.carreau;};
~Bezier_patch(){};/*Comment c'est y qu'on detruit un vector ?*/
Et comme par la suite je stocke mes patchs dans un tableau je me
retrouve avec un :
----------------
std::vector<Bezier_patch<Point> > A(N,Bezier_patch(60));
----------------
qui lance une grosse cascade de constructeurs :
N fois
- Bezier_patch(60)
30*61 fois construction + recopie de Point(0,0,0)
- recopie de Bezier_patch
----------------
alors que juste derriere je remplis mes patchs à la main avec des
'set'...
----------------
B[index].set(i,j,k,Point(x,y,z));
----------------
Alors je me fais peut-etre des noeuds au cerveau ( je confesse bien
volontier cette tendance :/ ), et dans mon cas ça reste certainement
modeste... N'empeche, ça m'a permis de prendre conscience qu'il y
avait une floppée de code "inutile" qui était appellée "dans mon
dos" pour faire les initialisations... Et je ne peux donc m'empecher de
me demander s'il n'y a pas moyen de donner une taille à un tableau
tout en lui interdisant l'initialisation des cases... Et puis après
tout 'porky' pour 'porky' on a déjà bien le droit d'utiliser [] en
dehors des bornes à nos risques et périls !
Bon, je vais déjà jeter un oeil aux boost::shared_ptr... et prendre
une verveine ;)
et arreter de me prendre la tete : sur mon cas concret y'a pas de
lézard ;)
Merci à tous
:) Oui, je suis d'accord dans le cas que j'ai évoqué c'est hors de propos. Simplement, intellectuelement parlant ce n'est pas satisfaisant... Et puis je suis certain de tomber un jour sur un cas où j'en aurai besoin. En fait ce qui m'a troublé c'est que mon cas (triangles de bezier ) est déjà un peu plus lourd que ce que j'ai ecrit. A peu de chose près ça ressemble à : ---------------- template <class _Point> class Bezier_patch { int degre; std::vector<_Point> carreau;
// A une coordonnée i,j,k du triangle faire correspondre // l'indice dans le tableau int map(int i,int j, int k) { //On oublie les tests sur i,j,k (tous positifs ou nuls et sommeÞgre) return ((deg-i)*(deg+1-i)/2 + k); };
public:
Bezier_patch(int degree=0):deg(degree){ init(); }; Bezier_patch(const Bezier_patch &Bp){deg=Bp.deg;init();carreau=Bp.carreau;}; ~Bezier_patch(){};/*Comment c'est y qu'on detruit un vector ?*/
Et comme par la suite je stocke mes patchs dans un tableau je me retrouve avec un : ---------------- std::vector<Bezier_patch<Point> > A(N,Bezier_patch(60)); ---------------- qui lance une grosse cascade de constructeurs : N fois - Bezier_patch(60) 30*61 fois construction + recopie de Point(0,0,0) - recopie de Bezier_patch ---------------- alors que juste derriere je remplis mes patchs à la main avec des 'set'... ---------------- B[index].set(i,j,k,Point(x,y,z)); ----------------
Alors je me fais peut-etre des noeuds au cerveau ( je confesse bien volontier cette tendance :/ ), et dans mon cas ça reste certainement modeste... N'empeche, ça m'a permis de prendre conscience qu'il y avait une floppée de code "inutile" qui était appellée "dans mon dos" pour faire les initialisations... Et je ne peux donc m'empecher de me demander s'il n'y a pas moyen de donner une taille à un tableau tout en lui interdisant l'initialisation des cases... Et puis après tout 'porky' pour 'porky' on a déjà bien le droit d'utiliser [] en dehors des bornes à nos risques et périls !
Bon, je vais déjà jeter un oeil aux boost::shared_ptr... et prendre une verveine ;) et arreter de me prendre la tete : sur mon cas concret y'a pas de lézard ;) Merci à tous
