Kann ein C++-Array an der Speichergrenze enden?

Question 1

Der C++-Standard (und C für diese Angelegenheit) erlaubt es, einen Zeiger auf ein Element hinter dem Ende des Arrays zu erstellen (allerdings nicht zu dereferenzieren). Bedeutet dies, dass ein Array niemals an einer solchen Stelle zugewiesen wird, dass sein letztes Element an der Speichergrenze endet? Ich verstehe, dass in der Praxis einige / alle Implementierungen dieser Konvention folgen könnten, aber welche der folgenden gilt:

Es ist tatsächlich falsch, und ein Array kann an der Speichergrenze ODER enden

Der C++-Standard schreibt vor, den Speicher mindestens eines Elements vor der Grenze OR zu beenden
Weder 1 noch 2, aber in aktuellen Compilern ist es immer noch so, weil es die Implementierung erleichtert.

Ist bei C etwas anders?

Aktualisieren:
Wie es scheint 1 ist die richtige Antwort. Siehe Antwort von James Kanze unten und siehe auch efence (http://linux.die.net/man/3/efence – danke an Michael Chastain für den Hinweis darauf)

Question 2

Eine Implementierung muss zulassen, dass ein Zeiger auf einen nach dem Ende existiert. Wie es das macht, ist seine Sache. Auf vielen Maschinen können Sie ohne Risiko jeden Wert in einen Zeiger setzen (es sei denn, Sie dereferenzieren ihn); Auf solchen Systemen kann dasjenige hinter dem Endzeiger auf nicht zugeordneten Speicher zeigen – ich bin tatsächlich auf einen Fall unter Windows gestoßen, in dem dies der Fall war.

Auf anderen Maschinen führt das bloße Laden eines Zeigers auf einen nicht zugeordneten Speicher in ein Register zu einem Trap, was zum Absturz des Programms führt. Auf solchen Maschinen muss die Implementierung sicherstellen, dass dies nicht passiert, indem entweder die Verwendung des letzten Bytes oder Wortes des zugewiesenen Speichers abgelehnt wird oder indem sichergestellt wird, dass jede Verwendung des Zeigers außer der Dereferenzierung alle Anweisungen vermeidet, die die Hardware verursachen könnten als ungültigen Zeiger zu behandeln. (Die meisten dieser Systeme haben separate Adress- und Datenregister und fangen nur ab, wenn der Zeiger in ein Adressregister geladen wird. Wenn die Datenregister groß genug sind, kann der Compiler den Zeiger sicher in ein Datenregister laden, z. B. zum Vergleich. Dies ist oft ohnehin notwendig, da die Adressregister nicht immer den Vergleich unterstützen.)

Zu Ihrer letzten Frage: C und C++ sind in dieser Hinsicht genau identisch; C++ hat einfach die Regeln von C übernommen.

Question 3

Es gibt eine interessante Passage bei §3.9.2/3 [Compound types]:

Der Typ eines Zeigers auf void oder eines Zeigers auf einen Objekttyp wird als Objektzeigertyp bezeichnet. […] Ein gültiger Wert eines Objektzeigertyps repräsentiert entweder die Adresse eines Bytes im Speicher (1.7) oder einen Nullzeiger (4.10).

Zusammen mit dem Text bei §5.7/5 [Additive operators]:

[…] Wenn außerdem der Ausdruck P auf das letzte Element eines Array-Objekts zeigt, zeigt der Ausdruck (P)+1 um eins nach dem letzten Element des Array-Objekts, und wenn der Ausdruck Q um eins nach dem letzten Element eines Array-Objekts zeigt, der Ausdruck (Q)-1 zeigt auf das letzte Element des Array-Objekts.

Es scheint, dass ein Array, das mit dem letzten Byte im Speicher endet, nicht zugewiesen werden kann, wenn die Anforderung besteht, dass der One-Past-the-End-Zeiger gültig sein muss. Wenn der One-Past-the-End-Zeiger ungültig sein darf, kenne ich die Antwort nicht.

Der Abschnitt §3.7.4.2/4 [Deallocation functions] besagt, dass:

Die Auswirkung der Verwendung eines ungültigen Zeigerwerts (einschließlich der Übergabe an eine Freigabefunktion) ist nicht definiert.

Wenn also der Vergleich eines Eins-nach-dem-Ende-Zeigers für ein zugewiesenes Array unterstützt werden muss, muss der Eins-nach-dem-Ende-Zeiger gültig sein.

Basierend auf den Kommentaren, die ich erhalten habe, gehe ich davon aus, dass eine Implementierung ein Array zuweisen kann, ohne sich darum kümmern zu müssen, ob der One-Past-the-End-Zeiger des Arrays verwendbar ist oder nicht. Allerdings würde ich gerne die entsprechenden Passagen in der Norm dazu herausfinden.

Question 4

Du hast halb recht. Angenommen, eine hypothetische Implementierung verwendet einen linear adressierten Speicher und Zeiger, die als vorzeichenlose 16-Bit-Ganzzahlen dargestellt werden. Nehmen Sie außerdem an, dass der Nullzeiger als Null dargestellt wird. Und schließlich, nehmen Sie an, Sie fragen nach 16 Byte Speicher, mit char *p = malloc(16);. Dann erhalten Sie garantiert einen Zeiger, dessen numerischer Wert kleiner als 65520 ist. Der Wert 65520 selbst wäre nicht gültig, denn wie Sie richtig anmerken, wenn die Zuweisung erfolgreich war, p + 16 ist ein gültiger Zeiger, der kein Nullzeiger sein darf.

Nehmen wir nun jedoch an, dass eine hypothetische Implementierung einen linear adressierten Speicher und Zeiger verwendet, die als vorzeichenlose 32-Bit-Ganzzahlen dargestellt werden, aber nur einen Adressraum von 16 Bit hat. Nehmen Sie auch wieder an, dass der Nullzeiger als Null dargestellt wird. Und schließlich nehmen Sie noch einmal an, Sie fragen nach 16 Byte Speicher, mit char *p = malloc(16);. Dann ist nur garantiert, dass Sie einen Zeiger erhalten, dessen numerischer Wert kleiner oder gleich 65520 ist. Der Wert 65520 selbst wäre gültig, solange die Implementierung dafür sorgt, dass die Addition von 16 dazu den Wert 65536 ergibt, und das Subtrahieren von 16 bringt Sie zurück zu 65520. Dies gilt auch dann, wenn an Adresse 65536 überhaupt kein Speicher (physisch oder virtuell) vorhanden ist.

Question 5

Der Standard gibt explizit an, was passiert, wenn Sie den Zeiger auf das letzte Element inkrementieren. Es gibt Ihnen einen Wert, der nur als Vergleich verwendet werden kann, um zu überprüfen, ob Sie am oder vor dem Ende des Arrays sind oder nicht. Der Zeiger kann durchaus auf gültig zugewiesenen Speicher für ein anderes Objekt zeigen, aber das ist ein vollständig undefiniertes (implementierungsdefiniertes?) Verhalten, und die Verwendung dieses Zeigers als solches ist definitiv ein undefiniertes Verhalten.

Worauf ich hinaus will, ist, dass der One-past-the-end-Zeiger genau das ist: Es ist der Zeiger, den Sie erhalten, wenn Sie den Zeiger auf das letzte Element erhöhen, um das Ende des Arrays auf sehr billige Weise zu markieren. Beachten Sie jedoch, dass das Vergleichen von Zeigern von nicht verwandten Objekten völlig unsinnig ist (und sogar undefiniertes Verhalten, wenn ich mich nicht irre). Die Tatsache, dass sich Zeiger-“Werte” über verschiedene Objekte hinweg überschneiden könnten, ist also kein Problem, denn wenn Sie dies ausnutzen, betreten Sie das Land des undefinierten Verhaltens.

Question 6

Dies hängt von der Implementierung ab. Zumindest in Visual C++ könnten Sie ohne Verwendung einer Form- oder Array-Bound-Prüfung einen Zeiger auf eine beliebige Anzahl von Elementen nach dem Ende des Arrays erstellen. Wenn Sie es dereferenzieren, funktioniert es weiterhin, solange sich die Speicheradresse, auf die Sie zugreifen, innerhalb des zugewiesenen Heap / Stack Ihres Programms befindet. Sie werden jeden Wert in diesem Speicherplatz lesen/ändern. Wenn die Adresse außerhalb des zugewiesenen Speicherplatzes liegt, wird ein Fehler ausgegeben.

Debugger haben Überprüfungen, um diese zu erkennen, da diese Art der Codierung Fehler verursacht, die sehr schwer zu verfolgen sind.