qu'est-ce que le polymorphisme?

Trognon Patrice

08/10/2004 à 21:03

max wrote:

En gros,qu'est-ce que le polymorphisme en C++?
Après plusieurs lectures de bouquins en C++,je n'arrive toujours pas à
vraiment comprendre ce que c'est(termes compliqués)

Merci.

Bonsoir,

Tout d'abord le polymorphisme n'est pas propre a C++
il existe dans tous les languages objet, c'est donc
avant tout une des bases de l'objet.

Voici tout d'abord une définition, puis un exemple en
C++, si tu veux aussi un exemple en Java aucun pb
suffit de demander.

1) Explication.
Avec du jargon UML cela donne :

Le polmymorphisme est le fait qu'un même message
puisse être interprété de differentes facons en
fonction de l'object qui recoit ce message.

Avec du jargon C++ cela donne :

Le polymorphisme est le fait que l'appel d'une
méthode définie sur une classes de base puisse
donner une exécution differente en fonction
de la classe dérivée instanciée.

Ce qui se nomme un message en UML est en fait
un appel de méthode en C++ (ou dans tout autre
language objet).

2) Code.

Comme rien ne vaut un bon exemple pour
comprendre, passons au code.

Voici ce que je vais modéliser ici.

Les Lions et les Chats sont des félins.
Je suis capable de dire comment s'exprime
un Lion (Il rugit, ROOAAAA).
Je suis capable de dire comment s'exprime
un Chat (Il miaule, Miaou).
Je sais que le Felin va etre capable de
s'exprimer, seulement je ne sais pas comment
un Felin s'exprime.

Imaginons une classe de base :

<----------------Felin.h------------------>
class Felin {

// Constructeur.
Felin();

// Destructeur
virtual ~Felin();

// Méthode faisant s'exprimer un Felin
// Je sais q'un Felin sait s'exprimer
// Seulement je ne sais pas comment il s'exprime.
// La méthode est donc virtual (mise en oeuvre du
// polymorphisme en C++)
// ET elle est aussi abstraite car elle ne peut
// pas avoir de code puisque je ne sais pas comment
// s'exprime un Felin (c'est le = 0 ; en C++).
virtual void parler() = 0 ;
} ;
<----------------/Felin.h------------------>

<----------------Felin.cpp------------------>
#inlude "Felin.h"

Felin::Felin() {
}

Felin::~Felin() {
}
<----------------/Felin.cpp------------------>

Maintenant imaginons la class du Lion

<----------------Lion.h------------------>
class Lion : public Felin {

// Constructeur.
Lion();

// Destructeur
virtual ~Lion();

// Je sais comment s'exprime un Lion (ROOAAAA).
void parler() ;
} ;
<----------------/Lion.h------------------>

<----------------Lion.cpp------------------>
#include "Lion.h"

Lion::Lion()
:Felin() {
}

Lion::~Lion() {
}

void Lion::parler() {
cout << "ROOAAA" << endl ;
}
<----------------/Lion.cpp------------------>

Maintenant imaginons la class du Chat

<----------------Chat.h------------------>
class Chat : public Felin {

// Constructeur.
Chat();

// Destructeur
virtual ~Chat();

// Je sais comment s'exprime un Chat (Miaou).
void parler() ;
} ;
<----------------/Chat.h------------------>

<----------------Chat.cpp------------------>
#include "Chat.h"

Chat::Chat()
:Felin() {
}

Chat::~Chat() {
}

void Chat::parler() {
cout << "Miaou" << endl ;
}
<----------------/Chat.cpp------------------>

3) Utilisation de ce code, donc mise en oeuvre du polymorphisme.

Imaginons que j'ai une class Cirque, dans laquelle j'ai des
lions et des chat, je veux les faire tous parler.
Voici ce que ca donne

<----------------Cirque.h------------------>
class Cirque {

// List de felins
List listeDeFelins ;

// Constructeur.
Cirque();

// tout le monde parle
void parlezTous() ;
} ;
<----------------/Cirque.h------------------>

<----------------Cirque.cpp------------------>
#include "Cirque.h"

//---
// Dans mon cirque j'ai 2 Chats et 1 Lion
Cirque::Cirque() {
listeDeFelins = new List();
list.add( new Chat() ) ;
list.add( new Lion() ) ;
list.add( new Chat() ) ;
}

