Quelle est la différence entre le polymorphisme et l'envoi multiple?

Question

... ou est-ce la même chose? Je remarque que chacun a sa propre entrée dans Wikipedia: Polymorphisme , Dispatch multiple , mais je ne parviens pas à comprendre en quoi les concepts diffèrent.

Modifier: Et comment Surcharger se trouve-t-il dans tout cela? ?

Answer 1

Le polymorphisme est la fonctionnalité qui permet à un langage / programme de prendre des décisions en cours d’exécution sur la méthode à appeler en fonction des types de paramètres envoyés à cette méthode.

Le nombre de paramètres utilisés par le langage / le runtime détermine le "type" de polymorphisme pris en charge par un langage.

La répartition unique est un type de polymorphisme dans lequel un seul paramètre est utilisé (le destinataire du message - this ou self) pour déterminer l'appel.

La répartition multiple est un type de polymorphisme dans lequel plusieurs paramètres sont utilisés pour déterminer la méthode à appeler. Dans ce cas, le récepteur ainsi que les types de paramètres de méthode sont utilisés pour indiquer la méthode à invoquer.

Vous pouvez donc dire que le polymorphisme est le terme général et que les envois multiples et uniques sont des types spécifiques de polymorphisme.

Addendum: la surcharge se produit pendant la compilation. Il utilise les informations de type disponibles lors de la compilation pour déterminer le type de méthode à appeler. La répartition unique / multiple se produit pendant l'exécution.

Exemple de code:

using NUnit.Framework;

namespace SanityCheck.UnitTests.StackOverflow
{
    [TestFixture]
    public class DispatchTypes
    {
        [Test]
        public void Polymorphism()
        {
            Baz baz = new Baz();
            Foo foo = new Foo();

            // overloading - parameter type is known during compile time
            Assert.AreEqual("zap object", baz.Zap("hello"));
            Assert.AreEqual("zap foo", baz.Zap(foo));


            // virtual call - single dispatch. Baz is used.
            Zapper zapper = baz;
            Assert.AreEqual("zap object", zapper.Zap("hello"));
            Assert.AreEqual("zap foo", zapper.Zap(foo));


            // C# has doesn't support multiple dispatch so it doesn't
            // know that oFoo is actually of type Foo.
            //
            // In languages with multiple dispatch, the type of oFoo will 
            // also be used in runtime so Baz.Zap(Foo) will be called
            // instead of Baz.Zap(object)
            object oFoo = foo;
            Assert.AreEqual("zap object", zapper.Zap(oFoo));
        }

        public class Zapper
        {
            public virtual string Zap(object o) { return "generic zapper" ; }
            public virtual string Zap(Foo f) { return "generic zapper"; }
        }

        public class Baz : Zapper
        {
            public override string Zap(object o) { return "zap object"; }
            public override string Zap(Foo f) { return "zap foo"; }
        }

        public class Foo { }
    }
}

Answer 2

Avec plusieurs envois, une méthode peut avoir plusieurs arguments qui lui sont passés et l'implémentation utilisée dépend du type de chaque argument. L'ordre dans lequel les types sont évalués dépend de la langue. Dans LISP, il vérifie chaque type du premier au dernier. Les langues à envoi multiple utilisent des fonctions génériques, qui ne sont que des déclarations de fonctions et ne ressemblent pas à des méthodes génériques, qui utilisent des paramètres de type.

Plusieurs envois permettent de sous-typer le polymorphisme des arguments d'appels de méthode .

La répartition unique permet également un type de polymorphisme plus limité (utiliser le même nom de méthode pour les objets qui implémentent la même interface ou héritent de la même classe de base). C'est l'exemple classique du polymorphisme, où vous avez des méthodes qui sont remplacées dans des sous-classes.

Au-delà de cela, les génériques fournissent un polymorphisme de type paramétrique (c’est-à-dire la même interface générique à utiliser avec différents types, même s’ils ne sont pas liés & # 8212; comme List<T>: it peut être une liste de n'importe quel type et est utilisée de la même manière quelle que soit).

Answer 3

Je n'ai jamais entendu parler de Multiple Dispatch auparavant, mais après avoir jeté un coup d'œil sur la page Wikipedia, il semble que MD est un type de polymorphisme, lorsqu'il est utilisé avec les arguments d'une méthode.

Le polymorphisme est essentiellement le concept selon lequel un objet peut être vu comme tout type de base. Donc, si vous avez un Car et un Truck, ils peuvent tous deux être vus comme un Vehicle. Cela signifie que vous pouvez appeler n'importe quelle void* méthode pour l'une ou l'autre.

La répartition multiple semble similaire, en ce sens qu'elle vous permet d'appeler des méthodes avec des arguments de plusieurs types, mais je ne vois pas certaines exigences dans la description. Premièrement, cela ne semble pas nécessiter un type de base commun (pas que je puisse imaginer implémenter QUE sans Start()) et plusieurs objets peuvent être impliqués.

Ainsi, au lieu d'appeler la méthode StartObject(Object C) sur chaque objet d'une liste (exemple classique de polymorphisme), vous pouvez appeler une méthode StartObject() définie ailleurs et la coder pour vérifier le type d'argument au moment de l'exécution et le gérer. c'est convenablement. La différence est que la méthode Car.Start(Key carKey) doit être intégrée à la classe, tandis que la méthode Missile.Start(int launchCode) peut être définie en dehors de la classe, de sorte que les divers objets ne doivent pas nécessairement être conformes à une interface.

Cela pourrait être utile si la méthode StartObject(theCar) devait être appelée avec des arguments différents. Peut-être StartObject(theMissile) contre <=>

Mais les deux peuvent s'appeler <=> ou <=>

Un concept intéressant ...

Answer 4

Le mode Dispatch multiple s'apparente davantage à une surcharge de fonctions (comme en Java / C ++), sauf que la fonction appelée dépend du type d'exécution des arguments, et non de leur type statique.

Answer 5

si vous voulez l'équivalent conceptuel d'une invocation de méthode

(obj_1, obj_2, ..., obj_n)->method

dépend de chaque type spécifique dans le tuple, vous souhaitez alors une répartition multiple. Le polymorphisme correspond au cas n = 1 et constitue une caractéristique nécessaire de la programmation orientée objet.

Answer 6

La répartition multiple est une sorte de polymorphisme. En Java / C # / C ++, il existe un polymorphisme par héritage et substitution, mais il ne s’agit pas d’une répartition multiple, qui repose sur deux arguments ou plus (pas seulement this, comme dans Java / C # / C ++)

Answer 7

La répartition multiple repose sur un polymorphisme. Le polymorphisme typique rencontré en C ++, C #, VB.NET, etc ... utilise une répartition unique - c’est-à-dire que la fonction appelée ne dépend que d’une seule instance de classe. La répartition multiple repose sur plusieurs instances de classe.