La signification des références C++ et la nature des références

1. La signification de la référence

La référence existe sous la forme 变量别名, elle peut donc remplacer le pointeur dans certaines occasions. La référence a une meilleure lisibilité et praticité que le pointeur

// swap函数的实现对比
void swap(int& a, int& b)
{
    int t = a;
    a = b;
    b = t;
}

void swap(int* a, int* b)
{
    int t = *a;
    *a = *b;
    *b = t;
}

Remarque :

Les paramètres de référence dans la fonction n'ont pas besoin d'être initialisés. L'initialisation est terminée lors de l'appel de

2 Références spéciales

const引用

. peut déclarer une référence const en C++. L'utilisation spécifique est la suivante : la référence

const Type& name = var;

const permet à la variable d'avoir un attribut en lecture seule. Cet attribut en lecture seule est pour le This actuel. l'alias et la variable peuvent être modifiés d'autres manières

int a = 4;              // a是一个变量
const int  & b = a;     // b是a的一个引用，但是b具有只读属性
int * p = (int *)&b;    // p = &a
b = 5;     // err, 引用b 被const修饰，b是一个只读变量
a = 6;     // ok
printf("a = %d\n", a);
*p = 5;    // ok
printf("a = %d\n", a);

Lorsqu'une constante est utilisée pour initialiser la référence const, le compilateur C++ allouera de l'espace pour la valeur constante et utilisera le nom de référence comme cet espace Alias ​​de

#include <stdio.h>
void Example()
{
    printf("Example:\n");  
    int a = 4;
    const int& b = a;
    int* p = (int*)&b;  
    //b = 5;    // b  
    *p = 5;   
    printf("a = %d\n", a);
    printf("b = %d\n", b);
}

void Demo()
{
    printf("Demo:\n");  
    const int& c = 1;
    int* p = (int*)&c;   
    //c = 5;
    *p = 5;
    printf("c = %d\n", c);
}

int main(int argc, char *argv[])
{
    Example(); 
    printf("\n");  
    Demo();
    
    return 0;
}

Conclusion :

Utiliser une constante pour initialiser la const référence produira une variable en lecture seule

Question : La référence a-t-elle son propre espace de stockage ?

struct TRef
{
    char& r;
}
printf("sizeof(TRef) = %d\n, sizeof(TRef));

Procédure de vérification :

#include <stdio.h>

struct TRef
{
    char& r;        // 字符类型引用
};

int main(int argc, char *argv[])
{ 
    char c = &#39;c&#39;;
    char & rc = c;
    TRef ref = { c }; // 用C进行初始化, TRef.r 就是 c的别名了
    
    printf("sizeof(char&) = %d\n", sizeof(char&));     // char引用的大小，引用即变量本身，求所对应的变量本身的大小，即sizeof(char) = 1
    printf("sizeof(rc) = %d\n", sizeof(rc));        // rc是一个引用，即sizeof(c) = 1
    
    printf("sizeof(TRef) = %d\n", sizeof(TRef));    // sizeof(TRef) = 4
    printf("sizeof(ref.r) = %d\n", sizeof(ref.r));  // TRef.r是 c的别名，sizeof(c) = 1

    // sizeof(TRef) = 4
    // 指针变量本身也是占4个字节
    // 引用和指针的关系
    
    return 0;
}

3. La nature de la référence

L'implémentation interne de la référence en C++ est un 指针常量

Remarque :

1. Le compilateur C++ utilise des constantes de pointeur comme implémentation interne des références pendant le processus de compilation, donc l'espace occupé par les références est le même que celui des pointeurs

2. Du point de vue de l'utilisation, une référence n'est qu'un alias, et C++ masque les détails de l'espace de stockage de la référence pour des raisons de convivialité.

#include <stdio.h>

struct TRef
{
    char* before;     // 4字节
    char& ref;        // 4字节
    char* after;    // 4字节
};

int main(int argc, char* argv[])
{
    char a = &#39;a&#39;;
    char& b = a;
    char c = &#39;c&#39;;

    TRef r = {&a, b, &c};

    printf("sizeof(r) = %d\n", sizeof(r));    // sizeof(r) = 12
    printf("sizeof(r.before) = %d\n", sizeof(r.before)); // sizeof(r.before) = 4
    printf("sizeof(r.after) = %d\n", sizeof(r.after));   // sizeof(r.after) = 4
    printf("&r.before = %p\n", &r.before);    // &r.before = 0xbuf8a300c
    printf("&r.after = %p\n", &r.after);    // &r.after  = 0xbuf8a3014

    /*
     0xbuf8a3014 - 0xbuf8a300c = 8
     before占了4个字节，所以ref也是占4个字节
    */
    return 0;
}

Signification de la référence :

Les références en C++ sont destinées à remplacer les pointeurs dans la plupart des cas

• Fonctionnalité : Peut répondre à la plupart des occasions où des pointeurs doivent être utilisés

• Sécurité : peut éviter les erreurs de mémoire causées par un fonctionnement inapproprié du pointeur

• Opérabilité : simple et facile à utiliser, mais puissant.

但是

Les références peuvent éviter les erreurs de mémoire dans la plupart des cas, et les retours de fonction. Les références aux variables locales ne peuvent pas être évitées. 🎜>

#include <stdio.h>

int& demo()
{
    int d = 0;
    
    printf("demo: d = %d\n", d);
    
    return d;    // 实际上是返回了局部变量的地址，局部变量函数结束就销毁了，返回错误
}

int& func()
{
    static int s = 0;
    
    printf("func: s = %d\n", s);
    
    return s;    // 返回静态局部变量的地址，静态局部变量存储在全局区，函数结束生命周期还在，返回成功
}

int main(int argc, char* argv[])
{
    int& rd = demo();    // rd 成为demo里面返回的局部变量d的别名，出现警告，但是通过编译
    int& rs = func();    // rs 成为静态局部变量 s 的别名
    
    printf("\n");
    printf("main: rd = %d\n", rd);    // rd = 13209588,rd代表的是一个不存在的变量，现在是一个野指针
    printf("main: rs = %d\n", rs);    // rs = 0
    printf("\n");
    
    rd = 10;
    rs = 11;        // 通过rs改变了静态局部变量s的值
    
    demo();            // d = 10
    func();            // s = 11
    
    printf("\n");
    printf("main: rd = %d\n", rd);    // rd = 13209588
    printf("main: rs = %d\n", rs);    // rs = 11
    printf("\n");
    
    return 0;
}

4. Résumé

Les références existent sous forme d'alias de variable et sont destinées à remplacer les pointeurs

Les références peuvent faire en sorte que les variables n'aient qu'une référence d'attribut Read const

. est implémenté à l'aide de constantes de pointeur à l'intérieur du compilateur

L'essence ultime de la référence est un pointeur

La référence peut éviter autant que possible les erreurs de mémoire

Articles connexes :

Un piège des boucles et références PHP, références de boucles PHP

Utilisation de guillemets doubles, guillemets simples PHP et guillemets doubles Différence

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!