void Cirque::parlezTous() {
for( int = 0 ; i < 3 , i++ ) {
//---
// Le premier va me renvoyer un Chat
// Le second va me renvoyer un Lion
// Le troisieme va me renvoyer un Chat
Felin felin = (Felin)list.get( i ) ;

// Ici mise en oeuvre du polymorphisme
felin.parler();
}
}
<----------------/Chat.cpp------------------>

Dans la mise en oeuvre du polymorphisme (l'appel de ma méthode
parler) peu imporque que ce soit un chat ou un lion, ce que
je recupere c'est un Felin, et comme la méthode parler est
définie dans la class Felin, je peux donc l'invoquer.
Si c'est un chat qui a été instanciée, c'est la méthode
parler du chat qui va etre exécutée.
Si c'est un lion qui a été instanciée, c'est la méthode
parler du lion qui va etre exécutée.

Le programme affiche donc :
Miaou
ROOAAAA
Miaou

dans la méthode parlezTous, je n'ai pas besoin de manipuler
un Chat ou un Lion spécialisé, j'ai uniquement besoin de manipuler
un objet qui a la méthode Parlez, MAIS je veux que ce soit
bien le lion qui parle si c'est un lion, et le chat qui parle
si c'est un chat.

A QUOI CA SERT ???

En Objet (donc en c++) le polymorphisme evite de tester
le type de l'objet pour effectuer un traitemetn spécifique
a cet objet, on appel la méthode, et c'est le polymorphisme
qui va permettre d'executer le code spécifique.

Patrice.
http://www.javadevel.com

max wrote:

En gros,qu'est-ce que le polymorphisme en C++?
Après plusieurs lectures de bouquins en C++,je n'arrive toujours pas à
vraiment comprendre ce que c'est(termes compliqués)

Merci.

Bonsoir,

Tout d'abord le polymorphisme n'est pas propre a C++
il existe dans tous les languages objet, c'est donc
avant tout une des bases de l'objet.

Voici tout d'abord une définition, puis un exemple en
C++, si tu veux aussi un exemple en Java aucun pb
suffit de demander.

1) Explication.
Avec du jargon UML cela donne :

Le polmymorphisme est le fait qu'un même message
puisse être interprété de differentes facons en
fonction de l'object qui recoit ce message.

Avec du jargon C++ cela donne :

Le polymorphisme est le fait que l'appel d'une
méthode définie sur une classes de base puisse
donner une exécution differente en fonction
de la classe dérivée instanciée.

Ce qui se nomme un message en UML est en fait
un appel de méthode en C++ (ou dans tout autre
language objet).

2) Code.

Comme rien ne vaut un bon exemple pour
comprendre, passons au code.

Voici ce que je vais modéliser ici.

Les Lions et les Chats sont des félins.
Je suis capable de dire comment s'exprime
un Lion (Il rugit, ROOAAAA).
Je suis capable de dire comment s'exprime
un Chat (Il miaule, Miaou).
Je sais que le Felin va etre capable de
s'exprimer, seulement je ne sais pas comment
un Felin s'exprime.

Imaginons une classe de base :

<----------------Felin.h------------------>
class Felin {

// Constructeur.
Felin();

// Destructeur
virtual ~Felin();

// Méthode faisant s'exprimer un Felin
// Je sais q'un Felin sait s'exprimer
// Seulement je ne sais pas comment il s'exprime.
// La méthode est donc virtual (mise en oeuvre du
// polymorphisme en C++)
// ET elle est aussi abstraite car elle ne peut
// pas avoir de code puisque je ne sais pas comment
// s'exprime un Felin (c'est le = 0 ; en C++).
virtual void parler() = 0 ;
} ;
<----------------/Felin.h------------------>

<----------------Felin.cpp------------------>
#inlude "Felin.h"

Felin::Felin() {
}

Felin::~Felin() {
}
<----------------/Felin.cpp------------------>

Maintenant imaginons la class du Lion

<----------------Lion.h------------------>
class Lion : public Felin {

// Constructeur.
Lion();

// Destructeur
virtual ~Lion();

// Je sais comment s'exprime un Lion (ROOAAAA).
void parler() ;
} ;
<----------------/Lion.h------------------>

<----------------Lion.cpp------------------>
#include "Lion.h"

Lion::Lion()
:Felin() {
}

Lion::~Lion() {
}

void Lion::parler() {
cout << "ROOAAA" << endl ;
}
<----------------/Lion.cpp------------------>

Maintenant imaginons la class du Chat

