Wie viele Zeigerebenen können wir haben?

Wie viele Zeiger (* ) sind in einer einzelnen Variablen zulässig?

Betrachten wir das folgende Beispiel.

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

Ebenso können wir haben

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

und so weiter.

Zum Beispiel,

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

Der CStandard legt die Untergrenze fest:

5.2.4.1 Übersetzungsgrenzen

276 Die Implementierung muss in der Lage sein, mindestens ein Programm zu übersetzen und auszuführen, das mindestens eine Instanz jeder der folgenden Grenzen enthält: [...]

279 - 12 Zeiger-, Array- und Funktionsdeklaratoren (in beliebigen Kombinationen), die einen Arithmetik-, Struktur-, Vereinigungs- oder Leertyp in einer Deklaration ändern

Die Obergrenze ist implementierungsspezifisch.

Tatsächlich verwenden C-Programme üblicherweise die Indirektion unendlicher Zeiger. Ein oder zwei statische Ebenen sind üblich. Dreifache Indirektion ist selten. Aber unendlich ist sehr verbreitet.

Eine unendliche Zeiger-Indirektion wird natürlich mit Hilfe einer Struktur erreicht, nicht mit einem direkten Deklarator, was unmöglich wäre. Und es wird eine Struktur benötigt, damit Sie andere Daten in diese Struktur auf den verschiedenen Ebenen aufnehmen können, auf denen dies enden kann.

struct list { struct list *next; ... };

jetzt kannst du haben list->next->next->next->...->next. Dies ist wirklich nur mehrere Zeiger Indirektionen : *(*(..(*(*(*list).next).next).next...).next).next. Und das .nextist im Grunde ein Noop, wenn es das erste Mitglied der Struktur ist, also können wir uns das als vorstellen ***..***ptr.

Dies ist wirklich unbegrenzt, da die Verknüpfungen eher mit einer Schleife als mit einem riesigen Ausdruck wie diesem durchlaufen werden können und außerdem die Struktur leicht kreisförmig gemacht werden kann.

Mit anderen Worten, verknüpfte Listen können das ultimative Beispiel für das Hinzufügen einer weiteren Indirektionsebene zur Lösung eines Problems sein, da Sie dies bei jeder Push-Operation dynamisch tun. :) :)

Theoretisch:

Sie können so viele Indirektionsebenen haben, wie Sie möchten.

Praktisch:

Natürlich kann nichts, was Speicher verbraucht, unbegrenzt sein. Aufgrund der in der Hostumgebung verfügbaren Ressourcen gibt es Einschränkungen. In der Praxis gibt es also eine Höchstgrenze für die Unterstützung einer Implementierung, und die Implementierung muss diese angemessen dokumentieren. In all diesen Artefakten gibt der Standard nicht die maximale Grenze an, sondern die unteren Grenzen.

Hier ist die Referenz:

C99 Standard 5.2.4.1 Übersetzungsgrenzen:

- 12 Zeiger-, Array- und Funktionsdeklaratoren (in beliebigen Kombinationen), die einen Arithmetik-, Struktur-, Vereinigungs- oder Leertyp in einer Deklaration ändern.

Dies gibt die Untergrenze an, die jede Implementierung unterstützen muss . Beachten Sie, dass in einer Footenote der Standard weiter sagt:

18) Durch Implementierungen sollten nach Möglichkeit feste Übersetzungsgrenzen vermieden werden.

Wie die Leute gesagt haben, keine Grenze "in der Theorie". Aus Interesse habe ich dies jedoch mit g ++ 4.1.2 ausgeführt und es funktionierte mit einer Größe von bis zu 20.000. Das Kompilieren war allerdings ziemlich langsam, deshalb habe ich es nicht höher versucht. Ich würde also vermuten, dass g ++ auch keine Grenzen setzt. (Versuchen Sie, size = 10ptr.cpp einzustellen und zu suchen, wenn dies nicht sofort offensichtlich ist.)

