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

Ich möchte darauf hinweisen, dass die Erzeugung eines Typs mit einer beliebigen Anzahl von * etwas ist, das mit der Metaprogrammierung von Vorlagen geschehen kann. Ich habe vergessen, was ich genau gemacht habe, aber es wurde vorgeschlagen, dass ich neue unterschiedliche Typen erzeugen kann, die eine Art von Meta-Manöver zwischen ihnen haben, indem ich rekursiv T*-Typen.

Schablonen-Metaprogrammierung ist ein langsamer Abstieg in den Wahnsinn, so dass es nicht notwendig ist, sich zu entschuldigen, wenn man einen Typ mit mehreren tausend Ebenen der Indirektion erzeugt. Es ist einfach ein praktischer Weg, um z.B. Peano-Ganzzahlen auf die Template-Erweiterung als funktionale Sprache abzubilden.

Answer 2

Artikel 17.5 des Jahres 2004 MISRA C Standard verbietet mehr als 2 Ebenen der Zeigerumlenkung.

Answer 3

Es gibt nicht so etwas wie tatsächliche Grenze aber es gibt Grenzen. Alle Zeiger sind Variablen, die normalerweise im Stapel gespeichert werden nicht horten . Stack ist in der Regel klein (es ist möglich, seine Größe während einiger Verknüpfung zu ändern). Sagen wir also, Sie haben 4MB Stack, was eine ganz normale Größe ist. Und sagen wir, wir haben einen Zeiger, der 4 Byte groß ist (Zeigergrößen sind je nach Architektur, Ziel und Compilereinstellungen nicht gleich).

In diesem Fall 4 MB / 4 b = 1024 Die mögliche Höchstzahl wäre also 1048576, aber wir sollten die Tatsache nicht ignorieren, dass sich noch andere Dinge im Stapel befinden.

Einige Compiler können jedoch eine maximale Anzahl von Zeigerketten vorsehen, aber die Grenze ist die Stackgröße. Wenn Sie also die Stack-Größe während des Linkens auf unendlich erhöhen und eine Maschine mit unendlich viel Speicher haben, auf der ein Betriebssystem läuft, das diesen Speicher handhabt, werden Sie eine unbegrenzte Zeigerkette haben.

Wenn Sie int *ptr = new int; und den Zeiger in den Heap setzen, ist das nicht so üblich Wegbegrenzung wäre die Heap-Größe, nicht der Stack.

EDIT Erkennen Sie einfach, dass infinity / 2 = infinity . Wenn die Maschine mehr Speicher hat, erhöht sich die Zeigergröße. Wenn also der Speicher unendlich ist und die Größe des Zeigers unendlich ist, dann ist das eine schlechte Nachricht... :)

Answer 4

Das hängt von dem Ort ab, an dem Sie Zeiger speichern. Wenn sie im Stack sind, haben Sie recht niedrig begrenzen. Wenn Sie es in Heap speichern, ist das Limit viel viel viel höher.

Sehen Sie sich dieses Programm an:

#include <iostream>

const int CBlockSize = 1048576;

int main() 
{
    int number = 0;
    int** ptr = new int*[CBlockSize];

    ptr[0] = &number;

    for (int i = 1; i < CBlockSize; ++i)
        ptr[i] = reinterpret_cast<int *> (&ptr[i - 1]);

    for (int i = CBlockSize-1; i >= 0; --i)
        std::cout << i << " " << (int)ptr[i] << "->" << *ptr[i] << std::endl;

    return 0;
}

Es werden 1M Zeiger erstellt und bei der Anzeige, was auf was zeigt, ist es leicht zu erkennen, was die Kette zur ersten Variablen geht number .

ÜBRIGENS. Es verwendet 92K des Arbeitsspeichers, also stellen Sie sich vor, wie tief Sie gehen können.