<----------------Chat.h------------------>
class Chat : public Felin {

// Constructeur.
Chat();

// Destructeur
virtual ~Chat();

// Je sais comment s'exprime un Chat (Miaou).
void parler() ;
} ;
<----------------/Chat.h------------------>

<----------------Chat.cpp------------------>
#include "Chat.h"

Chat::Chat()
:Felin() {
}

Chat::~Chat() {
}

void Chat::parler() {
cout << "Miaou" << endl ;
}
<----------------/Chat.cpp------------------>

3) Utilisation de ce code, donc mise en oeuvre du polymorphisme.

Imaginons que j'ai une class Cirque, dans laquelle j'ai des
lions et des chat, je veux les faire tous parler.
Voici ce que ca donne

<----------------Cirque.h------------------>
class Cirque {

// List de felins
List listeDeFelins ;

// Constructeur.
Cirque();

// tout le monde parle
void parlezTous() ;
} ;
<----------------/Cirque.h------------------>

<----------------Cirque.cpp------------------>
#include "Cirque.h"

//---
// Dans mon cirque j'ai 2 Chats et 1 Lion
Cirque::Cirque() {
listeDeFelins = new List();
list.add( new Chat() ) ;
list.add( new Lion() ) ;
list.add( new Chat() ) ;
}

void Cirque::parlezTous() {
for( int = 0 ; i < 3 , i++ ) {
//---
// Le premier va me renvoyer un Chat
// Le second va me renvoyer un Lion
// Le troisieme va me renvoyer un Chat
Felin felin = (Felin)list.get( i ) ;

// Ici mise en oeuvre du polymorphisme
felin.parler();
}
}
<----------------/Chat.cpp------------------>

Dans la mise en oeuvre du polymorphisme (l'appel de ma méthode
parler) peu imporque que ce soit un chat ou un lion, ce que
je recupere c'est un Felin, et comme la méthode parler est
définie dans la class Felin, je peux donc l'invoquer.
Si c'est un chat qui a été instanciée, c'est la méthode
parler du chat qui va etre exécutée.
Si c'est un lion qui a été instanciée, c'est la méthode
parler du lion qui va etre exécutée.

Le programme affiche donc :
Miaou
ROOAAAA
Miaou

dans la méthode parlezTous, je n'ai pas besoin de manipuler
un Chat ou un Lion spécialisé, j'ai uniquement besoin de manipuler
un objet qui a la méthode Parlez, MAIS je veux que ce soit
bien le lion qui parle si c'est un lion, et le chat qui parle
si c'est un chat.

A QUOI CA SERT ???

En Objet (donc en c++) le polymorphisme evite de tester
le type de l'objet pour effectuer un traitemetn spécifique
a cet objet, on appel la méthode, et c'est le polymorphisme
qui va permettre d'executer le code spécifique.

Patrice.
http://www.javadevel.com

Vous avez filtré cet utilisateur ! Consultez son message

max wrote:

En gros,qu'est-ce que le polymorphisme en C++?
Après plusieurs lectures de bouquins en C++,je n'arrive toujours pas à
vraiment comprendre ce que c'est(termes compliqués)

Merci.

Bonsoir,

Tout d'abord le polymorphisme n'est pas propre a C++
il existe dans tous les languages objet, c'est donc
avant tout une des bases de l'objet.

Voici tout d'abord une définition, puis un exemple en
C++, si tu veux aussi un exemple en Java aucun pb
suffit de demander.

1) Explication.
Avec du jargon UML cela donne :

Le polmymorphisme est le fait qu'un même message
puisse être interprété de differentes facons en
fonction de l'object qui recoit ce message.

Avec du jargon C++ cela donne :

Le polymorphisme est le fait que l'appel d'une
méthode définie sur une classes de base puisse
donner une exécution differente en fonction
de la classe dérivée instanciée.

Ce qui se nomme un message en UML est en fait
un appel de méthode en C++ (ou dans tout autre
language objet).

2) Code.

Comme rien ne vaut un bon exemple pour
comprendre, passons au code.

Voici ce que je vais modéliser ici.

Les Lions et les Chats sont des félins.
Je suis capable de dire comment s'exprime
un Lion (Il rugit, ROOAAAA).
Je suis capable de dire comment s'exprime
un Chat (Il miaule, Miaou).
Je sais que le Felin va etre capable de
s'exprimer, seulement je ne sais pas comment
un Felin s'exprime.

Imaginons une classe de base :

