Discussion :

[dj.motte]

Bonjour,

Je demande si la STL avec ses avantages supposées ne fabrique pas une machine à gérer des objets, mais moins des pointeurs sur ces objets.

Par exemple pour gérer un "vector" de type pointeur sur T ( T*) il faut faire du code supplémentaire et ennuyeux et parfois sans succès.

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
 
#include  <iostream>
#include  <vector>
using namespace std ;
void do1()
{
   vector < double * > v ;
 
   for ( size_t i = 0 ; i < 16 ; i++ )
   { 
     double * z = new double( 1 + (i) * 10) ;
     v.push_back( z  )  ;
   }
   cout << v  ;
 
   // pour supprimer 
   delete v[2] ;  // ajouté sinon caca
   v.erase( v.begin() + 2 ) ;
 
   double * x1 = new double(-100.005) ;
   v.insert( v.begin() + 6, x1 ) ;  // ok 
 
   // pour réduire le vecteur
   for( size_t i = 7 ; i < v.size(); i++ )  //ajouté sinon caca
   delete v[i];
   v.resize(7);
 
   // pour affecter
   double * x2 = new double( -1 ) ;
   delete v[1]; // ajouté sinon caca
   v[1] = x2 ;
 
   // alors ce qui suit c'est la catastrophe 
   // fill( v.begin(), v.end(), x2 ) ;
   cout << v ;
 
   // Enfin le Chorus final 
   for( size_t i = 0 ; i < v.size() ; i++)
   delete v[i];
}
 
int main()
{
  do1() ;
  return 0 ;
}

Evidemment pour maintenir la stabilité du code des concepteurs les utilisateurs doivent faire des efforts.

Pour le pointeur sur T faut-il s'en remettre au magique pointeur ?

Salut.

[Matthieu Brucher]

Pour le pointeur sur T faut-il s'en remettre au magique pointeur ?

Pointeurs intelligents ? Oui. Ou à un boost::ptr_vector.

[loufoque]

Ton code plus haut n'est pas exception-safe.

Tu peux avoir un vecteur de pointeurs, mais dans ce cas, il contient seulement des adresses. Si tu veux que le vecteur soit responsable de la durée de vie des objets pointés, faut utiliser autre chose...

[dj.motte]

Ton code plus haut n'est pas exception-safe.

Tu peux avoir un vecteur de pointeurs, mais dans ce cas, il contient seulement des adresses. Si tu veux que le vecteur soit responsable de la durée de vie des objets pointés, faut utiliser autre chose...

Mouais pas terrible le vector de pointeurs. Il faudrait utiliser quoi au juste ?

salut.

[Matthieu Brucher]

Pointeurs intelligents ? Oui. Ou à un boost::ptr_vector.

Mouais pas terrible le vector de pointeurs. Il faudrait utiliser quoi au juste ?

Réponse dans le texte.

[dj.motte]

Réponse dans le texte.

C'est bien ce que je pensais. Le std::vector c'est à usage finalement assez naïf. C'est simple tant que l'on est sur le type T. Après il faut des prothèses pour y arriver.

Et boost::ptr_vector ça fait partie de la STL ?

[Cheps]

Je vois pas trop le problème d'utiliser un vecteur de pointeurs, même stupides (pas intelligents quoi ). Mis à part le fait qu'il faut réserver l'utilisation des pointeurs aux cas vraiment nécessaires (polymorphisme, partage de données, etc), il ne faut jamais perdre de vue:

- Qui crée l'objet pointé?
- Qui détruit l'objet pointé?
- La logique du programme permet-elle qu'un objet pointé soit détruit alors qu'il est encore utilisé ailleurs, i.e. rendre un pointeur invalide? (et attention dans les applications multi-thread, une synchronisation de l'accès aux données peut être nécessaire)

Dans tous les cas, avec les pointeurs, il faut une vision globale pour pas se planter. Et même utiliser des pointeurs intelligents ne nous affranchit pas de devoir réfléchir un peu


"A chaque new doit correspondre un delete."

[white_tentacle]

J'ai l'impression que pour sauvegarder le squelette de la STL on est prêt à tous les sacrifices. La prothèse boost peut effectivement parer au nécessaire.

Non. L'idée est de bénéficier de toute la puissance que nous donne c++. Plutôt que de définir n*m conteneurs "intelligents", ou n est le type de conteneur, et m la stratégie de gestion de la mémoire, on écrit n conteneurs, m "pointeurs" qui gèrent la mémoire, et on utilise la généricité pour demander au compilateur de générer les n*m conteneurs.

Pour s'enfoncer dans les rajouts ce qu'il faut préserver c'est le défaut de conception.

STL est considérée comme très bien conçue, je ne connais pas de grosses critiques à son encontre.

Au fait je ne sais pas comment on déclare un vector< shared_ptr <toto> >

std::vector<std::shared_ptr<toto> > ?