class toto
{
public:
void maFonction1(string nom);
void maFonction1(int valeur);
};
Comment appelle-t-on le mécanisme qui permet à plusieurs fonctions de
disposer de différents paramètres tout en ayant le même nom.
Il y a très très longtemps j'avais cru lire qu'on appellait ça
polymorphisme. Or, je sais depuis que le polymorphisme c'est tout à fait
autre chose, suite d'ailleurs à de nombreuses discussions ici même (cf ici
http://www.alaide.com/dico.php?q=polymorphisme).
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Laurent Ballester
surcharge non ?
http://www.alaide.com/dico.php?q=surcharge
"Zouplaz" a écrit dans le message de news:
Bonjour, si j'ai une classe définie comme suit :
class toto { public: void maFonction1(string nom); void maFonction1(int valeur); };
Comment appelle-t-on le mécanisme qui permet à plusieurs fonctions de disposer de différents paramètres tout en ayant le même nom.
Il y a très très longtemps j'avais cru lire qu'on appellait ça polymorphisme. Or, je sais depuis que le polymorphisme c'est tout à fait autre chose, suite d'ailleurs à de nombreuses discussions ici même (cf ici http://www.alaide.com/dico.php?q=polymorphisme).
Alors qu'est-ce donc ? Quel terme utiliser ?
Quelqu'un peut m'éclairer ?
Merci
surcharge non ?
http://www.alaide.com/dico.php?q=surcharge
"Zouplaz" <pouet@pouet.com> a écrit dans le message de
news:Xns9483F020A6E4FZoupla@213.228.0.133...
Bonjour, si j'ai une classe définie comme suit :
class toto
{
public:
void maFonction1(string nom);
void maFonction1(int valeur);
};
Comment appelle-t-on le mécanisme qui permet à plusieurs fonctions de
disposer de différents paramètres tout en ayant le même nom.
Il y a très très longtemps j'avais cru lire qu'on appellait ça
polymorphisme. Or, je sais depuis que le polymorphisme c'est tout à fait
autre chose, suite d'ailleurs à de nombreuses discussions ici même (cf ici
http://www.alaide.com/dico.php?q=polymorphisme).
class toto { public: void maFonction1(string nom); void maFonction1(int valeur); };
Comment appelle-t-on le mécanisme qui permet à plusieurs fonctions de disposer de différents paramètres tout en ayant le même nom.
Il y a très très longtemps j'avais cru lire qu'on appellait ça polymorphisme. Or, je sais depuis que le polymorphisme c'est tout à fait autre chose, suite d'ailleurs à de nombreuses discussions ici même (cf ici http://www.alaide.com/dico.php?q=polymorphisme).
Alors qu'est-ce donc ? Quel terme utiliser ?
Quelqu'un peut m'éclairer ?
Merci
Arnaud ARZUFFI
Zouplaz wrote:
Bonjour, si j'ai une classe définie comme suit :
class toto { public: void maFonction1(string nom); void maFonction1(int valeur); };
Comment appelle-t-on le mécanisme qui permet à plusieurs fonctions de disposer de différents paramètres tout en ayant le même nom.
Il y a très très longtemps j'avais cru lire qu'on appellait ça polymorphisme. Or, je sais depuis que le polymorphisme c'est tout à fait autre chose, suite d'ailleurs à de nombreuses discussions ici même (cf ici http://www.alaide.com/dico.php?q=polymorphisme).
Alors qu'est-ce donc ? Quel terme utiliser ?
Quelqu'un peut m'éclairer ?
Merci
Réponse à la question : surcharge de méthode.
Discussion sur le polymorphisme (à cause de la définition proposée, qui est vraiment incomplète, voire fausse) :
Le polymorphisme est "la capacité d'un composant de programme à admettre plusieurs typages distincts", et pas un mécanisme particulier. Un polymorphisme est appelé universel lorsqu'un élément accepte un ensemble non borné de typages distincts et particulier dans la situation contraire (un élément accepte un ensemble borné de typages distincts).
Quelques exemples de polymorphismes (je laisse à d'autres effectuer une taxonomie complète, je suis pas spécialiste du domaine) :
1. polymorphisme de coercition (particulier) : le typage d'un élément est transformable, grâce à un ensemble de règles de conversion, pour se conformer au typage d'un autre élément (la conversion entier flottant proposée par de nombreux langages, ...) 2. polymorphisme de surcharge (particulier) : un identificateur unique représente plusieurs élements du programme (la surcharge de méthodes en C++ ou Java, ...). 3. polymorphisme d'union (particulier) : un typage représente plusieurs typages distincts (unions en C, types somme en ML, ...) 4. polymorphisme d'inclusion (universel) : hiérarchie de compatibilité entre typages ; possibilité de définir un élément de typage compatible avec le typage de déclaration (présent à travers le mécanisme d'héritage dans la plupart des langage à objets : C++, Java, ... ) 5. polymorphisme paramétrique (universel) : utilisation de variables de typage. Ce polymorphisme peut être implicite (génération des variables de typage en ML) ou explicite lorsque le typage est déclaré (C++, Java, Ada, ...) ; ce polymorphisme est parfois contraint (foncteurs en ML, généricité contrainte en Eiffel, GJ, une évolution de Java, ...) ou non-contraint (C++, ...).
-- Arnaud ARZUFFI
Zouplaz wrote:
Bonjour, si j'ai une classe définie comme suit :
class toto
{
public:
void maFonction1(string nom);
void maFonction1(int valeur);
};
Comment appelle-t-on le mécanisme qui permet à plusieurs fonctions de
disposer de différents paramètres tout en ayant le même nom.
Il y a très très longtemps j'avais cru lire qu'on appellait ça
polymorphisme. Or, je sais depuis que le polymorphisme c'est tout à fait
autre chose, suite d'ailleurs à de nombreuses discussions ici même (cf ici
http://www.alaide.com/dico.php?q=polymorphisme).
Alors qu'est-ce donc ? Quel terme utiliser ?
Quelqu'un peut m'éclairer ?
Merci
Réponse à la question : surcharge de méthode.
Discussion sur le polymorphisme (à cause de la définition proposée, qui est
vraiment incomplète, voire fausse) :
Le polymorphisme est "la capacité d'un composant de programme à admettre
plusieurs typages distincts", et pas un mécanisme particulier.
Un polymorphisme est appelé universel lorsqu'un élément accepte un ensemble
non borné de typages distincts et particulier dans la situation contraire
(un élément accepte un ensemble borné de typages distincts).
Quelques exemples de polymorphismes (je laisse à d'autres effectuer une
taxonomie complète, je suis pas spécialiste du domaine) :
1. polymorphisme de coercition (particulier) : le typage d'un élément est
transformable, grâce à un ensemble de règles de conversion, pour se
conformer au typage d'un autre élément (la conversion entier flottant
proposée par de nombreux langages, ...)
2. polymorphisme de surcharge (particulier) : un identificateur unique
représente plusieurs élements du programme (la surcharge de méthodes en C++
ou Java, ...).
3. polymorphisme d'union (particulier) : un typage représente plusieurs
typages distincts (unions en C, types somme en ML, ...)
4. polymorphisme d'inclusion (universel) : hiérarchie de compatibilité entre
typages ; possibilité de définir un élément de typage compatible avec le
typage de déclaration (présent à travers le mécanisme d'héritage dans la
plupart des langage à objets : C++, Java, ... )
5. polymorphisme paramétrique (universel) : utilisation de variables de
typage. Ce polymorphisme peut être implicite (génération des variables de
typage en ML) ou explicite lorsque le typage est déclaré (C++, Java,
Ada, ...) ; ce polymorphisme est parfois contraint (foncteurs en ML,
généricité contrainte en Eiffel, GJ, une évolution de Java, ...) ou
non-contraint (C++, ...).
class toto { public: void maFonction1(string nom); void maFonction1(int valeur); };
Comment appelle-t-on le mécanisme qui permet à plusieurs fonctions de disposer de différents paramètres tout en ayant le même nom.
Il y a très très longtemps j'avais cru lire qu'on appellait ça polymorphisme. Or, je sais depuis que le polymorphisme c'est tout à fait autre chose, suite d'ailleurs à de nombreuses discussions ici même (cf ici http://www.alaide.com/dico.php?q=polymorphisme).
Alors qu'est-ce donc ? Quel terme utiliser ?
Quelqu'un peut m'éclairer ?
Merci
Réponse à la question : surcharge de méthode.
Discussion sur le polymorphisme (à cause de la définition proposée, qui est vraiment incomplète, voire fausse) :
Le polymorphisme est "la capacité d'un composant de programme à admettre plusieurs typages distincts", et pas un mécanisme particulier. Un polymorphisme est appelé universel lorsqu'un élément accepte un ensemble non borné de typages distincts et particulier dans la situation contraire (un élément accepte un ensemble borné de typages distincts).
Quelques exemples de polymorphismes (je laisse à d'autres effectuer une taxonomie complète, je suis pas spécialiste du domaine) :
1. polymorphisme de coercition (particulier) : le typage d'un élément est transformable, grâce à un ensemble de règles de conversion, pour se conformer au typage d'un autre élément (la conversion entier flottant proposée par de nombreux langages, ...) 2. polymorphisme de surcharge (particulier) : un identificateur unique représente plusieurs élements du programme (la surcharge de méthodes en C++ ou Java, ...). 3. polymorphisme d'union (particulier) : un typage représente plusieurs typages distincts (unions en C, types somme en ML, ...) 4. polymorphisme d'inclusion (universel) : hiérarchie de compatibilité entre typages ; possibilité de définir un élément de typage compatible avec le typage de déclaration (présent à travers le mécanisme d'héritage dans la plupart des langage à objets : C++, Java, ... ) 5. polymorphisme paramétrique (universel) : utilisation de variables de typage. Ce polymorphisme peut être implicite (génération des variables de typage en ML) ou explicite lorsque le typage est déclaré (C++, Java, Ada, ...) ; ce polymorphisme est parfois contraint (foncteurs en ML, généricité contrainte en Eiffel, GJ, une évolution de Java, ...) ou non-contraint (C++, ...).
-- Arnaud ARZUFFI
Michel Michaud
Dans news:bvmoa1$j23$, Arnaud
Zouplaz wrote:
Bonjour, si j'ai une classe définie comme suit :
class toto { public: void maFonction1(string nom); void maFonction1(int valeur); };
Comment appelle-t-on le mécanisme qui permet à plusieurs fonctions de disposer de différents paramètres tout en ayant le même nom.
[...]
Réponse à la question : surcharge de méthode.
Comme la question porte sur C++ et que C++ ne connaît pas les « méthodes », disons simplement qu'il s'agit de surcharge. Dans ce cas-ci, de surcharge de fonctions membres, mais on pourrait aussi avoir la surcharge de fonction ordinaire (libre).
-- Michel Michaud http://www.gdzid.com FAQ de fr.comp.lang.c++ : http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Dans news:bvmoa1$j23$1@news.u-bordeaux.fr, Arnaud
Zouplaz wrote:
Bonjour, si j'ai une classe définie comme suit :
class toto
{
public:
void maFonction1(string nom);
void maFonction1(int valeur);
};
Comment appelle-t-on le mécanisme qui permet à plusieurs fonctions
de disposer de différents paramètres tout en ayant le même nom.
[...]
Réponse à la question : surcharge de méthode.
Comme la question porte sur C++ et que C++ ne connaît pas les
« méthodes », disons simplement qu'il s'agit de surcharge.
Dans ce cas-ci, de surcharge de fonctions membres, mais on
pourrait aussi avoir la surcharge de fonction ordinaire (libre).
--
Michel Michaud mm@gdzid.com
http://www.gdzid.com
FAQ de fr.comp.lang.c++ :
http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
class toto { public: void maFonction1(string nom); void maFonction1(int valeur); };
Comment appelle-t-on le mécanisme qui permet à plusieurs fonctions de disposer de différents paramètres tout en ayant le même nom.
[...]
Réponse à la question : surcharge de méthode.
Comme la question porte sur C++ et que C++ ne connaît pas les « méthodes », disons simplement qu'il s'agit de surcharge. Dans ce cas-ci, de surcharge de fonctions membres, mais on pourrait aussi avoir la surcharge de fonction ordinaire (libre).
-- Michel Michaud http://www.gdzid.com FAQ de fr.comp.lang.c++ : http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Arnaud ARZUFFI
Zouplaz wrote:
Bonjour, si j'ai une classe définie comme suit :
class toto { public: void maFonction1(string nom); void maFonction1(int valeur); };
Comment appelle-t-on le mécanisme qui permet à plusieurs fonctions de disposer de différents paramètres tout en ayant le même nom.
Il y a très très longtemps j'avais cru lire qu'on appellait ça polymorphisme. Or, je sais depuis que le polymorphisme c'est tout à fait autre chose, suite d'ailleurs à de nombreuses discussions ici même (cf ici http://www.alaide.com/dico.php?q=polymorphisme).
Alors qu'est-ce donc ? Quel terme utiliser ?
Quelqu'un peut m'éclairer ?
Merci
Réponse à la question : surcharge de méthode.
Discussion sur le polymorphisme (à cause de la définition proposée, qui est vraiment incomplète, voire fausse) :
Le polymorphisme est "la capacité d'un composant de programme à admettre plusieurs typages distincts", et pas un mécanisme particulier. Un polymorphisme est appelé universel lorsqu'un élément accepte un ensemble non borné de typages distincts et particulier dans la situation contraire (un élément accepte un ensemble borné de typages distincts).
Quelques exemples de polymorphismes (je laisse à d'autres effectuer une taxonomie complète, je suis pas spécialiste du domaine) :
1. polymorphisme de coercition (particulier) : le typage d'un élément est transformable, grâce à un ensemble de règles de conversion, pour se conformer au typage d'un autre élément (la conversion entier flottant proposée par de nombreux langages, ...) 2. polymorphisme de surcharge (particulier) : un identificateur unique représente plusieurs élements du programme (la surcharge de méthodes en C++ ou Java, ...). 3. polymorphisme d'union (particulier) : un typage représente plusieurs typages distincts (unions en C, types somme en ML, ...) 4. polymorphisme d'inclusion (universel) : hiérarchie de compatibilité entre typages ; possibilité de définir un élément de typage compatible avec le typage de déclaration (présent à travers le mécanisme d'héritage dans la plupart des langage à objets : C++, Java, ... ) 5. polymorphisme paramétrique (universel) : utilisation de variables de typage. Ce polymorphisme peut être implicite (génération des variables de typage en ML) ou explicite lorsque le typage est déclaré (C++, Java, Ada, ...) ; ce polymorphisme est parfois contraint (foncteurs en ML, généricité contrainte en Eiffel, GJ, une évolution de Java, ...) ou non-contraint (C++, ...).
-- Arnaud ARZUFFI
Zouplaz wrote:
Bonjour, si j'ai une classe définie comme suit :
class toto
{
public:
void maFonction1(string nom);
void maFonction1(int valeur);
};
Comment appelle-t-on le mécanisme qui permet à plusieurs fonctions de
disposer de différents paramètres tout en ayant le même nom.
Il y a très très longtemps j'avais cru lire qu'on appellait ça
polymorphisme. Or, je sais depuis que le polymorphisme c'est tout à fait
autre chose, suite d'ailleurs à de nombreuses discussions ici même (cf ici
http://www.alaide.com/dico.php?q=polymorphisme).
Alors qu'est-ce donc ? Quel terme utiliser ?
Quelqu'un peut m'éclairer ?
Merci
Réponse à la question : surcharge de méthode.
Discussion sur le polymorphisme (à cause de la définition proposée, qui est
vraiment incomplète, voire fausse) :
Le polymorphisme est "la capacité d'un composant de programme à admettre
plusieurs typages distincts", et pas un mécanisme particulier.
Un polymorphisme est appelé universel lorsqu'un élément accepte un ensemble
non borné de typages distincts et particulier dans la situation contraire
(un élément accepte un ensemble borné de typages distincts).
Quelques exemples de polymorphismes (je laisse à d'autres effectuer une
taxonomie complète, je suis pas spécialiste du domaine) :
1. polymorphisme de coercition (particulier) : le typage d'un élément est
transformable, grâce à un ensemble de règles de conversion, pour se
conformer au typage d'un autre élément (la conversion entier flottant
proposée par de nombreux langages, ...)
2. polymorphisme de surcharge (particulier) : un identificateur unique
représente plusieurs élements du programme (la surcharge de méthodes en C++
ou Java, ...).
3. polymorphisme d'union (particulier) : un typage représente plusieurs
typages distincts (unions en C, types somme en ML, ...)
4. polymorphisme d'inclusion (universel) : hiérarchie de compatibilité entre
typages ; possibilité de définir un élément de typage compatible avec le
typage de déclaration (présent à travers le mécanisme d'héritage dans la
plupart des langage à objets : C++, Java, ... )
5. polymorphisme paramétrique (universel) : utilisation de variables de
typage. Ce polymorphisme peut être implicite (génération des variables de
typage en ML) ou explicite lorsque le typage est déclaré (C++, Java,
Ada, ...) ; ce polymorphisme est parfois contraint (foncteurs en ML,
généricité contrainte en Eiffel, GJ, une évolution de Java, ...) ou
non-contraint (C++, ...).
class toto { public: void maFonction1(string nom); void maFonction1(int valeur); };
Comment appelle-t-on le mécanisme qui permet à plusieurs fonctions de disposer de différents paramètres tout en ayant le même nom.
Il y a très très longtemps j'avais cru lire qu'on appellait ça polymorphisme. Or, je sais depuis que le polymorphisme c'est tout à fait autre chose, suite d'ailleurs à de nombreuses discussions ici même (cf ici http://www.alaide.com/dico.php?q=polymorphisme).
Alors qu'est-ce donc ? Quel terme utiliser ?
Quelqu'un peut m'éclairer ?
Merci
Réponse à la question : surcharge de méthode.
Discussion sur le polymorphisme (à cause de la définition proposée, qui est vraiment incomplète, voire fausse) :
Le polymorphisme est "la capacité d'un composant de programme à admettre plusieurs typages distincts", et pas un mécanisme particulier. Un polymorphisme est appelé universel lorsqu'un élément accepte un ensemble non borné de typages distincts et particulier dans la situation contraire (un élément accepte un ensemble borné de typages distincts).
Quelques exemples de polymorphismes (je laisse à d'autres effectuer une taxonomie complète, je suis pas spécialiste du domaine) :
1. polymorphisme de coercition (particulier) : le typage d'un élément est transformable, grâce à un ensemble de règles de conversion, pour se conformer au typage d'un autre élément (la conversion entier flottant proposée par de nombreux langages, ...) 2. polymorphisme de surcharge (particulier) : un identificateur unique représente plusieurs élements du programme (la surcharge de méthodes en C++ ou Java, ...). 3. polymorphisme d'union (particulier) : un typage représente plusieurs typages distincts (unions en C, types somme en ML, ...) 4. polymorphisme d'inclusion (universel) : hiérarchie de compatibilité entre typages ; possibilité de définir un élément de typage compatible avec le typage de déclaration (présent à travers le mécanisme d'héritage dans la plupart des langage à objets : C++, Java, ... ) 5. polymorphisme paramétrique (universel) : utilisation de variables de typage. Ce polymorphisme peut être implicite (génération des variables de typage en ML) ou explicite lorsque le typage est déclaré (C++, Java, Ada, ...) ; ce polymorphisme est parfois contraint (foncteurs en ML, généricité contrainte en Eiffel, GJ, une évolution de Java, ...) ou non-contraint (C++, ...).
