Die Bedeutung von C++-Referenzen und die Art von Referenzen

1. Die Bedeutung von Referenz

Referenz existiert als 变量别名, daher kann sie in manchen Fällen den Zeiger ersetzen und ist besser lesbar und praktischer als der Zeiger

// 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;
}

Hinweis:

Die Referenzparameter in der Funktion müssen nicht initialisiert werden. Die Initialisierung ist abgeschlossen, wenn

2 aufgerufen wird. Spezielle Referenzen können

deklariert werden Die const引用-Referenz in C++ lautet wie folgt:

const Type& name = var;

const-Referenz ermöglicht es der Variablen, ein schreibgeschütztes Attribut für den aktuellen Alias, die Variable, zu haben auf andere Weise geändert werden

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);

Wenn eine Konstante zum Initialisieren einer const-Referenz verwendet wird, weist der C++-Compiler Platz für den Konstantenwert zu und verwendet den Referenznamen als Alias ​​für diesen Platz

#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;
}

Schlussfolgerung: constDie Verwendung einer Konstante zum Initialisieren der

-Referenz erzeugt eine schreibgeschützte Variable

constFrage: Verfügt die Referenz über einen eigenen Speicherplatz?

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

Verifizierungsprogramm:

#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. Die Art der Referenz

Die interne Implementierung der Referenz in C++ ist eine

指针常量

Hinweis:

1. Der C++-Compiler verwendet Zeigerkonstanten als interne Implementierung von Referenzen während des Kompilierungsprozesses, daher ist der von Referenzen belegte Platz derselbe wie der von Zeigern

2 Aus Sicht der Verwendung ist die Referenz nur ein Alias, und C++ verbirgt die Details des referenzierten Speicherplatzes aus Gründen der Benutzerfreundlichkeit.

#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;
}

Bedeutung der Referenz:

Referenzen in C++ sollen in den meisten Fällen Zeiger ersetzen

Funktionalität: Kann erfüllt werden die meisten Situationen, in denen Zeiger verwendet werden müssen

• Sicherheit: Kann Speicherfehler vermeiden, die durch unsachgemäße Zeigerbedienung verursacht werden

• Vorgänge: Einfach und benutzerfreundlich , aber dennoch leistungsstark.

Referenzen können in den meisten Fällen Speicherfehler vermeiden, und Funktionen geben lokale Variablen zurück. Es gibt keine Möglichkeit, die Referenz zu vermeiden 但是

#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. Zusammenfassung

Referenzen existieren als Variablenaliase und sollen Zeiger ersetzen

Referenzen können dazu führen, dass Variablen schreibgeschützte Attribute haben

Referenzen sind implementiert mithilfe von Zeigerkonstanten im Compilerconst

Das ultimative Wesen von Referenzen sind Zeiger

Referenzen können Speicherfehler so weit wie möglich vermeiden

Verwandter Artikel:

Eine Falle von Schleifen und Referenzen in PHP, PHP-Zirkelverweise

Verwendung von doppelten Anführungszeichen in PHP Der Unterschied zwischen einfachen Anführungszeichen und doppelten Anführungszeichen

Das obige ist der detaillierte Inhalt vonDie Bedeutung von C++-Referenzen und die Art von Referenzen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!