Notions C++:Polymorphisme,Virtual,Heritage,Typage dynamique :par l'exemple?

**observ** · 03/09/2006, 07h37

Bonjour,

Je me remets à vous pour m'eclaircir avec des exemples succintes redigés par vos propres soins et qui demontrent ces mecanismes .ce sont des notions que j'utilise sans vraiment les maïtriser.

--------------------------VIRTUAL------------------------------------

Il suffit d'une seule fonction virtuelle pure pour rendre une classe abstraite donc non instanciable.Est ce qu'une classe avec une methode virtuelle "non" pure est instanciable (je connais la reponse:instanciable) mais surtout à quoi ça sert les fonctions virtuelles non pures et comment s'utilisent leurs classes (un exemple peut être

).

-----------------------------------------------------------------------

---------------------------POLYMORPHISME----------------------------

Le polymorphisme comme je l'entends (!! vrai ou faux?) ne peut être evoqué sans passer par un heritage:donner à la classe mère plusieurs formes par l'instanciation de ses clesses derivées dans lesquelles on specialise les methodes virtuelles .
Donc est-ce qu'on est obligé de partir d'une classe abstraite pour par la suite redefinir les methodes dans les classes filles pour illustrer le polymophisme?

un exemple de polymophisme?

-------------------------------------------------------------------------

-------------------------Typage dynamique-----------------------------

C'est quoi ?
ça s'utilise comment?
un exemple de typage dynamique

Merci à vous tous...

**Alp** · 03/09/2006, 10h11

Salut,

N'ayant pas le temps de te répondre là, je veux juste te demander si tu as consulté la FAQ C++, car il risque d'y avoir pas mal de réponses et exemples dedans. Dans le genre, tu peux aussi chercher sur google "FAQ C++ Lite", "FAQ Comeau C++", "FAQ FCLC++".
Toutes ces FAQ apporteront surement les réponses que tu cherches.

Toute fois si cela ne suffit pas, je pense bien que des personnes répondront

**koala01** · 03/09/2006, 14h27

Salut,

De manière générale, les méthodes virtuelles pures, les classes abstraites, et le polymorphisme sont intimement liées...

L'idée d'une méthode virtuelle pure, c'est de dire que l'on décide de ne pas implémenter la méthode pour la classe que l'on est en train de créer parce que la classe est trop générique pour savoir exactement comment la méthode devra etre implémentée.

On décide de travailler de la sorte quand on veut indiquer que toutes les classes dérivée de notre classe générique disposeront d'une méthode bien précise, et que l'on ne sait pas, a priori, pour quelle classe dériviée la méthode sera appelée.

En déclarant une méthode virtuelle pure, on déclare de facto une classe abstraite, c'est à dire non instanciable (car on ne peut pas instancier une classe dont on ne sait pas comment réagit l'une de ses méthodes).

Cela ne t'empechera cependant pas de créer, au sein de ta classe de base, des fonction virtuelles qui seront correctement implémentée

Un exemple serait la méthode de "reproduction" des "etres vivants"

Entre les bactéries qui se reproduisent par division cellulaire, les poissons dont la femelle pond des oeufs non fécondés, et qui sont ensuite fécondés par le male, les oiseau et la plupart des reptiles qui pondent des oeuf fécondés précédemment, et les mamifères qui gardent les oeufs fécondés en eux jusqu'au terme de la gestation, comment pourrais tu implémenter la méthode "Reproduction" d'une classe "EtresVivants"?

Comme les classes "Bacteries","Poisson","Oiseaux","Reptiles" et "Mamiferes" ériteront toutes de la classe (devenue abstraite, du fait de la méthode non implémentée) "EtreVivants", elles disposeront toutes d'une méthode "Reproduction", héritée de la classe "EtreVivants".

Comme tu sais comment implémenter cette méthode, et qu'en plus, si tu ne le fais pas, tu créera une nouvelle classe abstraite (une meme cause ayant les memes effets

) tu pourras (devras si tu veux pouvoir instancier ta classe dérivée) l'implémenter.

