Questions sur les pointeurs intelligents

Version imprimable

Bonjour,

Je poursuis mon apprentissage du C++ et la j'ai besoin de savoir comment remplacer les pointeurs à la C par des pointeurs intelligents shared_ptr (je n'ai pas c++ 2011 juste la librairie boost ) dans ma collection hétérogène:

toolbox.h:

Code:

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
 
#ifndef TOOLBOX_H
#define TOOLBOX_H
 
#include "multimedia.h"
#include "photo.h"
#include "video.h"
#include <iostream>
#include <vector>
 
class ToolBox
{
public:
    //Constructeur
    ToolBox();
 
    //Methode d'ajout de pointeur sur des multimedia
    void ajouter_multimedia(Multimedia* nouveau);
 
    //Methode d'affichage
    void afficher() const;
 
    //Destructeur pour liberer la memoire allouee
    void liberer();
 
private:
    std::vector<Multimedia*> multimedia;
 
    //Constructeur de copie
    ToolBox(const ToolBox& autre);
 
    //Operateur d'affectation
    ToolBox& operator=(const ToolBox& source);
};
 
#endif // TOOLBOX_H

toolbox.cpp:

Code:

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
51
 
#include "toolbox.h"
//#include <boost/utility/swap.hpp>
 
ToolBox::ToolBox() : multimedia(){}
 
ToolBox::ToolBox(const ToolBox& autre)
    : multimedia()
{
    for(size_t i(0); i < autre.multimedia.size(); ++i)
        multimedia.push_back(autre.multimedia[i]->copie());
}
 
ToolBox& ToolBox::operator=(const ToolBox& source)
{
    if(this != &source)
    {
        liberer();
        for(size_t i(0); i < source.multimedia.size(); ++i)
            multimedia.push_back(source.multimedia[i]->copie());
    }
    return *this;
    /*boost::swap(multimedia, source.multimedia);
    return *this;*/
}
 
void ToolBox::ajouter_multimedia(Multimedia* nouveau)
{
    if(nouveau != NULL)
    {
        multimedia.push_back(nouveau);
    }
}
 
void ToolBox::afficher() const
{
    for(size_t i(0); i < multimedia.size(); ++i)
    {
        multimedia[i]->afficher(std::cout);
        std::cout << std::endl;
    }
}
 
void ToolBox::liberer()
{
    for(size_t i(0); i < multimedia.size(); ++i)
    {
        delete multimedia[i];
    }
    multimedia.clear();
}

J'ai fait des recherches mais il est dit que les shared_ptr ne sont incompatibles avec les raw pointers, qu'est-ce-que cela signifie??

20/01/2015, 20h28
iNaKoll

Bonsoir,

Cela peut signifie plusieurs choses :
1) boost::shared_ptr<Multimedia> et Multimedia* sont deux types différents. On ne peut pas assigner une variable du premier type à partir d'une variable du second type. On peut bien entendu construire un nouveau shared_ptr à partir d'un pointeur nu mais ça s'arrête là.
2) Corollaire de 1 : Quand on utilise des pointeurs intelligents à la place des pointeurs nus on ne mélange pas l'un et l'autre directement (on ne doit pas passer un pointeur nu à une fonction qui accepte un shared_ptr en paramètre!!!)
3) Corollaire de 2 : Si jamais on ne fait pas attention et que l'on mélange allègrement pointeur nu et pointeur intelligent, plus personne n'est réellement responsable de la libération de mémoire et tout peut alors arriver (on parle aussi de "code qui sent" dans ce cas). La mémoire peut être libérée plusieurs fois (inutile et provoque un comportement indéfini), la mémoire peut aussi être lue après avoir été libérée (provoque un comportement indéfini principalement source d'erreur de segmentation et de bugs variés : )

ok, j'ai réussi à résoudre le problème par contre j'ai un soucis lorsque je défini mon constructeur de copie pour faire de la copie profonde, j'ai un message d'erreur suivant:
Code:

1 2 3 4 5 6 7 8 ToolBox::ToolBox(const ToolBox& autre) : multimedia() { for(std::list< shared_ptr<Multimedia> >::const_iterator it = autre.multimedia.begin(); it != autre.multimedia.end(); ++it) multimedia.push_back((*it)->copie()); }
et le compilateur m'affiche ceci:
Code:

1 2 /home/farid/inf224/toolbox.cpp:10: erreur: no matching function for call to ‘std::list<std::tr1::shared_ptr<Multimedia> >::push_back(Multimedia*)’
que faut il changer dans cette expression qui ne convient pas: multimedia.push_back((*it)->copie());

25/01/2015, 22h46
jo_link_noir

ToolBox::ToolBox(const ToolBox&) = default; ne va pas ?

Sinon utilises emplace_back à la place de push_back. Ou fait un appel explicite au constructeur de shared_ptr.

Depuis c++11 il existe le range-loop (for (auto & x: container)).

Pourquoi préférer std::list plutôt que std::vector ?
25/01/2015, 23h52
kali38

Citation:

ToolBox::ToolBox(const ToolBox&) = default; ne va pas ?

Que signifie cette expression, c'est un constructeur par defaut?
26/01/2015, 01h09
JolyLoic

Citation:

Envoyé par jo_link_noir

ToolBox::ToolBox(const ToolBox&) = default;

A priori, il veut faire du deep-copy (appel de la fonction copie), ce que l'implémentation par défaut ne ferait pas.

kali38 : Pourquoi ne pas faire retourner un shared_ptr à ta fonction de clonage ? (ou éventuellement un unique_ptr, mais tu serais alors obligé de le transférer vers un shared_ptr au moment de l'insérer dans ton tableau).
26/01/2015, 01h29
jo_link_noir

Cela dit au compilateur de mettre le constructeur de copie par défaut. Ne pas mettre de constructeur de copie fait qu’implicitement le compilateur en met un.

En fait, je ne vois pas l’intérêt de faire appel à la fonction copie(). Si des shared_ptr sont utilisés c'est pour partager les instances, sinon, autant utiliser unique_ptr.
26/01/2015, 02h41
JolyLoic

On peut imaginer que les multimedia soient de manière générale gérés par shared_ptr, mais que quand on duplique un toolbox, on duplique les multimedia qu'il contient. Ça me semble peut-être compliqué, mais pas forcément faux.
26/01/2015, 13h45
kali38

Citation:

On peut imaginer que les multimedia soient de manière générale gérés par shared_ptr, mais que quand on duplique un toolbox, on duplique les multimedia qu'il contient. Ça me semble peut-être compliqué, mais pas forcément faux.

En effet JolyLoic, c'est exactement ce que je veux faire mais je crois que c'est pas utile avec les shared_ptr et que la copie de surface suffit amplement. J'utilisé la copie profonde pour les unique_ptr du fait qu'il n'est pas possible pour 2 unique_ptr de pointer sur la même zone mémoire.