<----------------Felin.h------------------>
class Felin {

// Constructeur.
Felin();

// Destructeur
virtual ~Felin();

// Méthode faisant s'exprimer un Felin
// Je sais q'un Felin sait s'exprimer
// Seulement je ne sais pas comment il s'exprime.
// La méthode est donc virtual (mise en oeuvre du
// polymorphisme en C++)
// ET elle est aussi abstraite car elle ne peut
// pas avoir de code puisque je ne sais pas comment
// s'exprime un Felin (c'est le = 0 ; en C++).
virtual void parler() = 0 ;
} ;
<----------------/Felin.h------------------>

<----------------Felin.cpp------------------>
#inlude "Felin.h"

Felin::Felin() {
}

Felin::~Felin() {
}
<----------------/Felin.cpp------------------>

Maintenant imaginons la class du Lion

<----------------Lion.h------------------>
class Lion : public Felin {

// Constructeur.
Lion();

// Destructeur
virtual ~Lion();

// Je sais comment s'exprime un Lion (ROOAAAA).
void parler() ;
} ;
<----------------/Lion.h------------------>

<----------------Lion.cpp------------------>
#include "Lion.h"

Lion::Lion()
:Felin() {
}

Lion::~Lion() {
}

void Lion::parler() {
cout << "ROOAAA" << endl ;
}
<----------------/Lion.cpp------------------>

Maintenant imaginons la class du Chat

<----------------Chat.h------------------>
class Chat : public Felin {

// Constructeur.
Chat();

// Destructeur
virtual ~Chat();

// Je sais comment s'exprime un Chat (Miaou).
void parler() ;
} ;
<----------------/Chat.h------------------>

<----------------Chat.cpp------------------>
#include "Chat.h"

Chat::Chat()
:Felin() {
}

Chat::~Chat() {
}

void Chat::parler() {
cout << "Miaou" << endl ;
}
<----------------/Chat.cpp------------------>

3) Utilisation de ce code, donc mise en oeuvre du polymorphisme.

Imaginons que j'ai une class Cirque, dans laquelle j'ai des
lions et des chat, je veux les faire tous parler.
Voici ce que ca donne

<----------------Cirque.h------------------>
class Cirque {

// List de felins
List listeDeFelins ;

// Constructeur.
Cirque();

// tout le monde parle
void parlezTous() ;
} ;
<----------------/Cirque.h------------------>

<----------------Cirque.cpp------------------>
#include "Cirque.h"

//---
// Dans mon cirque j'ai 2 Chats et 1 Lion
Cirque::Cirque() {
listeDeFelins = new List();
list.add( new Chat() ) ;
list.add( new Lion() ) ;
list.add( new Chat() ) ;
}

void Cirque::parlezTous() {
for( int = 0 ; i < 3 , i++ ) {
//---
// Le premier va me renvoyer un Chat
// Le second va me renvoyer un Lion
// Le troisieme va me renvoyer un Chat
Felin felin = (Felin)list.get( i ) ;

// Ici mise en oeuvre du polymorphisme
felin.parler();
}
}
<----------------/Chat.cpp------------------>

Dans la mise en oeuvre du polymorphisme (l'appel de ma méthode
parler) peu imporque que ce soit un chat ou un lion, ce que
je recupere c'est un Felin, et comme la méthode parler est
définie dans la class Felin, je peux donc l'invoquer.
Si c'est un chat qui a été instanciée, c'est la méthode
parler du chat qui va etre exécutée.
Si c'est un lion qui a été instanciée, c'est la méthode
parler du lion qui va etre exécutée.

Le programme affiche donc :
Miaou
ROOAAAA
Miaou

dans la méthode parlezTous, je n'ai pas besoin de manipuler
un Chat ou un Lion spécialisé, j'ai uniquement besoin de manipuler
un objet qui a la méthode Parlez, MAIS je veux que ce soit
bien le lion qui parle si c'est un lion, et le chat qui parle
si c'est un chat.

A QUOI CA SERT ???

En Objet (donc en c++) le polymorphisme evite de tester
le type de l'objet pour effectuer un traitemetn spécifique
a cet objet, on appel la méthode, et c'est le polymorphisme
qui va permettre d'executer le code spécifique.

Patrice.
http://www.javadevel.com

Fabien LE LEZ

08/10/2004 à 21:32

On Fri, 08 Oct 2004 21:03:42 +0200, Trognon Patrice
:

Voici tout d'abord une définition

... du polymorphisme d'héritage.

