Qu'est-ce que le détournement de nom, et comment cela fonctionne-t-il ?

Question

Veuillez expliquer ce qu'est le name mangling, comment il fonctionne, quel problème il résout, et dans quels contextes et langues il est utilisé. Les stratégies de "name mangling" (par exemple, quel nom est choisi par le compilateur et pourquoi) sont un plus.

Answer 1

Dans le langage de programmation de votre choix, si un identificateur est exporté à partir d'une unité compilée séparément, il a besoin d'un nom par lequel il sera connu au moment de la liaison. Manipulation des noms résout le problème des identificateurs surchargés dans les langages de programmation. (Un identifiant est "surchargé" si le même nom est utilisé dans plus d'un contexte ou avec plus d'une signification).

Quelques exemples :

• En C++, la fonction ou la méthode get peut être surchargé à plusieurs types.

• En Ada ou Modula-3, la fonction get peut apparaître dans plusieurs modules.

De multiples types et de multiples modules couvrent les contextes habituels.

Stratégies typiques :

• Mettez en correspondance chaque type avec une chaîne et utilisez la combinaison de l'identifiant de haut niveau et de la "chaîne de type" comme nom de lien. Courant en C++ (particulièrement facile puisque la surcharge n'est autorisée que pour les fonctions/méthodes et uniquement sur les types d'arguments) et en Ada (où vous pouvez également surcharger les types de résultats).

• Si un identifiant est utilisé dans plusieurs modules ou espaces de noms, joignez le nom du module au nom de l'identifiant, par ex, List_get au lieu de List.get .

En fonction des caractères autorisés dans les noms de liens, vous devrez peut-être effectuer une manipulation supplémentaire ; par exemple, il peut être nécessaire d'utiliser le trait de soulignement comme caractère d'échappement, afin de pouvoir distinguer

• List_my.get -> List__my_get

de

• List.my_get -> List_my__get

(Certes, cet exemple est tendu, mais en tant qu'auteur de compilateur, je dois garantir que des identifiants distincts dans le code source correspondent à des noms distincts au moment de la liaison. . C'est la raison et le but de la confusion des noms).

Answer 2

En termes simples, le mélange de noms est un processus par lequel les compilateurs modifient les noms des identificateurs dans votre code source afin de faciliter le processus d'intégration des données. linker dans la désambiguïsation entre ces identifiants.

Wikipedia a un article merveilleux sur ce sujet avec plusieurs bons exemples.

Answer 3

Manipulation des noms est un moyen par lequel les compilateurs modifient le nom "compilé" d'un objet, pour le rendre différent de ce que vous avez spécifié de manière cohérente.

Cela permet à un langage de programmation de fournir le même nom à plusieurs objets compilés et de disposer d'un moyen cohérent de rechercher l'objet approprié. Par exemple, cela permet à plusieurs classes portant le même nom d'exister dans différents espaces de noms (souvent en ajoutant l'espace de noms au nom de la classe, etc.)

La surcharge des opérateurs et des méthodes dans de nombreux langages va encore plus loin : chaque méthode porte un nom "modifié" dans la bibliothèque compilée afin de permettre à plusieurs méthodes d'un même type d'exister avec le même nom.

Answer 4

En python, le mélange de noms est un système par lequel les variables de classe ont des noms différents à l'intérieur et à l'extérieur de la classe. Le programmeur l'"active" en mettant deux traits de soulignement au début du nom de la variable.

Par exemple, je peux définir une classe simple avec quelques membres :

>>> class Foo(object):
...  def __init__(self):
...   self.x = 3
...   self._y = 4
...   self.__z = 5
... 

Dans la pratique python, un nom de variable commençant par un trait de soulignement est "interne" et ne fait pas partie de l'interface de la classe, et les programmeurs ne doivent donc pas s'y fier. Cependant, il est toujours visible :

>>> f = Foo()
>>> f.x
3
>>> f._y
4

Un nom de variable commençant par deux traits de soulignement est toujours public, mais il est mélangé au nom et donc plus difficile d'accès :

>>> f.__z  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Foo' object has no attribute '__z'

Cependant, si nous savons comment fonctionne la confusion des noms, nous pouvons l'aborder :

>>> f._Foo__z
5

c'est-à-dire que le nom de la classe est ajouté au nom de la variable avec un trait de soulignement supplémentaire.

Python n'a pas de concept de membres "privés" ou "publics" ; tout est public. Le mélange de noms est le signal le plus fort qu'un programmeur puisse envoyer pour indiquer que la variable ne doit pas être accessible depuis l'extérieur de la classe.

Answer 5

Source : http://sickprogrammersarea.blogspot.in/2014/03/technical-interview-questions-on-c_6.html

La gestion des noms est le processus utilisé par les compilateurs C++ pour donner un nom unique à chaque fonction de votre programme. En C++, les programmes ont généralement au moins quelques fonctions portant le même nom. La gestion des noms peut donc être considérée comme un aspect important du C++.

Exemple : En général, les noms des membres sont générés de manière unique en concaténant le nom du membre avec celui de la classe, par exemple dans la déclaration :

class Class1
 {
        public:
            int val;
            ...
  };

val devient quelque chose comme :

  // a possible member name mangling
     val__11Class1