Discussion :

[megamario]

Bonjour à tous.

Voila l'examen arrive enfin.

Je suis en pleine révision et il y a une chose que j'arrive pas à me mettre en tête, c'est l'implémentation en C++ différente relation entre classes que l'on voie en UML.
L'agrégation, la composition, l'héritage.

Pour l'héritage il me semble que cela s'écrit avec le nom de la classe suivit de : puis le nom de la classe hérité:

class tExemple : NomClassHeritage.

Je continu à chercher mais merci de votre aide.

[atttchoum]

Bonjour,

L'UML permet de modéliser, il n'y a pas forcement d'implémentation direct des notions d'UML en c++.

Alors pour l'héritage évidement il existe en c++ comme dans tout langage orienté objet :

Code :

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

1
2
3
4
5
6
7
8
 
class ClasseMere {
...
}
 
class ClasseFille : public ClasseMere{
...
}

Pour plus d'info cf la FAQ.

pour la composition ce qui correspond le plus a priori sa serai les membres d'une classe:

Code :

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

1
2
3
4
5
6
 
class Livre{
    Page page1
    Page page2
    Page page3
}

(désolé pour les exemples foireux évidemment on ferais plutôt un tableau de pages.)
Les objets Page seront détruits avec le livre.

Enfin l'agrégation peut être fais grâce à des pointeurs:

Code :

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

1
2
3
4
5
6
7
8
 
class Email{
    Email(fichier *f){
	fichierAttache = f; 
    }
 
    Fichier *fichierAttache;
};

ici le fichier sera juste lier a l'instance de Email et ne sera pas détruit avec lui.
on peut aussi utiliser les références.

[megamario]

Merci pour ce rappel

[djuju]

Bonjour,

Note tout de même que dans le cas général, une agregation et une composition est faite sur une collection d'objets.

Le code devient alors:

Code :

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

1
2
3
4
 
class Livre{
    Page pages[3];
};

Code :

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

1
2
3
4
5
6
7
8
9
 
class Email{
    Email(Fichier **f, int count){
        for(int i=0; i<count; i++)
           fichiersAttaches.push_back(f[i]);
    }
 
    vector<*Fichier> fichiersAttaches;
};

Un petit lien : http://ootips.org/uml-hasa.html

[gl]

Note tout de même que dans le cas général, une agregation et une composition est faite sur une collection d'objets.

Pourrais-tu développer ?

[Luc Hermitte]

Dans l'aggrégation, la notion de propriété est plus relâchée que dans la composition. Dans tous les cas, nous avons une relation forte, mais la composition exclut par définition le partage.

Donc, oui on peut composer avec des membres sans passer par du pointeur, mais ce n'est pas exclu pour autant si tant est que l'on force ce non partage.

(Dans la cas général, une personne reste composée d'un seul nom ...)

Si l'aggrégation est possible via référence, la composition nullement (à moins de mettre en place des alias à l'intérieur d'un même objet). Toutefois, on la rencontrera plutôt pour de simple mises en relation. Chose que les pointeurs permettent aussi.

Pour les héritages UML, c'est lh'éritage public qui leur correspond en C++. Le C++ dispose aussi d'un héritage de pure importation de code (i.e. qui exclut tout substituabilité) (-> l'héritage privé), qui dans mes souvenirs est totalement absent en UML.

[megamario]

J'arrive pas encore à bien saisir car j'ai quelque souvenir (j'arrive pas à retrouver mon court sa m'énerve) pour l'agrégation et la composition il y en avait un que l'on implémentait avec un new et pas l'autre.

ce qui donnerais

Code :

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

1
2
3
4
class ClMere
{
   ClFille *maFille;
}

et lorsque l'on en a besoin se serait

Code :

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

1
2
3
maFille = new ClFille;
 
maFille.MethodeFille(); //je sais plus si faut un . ou un ->

Je pense qu'il faut rajouter le

Code :

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

