Discussion :

[TNT89]

Bonjour,

Comme un petit bout de code vaut mieux qu'un long discours :

Code :

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

1
2
3
4
5
6
 
template< unsigned int Dim, typename T>
struct VECTOR
{
        T data[Dim];
};

OU

Code :

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

1
2
3
4
5
6
 
template< unsigned int Dim, typename T>
struct VECTOR
{
        T* data[Dim];
};

En fait je ne sais pas quel code adopter entre ces deux possibilités sachant que T peut être un type primitif ou une structure...
Comment se passe la gestion en mémoire des objets? (leurs composantes sont elles maintenues groupées ou, au contraire, éclatées?)

Cordialement

[Goten]

Code :

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

1
2
 
T* data[dim]

ne compilera pas.

en revanche :

Code :

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

1
2
 
T* data;

compilera.

Pour répondre a la question :
Bas c'est simple ça dépend de la quantité et des opérations a effectuée sur la donnée.
Si tu as beaucoup de données a allouer par exemple (dès que tu dépasses le mo vois moins) T data[dim] ne suffira pas car c'est alloué sur la pile et ça pétera. Si tu dois faire des agrandissements (vu le nom de la structure ça me parait fort probable) pareil, un tableau statique est pas ce qu'il y'a de plus pratiques.
En contrepartie :

Code :

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

T* data;

impose une allocation dynamique et donc de gérer la mémoire. (ça implique de déclarer ta classe sous la forme canonique orthodoxe de coplien).
Pour l'alignement mémoire : oui les objets seront alignés en mémoire.

Enfin si c'est a visé didactique pourquoi pas, sinon autant utilisé la STL et notamment ici std::vector<>

[koala01]

Salut,

Code :

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

1
2
 
T* data[dim]

ne compilera pas.

FAUX...

[EDIT]Du moins pour autant que dim soit une constante connue à la compilation (mais cette réserve est également valable pour T tab[dim] )
[/EDIT]

Par contre, tu n'aura pas forcément ce que tu crois :