Cette implémentation, différente en fonction de la classe dérivée, fera apparaitre le phénomene du polymorphisme (qui signifie tout simplement "une meme action produit des effets différents en fonction du contexte dans lequel elle est effectuée).

Un exemple beaucoup plus pratique concernant le polymorphisme est l'exemple des structures dynamiques (pile, file, liste)...

L'idée est de pouvoir rajouter dynamiquement un objet à un des bout de la structure (pour la création d'une chaine de caractères d'une taile inconnue, par exemple?)

Chaque élément de la pile, file ou liste sera composé de la meme manière, à savoir

- Un membre permettant de garder l'information (on va dire, pour l'exemple, un caractère)
- Un membre permettant d'accéder à l'élément suivant de la liste (un pointeur sur l'élément suivant)

Seulement, chaque élément risque de réagir différemment selon sa place au sein de la liste:
-le premier élément n'aura pas de valeur et servira de "borne de départ"
-Le dernier élément n'aura pas de valeur (ou une valeur "\0"), n'aura pas de membre permettant d'accéder à l'élément suivant et servira de "borne d'arrivee"
-Tous les points entre le premier et le dernier éléments DOIVENT avoir une valeur.

Bien que ce ne soit pas *forcément* l'idéal, nous utiliserons grandement la récursivité pour faire fonctionner le système (même si la récursivité n'apparait pas forcément comme telle)

On créerait donc une premiere classe générique qui fournirait l'ensemble des méthodes qui seront identiques pour les trois catégories (et qu'on retrouve réellement dans chacune d'elle) On va nommer cette classe IListItem.

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 IListItem
{
    //Les classes dérivées doivent accéder aux méthodes, on les place donc
    // en protected
    //constructeurs et destructeurs ne font rien dans notre cas
    public:
        IListItem(){};
        virtual ~IListItem(){};
    protected:
        virtual unsigned int count()=0//méthode permettant d'obtenir le nombre 
                              //d'éléments a implémenter dans chacune des classes
                              //dérivée
        virutal IListItem* Add(char value)=0;//méthode permettant
                             //de rajouter un élément à la fin de la file
    //surcharge de quelques operateurs utiles
        virtual char& operator[](unsigned int num)=0;
        virtual IListItem* operator++()=0;
    //itérateurs sur le début et la fin de la liste
        IListItem* Debut()=0;
        IListItem* Fin()=0;
};

Comme tu peux le remarquer, il n'y a aucun membre, et toutes les méthodes sont virtuelles pures...
Nous allons maintenant créer la classe pour les éléments "centraux" de la liste
(nommons la CentreItem)
Il contiennent les deux membres, et implémentent chacune des méthodes créés

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
//déclaration de la classe
class CentreItem:public IListItem
{
    public:
    //le constructeur que l'on va utiliser
        CentreItem(char value, IListItem* suivant);
        virtual ~CentreItem();
    //déclaration des méthodes virtuelles pures
       virtual unsigned int Count();
       virtual IListItem* Add(char value);
       virtual char& operator[](unsigned int i);
       virtual IListItem* operator++(IListItem* i);
    //l'itérateur Debut passe en privé (inaccessible depuis un CentreItem), mais 
    //literateur Fin est accessible
       virtual IListItem* Fin();
    //les membres de cette classe
       char Valeur;
    //l'élément Suivant est polymorphique... raison pour laquelle il prend le type
    // de la classe de base
       IListItem* Suivant;
    private:
       virtual IListItem* Debut(){};
};
//implémentation
//du constructeur utilisé
CentreItem::CentreItem(char value, IListItem *suivant)
{
    Valeur=value;
    Suivant=suivant;
}
// du destructeur (qui libère la mémoire de l'élément suivant
CentreItem::~CentreItem()
{
    delete Suivant;
    Suivant=NULL;
}
// de l'opérateur ++
IListItem* CentreItem::operator++()
{
    return Suivant;
}
// de l'operateur []
char& CentreItem::operator[](unsigned int i)
{
// renvoie this si c'est l'élément attendu, sinon, appelle operator[] sur 
//l'élément suivant
    if(i==0)
        return Valeur;
    return Suivant->operator[](i-1);
}
//de l'itérateur sur la fin de liste
IListItem* Fin()
{
//appel récursif sur Suivant->Fin()
    return Suivant->Fin();
}
//de la méthode Add()
IListItem* Add(char value)
{
// Appelle Suivant->Add() et renvoie this
    Suivant=Suivant->Add(value);
    return this;
}
//de la méthode Count()
unsigned int Count()
{
//renvoie le résultat de Suivant->count(), incrémenté de 1
    return (Suivant->Count()+1);
}

