Inhaltsverzeichnis
zitieren
1. Einleitung
Im Leben geben wir einigen Schülern auch Spitznamen. Nehmen wir zum Beispiel „Zhang Lei“, wir können ihn „Zhang Sanshi“ nennen. Wenn wir diesen Spitznamen nennen, denken wir natürlich an „Zhang Lei“, „Zhang Sanshi“. ist Zhang Leis Alias, und das Zitat kann auf diese einfache Weise verstanden werden: Auf grammatikalischer Ebene ist ein Zitat ein Alias .
Zweitens: Die problematischeren Operatoren in C++
* und & in C++ haben mehrere Bedeutungen und unter verschiedenen Nutzungsbedingungen unterschiedliche Bedeutungen:
*
int *p = &a; /1.指针
a = a * b; /2.乘法
*p = 100; /3.指向
&
int c = a&b; /1.位运算 转换为二进制
int *p = &a; /2.取地址
int a = 100;
int & ar = a; /3.引用
3. Referenzdefinition
Eine Referenz stellt keine neue Definition einer Variablen, sondern einen Alias für eine vorhandene Variable dar. Der Compiler öffnet keinen Speicherplatz für die Referenzvariable und teilt sich den gleichen Speicherplatz mit der referenzierten Variablen.
Das Format ist wie folgt :
Name der Typ- und Referenzvariablen (Objektname) = Referenzeinheit
Beachten Sie, dass das Leerzeichen hier optional ist, dh
- Vor und nach dem &-Symbol kann ein Leerzeichen wie folgt stehen: int & ra=a;
- Neben dem Typ steht das Symbol & wie folgt: int& ra=a;
- Das &-Symbol steht wie folgt neben dem Referenznamen: int &ra=a;
int main()
{
int a =100; \\定义变量名
int b = a;\\将a的值赋给变量
int &c = a;\\引用 将c作为a的别名 c11中成为左值引用
return 0;
}
Hier ist es gleichbedeutend mit einer Entität, die zwei Namen als a und c annimmt, und eröffnet keinen neuen Raum in diesem Raum.
4. Merkmale von Zitaten
- Muss beim Definieren einer Referenz initialisiert werden
- keine Nullreferenzen
- Es gibt kein sekundäres Zitat
- Eine Variable kann mehrere Referenzen haben (dies ist äquivalent zu einer Variablen mit mehreren Aliasen, was möglich ist)
Erklärung:
int main()
{
int a = 10;
int& b = a;
int& x;
int& y = NULL;
int&& c = a;
}
Kurz gesagt:
Die Referenz selbst ist eine Variable, aber diese Variable ist nur eine weitere Variable und ein Alias, sie belegt keinen Speicherplatz, sie ist kein Zeiger! Nur ein Pseudonym!
5. Vergleich von Zeigern und Referenzen
Nehmen wir die Swap-Funktion als Beispiel,
um zwei Integer-Werte mithilfe von Zeigern zu tauschen:
int my _swap (int*ap， int*bp)
{
assert(ap != NULL && bp != NULL);
int tmp = *ap;*ap = *bp;*bp = *ap;
}
int main()
{
int x = 10, y = 20;
my_swap{
&x，&y);
cout<< "x = " << x << " y = " << y << endl;
return 0;
}
Tauschen Sie zwei Zeiger mithilfe von Referenzen aus:
void my_swap (int& a，int& b)
{
int tmp = a;a = b;
b = tmp;
}
int main ()
{
int x = 10, y = 20;my_swap(x,y) ;
cout << " x = " << x<< " y = " << y << endl;
return 0;
}
Wenn der formale Parameter ein Zeiger ist: der erste Satz muss behauptet werden, und es muss beurteilt werden, ob er leer ist; und wenn wir Zeiger verwenden, müssen wir darauf achten: ob er leer istwilder Zeiger,Null Zeiger,Invalidierungszeiger.
Wenn wir Referenzen verwenden, gibt es keine NULL-Referenz, keine Notwendigkeit, null zu beurteilen, und es ist sicherer als Zeiger
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
所以：能不使用指针就尽量不要使用指针！
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
6. Der Unterschied zwischen Referenzen und Zeigern ( Hervorhebung )
1. Unterschiede auf grammatikalischer Ebene
- Aus grammatikalischer Sicht speichert eine Zeigervariable die Adresse einer Instanz (Variable oder Objekt),
eine Referenz ist ein Alias einer Instanz. - Das Programm weist Speicherbereiche für Pointer-Variablen zu, es weist keine Speicherbereiche für Referenzen zu.
int main()
{
int a = 10;
int* ip = &a;
int& b = a; \\b是a的别名 并没有分配新的空间
}
- Die Dereferenzierung besteht darin, vor der Verwendung des Zeigers ein "*" hinzuzufügen, die Referenz kann direkt verwendet werden.
int main()
{
int a = 10;
int* ip = &a;
int& b = a;
*ip = 100；//对于指针使用加“*”
b = 200； //引用不需要“*”
}
- Der Wert der Zeigervariablen kann geändert werden, um die Adressen verschiedener Instanzen zu speichern;
die Referenz wird initialisiert, wenn sie definiert wird, und kann danach nicht mehr geändert werden (es kann keine Referenz auf andere Instanzen sein).
int main()
{
int a = 10,b = 20;
int* ip = &a;
ip = &b ;
int& c = a;
c = b; //b的值给c实则是把b的值给a，将a的值改为20
}
- Der Wert einer Zeigervariablen kann leer sein (NULL, nullptr), es gibt keine Nullreferenzen.
- Wenn eine Zeigervariable als formaler Parameter verwendet wird, muss ihre Gültigkeit getestet werden (Beurteilung von NULL);
Referenzen müssen nicht als NULL beurteilt werden. - Die Verwendung von „sizeof“ für eine Zeigervariable erhält die Größe der Zeigervariablen;
die Verwendung von „sizeof“ für eine Referenzvariable erhält die Größe der Variablen.
int main()
{
double dx = 10;
double* dp = &dx;
double& a = dx;
printf("sizeof(dp):%d\n", sizeof(dp));
printf("sizeof(a):%d", sizeof(a));
}
Operationsergebnis:
-
Theoretisch ist die Anzahl der Zeigerebenen unbegrenzt, aber es gibt nur eine Referenzebene.
d.h. es gibt keine Verweise auf Verweise, aber es kann Zeiger auf Zeiger geben. -
++Referenzen haben andere Auswirkungen als ++Zeiger.
Zum Beispiel in Bezug auf ++ Operationen:
int main()
(
int ar[5] = {
1,2,3，4,5 };
int* ip = ar; //数组首元素地址
int& b = ar[O]; //数组首元素的别名叫b
++ip; //由0下标的地址指向1下标的地址
++b； //由0下标指向1下标
}
- Operationen auf Referenzen reagieren direkt auf die referenzierte Entität (Variable oder Objekt).
Die Operation auf der Zeigervariable lässt die Zeigervariable auf die Adresse der nächsten Entität (Variable oder Objekt) zeigen, anstatt den Inhalt der angezeigten Entität (Variable oder Objekt) zu ändern.
int main()
(
int ar[5] = {
1,2,3，4,5 };
int* ip = ar; //数组首元素地址
int& b = ar[O]; //数组首元素的别名叫b
++(*ip); //值由1>>2
(*ip)++; //所有表达式结束后 进行++
//有括号 先取ip的值与*结合 然后++为所指之物的++
int x = *ip++;
//没有括号 先将ip的值取出 与*结合 把所指之物取出(此时已与*结合完) 然后将ip取出进行++ ++后的值回写给ip 将值存储到x中
//通过（）提高了优先级
}
-
Lokale Variablen oder Objekte in Funktionen können nicht per Referenz oder Zeiger zurückgegeben werden.
Die Adresse kann zurückgegeben werden, wenn die Lebensdauer der Variablen nicht von der Funktion beeinflusst wird
2. Unterschiede auf Baugruppenebene
Auf Assembly-Ebene ist eine Referenz ein Zeiger, aber eine Referenz ist kein gewöhnlicher Zeiger, sondern ein Syntax-Slot für Zeiger und kann auch als regulärer Zeiger betrachtet werden.
int main()
{
int a = 10;
int* ip = &a;
int& x = a;
*ip = 100;
x = 200;
}
7. Andere Verwendungen von Referenzen
- Oft zitiert:
Eine Konstantenreferenz ist eigentlich eine universelle Referenz, die auf gewöhnliche Variablen, Konstanten oder Literalkonstanten verweisen kann .
(1) Beziehen sich auf gewöhnliche Variablen
int main()
{
int a = 10;
int & b = a;
const int& c = a;
b += 10;
a += 10;
c += 10;
return 0;
}
Für dieses Fehlerproblem: weil c nicht modifizierbar ist
(2) Referenzkonstante
int main()
{
int a = 10;
const int b =20;
int& x = a;
int& y = b; //error 不安全
const int& y = b; //ok
const int& z =10; //ok
return 0;
}
(3) Literale Konstanten in Anführungszeichen setzen
Der Verweis auf eine literale Konstante ist in zwei Schritte unterteilt: Definieren Sie zunächst ein temporäres Element, um auf das temporäre zu verweisen, anstatt auf die tatsächliche literale Konstante zu verweisen 10.
int main()
{
int a = 10;
const int& z =10; //ok
//int tmp =10；
//const int &z = tmp;
return 0;
}
- Array-Referenz
Beim Referenzieren eines Arrays muss die Größe des Arrays bekannt sein
int main()
{
int a = 10;
int b = 10;
int ar[5] = {
1,2,3,4,5 };
int& x = ar[0]; //ok
int(&x)[5] = ar; //ok 没有[5]无法编译通过
return 0;
}
- Zeiger Referenz
Da die Referenz eine Variable ist, kann ich der Zeigervariable auch einen Alias geben
int main()
{
int a = 100;
int *p = &a;
int * &rp = p;
cout << a << endl;
cout << *p << endl;
cout << *rp << endl; //这里为什么要将*放在前面，因为p的类型是 int * 作为一个整体哦！！
cout << p << endl;
cout << rp << endl;
getchar();
return 0;
}
/*
100
100
100
012FF84C
012FF84C
*/
Wir haben festgestellt, dass die Zeigervariable p hier genau dieselbe ist wie ihre Referenz (Alias) rp. Da der Zweck einer Referenz jedoch dem eines Zeigers ähnlich ist, besteht im Allgemeinen keine Notwendigkeit, den Zeiger mit einem Alias zu versehen.