Zunächst wollen wir ein erstes Verständnis für einige Punkte gewinnen, die bei Referenzen und Zeigern zu beachten sind.
- Eine Referenz ist kein Objekt
- Eine Referenz muss initialisiert werden
- Eine Referenz kann nur an ein Objekt gebunden werden und kann nicht an einen Literalwert oder das Ergebnis eines Ausdrucks gebunden werden
- Typen müssen strikt übereinstimmen
int &a = 10; //错误:引用类型的初始值必须是一个对象 double a = 3.14; int &b = a; //错误:此处引用类型的初始值必须是int型对象
Ein Zeiger selbst ist ein Objekt
Der Typ des Zeigers muss strikt mit dem Objekt übereinstimmen, auf das er zeigt
double dval; double *pd = &dval; //正确 double *pd2 = pd; //正确 int *pi = pd; //错误:指针pi的类型和pd的类型不匹配 pi = &dval; //错误:试图把double型对象的地址赋给int型指针
Es gibt eine Ausnahme: die Einführung des const-Qualifizierers
Konstante Referenz
Beim Initialisieren einer konstanten Referenz ist jeder Ausdruck als Initialwert zulässig
int i = 42; const int &r1 = i; //正确:允许将const int & 绑定到一个普通int对象上 const int &r2 = 42; //正确 const int &r3 = r1 * 2; //正确 int &r4 = r1 * 2; //错误 double dval = 3.14; const int &ri = dval; //正确 //等价于 const int temp = dval; const int &ri = temp; int i = 42; int &r1 = i; const int &r2 = i; r1 = 0; //正确 r2 = 0; //错误
Konstanter Zeiger
Definition:Auch als konstanter Zeiger bezeichnet, kann er als Zeiger auf eine Konstante verstanden werden. Das heißt, dies ist ein Zeiger, aber das, worauf er zeigt, ist eine Konstante. Diese Konstante ist der Wert (die Adresse) des Zeigers, nicht der Wert, auf den die Adresse zeigt.
Wichtige Punkte:
- 1. Das Objekt, auf das ein konstanter Zeiger zeigt, kann nicht über diesen Zeiger geändert werden, aber es kann weiterhin über die ursprüngliche Deklaration geändert werden;
- 2. Einem konstanten Zeiger kann die Adresse einer Variablen zugewiesen werden; der Grund, warum er konstanter Zeiger genannt wird, ist, dass er das Ändern des Werts der Variablen über diesen Zeiger einschränkt;
- 3. Der Zeiger kann auch auf etwas anderes zeigen, weil der Zeiger selbst nur eine Variable ist und auf jede Adresse zeigen kann;
Codeform:
Zeiger auf Konstante (
const int* ptr): Der Inhalt, auf den der Zeiger zeigt, ist eine Konstante und kann nicht über den Zeiger geändert werden. Der Zeiger selbst (das heißt die im Zeiger gespeicherte Adresse) kann jedoch geändert werden.Konstanter Zeiger (
int* const ptr): Der Zeiger selbst (das heißt die im Zeiger gespeicherte Adresse) ist eine Konstante und kann nicht geändert werden, aber der Inhalt, auf den der Zeiger zeigt, kann geändert werden.Konstanter Zeiger auf Konstante (
const int* const ptr): Sowohl der Zeiger selbst (das heißt die im Zeiger gespeicherte Adresse) als auch der Inhalt, auf den der Zeiger zeigt, sind Konstanten. Weder die Adresse des Zeigers noch der Inhalt, auf den gezeigt wird, können geändert werden.
Konstanter Zeiger
Definition:Er ist im Wesentlichen eine Konstante, die durch einen Zeiger modifiziert wird. Sein eigener Wert (das heißt die Adresse des Zeigers) ist eine Konstante und kann nicht geändert werden. Mit anderen Worten: Nach der Initialisierung zeigt die Zeigervariable immer auf dieselbe Adresse. Obwohl die Adresse des Zeigers fest ist, kann der Inhalt, auf den er zeigt, über den Zeiger geändert werden.
Kernpunkte:Der Zeiger selbst (das heißt die im Zeiger gespeicherte Adresse) ist eine Konstante und kann nicht geändert werden, aber der Inhalt, auf den der Zeiger zeigt, kann geändert werden.
Codeform:
int* const p;
Konstanter Zeiger auf eine Konstante
Definition:Ein konstanter Zeiger, der auf eine Konstante zeigt, ist eine Konstante, und das Objekt, auf das er zeigt, ist ebenfalls eine Konstante.
Wichtige Punkte:
- 1. Ein konstanter Zeiger zeigt auf ein Zeigerobjekt;
- 2. Das Zeigerobjekt, auf das er zeigt, ist ebenfalls eine Konstante, das heißt, das Objekt, auf das er zeigt, kann sich nicht ändern;
Codeform:
const int* const p;
Wie unterscheiden wir also diese Typen? Der mit zwei const-Qualifizierern ist definitiv ein konstanter Zeiger auf eine Konstante, was leicht zu verstehen ist. Der Hauptpunkt ist, wie man einen Zeiger auf eine Konstante von einem konstanten Zeiger unterscheidet:
Eine Möglichkeit ist, die Reihenfolge von * und const zu betrachten, zum Beispiel
int const* p; //const * 即常量指针 const int* p; //const * 即常量指针 int* const p; //* const 即指针常量
Eine andere Möglichkeit ist zu sehen, welchem Element const näher steht, das heißt, von rechts nach links zu lesen, zum Beispiel
int const* p; //const修饰的是*p,即*p的内容不可通过p改变,但p不是const,p可以修改,*p不可修改; const int* p; //同上 int* const p; //const修饰的是p,p是指针,p指向的地址不能修改,p不能修改,但*p可以修改;
Beispiel
//-------常量指针------- const int *p1 = &a; a = 300; //OK,仍然可以通过原来的声明修改值, //*p1 = 56; //Error,*p1是const int的,不可修改,即常量指针不可修改其指向地址 p1 = &b; //OK,指针还可以指向别处,因为指针只是个变量,可以随意指向; //-------指针常量-------// int* const p2 = &a; a = 500; //OK,仍然可以通过原来的声明修改值, *p2 = 400; //OK,指针是常量,指向的地址不可以变化,但是指向的地址所对应的内容可以变化 //p2 = &b; //Error,因为p2是const 指针,因此不能改变p2指向的内容 //-------指向常量的常量指针-------// const int* const p3 = &a; //*p3 = 1; //Error //p3 = &b; //Error a = 5000; //OK,仍然可以通过原来的声明修改值
In der Praxis werden Zeiger auf Konstanten häufiger verwendet als konstante Zeiger. Beispielsweise werden Zeiger auf Konstanten oft bei der Übergabe von Funktionsparametern verwendet, um zu vermeiden, dass der Inhalt innerhalb der Funktion geändert wird.
size_t strlen(const char* src); //常量指针,src的值不可改变; char a[] = "hello"; char b[] = "world"; size_t a1 = strlen(a); size_t b1 = strlen(b);
Obwohl a und b geändert werden können, kann garantiert werden, dass die Inhalte von a und b innerhalb der strlen-Funktion nicht geändert werden.
Nullzeiger, Wildzeiger
Da wir über Zeiger gesprochen haben, wollen wir auch die Probleme von Nullzeigern und Wildzeigern erwähnen.
Ein Nullzeiger ist ein Zeiger, der eine leere Adresse speichert. Bei der Verwendung eines Zeigers muss zuerst festgestellt werden, ob es sich um einen Nullzeiger handelt; viele Probleme entstehen durch diesen Schritt.
Ein Wildzeiger ist ein Zeiger, der nach dem Löschen des Zeigers nicht auf 0 gesetzt wird, wodurch der Zeiger beliebig auf eine Speicheradresse zeigt. Wenn er weiter verwendet wird, verursacht er unvorhersehbare Speicherfehler.
Darüber hinaus kann ein unsachgemäßer Umgang mit Zeigern leicht zu Fehlern oder Speicherlecks führen.
Schauen Sie sich den Code an:
//-------空指针-------//
int *p4 = NULL;
//printf("%d",*p4); //运行Error,使用指针时必须先判断是否空指针
//-------野指针(悬浮、迷途指针)-------//
int *p5 = new int(5);
delete p5;
p5 = NULL; //一定要有这一步
printf("%d",*p5); //隐藏bug,delete掉指针后一定要置0,不然指针指向位置不可控,运行中可导致系统挂掉
//-------指针的内存泄漏-------//
int *p6 = new int(6);
p6 = new int(7); //p6原本指向的那块内存尚未释放,结果p6又指向了别处,原来new的内存无法访问,也无法delete了,造成memory leak
Referenzadresse:
http://blog.csdn.net/Rueing839/article/details/48416907
http://www.cnblogs.com/lizhenghn/p/3630405.html