Compréhension approfondie des détails de l'application de liaison dynamique et de liaison statique de C

Afin de prendre en charge le polymorphisme de c, la liaison dynamique et la liaison statique sont utilisées. Comprendre leurs différences peut vous aider à mieux comprendre le polymorphisme et à éviter de commettre des erreurs lors de la programmation.
Vous devez comprendre quatre noms :
1. Type d'objet statique : le type utilisé par l'objet lorsqu'il est déclaré. Il est déterminé au moment de la compilation.
2. Type d'objet dynamique : le type de l'objet actuellement pointé. Il est déterminé lors de l'exécution. Le type dynamique d'un objet peut être modifié, mais le type statique ne peut pas être modifié.
Concernant le type statique et le type dynamique des objets, regardez un exemple :

class B
{
}
class C : public B
{
}
class D : public B
{
}
D* pD = new D();//pD的静态类型是它声明的类型D*，动态类型也是D*
B* pB = pD;//pB的静态类型是它声明的类型B*，动态类型是pB所指向的对象pD的类型D*
C* pC = new C();
pB = pC;//pB的动态类型是可以更改的，现在它的动态类型是C*

3. Liaison statique : ce qui est lié est le type statique de l'objet. Une certaine fonctionnalité (comme un. fonction) dépend de l'objet. Le typage statique se produit au moment de la compilation.
4. Liaison dynamique : ce qui est lié est le type dynamique de l'objet. Une certaine fonctionnalité (comme une fonction) dépend du type dynamique de l'objet et se produit pendant l'exécution.

class B
{
    void DoSomething();
    virtual void vfun();
}
class C : public B
{
    void DoSomething();//首先说明一下，这个子类重新定义了父类的no-virtual函数，这是一个不好的设计，会导致名称遮掩；这里只是为了说明动态绑定和静态绑定才这样使用。
    virtual void vfun();
}
class D : public B
{
    void DoSomething();
    virtual void vfun();
}
D* pD = new D();
B* pB = pD;

Jetons un coup d'oeil, est-ce que pD->DoSomething() et pB->DoSomething() appellent la même fonction ?
Non, bien que pD et pB pointent tous deux vers le même objet. Étant donné que la fonction DoSomething est une fonction non virtuelle, elle est liée statiquement, c'est-à-dire que le compilateur sélectionnera la fonction en fonction du type statique de l'objet au moment de la compilation. Le type statique de pD est D*, donc le compilateur le pointera vers D::DoSomething() lors du traitement de pD->DoSomething(). De la même manière, le type statique de pB est B*, puis pB->DoSomething() appelle B::DoSomething().
Regardons à nouveau, est-ce que pD->vfun() et pB->vfun() appellent la même fonction ?
Oui. Étant donné que vfun est une fonction virtuelle, elle est liée dynamiquement, ce qui signifie qu'elle est liée au type dynamique de l'objet. Bien que pB et pD aient des types statiques différents, ils pointent vers un objet en même temps et leurs types dynamiques le sont. le même. est D*, donc ils appellent la même fonction : D::vfun().
Les éléments ci-dessus concernent tous les pointeurs d'objet, et il en va de même pour les références.
Les types dynamiques et statiques de pointeurs et de références peuvent être incohérents, mais les types dynamiques et statiques d'objets sont cohérents.
D D;
D.DoSomething() et D.vfun() appellent toujours D::DoSomething() et D::vfun().
Quant à ces choses qui sont liées dynamiquement et celles qui sont liées statiquement, il y a un article qui le résume très bien :
Je l'ai résumé en une phrase : seules les fonctions virtuelles utilisent la liaison dynamique, et tout le reste est liaison statique Certainement. Jusqu'à présent, je n'ai rien trouvé qui ne s'applique pas à cette phrase. S'il y a une erreur, j'espère que vous pourrez la signaler.
Quelque chose qui nécessite une attention particulière
Lorsque les paramètres par défaut et les fonctions virtuelles apparaissent ensemble, la situation est un peu compliquée et il est facile de faire des erreurs. Nous savons que les fonctions virtuelles sont liées dynamiquement, mais pour plus d'efficacité d'exécution, les paramètres par défaut sont liés statiquement.

class B
{
 virtual void vfun(int i = 10);
}
class D : public B
{
 virtual void vfun(int i = 20);
}
D* pD = new D();
B* pB = pD;
pD->vfun();
pB->vfun();

D'après l'analyse ci-dessus, on peut voir que les appels pD->vfun() et pB->vfun() sont tous deux des fonctions D::vfun(), mais quels sont leurs paramètres par défaut ?
Analyse, les paramètres par défaut sont liés statiquement. Lorsque pD->vfun(), le type statique de pD est D*, donc son paramètre par défaut doit être 20 de la même manière, pB->vfun Le paramètre par défaut pour ( ) devrait être 10. J'ai écrit le code et je l'ai vérifié, et il est correct.
Je suppose que personne n’aimera cette fonctionnalité. Alors, rappelez-vous toujours :
"Ne redéfinissez jamais la valeur des paramètres par défaut hérités de la fonction."
À propos du langage C
À l'heure actuelle, je travaille essentiellement dans le sous-ensemble "programmation orientée objet". Je ne sais pas grand-chose sur des connaissances plus complexes. Même ainsi, il y a déjà beaucoup de choses auxquelles il faut prêter attention lors de la programmation jusqu'à présent, et il se peut qu'il y en ait encore davantage à l'avenir. C'est peut-être la raison pour laquelle de nombreuses personnes s'opposent à c.

c est l'une des quatre langues officielles de Google. Cependant, Google a bel et bien lancé le langage go ces dernières années, et son positionnement est similaire à c/c. Compte tenu de cette situation, je pense qu'il se peut que les programmeurs de Google soient profondément conscients de la complexité de c, ils souhaitent donc développer un langage alternatif à c. Lorsque vous avez le temps, vous devriez en apprendre davantage sur le langage Go et voir comment il fait des choix sur des problèmes comme C.

Pour une compréhension plus approfondie de l'application de la liaison dynamique et de la liaison statique en C, veuillez prêter attention au site Web PHP chinois pour les articles connexes !