Comment les références sont-elles réellement implémentées en C ?

Implémentation de références dans les compilateurs et les configurations

Les références en C sont une fonctionnalité puissante qui permet un accès efficace à la mémoire au-delà de la portée d'une variable . Mais comment sont-ils réellement implémentés sous le capot ?

Recommandations standard et différences de mise en œuvre

La norme C n'exige pas une implémentation spécifique pour les références. Cependant, les compilateurs adhèrent généralement à certaines directives :

• Les références sont généralement implémentées sous forme de pointeurs vers l'objet référencé.
• Les références peuvent faire référence à des variables locales et globales.
• Les pointeurs et les références sont souvent interchangeables.

Exemple de programme et de compilateur Sortie

Pour démontrer l'implémentation interne des références, considérons le programme suivant :

#include <stdio.h>
#include <stdlib.h>

int byref(int &amp;foo) { printf("%d\n", foo); }
int byptr(int *foo) { printf("%d\n", *foo); }

int main() {
  int aFoo = 5;
  byref(aFoo);
  byptr(&amp;aFoo);
}

La compilation de ce programme avec LLVM et les optimisations désactivées produit un code assembleur identique pour byref et byptr fonctions :

define i32 @_Z5byrefRi(i32* %foo) {
  %foo_addr = alloca i32*                         ; <i32**> [#uses=2]
  %retval = alloca i32                            ; <i32*> [#uses=1]
  %"alloca point" = bitcast i32 0 to i32          ; <i32> [#uses=0]
  store i32* %foo, i32** %foo_addr
  %0 = load i32** %foo_addr, align 8              ; <i32*> [#uses=1]
  %1 = load i32* %0, align 4                      ; <i32> [#uses=1]
  %2 = call i32 (i8*, ...)* @printf(i8* noalias getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), i32 %1) ; <i32> [#uses=0]
  br label %return

return:                                           ; preds = %entry
  %retval1 = load i32* %retval                    ; <i32> [#uses=1]
  ret i32 %retval1
}

define i32 @_Z5byptrPi(i32* %foo) {
  %foo_addr = alloca i32*                         ; <i32**> [#uses=2]
  %retval = alloca i32                            ; <i32*> [#uses=1]
  %"alloca point" = bitcast i32 0 to i32          ; <i32> [#uses=0]
  store i32* %foo, i32** %foo_addr
  %0 = load i32** %foo_addr, align 8              ; <i32*> [#uses=1]
  %1 = load i32* %0, align 4                      ; <i32> [#uses=1]
  %2 = call i32 (i8*, ...)* @printf(i8* noalias getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), i32 %1) ; <i32> [#uses=0]
  br label %return

return:                                           ; preds = %entry
  %retval1 = load i32* %retval                    ; <i32> [#uses=1]
  ret i32 %retval1
}

Dans ce code assembleur, les deux fonctions utilisent des instructions identiques pour charger et déréférencer la variable d'entrée foo. Cela démontre que le compilateur traite les références et les pointeurs de la même manière sous le capot.

Conclusion

Les références et les pointeurs sont des concepts étroitement liés en C . Bien que la norme ne prescrive pas d'implémentation spécifique, les compilateurs implémentent généralement les références sous forme de pointeurs. Cela permet une utilisation efficace et interchangeable des références et des pointeurs pour accéder à la mémoire au-delà de la portée des variables.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!