Nous allons maintenant créer la classe de fin de liste (nommons la TailList)
Elle n'a pas de membres, mais va servir à la sécurisation de la liste

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
 
class TailList
{
    public:
    //constructeurs et destructeurs qui ne font rien
        TailList(){};
        virtual ~TailList(){};
    //operateur [] et ++ qui lancent une exception
        virtual char& operator[](unsigned int i){throw std::invalid_argument("indice hors limites");}
 
        virtual operator++(){throw std::invalid_argument("indice hors limites");}
    //la méthode Add() (implémentée plus loin ;) )
        IListItem*Add(char value);
    //Fin() renvoie this;
    virtual IListItem* Fin(){return this;}
    //ajout des opérateur d'(in)égalité
        virtual bool operator==(IListItem* i){return (this==i);}
        virtual bool operator!=(IListItem*){return (this!=i);}
    //peut etre voudra tu rajouter des méthodes propres aux éléments de ta liste
    private:
    //Debut n'est pas accessible et ne fait rien
        virtual IListItem* Debut(){};
};
// implémentation de la méthode Add
IListItem* TailList::Add(char value)
{
// crée un nouvel élément de type CentreItem et le renvoie
    CentreItem *nouveau=new CentreItem(value,this);
    return nouveau;
}

Il ne reste plus qu'à créer une classe pour la tete de liste (nommée TeteListe)...
Elle ne dispose que d'un seul membre: Suivant, mais fournis les méthodes qui permettent d'accéder aux autres éléments

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
class TeteListe:public IListItem
{
    public:
    //constructeurs et destructeurs (implémentés plus loin)
        TeteListe();
        virtual ~TeteListe();
    //sécurisation de Add: une nouvelle méthode qui récupère l'exception
    //(implémentée plus loin)
        virtual bool Insert(char value);
    //La méthode Count()
        virtual unsigend int Count(){return Suivant->Count();}
    //les opérateurs 
        virtual char& operator[](unsigned int i){return Suivant->operator[](i);}
    //Implémentation des itérateurs
        IListItem* Debut(){return Suivant;}
        IListItem* Fin(){rerturn Suivant->Fin();}
    //Le seul membre utilisé
        IListItem* Suivant;
    private:
    //La méthode Add() (implémentée plus loin)
        virtual IListItem* Add(char value);
};
//l'implémentation
//Du construteur
TeteListe::TeteListe()
{
    //initialise Suivant comme fin de liste
    Suivant=new TailList();
}
//du destructeur
TeteListe::~TeteListe()
{
    //libere la mémorie de suivant
    delete Suivant;
    Suivant=NULL;
}
//de la méthode Add()
ListItem* TeteListe::Add(char value)
{
    Suivant=Suivant->Add(value);
    return this;
}
//de la méthode insert
bool TeteListe::Insert(char value)
{
   bool ok=true;
   try
   {
       Add(value);
   }
   //récupération de l'exception  si elle survient
   catch(...)
   {
         ok=false;
   }
   return ok;
}

**Luc Hermitte** · 04/09/2006, 02h10

a- En regroupant définitions et propriétés on a :
A est abstraite
<=> A dispose d'au moins une fonction membre virtuelle pure
<=> A est non instanciable

Autrement dit, la présence d'une fonction membre virtuelle non pure ne suffit pas à garantir l'instanciabilité

