Quelle est la différence entre la distribution dynamique et la fin de la liaison en C++?

La liaison tardive est l'appel d'une méthode par nom lors de l'exécution.
Vous n'avez pas vraiment ce en c++, sauf pour l'importation de méthodes à partir d'une DLL.

Un exemple de cela pourrait être: GetProcAddress()

Avec répartition dynamique, le compilateur a suffisamment d'informations pour appeler la bonne mise en œuvre de la méthode. Ceci est habituellement fait par la création d'un table virtuelle.

En C++, les deux sont les mêmes.

En C++, il existe deux types de liaison:

• statique de la liaison qui se fait au moment de la compilation.
• de liaison dynamique — ce qui est fait au moment de l'exécution.

De liaison dynamique, puisqu'il est fait au moment de l'exécution, est aussi appelé la liaison tardive et statique de la liaison est parfois appelé comme la liaison anticipée.

Dynamiques à l'aide de liaison, C++ prend en charge l'exécution de polymorphisme à travers virtuel fonctions (ou pointeurs de fonction), et à l'aide de statique de liaison, tous les autres des appels de fonctions sont résolus.

Laissez-moi vous donner un exemple des différences parce qu'ils ne sont PAS les mêmes. Oui, répartition dynamique vous permet de choisir la méthode appropriée lorsque vous faites référence à un objet par une super-classe, mais que la magie est très spécifique à cette hiérarchie de classe, et que vous avez à faire certaines déclarations dans la classe de base pour le faire fonctionner (méthodes abstraites remplir les vtables depuis que l'indice de la méthode dans le tableau cant changement entre les types spécifiques). Ainsi, vous pouvez appeler des méthodes dans Tabby et le Lion et le Tigre tous par un générique Chat pointeur et même avoir des tableaux de Chats rempli avec les Lions et les Tigres et les Tabbys. Il sait ce qu' index ces méthodes font référence à l'objet qui est vtable au moment de la compilation (statique/liaison précoce), même si la méthode est sélectionné au moment de l'exécution (dynamique de l'expédition).

Maintenant, permet de mettre en œuvre un tableau qui contient des Lions et des Tigres et des Ours! ((Oh Mon Dieu!)). En supposant que nous n'avons pas une classe de base appelée Animal, en C++, vous allez avoir beaucoup de travail à faire parce que le compilateur ne va pas vous permettre de faire toute la distribution dynamique sans une classe de base commune. Les indices pour les vtables besoin de faire correspondre, et qui ne peut être fait entre unreleated classes. Vous auriez besoin d'avoir une vtable assez grand pour contenir les méthodes virtuelles de toutes les classes dans le système. Les programmeurs C++ est rare de voir cela comme une limitation, car vous avez été formé à penser d'une certaine manière au sujet de la conception des classes. Je ne dis pas que son meilleur ou pour le pire.

Avec la liaison tardive, au moment de l'exécution prend en charge ce sans une classe de base commune. Il y a normalement une table de hachage utilisé pour trouver des méthodes dans les classes avec un système de cache utilisé dans le répartiteur. Où en C++, le compilateur sait tous les types. Dans une fin liée à la langue, les objets eux-mêmes connaître leur type (ce n'est pas sans type, les objets eux-mêmes savent exactement qui ils sont dans la plupart des cas). Cela signifie que je peux avoir des tableaux de plusieurs types d'objets si je veux (Lions et des Tigres et des Ours). Et vous pouvez mettre en œuvre le transfert de messages et de prototypage (permet de comportements à être changé par objet sans changer la classe) et toutes sortes d'autres choses d'une manière beaucoup plus souple et le plomb à moins de code de frais généraux que dans les langues qui ne prennent pas en charge la liaison tardive.

Jamais programme Android et utiliser findViewById()? Vous avez presque toujours en fin de coulée, le résultat à obtenir le bon type, et le casting est essentiellement mentir pour le compilateur et de renoncer à tous les types statiques-la vérification de la bonté qui est censé prendre des langages statiques supérieur. Bien sûr, vous pourriez avoir findTextViewById(), findEditTextById(), et un million d'autres, de sorte que votre retour types de match, mais qui est en train de jeter le polymorphisme de la fenêtre; sans doute l'ensemble de la base de la programmation orientée objet. Un retard lié à la langue serait probablement vous permettre tout simplement de l'indice par un ID, et la traiter comme une table de hachage et de ne pas garde à ce que le type était en cours d'indexation, ni retournés.

