Bonjour à tous OC

j'ai 3 classes A, B et C.

J'ai le code :

A *a = new A("....");
B *b = new B(a);
C *c = new C(b); 

où chaque seconde et troisième ligne est initialisé avec la ligne précédente.

Ayant déjà un peu vu les Design patterns, je cherche sur wikipédia pour m'améliorer et pour deviner de quel design pattern il s'agit.

Selon moi, il s'agirait de Decorator.

Je suis très loin d'être sûr. J'aimerais avoir votre avis.

Merci

Ce n'est rien du tout.

Un design pattern, c'est une proposition de solution à une problématique. Sans préciser à quoi correspond ces classes et la problématique, ça n'a pas de sens de parler de pattern.

Moi je sais: le design pattern de "la fuite de mémoire causée par trois lignes de code pre-C++11 et du new sans delete".

J'ai bon?

VaultBoy a écrit:

Moi je sais: le design pattern de "la fuite de mémoire causée par trois lignes de code pre-C++11 et du new sans delete".

J'ai bon?

Pas forcément...

Cela dépend de ce que feront B et C des pointeurs qui leur sont fournis

Par exemple, avec B et C prenant la forme de

class B{
public:
    B(A* ptr):data_{ptr}{}
private:
    std::unique_ptr<A> data_;
};
class C{
public:
    C(B* ptr):data_{ptr}{}
private:
    std::unique_ptr<B> data_;
};

Pour autant que new B(a); ou new C(b); ne lancent pas une exception (ce qui, en l'état, a malgré tout peu de chance d'arriver), il n'y aura pas la moindre fuite mémoire.

Et comme nous sommes dans main, nous pourrions même encore nous en foutre, car, bien que ce ne soit pas "très sympa", le fait que la levée d'une exception nous fera sortir de l'application nous assure que le système d'exploitation fera le ménage pour nous

Une forme proche de

class B{
public:
    B(A* ptr):data_{ptr}{}
    ~B(){
        delete data_;
    }
private:
    A* data_;
};
class B{
public:
    C(B* ptr):data_{ptr}{}
    ~C(){
        delete data_;
    }
private:
    B* data_;
};

aurait d'ailleurs, à ce titre, exactement le même effet (mais ce sont le constructeur de copies et l'opérateur d'affectation qui fouteraient la merde :P)

-
Edité par koala01 18 juin 2018 à 22:17:26

lmghs a écrit:

Il n'y a pas de "ça dépend" pour moi car rien dans le code ne permet de savoir qui est responsable du contenu à l'adresse "a". Est-ce "a" ? Est-ce "*b" ?

C'était surtout pour dire que, bien que l'on puisse craindre une fuite mémoire à la vue de ces trois lignes de code, comme on n'a aucune informations sur ce que font B et C, on ne peut pas dire qu'il y en aura d'office une .

Les deux codes que je présente démontrent en effet que, à part pour C (qui sera récupéré par le système), il pourrait n'y avoir de fuite mémoire ni sur A ni sur B (bien que la fuite mémoire sur C les ferait arriver "en cascade" :P)

A *a = new QObject();
B *b = new QObject(a);
C *c = new QObject(b);

gbdivers a écrit:

A *a = new QObject();
B *b = new QObject(a);
C *c = new QObject(b);

Code parfaitement valide et sans fuite memoire

C'est moi ou "a" n'a pas de parent ?

C'est toi.

En plus, pas d'exception avec Qt, donc pas de probleme.

Qt is the power!