Wie viele Ebenen von Zeigern können wir haben?

Question

Wie viele Zeiger ( * ) in einer einzigen Variablen erlaubt sind?

Betrachten wir das folgende Beispiel.

int a = 10;
int *p = &a;

In ähnlicher Weise können wir haben

int **q = &p;
int ***r = &q;

und so weiter.

Zum Beispiel,

int ****************zz;

Answer 1

Es gibt kein Limit, siehe Beispiel unter Zeiger :: C Interview Fragen und Antworten .

Die Antwort hängt davon ab, was Sie mit "Ebenen von Zeigern" meinen. Wenn Sie meinen: "Wie viele Ebenen der Indirektion können Sie in einer einzigen Deklaration haben?", lautet die Antwort: "Mindestens 12."

int i = 0;

int *ip01 = & i;

int **ip02 = & ip01;

int ***ip03 = & ip02;

int ****ip04 = & ip03;

int *****ip05 = & ip04;

int ******ip06 = & ip05;

int *******ip07 = & ip06;

int ********ip08 = & ip07;

int *********ip09 = & ip08;

int **********ip10 = & ip09;

int ***********ip11 = & ip10;

int ************ip12 = & ip11;

************ip12 = 1; /* i = 1 */

Wenn Sie meinen, wie viele Zeigerebenen Sie verwenden können, bevor das Programm unübersichtlich wird, ist das Geschmackssache, aber es gibt eine Grenze. Zwei Ebenen der Umleitung (ein Zeiger auf einen Zeiger auf etwas) sind üblich. Mehr als das wird ein bisschen schwieriger zu denken; tun Sie es nicht, es sei denn, die Alternative wäre schlimmer.

Wenn Sie meinen: "Wie viele Ebenen der Zeigerumlenkung können Sie zur Laufzeit haben", gibt es keine Grenze. Dieser Punkt ist besonders wichtig für kreisförmige Listen, in denen jeder Knoten auf den nächsten zeigt. Ihr Programm kann den Zeigern ewig folgen.

Answer 2

Mit Zeigern auf Funktionen ist es sogar noch lustiger.

#include <cstdio>

typedef void (*FuncType)();

static void Print() { std::printf("%s", "Hello, World!\n"); }

int main() {
  FuncType const ft = &Print;
  ft();
  (*ft)();
  (**ft)();
  /* ... */
}

Wie illustriert aquí dies ergibt:

Hallo, Welt!
Hallo, Welt!
Hallo, Welt!

Außerdem ist damit kein Laufzeit-Overhead verbunden, so dass Sie sie wahrscheinlich so oft stapeln können, wie Sie wollen... bis Ihr Compiler an der Datei erstickt.

Answer 3

Es gibt kein Limit . Ein Zeiger ist ein Stück Speicher, dessen Inhalt eine Adresse ist.
Wie Sie sagten

int a = 10;
int *p = &a;

Ein Zeiger auf einen Zeiger ist auch eine Variable, die eine Adresse eines anderen Zeigers enthält.

int **q = &p;

Ici q ist ein Zeiger auf einen Zeiger, der die Adresse von p die bereits die Adresse von a .

Es gibt nichts Besonderes an einem Zeiger auf einen Zeiger.
Es gibt also keine Begrenzung für die Kette von Zeigern, die die Adresse eines anderen Zeigers enthalten.
d. h.

 int **************************************************************************z;

ist erlaubt.

Answer 4

Jeder C++-Entwickler sollte schon einmal von der (un)berühmten Drei-Sterne-Programmierer .

Und es scheint wirklich eine magische "Zeigerbarriere" zu geben, die getarnt werden muss.

Zitat von C2:

Drei-Sterne-Programmierer

Ein Bewertungssystem für C-Programmierer. Je indirekter Ihre Zeiger sind (d.h. je mehr "*" vor Ihren Variablen), desto höher wird Ihr Ansehen sein. C-Programmierer ohne Stern gibt es praktisch nicht, da praktisch alle nicht-trivialen Programme die Verwendung von Zeigern erfordern. Die meisten sind Ein-Stern-Programmierer. In den alten Zeiten (nun, ich bin jung, also sieht es zumindest für mich nach alten Zeiten aus) fand man gelegentlich ein Stück Code, das von einem Drei-Sterne-Programmierer erstellt wurde, und erschauerte vor Ehrfurcht. Einige Leute behaupteten sogar, sie hätten Drei-Sterne-Code mit Funktionszeigern gesehen, und zwar auf mehr als einer Ebene der Indirektion. Das klang für mich so real wie UFOs.

Answer 5

Beachten Sie, dass es hier zwei mögliche Fragen gibt: Wie viele Ebenen der Zeigerumlenkung können wir in einem C-Typ erreichen, und wie viele Ebenen der Zeigerumlenkung können wir in einen einzigen Deklarator packen.

Die C-Norm erlaubt es, für erstere einen Höchstwert festzulegen (und gibt dafür einen Mindestwert an). Dies kann jedoch durch mehrere typedef-Deklarationen umgangen werden:

typedef int *type0;
typedef type0 *type1;
typedef type1 *type2; /* etc */

Letztlich handelt es sich also um ein Implementierungsproblem, das mit der Frage zusammenhängt, wie groß/komplex ein C-Programm sein kann, bevor es abgelehnt wird, was sehr compilerspezifisch ist.