[C++] Grundkonzepte und Verwendungsszenarien von Zitaten

---

Vorwort

In diesem Artikel wird eine neue Syntaxreferenz vorgestellt , die von C++ im Vergleich zur C-Sprache eingeführt wurde . –Der Artikel beginnt hauptsächlich mitKonzept des Zitierens、Zitieren Sie NutzungsszenarienUnd die Unterschiede zwischen Referenzen und Zeigern werden in drei Aspekten vorgestellt.

---

1. Was ist ein Zitat?

Zitat So wie wir unseren Freunden Spitznamen geben, ist Zhang San sein richtiger Name und Goudan ist der Spitzname, der ihm gegeben wurde. Wenn wir Zhang San oder Goudan anrufen, wird diese Person antworten, und das Gleiche gilt für Zitate.
Eine Referenz definiert keine neue Variable, sondern gibt einer vorhandenen Variablen einen Alias. Der Compiler weist der Referenzvariablen keinen Speicherplatz zu. Sie teilt sich denselben Speicherplatz mit der Variablen, auf die sie verweist.
Syntax: Typ- und Referenzvariablenname (Alias ​​für Entitätsnamen) = Entitätsname

#include <iostream>
using namespace std;
int main()
{
    
    
	int a = 0;
	//b成为了a的别名，对b的赋值，加减等各种运算也会对a进行相应的改变
	int& b = a;
	//输出a和b两个变量的地址，可以看到是相同的，说明两个变量共用一块空间
	cout << &b << endl;
	cout << &a << endl;
	return 0;
}

Beachten! Der Referenztyp muss vom gleichen Typ sein wie die referenzierte Entität

---

2. Merkmale von Zitaten

1. Die Referenz muss initialisiert werden

#include <iostream>
using namespace std;
int main()
{
    
    
	int a = 0;
	//int& b;此处编译器会报错，引用必须初始化
	int& b = a;
	return 0;
}

2. Sobald sich eine Referenz auf eine Entität bezieht, kann sie nicht auf andere Entitäten verweisen.

Anfänger denken oft, dass der folgende Code eine Umleitung von b zum Verweis auf c implementiert, tatsächlich implementiert er jedoch nur eine Kopierfunktion

#include <iostream>
using namespace std;
int main()
{
    
    
	int a = 0;
	int c = 1;
	int& b = a;
	b = c;//把c的值赋给了b
	return 0;
}

3. Eine Entität kann mehrere Referenzen haben

#include <iostream>
using namespace std;
int main()
{
    
    
	int a = 0;
	//b和m都是a的引用
	int& b = a;
	int& m = a;
	return 0;
}

4. Konstante Referenz

#include <iostream>
using namespace std;
int main()
{
    
    
	const int a = 10;
	//这条语句会报错是因为，a为常量
	//当我们用非常量类型的b去作为a的引用，则a的内容可能会因为b的改变而被修改
	//为了避免这样的情况发生，我们必须用同为常量的类型作为a的引用
	//int& b = a;

	const int& b = a;
	return 0;
}

---

3. Referenznutzungsszenarien

1. Parameter erstellen

//这样就可以不使用指针而实现两个数的交换
void Swap(int& a, int& b)
{
    
    
	int tem = a;
	a = b;
	b = tem;
}

2. Legen Sie den Rückgabewert fest

//这样就返回了静态变量c的引用
int& test()
{
    
    
	static int c = 5;
	c++;
	return c;
}

Beachten! Wenn eine Variable den Gültigkeitsbereich verlässt und zerstört wird, kann ihre Referenz nicht zurückgegeben werden, wie unten gezeigt

int& test()
{
    
    
	int c = 5;//c出了函数会被销毁，所以不能返回它的引用
	c++;
	return c;
}

4. Der Unterschied zwischen Referenzen und Zeigern

1. Grammatische Ebene

Ein Zeiger öffnet einen Speicherplatz zum Speichern der Adresse der Variablen, auf die gezeigt wird.
Eine Referenz ist ein Alias, sie hat kein unabhängiges Leerzeichen und das Subjekt der Referenz teilt sich ein Leerzeichen.
Aus dem folgenden Code ist ersichtlich, dass sich die Adressen von Referenzvariablen und Entitäten ein Leerzeichen teilen

#include <iostream>
using namespace std;
int main()
{
    
    
	int a = 4.0;
	int& b = a;
	cout << "&a = " << &a << endl;
	cout << "&b = " << &b << endl;
	return 0;
}

2. Grundlegende Implementierung

In der zugrunde liegenden Implementierung werden Referenzen tatsächlich in Form von Zeigern implementiert.
Übersetzen Sie den folgenden Code in Assembler-Code, um zu sehen, dass Zeiger und Referenzen unter der Haube auf die gleiche Weise implementiert werden.

#include <iostream>
using namespace std;
int main()
{
    
    
	int a = 4;
	int& b = a;
	b = 10;

	int* pa = &a;
	*pa = 10;
	return 0;
}

3. Andere Unterschiede

1. Referenz definiert konzeptionell einen Alias ​​einer Variablen, und ein Zeiger speichert eine Variablenadresse.
2. Referenzen müssen bei der Definition initialisiert werden und es gibt keine Anforderungen für Zeiger.
3. Nachdem eine Referenz während der Initialisierung auf eine Entität verwiesen hat, kann sie nicht auf andere Entitäten verweisen, und ein Zeiger kann jederzeit auf
eine beliebige Entität desselben Typs verweisen.
4. Die Bedeutung von sizeof ist unterschiedlich: Das Referenzergebnis ist die Größe des Referenztyps, der Zeiger ist jedoch immer die Anzahl der vom Adressraum belegten Bytes.
6. Die Referenz wird inkrementiert, das heißt, die referenzierte Entität wird um 1 erhöht, und der Zeiger wird inkrementiert, das heißt, der Zeiger wird um die Größe des Typs nach hinten versetzt.
7. Es gibt mehrstufige Zeiger, aber keine mehrstufigen Referenzen.
8. Der Zugriff auf Entitäten ist unterschiedlich: Der Zeiger muss explizit dereferenziert werden, und der Referenz-Compiler verarbeitet ihn selbst.
9. Referenzen sind relativ sicherer zu verwenden als Zeiger.

---

Zusammenfassen

In diesem Artikel werden die grundlegenden Konzepte, Merkmale und Verwendungsszenarien von Referenzen sowie die Unterschiede zwischen Zeigern und Referenzen vorgestellt. Ich hoffe, dieser Artikel wird Ihnen hilfreich sein.