#include ClFille.h";

Cela correspondrais à l'agrégation suivant ce que vous m'avez donner plus haut

**************************************
Et pour l'autre je me souviens d'une chose comme

Code :

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

1
2
3
4
class ClMere
{
   ClFille MaFille;
}

mais après je sais plus comment l'utiliser ???

Il faut rajouter le

Code :

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

#include ClFille.h";

**************************************

Pour l'héritage il me semble que l'on ajoute par

Code :

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

1
2
3
4
class ClFille : public ClMere
{
 
}

Je pense que l'on peut utilisé directement les méthodes public de ClMere dans ClFille comme si elles étaient déclarés dans ClFille.

il faut rajouter le

Code :

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

#include ClMere.h";

**************************************

Pour l'association je sais plus car j'ai trouvé des chose qui ressemble beaucoup à l'agrégation

[megamario]

A au faite désoler d'être aussi perturbé la dessus, cela devrait être acquis mais cela fait 5 mois que j'ai pas pratiqué du C++ car j'était en projet avec du VB.Net, et j'avoue que j'ai la mémoire qui flanche.

Vivement que cela se termine les examens que je puisse avoir l'esprit libre, demain c'est la fin. Il me restera l'oral d'info mais la je suis plus confiant.

[megamario]

Pour l'association se serait pas

Class ClMere :: ClFille // les 2 petits points double
{
...
};

[Goten]

Non, ça c'est pas une syntaxe valide.

[megamario]

Non, ça c'est pas une syntaxe valide.

Ok, mais alors on le fait comment s'il vous plaie.

Et est-ce que j'ai écrit plus haut, est-ce que c'est bon ?

[atttchoum]

Encore une fois on ne peut porter tous les concepts UML directement en C++. si l'héritage est quelque chose de précis, l'association l'est beaucoup moins et il faudra réfléchir un peu quand à la façons de l'implémenter.

Code :

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

1
2
3
4
5
 
class ClMere
{
   ClFille *maFille;
}

cela correspondrai a une agrégation.

Code :

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

1
2
3
maFille = new ClFille;
 
maFille.MethodeFille(); //je sais plus si faut un . ou un ->

maFille est un pointeur on utilise donc ->
Un petit tour a la FAQ serai le bienvenu
le new permet de créer ta variable, attention si elle est partagé ce n'est pas forcement la classe contenant (ici ClMere qui est un très mauvais choix de nom sauf si tu veux t'embrouiller ) qui doit créer ta variable.

Code :

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

#include ClFille.h";

tu as oublier un "

Code :

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

#include "ClFille.h";

Code :

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

1
2
3
4
class ClMere
{
   ClFille MaFille;
}

cela correspond plutôt a une composition.

si tu créer un objet de type ClMere un objet de type ClFille sera automatiquement créé et mis dans maFille. Quand l'instance de ClMere sera détruit maFille sera détruit lui aussi.
ça n'est pas le cas pour le pointeur vu plus haut, lorsque l'on créai une ClMere maFille n'était qu'un pointeur vide il fallait utiliser new, de même la variable pointé par maFille ne sera pas détruite automatiquement a la destruction de l'instance de ClMere, il faudra utiliser delete.

[megamario]

Merci beaucoup pour ces explications.

L'examen et passé, je suis lessivé. Mais demain je reprend le chemin du boulot dans le service R&D informatique donc je continu sur m'a lancé.


Merci en tous cas à tous ceux qui on bien voulu m'aider durant ces 2 dernières années.

Merci Merci Merci.


Maintenant une page est tournée, on en ouvre une autre.

[djuju]

Pourrais-tu développer ?

Bonjour,

La notation UML permet de spécifier une multiplicité de l'objet qui "agrége" ou qui "compose". Même si cette multiplicité est à 1 ce n'est pas le cas le plus inclusif (ou général, mais c'est vrai que c'est un abus de langage) offert par la notation UML.

Ju