tu obtiendra en fait un tableau contenant dim pointeurs vers une structure de type T contigus en mémoire (les pointeurs étant contigus en mémoire, les objet pointés ayant de grandes chances d'être décéminés )

Sinon:

Si tu es sur qu'il ne te faut que maximum dim éléments (qu'il ne t'en faudra jamais dim +1), d'avoir en permancence dim éléments utilisés (ou plus près de dim que de 0 éléments utilisés), et que dim représente un nombre relativement limité (donc, pas surement pas 100 et plus), tu peux effectivement utiliser les deux solutions mais dans des circonstances différentes:

Tu utilisera la première (T tab[dim]), si tu sais que tu va travailler avec des objets de type T et que tu n'a aucun besoin d'appliquer le polymoprhisme.

Tu utilisera la seconde ( T* tab[dim]) si tu sais que tu va travailler avec des pointeurs ou si tu estime qu'il est possible que T puisse avoir un comportement polymorphe.

Cependant, il faudra aussi porter une attention toute particulière à la validité de tes pointeur dans le deuxième cas (il faut être sur que ta structure ne fasse jamais référence à une adresse devenue invalide suite à la destruction de l'objet pointé), ce qui peut arriver très vite.

Il peut donc être intéressant de travailler non plus avec des pointeurs bruts, mais plutôt avec des pointeurs intelligents (auto_ptr ou autres)

Enfin, si tu ne sais pas à la base estimer clairement le nombre d'éléments (ou de pointeurs sur éléments de type T) que ta structure devra manipuler, il sera certainement très intéressant d'utiliser les conteneurs de la STL (dont par exemple la classe vector, disponible dans l'espace de noms std par inclusion du fichier d'en-tête <vector>, qui fonctionne exactement comme un tableau "C style" )

Si tu décide de travailler avec des pointeurs vers des adresses mémoires allouées dynamiquement, boost::ptr_container sera sans doute à préférer de manière à manipuler plus surement tes pointeurs

[Goten]

Ouaip autant pour moi, j'ai étais un peu vite en besogne. (on mettra ça sur le compte de la fatigue). Toujours est-il que ce que je voulais dire c'est que même si ça compile, ça fera pas ce à quoi il s'attend...

[3DArchi]

Salut,
Comme expliqué précédemment, les 2 sémantiques sont différentes. Dans un cas tu as un tableau de dim éléments de type T, dans le second tu as un tableau de dim éléments de type pointeur (sur T). Si ton objet en s'appelant VECTOR veut modéliser un vecteur au sens de std::vector, alors le plus pertinent est le cas suivant :

Code :

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

1
2
3
4
5
template< unsigned int Dim, typename T>
struct VECTOR
{
        T data[Dim];
};

car en général on attend à ce que les éléments soient contigües en mémoire.

L'avantage de cette solution est qu'elle peut aussi être utilisée pour l'autre :

Code :

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

1
2
3
 
VECTOR<3,int> tab_entier;
VECTOR<3,int*> tab_pointeur_entier;

Enfin, comme l'a précisé Koala, les pointeurs bruts risquent de te poser des problèmes si tu ne les encapsules pas avec des pointeurs intelligents. Et encore dans ce cas, que signifie un tel tableau avec des trous ?

[Florian Goo]

Bonjour,

À moins qu'il s'agisse d'un exercice, std::tr1::array fait exactement ce que tu veux.

Sinon, préfère « Vector » à « VECTOR », le tout majuscule étant en général associé aux macros.

[TNT89]

Tout d'abord, merci de vos réponses.
A propos de l'utilisation de std::vector : je n'ai toujours pas compris pourquoi cela est appelé "vector" alors que c'est en fait une liste. En fait j'ai une vision très mathématique de la chose, et donc pour moi un vecteur est de dimension fixé, sinon ça n'est pas un vecteur. Ensuite, oui cela s'approche d'un exercice, exit donc le recours à une bibliothèque tierce.
Une utilisation par exemple :

Code :

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

1
2
3
4
5
6
 
    template<typename T>
    struct Complex : Vector<2, T>
    {
         //operateurs, etc...
    };

Et une déclaration d'un vecteur à trois composantes sur le corps complexe :

Code :

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

1
2
 
    Vector<3, Complex<double> > mon_vecteur;

-> 3DArchi, effectivement la première solution permet d'accéder à la deuxième...
-> koala01, qu'entends-tu par comportement polymorphe?

[Goten]

Si tu veux faire du polymorphisme dynamique dans ton conteneur.
Et non vector n'est pas une list, enfin pas une liste chainée en tout cas.

Pour:

Code :

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

1
2
 
    struct Complex : Vector<2, T>

Sa a pas vraiment de sens...

[3DArchi]

Il est vrai qu'une liste et un vecteur sont deux structures de données qui se ressemblent (tu peux jeter un coup d'oeil à ce tuto si ça t'intéresse). Les différences principales sont :
1/ Le vecteur t'assure une contiguïté des objets en mémoire ;
2/ Une liste a un cout d'ajout et de suppression bien moindre qu'un vecteur.
Si on tient compte de cette dernière remarque, un vector (ou un tableau) est bien un type implémentant les vecteurs mathématiques : la possibilité de modifier la taille du tableau n'étant là que pour se faciliter la vie ponctuellement. Si la structure doit varier régulièrement en nombre d'élément, une liste est effectivement plus appropriée.

Pour le comportement polymorphe : si ton tableau doit contenir des éléments en même temps d'un type de base et de types héritant de ce type de base et que tu veux que les appels aux méthodes virtuelles se passe bien, en C++ tu ne peux passer que par des pointeurs (ou des références mais pour ton tableau, ça n'a pas de sens) :

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
#include <iostream>
 
class A
{
   public:
   virtual void do_it()const
   {
      std::cout<<"A::do_it"<<std::endl;
   }
};
class B : public A
{
   public:
   virtual void do_it()const
   {
      std::cout<<"B::do_it"<<std::endl;
   }
};
 
template< unsigned int Dim, typename T>
struct VECTOR
{
  T data[Dim];
};
int main()
{
   A a;
   B b;
   VECTOR<2,A> vect_1;
   vect_1.data[0]=a;
   vect_1.data[1]=b;
 
   std::cout<<"VECTOR<2,A> -> do_it"<<std::endl;
  for(int index=0;index<2;++index)
  {
     vect_1.data[index].do_it();
  }
 
   VECTOR<2,A const*> vect_2;
   vect_2.data[0]=&a;
   vect_2.data[1]=&b;
   std::cout<<"VECTOR<2,A const *> -> do_it"<<std::endl;
  for(int index=0;index<2;++index)
  {
     vect_2.data[index]->do_it();
  }
 
   return 0;
}

Donne :

Code :

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

1
2
3
4
5
6
7
8
 
VECTOR<2,A> -> do_it
A::do_it
A::do_it
 
VECTOR<2,A const *> -> do_it
A::do_it
B::do_it

[TNT89]

Sa a pas vraiment de sens...

Pourquoi?

En tout cas je dois privilégier la première écriture mais être prudent dans son utilisation?

[3DArchi]

En tout cas je dois privilégier la première écriture

J'aurais tendance à dire oui.

mais être prudent dans son utilisation?

Il ne s'agit pas vraiment de prudence. Car la même remarque s'applique aux conteneurs standards (std::vector par exemple). Si tu veux utiliser les éléments avec leur type de base, alors il faut stocker les éléments par adresses (VECTOR<2,A const *>) et non par valeurs (VECTOR<2,A>).
On voit ainsi que la première écriture te permet de choisir au niveau de la variable et ne l'impose pas au niveau de la structure.

[TNT89]

Merci pour votre aide!