Voici un autre exemple. Disons que vous avez votre Lion classe et de son comportement par défaut est de vous manger quand vous le voyez. En C++, si vous voulez avoir un seul "formés" le lion, vous devez faire une nouvelle sous-classe. Prototypage vous permet de modifier simplement l'une ou les deux méthodes de Lion qui a besoin d'être changé. C'est la classe et le genre ne changent pas. C++ ne peut pas le faire. Ceci est important car lorsque vous avez un nouveau "AfricanSpottedLion" qui hérite de Lion, vous pouvez vous entraîner aussi. Le prototypage ne change pas la structure de classe de sorte qu'il peut être étendu. Normalement, c'est la façon dont ces langues de traiter les questions qui exigent normalement l'héritage multiple, ou peut-être l'héritage multiple est la façon dont vous gérez un manque de prototypage.

Pour info, Objective-C est C avec SmallTalk du message en passant ajoutée et SmallTalk est à l'origine de la programmation orientée objet, et les deux sont en retard lié avec toutes les caractéristiques ci-dessus et plus. Tardive des langues peut être un peu plus lent à partir d'un micro-niveau point de vue, mais il peut souvent permettre le code structuré d'une manière qui est plus efficace au niveau macro-économique, et tout se résume à la préférence.

Répartition dynamique est ce qui arrive lorsque vous utilisez le virtual mot-clé en C++. Ainsi, par exemple:

struct Base
{
    virtual int method1() { return 1; }
    virtual int method2() { return 2; } //not overridden
};

struct Derived : public Base
{
    virtual int method1() { return 3; }
}

int main()
{
    Base* b = new Derived;
    std::cout << b->method1() << std::endl;
}

imprime 3, parce que la méthode a été dynamiquement distribué. La norme C++ est très prudent pas pour spécifier comment exactement ce qui se passe en coulisses, mais chaque compilateur sous le soleil est-il de la même manière. Ils créent un tableau de pointeurs de fonction pour chaque type polymorphe (appelé le table virtuelle ou vtable), et lorsque vous appelez une méthode virtuelle, la "vraie" méthode est recherchée dans la vtable, et cette version est appelée. De sorte que vous pouvez l'imagerie quelque chose comme ce pseudo-code:

struct BaseVTable
{
    int (*_method1) () = &Base::method1; //real function address
    int (*_method2) () = &Base::method2;
};

struct DerivedVTable
{  
    int (*method) () = &Derived::method1;
    int (*method2) () = &Base::method2; //not overridden
};

De cette façon, le compilateur peut être sûr que d'une méthode avec une signature existe au moment de la compilation. Cependant, au moment de l'exécution, l'appel peut être envoyé par la vtable à une fonction différente. Les appels à des fonctions virtuelles sont un tout petit peu plus lent que les non-virtuel les appels, en raison de la supplémentaire d'indirection étape.

D'autre part, ma compréhension du terme la liaison tardive est que le pointeur de fonction est regardé par nom au moment de l'exécution, à partir d'une table de hachage ou quelque chose de similaire. C'est la façon dont les choses sont faites en Python, JavaScript et (si ma mémoire est bonne) Objective-C. Cela permet d'ajouter de nouvelles méthodes à une classe au moment de l'exécution, qui ne peuvent pas directement être fait en C++. Ceci est particulièrement utile pour la mise en œuvre de choses comme mixin. Cependant, l'inconvénient est que le temps d'exécution de recherche est généralement nettement plus lent que même un appel virtuel en C++, et le compilateur n'est pas en mesure d'effectuer tout type de compilation vérification pour le nouvellement ajouté méthodes.

Ce question pourrait vous aider.

Répartition dynamique se réfère généralement à la répartition multiple.

Considérons l'exemple ci-dessous. J'espère que ça peut vous aider.

    class Base2;
    class Derived2; //Derived2 class is child of Base2
class Base1 {
    public:
        virtual void function1 (Base2 *);
        virtual void function1 (Derived2 *);
}

class Derived1: public Base1 {
    public:
    //override.
    virtual void function1(Base2 *);
    virtual void function1(Derived2 *);
};

Prenons le cas de la ci-dessous.

Derived1 * d = new Derived1;
Base2 * b = new Derived2;

//Now which function1 will be called.
d->function1(b);

Il va appeler function1 prendre Base2* pas Derived2*. Cela est dû au manque de dynamique de la répartition multiple.

La liaison tardive est l'un des mécanisme de mise en œuvre dynamique unique de l'expédition.