Discussion :

[coberle]

Bonjour,

J'ai une classe qui contient un tableau de Point (une autre classe définie par ailleurs) et j'ai "testé" les trois écritures suivantes. Chacune donne des résultats et des problèmes différents et du coup, je ne sais pas quoi faire de mieux.

Cas 1 ("tableau statique")
------

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
 
Class A:
{
  Point tP[nbrPoints];
 
  A();
  addPoint(int i, Point *P);
}
 
A::A()
{  }
 
A::addPoint(int i, Point *P)
{
  (tP+i)->x=P->x;
  (tP+i)->y=P->y;
  (tP+i)->z=P->z;
 
}

Cela semble OK, mais est-ce la bonne façon de faire en C++?

Cas 2 ("tableau dynamique")
------

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
 
Class A:
{
  Point *tP;
 
  A(const int& size);
  addPoint(int i, Point *P);
}
 
A::A(const int& size)
{
  tP=new Point[size];
}
 
A::addPoint(int i, Point *P)
{
  (tP+i)->x=P->x;
  (tP+i)->y=P->y;
  (tP+i)->z=P->z;
 
}

Ceci me semble une version améliorée du cas 1, où j'utilise la directive new. Or, j'appelle souvent la classe A et dans ce cas, je constate une chute des performances assez dramatique et une augmentation incroyable de la mémoire (genre de 10 à 300 !). Pas très surprenant vu l'appel du new dans le constructeur.

Cas 3: ("tableau de pointeurs")
------

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
 
Class A:
{
  Point *tP[size];
 
  A();
  addPoint(int i, Point *P);
}
 
A::A()
{ }
 
addPoint(int i, Point *P)
{
  *(tP+i)=P;
}

Cette méthode me semble très efficace (du point de vue performances très certainement). Je suis cependant embêté par le fait que je fais des "Point *P=new Point()" suivis de "addPoint(i,P)" en divers endroits où cette classe est utilisée ... ce qui ne me semble pas super propre (difficile de contrôler, difficulté à faire un destructeur propre) ...

Quelle méthode me recommenderiez-vous? Quel est le destructeur dans chacun de ces cas?
Christian

[3DArchi]

Bonjour,
La bonne (et seule !) façon de faire un tableau en C++ est :

Code :

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

1
2
 
std::vector<Point> mon_tableau;

Cas 1 : risque de poser des problèmes à ta pile
Cas 2 : des chances que les pointeurs en brut posent problème (fais une recherche dans la FAQ sur pointeur intelligent). C'est d'ailleurs certainement un problème de fuite mémoire qui te cause des soucis.
Cas 3 : idem que cas 2 mais en pire

[coyotte507]

Si tu veux que le cas 2 marche, tu as juste à libérer la mémoire allouée par new lorsque la classe est détruite:

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
 
Class A:
{
  Point *tP;
 
  A(const int& size);
  ~A();
  addPoint(int i, Point *P);
}
 
A::A(const int& size)
{
  tP=new Point[size];
}
A::~A()
{
  delete [] tP;// le [] car c'est un tableau
}
 
A::addPoint(int i, Point *P)
{
  (tP+i)->x=P->x;
  (tP+i)->y=P->y;
  (tP+i)->z=P->z;
 
}

De plus si ta classe Point contient juste les variables x,y,z, tu peux faire:

Code :

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

1
2
3
4
A::addPoint(int i, Point *P)
{
  *(tP+i)=*P;
}

voilà!

Mais c'est vrai que si tu es amené à faire beaucoup de classes qui utilisent des tableaux de taille non connue à la compilation, tu devrais utiliser une classe template (vector ou autre chose de plus léger) qui marche dans tous les cas.

[poukill]

Juste pour aller un tout petit peu plus loin que 3DArchi, en C++ :

• Tableau statique : std::tr1::array
• Tableau dynamique : std::vector

A+

[Goten]

Ou boost::array si ton compilo implémente pas tr1