g++ create.cpp -o create ; ./create > ptr.cpp ; g++ ptr.cpp -o ptr ; ./ptr

create.cpp

#include <iostream>

int main()
{
    const int size = 200;
    std::cout << "#include <iostream>\n\n";
    std::cout << "int main()\n{\n";
    std::cout << "    int i0 = " << size << ";";
    for (int i = 1; i < size; ++i)
    {
        std::cout << "    int ";
        for (int j = 0; j < i; ++j) std::cout << "*";
        std::cout << " i" << i << " = &i" << i-1 << ";\n";
    }
    std::cout << "    std::cout << ";
    for (int i = 1; i < size; ++i) std::cout << "*";
    std::cout << "i" << size-1 << " << \"\\n\";\n";
    std::cout << "    return 0;\n}\n";
    return 0;
}

Klingt lustig zu überprüfen.

• In Visual Studio 2010 (unter Windows 7) können Sie 1011 Ebenen haben, bevor dieser Fehler angezeigt wird:

  Schwerwiegender Fehler C1026: Parser-Stack-Überlauf, Programm zu komplex

• gcc (Ubuntu), 100k + *ohne Absturz! Ich denke, die Hardware ist hier die Grenze.

(getestet mit nur einer Variablendeklaration)

Es gibt keine Begrenzung, siehe Beispiel hier .

Die Antwort hängt davon ab, was Sie unter "Zeigerstufen" verstehen. Wenn Sie meinen "Wie viele Indirektionsebenen können Sie in einer einzelnen Deklaration haben?" Die Antwort lautet "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 können Sie verwenden, bevor das Programm schwer zu lesen ist", ist das Geschmackssache, aber es gibt eine Grenze. Es ist üblich, zwei Indirektionsebenen zu haben (einen Zeiger auf einen Zeiger auf etwas). Mehr als das wird etwas schwieriger, leicht darüber nachzudenken; Tu es nicht, es sei denn, die Alternative wäre schlimmer.

Wenn Sie "Wie viele Ebenen der Zeiger-Indirektion können Sie zur Laufzeit haben" meinen, gibt es keine Begrenzung. Dieser Punkt ist besonders wichtig für zirkuläre Listen, in denen jeder Knoten auf den nächsten zeigt. Ihr Programm kann den Zeigern für immer folgen.

Es ist sogar noch lustiger mit Zeiger auf Funktionen.

#include <cstdio>

typedef void (*FuncType)();

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

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

Wie hier dargestellt, ergibt dies:

Hallo Welt!
Hallo Welt!
Hallo Welt!

Und es ist kein Laufzeitaufwand erforderlich, sodass Sie sie wahrscheinlich so oft stapeln können, wie Sie möchten ... bis Ihr Compiler die Datei erstickt.

Es gibt keine Begrenzung . Ein Zeiger ist ein Speicherblock, dessen Inhalt eine Adresse ist.
Wie du gesagt hast

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;

Hier qist Zeiger auf Zeiger, dessen Adresse pbereits die Adresse von enthälta .

Ein Zeiger auf einen Zeiger hat nichts Besonderes.
Es gibt also keine Begrenzung für die Kette von Ponitern, die die Adresse eines anderen Zeigers enthalten.
dh.

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

ist erlaubt.

Jeder C ++ - Entwickler sollte von dem (in) berühmten Drei-Sterne-Programmierer gehört haben

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

Zitat aus C2:

Drei-Sterne-Programmierer

