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