Discussion :

[adurandet]

Bonjour tout le monde,

j'vais un probelme d'allocation et de desallocation de tableau et qqun m'a cosneillé de faire ça avec des std::vector.

alros je me demandais si ca posait u probleme de melanger des delete et des std::vector ?

Parce que j'ai deja fait un bon bout de mon programme et j'utilise bcp de new et delete pour certaine variable et puis pour mon tableau je pense que je vais utiliser std::vector car ca a l'air simple d'utilisation. Est ce que ca pose un porbleme ?

Merci pour vos réponse,

[koala01]

Salut,

Tout dépend de ce que tu mets dans ton tableau...:

• A la base, std::vector, c'est un conteneur tout à fait générique.
• Généralement, quand tu utilise le mot clé new, cela signifie
  
  1. que tu veux prendre le contrôle de la durée de vie d'un objet
  2. que tu accepte d'en prendre la responsabilité

De manière générale, il faut savoir que toute utilisation de new doit trouver son pendant dans une utilisation de delete, et que le fait d'utiliser un std::vector n'y changera rien... Même si c'est de nature à en faciliter l'usage

J'ai écrit que cela dépend de ce que tu met dans ton tableau... cela mérite une petite précision:

Si, dans ton tableau, tu déclare ton tableau ne contenant que des objet (sous une forme proche de std::vector<TonType> tab), tu n'a *sans doute* aucun besoin de faire des appels à new, et donc, tu n'a pas d'avantage besoin de faire appel à delete (mais il faut être attentif au fait que tes objets n'auront une durée de vie qu'en tout cas égale à celle du tableau).

Si, par contre, tu déclare ton tableau comme contenant des pointeurs sur tes objets (sous une forme proche de std::vector<TonType*> tab) - et les raisons "qui font que" sont variées et multiples - il est fort vraissemblable que chaque objet ajouté au tableau soit créé avec le recours à new, et donc que la mémoire allouée à tout objet que tu supprimera de ton tableau devra être libérée par le delete correspondant, y compris (et surtout ) si tu veux carrément vider le tableau d'objets.

Maintenant, on peut *envisager* le fait que tu veuille carrément disposer d'un "gestionnaire d'objets"... Et, dans ce cas, la programmation orientée objet peut venir à ton secours, de par les méthodes que tu peux donner à au type "gestionnaire d'objets", et, principalement son destructeur, voire, une méthode perso "SuppressAllElement"

[adurandet]

ok merci de tes explications.

Comme tu le dis dans celles ci j'utilise un std::vector<TComposant*> Composants. (TComposant est une classe que j'ai créé, et Composants c'est mon tableau qui va contenir tous mes TComposant). Je vais donc utilisé des new pour chaque nouvelle case du tableau. Il faudra donc que j'aille supprimer avec delete chaque objet par la suite.

Mais alors je ne comprends plus l'interet d'utilsier std::vector par rapport a un tableau classique qui contient lui aussi des pointeurs ?

merci de m'eclaircir !

[poukill]

Effectivement, si ton conteneur contient des pointeurs, il te faudra également désallouer à la main via des "delete".
L'avantage de std::vector reste la réallocation de mémoire (push_back() ).

Maintenant, il existe un conteneur exactement comme std::vector mais exprès pour les pointeurs, c'est boost::ptr_vector !

Code :

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

std::vector <MaClasse*> vect;

et

Code :

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

boost::ptr_vector<MaClasse> vect2; // ou std::tr1::ptr_vector

sont complètement équivalent, et boost supprimera automatiquement les espaces mémoires...

[adurandet]

ok, donc dans mon cas je ferais mieux d'utilier boost.

Enfaite derriere mes questions se cache un probleme.

j'alloue mon tableau à un moment de mon programme puis je le desalloue lorsque une autre classe s'en est servie.

Le probleme c'est qu'au moment de le desallouer en fonction de ce qui sais passé je ne suis pas sur qu'il est été alloué!
Du coup lorsque je désalloue les pointeurs contenu dans mon tableau, si ceci n'ont pas été allouer alors mon programme plante.

Donc si j'utilise std::vector ou boost:: je pourrais tester si mes pointeurs ont été allouer ou même directement desallouer le vector sans avoir à savoir si mes pointeurs contenu dans celui ci ont été allouer, n'est ce pas ?

Est ce que je suis clair ? sinon demander moi des precisions car j'aimerais etre sur de ce que je vais faire !


Merci encore !

[koala01]

En fait, tu semble confirmer ce que je subodorais: ce qu'il te faut, c'est un moyen cohérent de gérer la durée de vie de tes TComposant...