Ein Bewertungssystem für C-Programmierer. Je indirekter Ihre Zeiger sind (dh je mehr "*" vor Ihren Variablen steht), desto höher ist Ihr Ruf. No-Star-C-Programmierer sind praktisch nicht vorhanden, da praktisch alle nicht trivialen Programme die Verwendung von Zeigern erfordern. Die meisten sind Ein-Stern-Programmierer. In alten Zeiten (nun, ich bin jung, also sehen diese für mich zumindest wie alte Zeiten aus) fand man gelegentlich einen Code, der von einem Drei-Sterne-Programmierer erstellt wurde und vor Ehrfurcht zitterte. Einige Leute behaupteten sogar, sie hätten Drei-Sterne-Code mit Funktionszeigern auf mehr als einer Indirektionsebene gesehen. Für mich klang es so real wie UFOs.

Beachten Sie, dass es hier zwei mögliche Fragen gibt: Wie viele Ebenen der Zeiger-Indirektion können wir in einem C-Typ erreichen, und wie viele Ebenen der Zeiger-Indirektion können wir in einen einzelnen Deklarator einfügen.

Der C-Standard erlaubt es, dem ersteren ein Maximum aufzuerlegen (und gibt dafür einen minimalen Wert an). Dies kann jedoch über mehrere typedef-Deklarationen umgangen werden:

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

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

Ich möchte darauf hinweisen, dass das Erstellen eines Typs mit einer beliebigen Anzahl von * mit der Metaprogrammierung von Vorlagen möglich ist. Ich habe vergessen, was ich genau tat, aber es wurde vorgeschlagen, dass ich mithilfe rekursiver T * -Typen neue unterschiedliche Typen erzeugen könnte, zwischen denen eine Art Meta-Manöver besteht .

Template Metaprogramming ist ein langsamer Abstieg in den Wahnsinn, daher ist es nicht notwendig, Ausreden zu treffen, wenn ein Typ mit mehreren tausend Indirektionsebenen generiert wird. Es ist nur eine praktische Möglichkeit, Peano-Ganzzahlen beispielsweise der Vorlagenerweiterung als funktionale Sprache zuzuordnen.

Regel 17.5 des MISRA C- Standards von 2004 verbietet mehr als zwei Ebenen der Zeiger-Indirektion.

Es gibt kein echtes Limit, aber es gibt ein Limit. Alle Zeiger sind Variablen, die normalerweise im Stapel und nicht im Heap gespeichert werden . Der Stapel ist normalerweise klein (es ist möglich, seine Größe während einer Verknüpfung zu ändern). Nehmen wir also an, Sie haben einen 4-MB-Stapel, was eine ganz normale Größe ist. Nehmen wir an, wir haben einen Zeiger mit einer Größe von 4 Bytes (die Zeigergrößen sind je nach Architektur, Ziel- und Compilereinstellungen nicht gleich).

In diesem Fall 4 MB / 4 b = 1024wäre die maximal mögliche Anzahl 1048576, aber wir sollten die Tatsache nicht ignorieren, dass einige andere Dinge im Stapel sind.

Einige Compiler haben möglicherweise die maximale Anzahl von Zeigerketten, aber die Grenze ist die Stapelgröße. Wenn Sie also die Stapelgröße während der Verknüpfung mit unendlich erhöhen und einen Computer mit unendlichem Speicher haben, auf dem das Betriebssystem ausgeführt wird, das diesen Speicher verarbeitet, haben Sie eine unbegrenzte Zeigerkette.

Wenn Sie int *ptr = new int;Ihren Zeiger verwenden und in den Heap setzen, ist dies nicht die übliche Beschränkung auf die Größe des Heapspeichers und nicht auf den Stapel.

BEARBEITEN Erkenne das einfach 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, sind es schlechte Nachrichten ... :)

Dies hängt von der Stelle ab, an der Sie Zeiger speichern. Wenn sie im Stapel sind, haben Sie ziemlich niedrige Grenze. Wenn Sie es auf einem Haufen speichern, ist Ihr Limit viel, viel höher.

Schauen 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 auf den Shows, an welchem ​​Punkt zu erkennen ist, was die Kette zur ersten Variablen führt number.

Übrigens. Es wird 92KRAM verwendet, stellen Sie sich also vor, wie tief Sie gehen können.