b- Le polymorphisme d'inclusion, tel que pratiqué en C++, est fortement lié à l'héritage (public !). C'est quand tu peux utiliser un objet d'une classe fille là où tu attends un objet de la classe mère.
La virtualité n'est pas nécessaire. Fréquente, mais non nécessaire. Tu peux très bien dériver une classe qui ne dispose d'aucune fonction membre virtuelle pour lui rajouter de nouvelles fonctions.
Dans ce cas, je crois que l'on parle de sous-typage, alors que dans le cas de la supplantation d'une fonction membre virtuelle, on parle de specialisation -- à confirmer.

Dans l'absolu, le polymorphisme désigne plus de choses que juste le polymorphisme d'inclusion. Le truc est que les langages OO ont "piraté" le terme dans leur contexte.

c- J'avoue que c'est un terme que je n'emploie jamais. Du coup, je peux très bien le connaitre sous une autre appelation.

**Jean-Marc.Bourguet** · 04/09/2006, 18h48

J'ai commencé à répondre mais le résultat est vraissemblablement un peu
trop long et trop théorique. Pour ceux que ça intéresse, ce
document donne ma
compréhension de la chose. Tous les commentaires m'intéressent.

J'ai du mal à comprendre la première question. C'est les fonctions
virtuelles pures qui devraient poser un problème

Les fonctions
virtuelles non pures permettent d'introduire du typage dynamique dans un
langage qui est essentiellement typé statiquement. Autrement dit, un appel
virtuel permet d'appeler le membre du type réel plutôt que du type déclaré.
Dans

Code :

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

1
2
3
4
5
6
7
8
9
10
struct A { 
   virtual void f();
};
struct B: A {
   virtual void f();
};
...
   A* ptr = new B;
   ptr->();
...

c'est B::f() qui est appelé et pas A::f() parce que bien que ptr
soit déclaré comme pointant vers un A, il pointe en réalité vers un B et
que f() est virtuelle.

Pour le polymorphisme, j'ai du mal à ne pas t'envoyer vers
le document que j'ai écrit: en résumé, il y a plusieurs
types de polymorphisme. Mais non, on n'est pas obligé de
partir d'une classe abstraite.

Pour le typage dynamique, c'est quand le type de l'objet est
indiqué dans sa valeur.

**Jean-Marc.Bourguet** · 04/09/2006, 18h50

Envoyé par koala01

L'idée d'une méthode virtuelle pure, c'est de dire que l'on décide de ne pas implémenter la méthode pour la classe que l'on est en train de créer parce que la classe est trop générique pour savoir exactement comment la méthode devra etre implémentée.