Je crois qu'on utilise aussi le mot "polymorphisme" pour parler du
mécanisme des templates, ainsi que pour parler de fonctions ayant le
même nom :

void foo (int);
int foo (std::string, std::string);

Mais j'avoue que le vocabulaire n'est pas mot fort.

--
;-)

Trognon Patrice

08/10/2004 à 21:56

Fabien LE LEZ wrote:

On Fri, 08 Oct 2004 21:03:42 +0200, Trognon Patrice
:

Voici tout d'abord une définition

... du polymorphisme d'héritage.

Je crois qu'on utilise aussi le mot "polymorphisme" pour parler du
mécanisme des templates, ainsi que pour parler de fonctions ayant le
même nom :

void foo (int);
int foo (std::string, std::string);

Non, ce dont tu parles, c'est de la surcharge et non du polymorphisme.

voir mon post précédent, la définition y est complete ;)

Patrice.
http://www.javadevel.com

Loïc Joly

08/10/2004 à 22:36

Trognon Patrice wrote:

Fabien LE LEZ wrote:

On Fri, 08 Oct 2004 21:03:42 +0200, Trognon Patrice
:

Voici tout d'abord une définition

... du polymorphisme d'héritage.

Je crois qu'on utilise aussi le mot "polymorphisme" pour parler du
mécanisme des templates, ainsi que pour parler de fonctions ayant le
même nom :

void foo (int);
int foo (std::string, std::string);

Non, ce dont tu parles, c'est de la surcharge et non du polymorphisme.

La surcharge est une forme de polymorphisme.

Le polymorphisme est un concept surchargé ;) J'ai vu selon les cas les
gens voir de 3 à 5 types de polymorphisme différent. Dans tous les cas,
la surcharge de fonction en est une instance, aussi appelé polymorhisme
ad hoc.

Il est vrai que dans le monde hors universitaire, quand on dit
polymorphisme tout court, on fait souvent implicitement référence au
polymorphisme d'héritage, que tu as décrit.

--
Loïc

benoit.breholee

08/10/2004 à 22:42

Trognon Patrice :

| Fabien LE LEZ wrote:
|
| > On Fri, 08 Oct 2004 21:03:42 +0200, Trognon Patrice
| > :
| >
| >>Voici tout d'abord une définition
| >
| > ... du polymorphisme d'héritage.
| >
| > Je crois qu'on utilise aussi le mot "polymorphisme" pour parler du
| > mécanisme des templates, ainsi que pour parler de fonctions ayant le
| > même nom :

Oui, et on l'utilise aussi pour parler des conversions implicites.

| Non, ce dont tu parles, c'est de la surcharge et non du polymorphisme.

C'est de la surcharge, mais c'est *aussi* du polymorphisme.

| voir mon post précédent, la définition y est complete ;)

Ce dont tu parles, comme l'a dit Fabien, ce n'est *que* le
polymorphisme d'héritage (ou polymorphisme de substitution),
pas le polymorphisme en général.

Luc Hermitte

08/10/2004 à 22:50

Trognon Patrice wrote in news:4166effd$0
$8662$:

Voici tout d'abord une définition

... du polymorphisme d'héritage.

Je crois qu'on utilise aussi le mot "polymorphisme" pour parler du
mécanisme des templates, ainsi que pour parler de fonctions ayant le
même nom :

Non, ce dont tu parles, c'est de la surcharge et non du polymorphisme.

J'ai les mêmes définitions que Fabien.

voir mon post précédent, la définition y est complete ;)

Ca dépend des auteurs alors. Chez les miens, la surcharge a toujours été
un polymorphisme.

Suivant une nomenclature que j'aime bien (et qui est présentée dans un
article, d'une italienne je crois, et dont Gabriel semble se souvenir des
références), la surcharge est une des 4 formes de polymorphisme, de la
famille des "polymorphismes ad'hoc", avec les convertions implicites. On
trouve aussi le polymorphisme paramétrique (la généricité).

Associer le "polymorphisme ad'hoc" à la surcharge est encore antérieur,
si je puis dire.

Maintenant, il se trouve que lorsque l'on parle juste de polymorphisme,
il est à 99% sous entendu qu'il s'agit du polymorphisme d'inclusion (aka
d'héritage).

--
Luc Hermitte <hermitte at free.fr>
FAQ de <news:fr.comp.lang.c++> :
<http://www.cmla.ens-cachan.fr/Utilisateurs/dosreis/C++/FAQ/>
Dejanews : <http://groups.google.com/advanced_group_search>