Dés lors, ce que je te conseillerais peut etre, c'est d'envisager la création d'une classe que l'on pourrait nommer "ComposantHolder", par exemple, et qui pourrait prendre comme base un code du genre de

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
class CompsantHolder
{
    public:
        ComposantHolder(); /* constructeur par défaut */
        ComposantHolder(size_t nbelem);/* constructeur si on sait le nombre
                                        * d'élément à insérer à la base */
        ~ComposantHolder(); /* destructeur du gestionnaire */
        void AddComposant(size_t nb); /* permet d'ajouter des composants */
        void RemoveComposant(size_t index);/* permet d'en supprimer un */
        void RemoveComposants(size_t inddeb, size_t indfin);/* permet d'en 
                                                             * supprimer plusieurs */
        void ClearAll() /* les supprimes tous */
        TComposant* operator[](size_t ind);/* permet de récupérer le 
                                            * composant à l'index donné (RW)*/
        const TComposant* operator[](size_t ind) const;/* permet de récupérer 
                                                      * le composant à l'index donné 
                                                      * (RO)*/
        /* pour faire "bonne mesure" */
        size_t Size() const; /* indique le nombre de composants existant */
    private:
        std::vector<TComposant*> tab;
};

[EDIT]l'implémentation en serait, afin de s'assurer que l'on n'oublie pas de libérer la mémoire, dans le genre de

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
ComposantHolder::ComposantHolder()
{
    /*simplement rien :D */
}
ComposantHolder::ComposantHolder(size_t nbcomposant)
{
    for(size_t i=0;i<nbcomposant;i++)
        tab.push_back(new TComposant);
}
ComposantHolder::~ComposantHolder()
{
    for(size_t i=0;i<tab.size();i++)
        delete tab[i];
    tab.clear();
}
void ComposantHolder::AddComposant(size_t nb)
{
    for(size_t i=0;i<nb;i++)
        tab.push_back(new TComposant);
}
void ComposantHolder::RemoveComposant(size_t index)
{
    if(tab.size()>index)
    {
        /* libération de la mémoire du composant vise */
        delete tab[index];
        /* et suppression de l'élément */
        tab.remove(tab.begin()+index);
    }
}
/* pour les autres... ce devrait etre facile :D */

[Alp]

J'ai exactement compris ton problème, et koala01 y a très bien répondu. C'est une technique très répandue et il serait bon que tu assimiles ce qui est dit dans le message précédent, car cela te servira beaucoup.

[adurandet]

J'ai exactement compris ton problème, et koala01 y a très bien répondu. C'est une technique très répandue et il serait bon que tu assimiles ce qui est dit dans le message précédent, car cela te servira beaucoup.

j'ai bien saisi le code donner par koala01, mais dans mon cas je n'ai pas besoin d'autant de fonction ,mais juste besoin de faire :

- soit mon vecteur est rempli et je supprime les pointeur a l'interieur et le vecteur
- soit mon vecteur est vide et je supprime seulement le vecteur.


Mais en tout cas merci, ca m'aide bcp pour l'utilisation des vecteurs que je pensais plus compliqué que ca dans leur utiliation.


à vous !

[koala01]

Mais, pourquoi supprimer le vecteur

En plus, un vecteur n'est jamais "rempli", vu que l'espace qui lui est alloué augmente en fonction des besoins...

Tu peux, effectivement, sans doute te contenter d'une fonction Add, de l'operateur [] et de la fonction "Clear()" (qui libère la mémoire de tous les TComposants et qui vide le vecteur), si ton analyse te porte à en être sûr.

Mais l'idée générale est:

1. Que le ComposantHolder soit le seul responsable de l'allocation de mémoire ou de la libération de la mémoire allouée à un TComposant
2. Que le ComposantHolder maintienne la liste de tous les Composant qu'on lui a demandé de créer.
3. Qu'il faille passer systématiquement par un ComposantHolder pour obtenir un nouveau TComposant, ou détruire celui qui est devenu inutile.
   *Idealement*, il faudrait d'ailleurs interdire l'acces aux constructeurs et au destructeur du TComposant en les déclarant privés (ou protégés, s'il y a de l'héritage) et en déclarant ComposantHolder ami de TComposant.
4. Que la destruction - entre autre du fait d'une sortie de portée - d'un ComposantHolder provoque systématiquement la libération de la mémoire alloué à l'ensemble des TComposant qui n'auront pas été détruits
5. Qu'un ComposantHolder ne puisse pas être copié, pour éviter les problème de double libération de la mémoire allouée au TComposant

[adurandet]

J'ai utilisé le erme supprimer parce qu eje comprends encore mal le concept de vecteur mais j'ai compris qu'il ne servait a rien de la supprimer vu qu'il est vide quand on le clear.


merci de ton aide koala01