Non, l'idée d'une virtuelle pure c'est d'imposer aux descendants de la supplanter. La classe déclarant une fonction virtuelle pure peut (mais n'est pas obligée) la définir.

**Jean-Marc.Bourguet** · 04/09/2006, 18h56

Envoyé par Luc Hermitte

Dans ce cas, je crois que l'on parle de sous-typage,

Si tu considères les types comme des ensembles, un sous-type est un type contenu dans un autre.

alors que dans le cas de la supplantation d'une fonction membre virtuelle, on parle de specialisation -- à confirmer.

J'ai l'impression mais ce n'est pas un mot que j'utilise beaucoup. Je ne l'ai pas trouvé dans les index de mes bouquins sur les types.

**David Fleury** · 04/09/2006, 23h10

Je ne suis pas très à l'aise avec le terme "polymorphisme d'inclusion".

Il semble que vous le rapprochiez (JM et Luc) à l'utilisation de l'héritage.

Est-ce que ce terme est à rapprocher du terme "polymorphisme dynamique" ?

Et si oui (mon terme est peut être imprécis), quel serait le terme à rapprocher au "polymorphisme statique" que s'assimile à utilisation en C++ des templates ?

**Luc Hermitte** · 05/09/2006, 01h39

@Hylvénir. Je ne suis pas sûr, mais je crois bien que ce sont les travaux et en particulier un article de Cardelli qui ont contribué aux termes "polymorphisme paramétrique" et "polymorphisme d'inclusion" (et universel, ...) -- du moins dans une partie de la communauté C++. Personnellement je les préfère aux termes (resp.) "polymorphisme statique" (ou "de compilation") et "polymorphisme dynamique" (un doute pour ce dernier).
Ces derniers sont très techniques et C++iens je trouve. En plus, je trouve que leur noms s'attachent plus au comment qu'au pourquoi.

@JM. Pour sous-typage et compagnie. J'ai dû m'emmeler les pinceaux visiblement. Un des rares endroits, que j'arrive à retrouver, où tous ces termes sont réunis (et de façon pas toujours très heureuse) c'est sur l'article wikipédien sur l'héritage (VF ou VA, je ne sais plus).

Pour le document, je confirme qu'il faille le lire à tête reposée.

J'y reviendrai.

Peut-on considérer que l'on a un typage dynamique dans un langage de script ? Si dans ce langage on a une fonction qui reçoit deux paramètres (non statiquement typés) et que la fonction réalise un '+' sur les paramètes. Pour des chaînes on concatène, pour des nombres, on additionne -- les paramètres réels ayant été déterminés dynamiquement après saisie clavier. Et on envoie le résultat à la console. Est-ce un cas de typage dynamique ?
En fait la question cachée est : le typage dynamique concerne-t-il uniquement les Langages OO ?

**Jean-Marc.Bourguet** · 05/09/2006, 09h50

Envoyé par Hylvenir

Je ne suis pas très à l'aise avec le terme "polymorphisme d'inclusion".

C'est la possibilité pour des valeurs de faire partie de plusieurs types. En C++, les variables pointeurs peuvent pointer aussi bien vers un objet d'une classe qu'un objet d'un classe descendant de cette classe. Donc les valeurs pointeurs sont à la fois du type pointeur vers classe, mais aussi des types pointeur vers ancêtres publics.

Il semble que vous le rapprochiez (JM et Luc) à l'utilisation de l'héritage.

L'héritage est le mécanisme en C++ permettant de créer des sous-types. Mais il n'a pas toujours cet effet -- du moins si on regarde de l'extérieur de la classe -- car on ne peut pas dire qu'un pointeur vers une classe est aussi un pointeur vers une de ses bases privées.

Est-ce que ce terme est à rapprocher du terme "polymorphisme dynamique" ?

Et si oui (mon terme est peut être imprécis), quel serait le terme à rapprocher au "polymorphisme statique" que s'assimile à utilisation en C++ des templates ?[/QUOTE]

Pour moi polymorphisme dynamique ou statique est une découpe logiquement orthogonale à la découpe polymorphisme d'inclusion, polymorphisme paramétrique: elle décrit simplement quel type est pris en compte. Le polymorphisme statique ne peut par définition exister que dans des langages typés statiquement, dans les langages typés dynamiquement tous les types de polymorphisme sont possibles et les types considérés sont toujours les types dynamiques: ce sont les seuls.

Ce qui se passe, c'est qu'on a introduit une part de typage dynamique dans des langages typés statiquement. Et dans ce cas on choisit généralement (en fait je ne vois pas d'exceptions mais je ne connais pas tous les langages dont on a rêvé):
- de ne fournir du polymorphisme paramétrique que statique
- de fournir du polymorphisme d'inclusion statique (le C++ permet du polymorphisme d'inclusion dynamique avec dynamic_cast)
- de fournir une forme de surcharge dynamique (les appels de fonctions virtuelles en C++) liée à l'héritage.

Pour résumé au sujet de l'héritage a un rôle triple en C++:
- permettre de définir de nouveaux types par modification d'anciens (c'est le seul rôle qu'on ne peut pas éviter)
- introduire la relation de sous-type qui sert à vérifier statiquement que le polymorphisme d'inclusion est autorisé (on évite en héritant de manière privée)
- introduire de la surcharge dynamique (on évite en ne déclarant pas de membres virtuels)

Il est intéressant de constater que ce qui fait la puissance des techniques orientées objets: une combinaison entre du polymorphisme d'inclusion et du polymorphisme ad hoc est aussi ce qui fait la puissance des templates en C++ par rapport à d'autres langages: la combinaison du polymorphisme paramétrique et d'un polymorphisme ad hoc (les spécialisations explicites).

**Jean-Marc.Bourguet** · 05/09/2006, 09h59

Envoyé par Luc Hermitte

Peut-on considérer que l'on a un typage dynamique dans un langage de script ? Si dans ce langage on a une fonction qui reçoit deux paramètres (non statiquement typés) et que la fonction réalise un '+' sur les paramètes. Pour des chaînes on concatène, pour des nombres, on additionne -- les paramètres réels ayant été déterminés dynamiquement après saisie clavier. Et on envoie le résultat à la console. Est-ce un cas de typage dynamique ?

C'est de la surcharge dynamique, qui est disponible en C++ avec les fonctions virtuelles.

En fait la question cachée est : le typage dynamique concerne-t-il uniquement les Langages OO ?

En rien. Le lisp est définit comme ayant un typage dynamique depuis avant qu'on pense à l'OO. (Le lambda calcul lui est non typé).

**David Fleury** · 05/09/2006, 10h19

Ok, j'arrive maintenant un peu à faire la traduction.
Il est vrai que je ne fais exclusivement que du C++, et j'ai laissé de côté un peu la théorie.
Il semble que les théoriciens aient presque tous chacuns leur vocabulaire (en fonction de leur langage peut être ?)

Mais je risque d'avoir du mal à me débarasser des termes "polymorphisme statique" (ou de compilation, template ) et "polymorphisme dynamique" (héritage, virtuel).

Je vais voir ce que je peux trouver sur Cardelli.
Merci.

**David Fleury** · 05/09/2006, 10h52

J'ai trouvé des choses intéressantes.
Par contre, je suis étonné, Cardelli classe la surchage comme une forme de polymorphisme.
Je me souviens avoir vu un début de guerre (de religion?) sur un liste de diffusion quand quelqu'un à un oser lier ces deux notions.

Il semble que ce genre de sujet fait souvent débat. Il suffit de lire les anciens sujets.

**Luc Hermitte** · 06/09/2006, 02h14

Il n'y a pas de guerre je pense. La surcharge est un polymorphisme ad'hoc. Je l'avais appris comme ça il y a quelques temps maintenant.
Le problème est que j'ai l'impression que la POO s'est approprié le terme polymorphisme de telle sorte que les autres cas de figures ne seraient plus du polymorphisme si on acceptait le glissement de la définition. J'aime assez les articles au sujet du polymorphisme sur wikipédia. (Bon il faut dire qu'ils reprennent la taxinomie de Cardelli.) Au passage, ils nous rappellent p.ex. que le polymorphisme paramétrique est historiquement le "premier" polymorphisme.* dont on ait disposé.

**Jean-Marc.Bourguet** · 06/09/2006, 09h10

Envoyé par Hylvenir

Il semble que les théoriciens aient presque tous chacuns leur vocabulaire (en fonction de leur langage peut être ?)

Il me semble que le langage des théoriciens des types et des langages soit relativement homogène, du moins tant qu'on ne considère pas les langages dynamiques. Il y a en tout cas plus de variété parmis les praticiens des langages qui ont tendance à considéré tout ce qui différe de l'expression d'un concept d'un leur langage pour quelque chose de non représentatif du concept.

**Jean-Marc.Bourguet** · 06/09/2006, 09h19

Envoyé par Luc Hermitte

Au passage, ils nous rappellent p.ex. que le polymorphisme paramétrique est historiquement le "premier" polymorphisme.* dont on ait disposé.

Il me semble qu'on a disposité des conversions implicites et de la surcharge très tôt, dès les premières versions de Fortran. Naturellement, ce n'était pas pour des types défini par l'utilisateur, il n'y en avait pas encore.

Quand au polymorphisme d'inclusion, il a des relations très étroites avec le typage dynamique, qu'on peut considéré comme ayant un typage statique où on a un type parent universel et où on se contraint à ne manipuler des variables que de ce type-là. Mais comme je l'ai écrit, les théoriciens on du mal avec le typage dynamique...

Le polymorphisme d'inclusion est aussi présent d'une certaine façon dans les types unions, qui sont aussi présents assez tôt.

**David Fleury** · 06/09/2006, 09h29

Luc : j'ai lu la page wiki anglaise sur le polymoorphisme.
Je l'ai trouvé très politiquement correct en tout cas avec ces "Some can argue" tout le temps. Un peu comme si Cardelli l'avait écrite mais préviendrait en même temps que tout le monde n'est pas d'accord (par exemple sur la surcharge non considérée comme un polymorphisme, ou les templates qui génére du code par type et non une fonction générique - ces débats me dépassant mais bon)

JM : par exemple B Meyer, dans son livre sur la POO parle de "liaison dynamique" pour le polymorphisme dynamique ( euh.. d'inclusion) quand il introduit ces concepts pour Eiffel. Bon il est vrai que je l'ai lu, il y a moment, j'ai pu oublier des choses.

Il y a en tout cas plus de variété parmis les praticiens des langages qui ont tendance à considérer tout ce qui différe de l'expression d'un concept dans leur langage pour quelque chose de non représentatif du concept.

A cette heure, j'ai lu lire cette phrase deux fois mais je suis d'accord et c'était l'idée que je voulais exprimée

Je fais du C++ depuis trop longtemps... ça doit faire parti des effets de bord.

**Jean-Marc.Bourguet** · 06/09/2006, 10h00

Envoyé par Hylvenir

Luc : j'ai lu la page wiki anglaise sur le polymoorphisme.
Je l'ai trouvé très politiquement correct

C'est une des caractéristique de wikipédia, être très, trop irénique. L'autre caractéristique, c'est qu'il y a des horreurs qui durent. Au point que quand je connais plus ou moins un domaine et que je ne suis pas d'accord avec ce qui y est écrit, j'ai du mal à me remettre en question. Domage pour quelque chose qui se veut une référence.

JM : par exemple B Meyer, dans son livre sur la POO parle de "liaison dynamique" pour le polymorphisme dynamique ( euh.. d'inclusion) quand il introduit ces concepts pour Eiffel. Bon il est vrai que je l'ai lu, il y a moment, j'ai pu oublier des choses.

B. Meyer n'est certainement pas un théoricien des types ni des langages. S'il est théoricien de quelque chose, c'est des méthodologies de conception. Et là c'est un domaine de chapelles et d'excommunication.

**David Fleury** · 06/09/2006, 13h10

Code :

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

1
2
3
 
 
C'est une des caractéristique de wikipédia, être très, trop irénique. L'autre caractéristique, c'est qu'il y a des horreurs qui durent. Au point que quand je connais plus ou moins un domaine et que je ne suis pas d'accord avec ce qui y est écrit, j'ai du mal à me remettre en question. Domage pour quelque chose qui se veut une référence.

J'apprends un nouveau mot (irénique ici )à chacune de tes réponses

trop fort.
C'est peut être la nature même d'une référence de ne pouvoir satisfaire tout le monde (Pluton sera t'elle finalement une planête ?).

Je suis trop practicien pour reconnaitre les théoriciens et leur domaine respectif. J'ai assez de guerre de religion de mon côté pour aller en chercher ailleurs (vi contre emacs, espace contre tabulation, l'indentation... )

**Jean-Marc.Bourguet** · 06/09/2006, 13h48

Envoyé par Hylvenir

C'est peut être la nature même d'une référence de ne pouvoir satisfaire tout le monde (Pluton sera t'elle finalement une planête ?).

Le défaut est un peu inverse, ils cherchent trop à contenter tout le monde.

Je suis trop practicien pour reconnaitre les théoriciens et leur domaine respectif.

C'est vrai que je suis à l'aise aussi bien avec la théorie qu'avec la pratique,
mais je crois que je suis plus praticien que théoricien.

J'ai assez de guerre de religion de mon côté pour aller en chercher ailleurs (vi contre emacs,

Luc et moi ne nous bagarrons pourtant pas.

espace contre tabulation,

Y-at'il un bon argument pour les tabulations?

l'indentation... )

Il n'y a pas de quoi se bagarrer là dedans, l'important c'est d'avoir une convention et de s'y tenir.

Notions C++:Polymorphisme,Virtual,Heritage,Typage dynamique :par l'exemple?

C++

Discussions similaires

Partager

Partager