Il le sait à cause des modèles et des formats.
Le programme / la fonction / l'ordinateur ne sait pas vraiment où se trouve quoi que ce soit. Il s'attend juste à ce que quelque chose soit à un certain endroit. Prenons un exemple.
class simpleClass{
public:
int varA=58;
int varB=73;
simpleClass* nextObject=NULL;
};
Notre nouvelle classe «simpleClass» contient 3 variables importantes - deux entiers qui peuvent contenir des données lorsque nous en avons besoin et un pointeur vers un autre «objet simpleClass». Supposons que nous soyons sur une machine 32 bits pour des raisons de simplicité. 'gcc' ou un autre compilateur 'C' ferait un modèle avec lequel nous pourrions allouer des données.
Types simples
Premièrement, quand on utilise un mot-clé pour un type simple comme 'int', une note est faite par le compilateur dans la section '.data' ou '.bss' du fichier exécutable de sorte que quand il est exécuté par le système d'exploitation, les données sont disponible au programme. Le mot clé 'int' allouerait 4 octets (32 bits), tandis qu'un 'long int' allouerait 8 octets (64 bits).
Parfois, de manière cellule par cellule, une variable peut apparaître juste après l'instruction qui est censée la charger en mémoire, elle ressemblerait donc à ceci dans un pseudo-assemblage:
...
clear register EAX
clear register EBX
load the immediate (next) value into EAX
5
copy the value in register EAX to register EBX
...
Cela se terminerait par la valeur «5» dans EAX et EBX.
Pendant que le programme s'exécute, chaque instruction est exécutée, à l'exception du «5», car la charge immédiate y fait référence et oblige la CPU à la sauter.
L'inconvénient de cette méthode est qu'elle n'est vraiment pratique que pour les constantes, car il serait peu pratique de conserver les tableaux / tampons / chaînes au milieu de votre code. Donc, généralement, la plupart des variables sont conservées dans les en-têtes de programme.
Si l'on avait besoin d'accéder à l'une de ces variables dynamiques, alors on pourrait traiter la valeur immédiate comme s'il s'agissait d'un pointeur:
...
clear register EAX
clear register EBX
load the immediate value into EAX
0x0AF2CE66 (Let's say this is the address of a cell containing '5')
load the value pointed to by EAX into EBX
...
Cela se terminerait par la valeur «0x0AF2CE66» dans le registre EAX et la valeur de «5» dans le registre EBX. On peut également ajouter des valeurs dans les registres ensemble, afin que nous puissions trouver des éléments d'un tableau ou d'une chaîne en utilisant cette méthode.
Un autre point important est que l'on peut stocker des valeurs lors de l'utilisation d'adresses d'une manière similaire, afin que l'on puisse référencer les valeurs à ces cellules plus tard.
Types complexes
Si nous faisons deux objets de cette classe:
simpleClass newObjA;
simpleClass newObjB;
alors nous pouvons assigner un pointeur au deuxième objet au champ disponible pour lui dans le premier objet:
newObjA.nextObject=&newObjB;
Maintenant, le programme peut s'attendre à trouver l'adresse du deuxième objet dans le champ de pointeur du premier objet. En mémoire, cela ressemblerait à quelque chose comme:
newObjA: 58
73
&newObjB
...
newObjB: 58
73
NULL
Un fait très important à noter ici est que «newObjA» et «newObjB» n'ont pas de noms lorsqu'ils sont compilés. Ce ne sont que des endroits où nous attendons des données. Donc, si nous ajoutons 2 cellules à & newObjA, nous trouvons la cellule qui agit comme «nextObject». Par conséquent, si nous connaissons l'adresse de 'newObjA' et où la cellule 'nextObject' lui est relative, alors nous pouvons connaître l'adresse de 'newObjB':
...
load the immediate value into EAX
&newObjA
add the immediate value to EAX
2
load the value in EAX into EBX
Cela se terminerait par «2 + & newObjA» dans «EAX» et «& newObjB» dans «EBX».
Modèles / Formats
Lorsque le compilateur compile la définition de classe, il s'agit vraiment de compiler un moyen de créer un format, un moyen d'écrire dans un format et un moyen de lire à partir d'un format.
L'exemple donné ci-dessus est un modèle pour une liste à liaison unique avec deux variables «int». Ces types de constructions sont très importants pour l'allocation dynamique de mémoire, ainsi que les arbres binaires et n-aires. Les applications pratiques des arbres n-aires seraient des systèmes de fichiers composés de répertoires pointant vers des fichiers, des répertoires ou d'autres instances reconnues par les pilotes / le système d'exploitation.
Pour accéder à tous les éléments, pensez à une chenille qui monte et descend dans la structure. De cette façon, le programme / la fonction / l'ordinateur ne sait rien, il exécute simplement les instructions pour déplacer les données.