Discussion :

[Jahjouh]

Bonjour à tous;

J'ai un problème dans l'utilisation de conteneur vector
Voici un bout de code que j'utilise

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
 
vector<Classetype*>m_Liste;
void RemplirListe(){
ClassType MonObjet1=new ClassType();
m_Liste.push_back;
.
.
.
ClassType MonObjet10=new ClassTYpe();
m_Liste_push_back(MonObje10);
}
 
void Supprimer(int type)
{
for(int i=0;i<m_Liste.size();i++)
ClassType*  pObjet=(ClassType*)m_Liste[i]
  if(pObjet->TYpe()==type){
     delete pObjet;
     m_Liste.erase(&m_Liste[i]);
     return;
  }
}

Est ce que erase suffit tout seul ?

2)Une autre petite question

Code :

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

1
2
3
4
5
6
7
 
ClassType* pMonObjet=new ClassType();
void affectation(ClassType* pObjet)
{
pMonOBjet=new ClassType(*pObjet)//Constructeur par copie
 
}

Est ce que cette affectation produit une perte de mémoire
Où, bien avant d'affecter, il faut faire un delete.

Merci infiniment pour votre aide.

[Syrmonsieur]

Un vecteur de T n'alloue que la mémoire necessaire au stockage des objets de type T.

Dans le cas ou T=Type*, il n'allouera que l'espace necessaire au stockage du pointeur et non l'espace de l'objet pointé.

En conséquence tu doit allouer pour chaque push_back et détruire avant chaque remove :

Code :

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

1
2
3
4
5
6
7
8
 
vector<T*> mon_vecteur;
vector<T*>::iterator it;
 
mon_vecteur.push_back(new T(...));
...
delete *it; // libère la mémoire pour stocker le T
mon_vecteur.erase(it); // Retire et libère la mémoire pour stocker le T*

[Jean-Marc.Bourguet]

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
 
vector<Classetype*>m_Liste;
void RemplirListe(){
ClassType MonObjet1=new ClassType();
m_Liste.push_back;
.
.
.
ClassType MonObjet10=new ClassTYpe();
m_Liste_push_back(MonObje10);
}
 
void Supprimer(int type)
{
for(int i=0;i<m_Liste.size();i++)
ClassType*  pObjet=(ClassType*)m_Liste[i]
  if(pObjet->TYpe()==type){
     delete pObjet;
     m_Liste.erase(&m_Liste[i]);
     return;
  }
}

Est ce que erase suffit tout seul ?

erase suffit mais &m_Liste[i] n'est pas un moyen conforme d'obtenir un itérateur sur le ieme élément. Il faut utiliser m_Liste.begin() + i ou bien itérer avec un ... itérateur.

Si supprimer un élément au milieu est courant et que l'indexation ne l'est pas (du moins l'indexation utile, pas celle de l'exemple où elle ne sert qu'à itérer), il faut envisager l'utilisation des std::list pour lesquels erase est plus performant.

Code :

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

1
2
3
4
5
6
7
 
ClassType* pMonObjet=new ClassType();
void affectation(ClassType* pObjet)
{
pMonOBjet=new ClassType(*pObjet)//Constructeur par copie
 
}

Est ce que cette affectation produit une perte de mémoire
Où, bien avant d'affecter, il faut faire un delete.

Il vaudrait vraissemblablement mieux en effet. Mais je me demande l'intérêt de ce que tu fais par rapport à

Code :

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

1
2
3
4
5
ClassType monObjet;
void affectation(ClassType* pObjet)
{
   monObjet=*pObjet;
}

Normalement un intérêt des pointeurs est l'utilisation du polymorphisme, mais ici tu as des constructeurs de copie (ce qui n'est pas très fréquent quand on utilise du polymorphisme) et surtout tu fais une affectation "tronquante" si le type dynamique de *pObjet n'est pas ClassType, ce que je n'ai jamais vu adéquat en présence de polymorphisme.

[Jahjouh]

En fait pour l'affectation de l'objet. Cet objet que je lui affecte un autre objet par construction de copie, c'est dans le cas d'une modification d'un objet dans une liste gérée par un mutex.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
T* Lire(U Identifiant); //renvoie un element de la liste
void Traitement(T* pObjet) //modifie pObjet sans exlusion
void Modifier(T* pObjet){
 
delete pMonObjet; // objet cree precedement
//pObjet est une copie modifiee de pMonObjet
//Ensuite on met à jour pMonObjet par pObjet
delete pMonObjet //libération 
pMonObjet=new T(*pObjet) // pour la mise à jour.
}