Trognon Patrice

08/10/2004 à 22:58

Loïc Joly wrote:

Trognon Patrice wrote:

Fabien LE LEZ wrote:

On Fri, 08 Oct 2004 21:03:42 +0200, Trognon Patrice
:

Voici tout d'abord une définition

... du polymorphisme d'héritage.

Je crois qu'on utilise aussi le mot "polymorphisme" pour parler du
mécanisme des templates, ainsi que pour parler de fonctions ayant le
même nom :

void foo (int);
int foo (std::string, std::string);

Non, ce dont tu parles, c'est de la surcharge et non du polymorphisme.

La surcharge est une forme de polymorphisme.

Le polymorphisme est un concept surchargé ;) J'ai vu selon les cas les
gens voir de 3 à 5 types de polymorphisme différent. Dans tous les cas,
la surcharge de fonction en est une instance, aussi appelé polymorhisme
ad hoc.

Il est vrai que dans le monde hors universitaire, quand on dit
polymorphisme tout court, on fait souvent implicitement référence au
polymorphisme d'héritage, que tu as décrit.

Donnant des cours sur C++ et Java je me dois d'utiliser un même mot
pour définir toujours le même concept.

Utiliser le mot polymorphisme dans differents contexte ne fait qu'allourdir
sa comprehension.

Je prefere donc parler de polymorphisme pour ce que tu appelles polymorphisme
d'heritage
de surcharge pour le
void foo (int);
int foo (std::string, std::string);
Remarquons que le terme de surcharge est aussi utilisé dans un autre
contexte en francais, alors qu'en anglais ils le differencient bien
en parlant d'overload et overrive.

Bref, sur le fond nous sommes en phase, c'est la forme qui change.
Seulement, quand un débuttant pose une question sur un des concepts
de base, évitons de lui embrouiller l'esprit, surtout si il a déjà
été enduit en erreur par ce qu'il a lu.
Stroustrup n'est pas le plus grand pédagogue que je connaisse,
il suffit de lire sa bible pour s'en rendre compte ;)

Patrice.

Michel Michaud

08/10/2004 à 23:12

Dans le message 4166fe7e$0$8663$,

Donnant des cours sur C++ et Java je me dois d'utiliser un même mot
pour définir toujours le même concept.

Comment doit-on interpréter cette phrase ? Par exemple, tu as
utilisé méthode en parlant de C++ alors qu'il n'y a pas de
méthode en C++ d'après la norme. Est-ce que tu nommes le concept
et espère ainsi ne pas avoir à parler du vocabulaire spécifique
ou si tu veux au contraire corriger les langages en donnant les
noms que tu crois correct ? (il faudrait alors savoir comment
nommer correctement les fonctions non virtuelles en C++ et les
fonctions final en Java...)

Utiliser le mot polymorphisme dans differents contexte ne fait
qu'allourdir sa comprehension.

Sauf que si c'est pour énoncer une réalité, c'est essentiel !

--
Michel Michaud
http://www.gdzid.com
FAQ de fr.comp.lang.c++ :
http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/

Loïc Joly

08/10/2004 à 23:12

Trognon Patrice wrote:

Loïc Joly wrote:
Le polymorphisme est un concept surchargé ;) J'ai vu selon les cas les
gens voir de 3 à 5 types de polymorphisme différent. Dans tous les cas,
la surcharge de fonction en est une instance, aussi appelé polymorhisme
ad hoc.

Il est vrai que dans le monde hors universitaire, quand on dit
polymorphisme tout court, on fait souvent implicitement référence au
polymorphisme d'héritage, que tu as décrit.

Donnant des cours sur C++ et Java je me dois d'utiliser un même mot
pour définir toujours le même concept.

Utiliser le mot polymorphisme dans differents contexte ne fait qu'allourdir
sa comprehension.

Les sens du mot en question ne sont aucunement définis par le C++, mais
plus par les théoriciens du langage, et sont donc autant valides en C++
qu'en Java.

--
Loïc

Fabien LE LEZ

08/10/2004 à 23:21

On Fri, 08 Oct 2004 22:58:24 +0200, Trognon Patrice
:

Donnant des cours sur C++ et Java je me dois d'utiliser un même mot
pour définir toujours le même concept.

Mouais... Mais sur le présent forum, seul C++ importe -- Java n'existe
pas.

--
;-)

qu'est-ce que le polymorphisme?

10 réponses

Veuillez sélectionner un problème