Warum ist die maximale Größe eines Arrays “zu groß”?

Ich habe den gleichen Eindruck wie diese Antwort, das size_t wird durch den Standard immer garantiert, groß genug zu sein, um den größtmöglichen Typ eines gegebenen Systems aufzunehmen.

Dieser Code kann jedoch nicht auf gcc/Mingw kompiliert werden:

#include <stdint.h>
#include <stddef.h>

typedef uint8_t array_t [SIZE_MAX];

Fehler: Größe des Arrays ‘array_t’ ist zu groß

Verstehe ich hier etwas in der Norm falsch? Ist size_t darf für eine bestimmte Implementierung zu groß sein? Oder ist das ein weiterer Fehler in Mingw?

EDIT: Weitere Recherchen zeigen das

typedef uint8_t array_t [SIZE_MAX/2];   // does compile
typedef uint8_t array_t [SIZE_MAX/2+1]; // does not compile

Was zufällig dasselbe ist wie

#include <limits.h>

typedef uint8_t array_t [LLONG_MAX];           // does compile
typedef uint8_t array_t [LLONG_MAX+(size_t)1]; // does not compile

Daher neige ich jetzt zu der Annahme, dass dies ein Fehler in Mingw ist, da das Festlegen der maximal zulässigen Größe basierend auf einem vorzeichenbehafteten Integer-Typ keinen Sinn ergibt.

Die Grenze SIZE_MAX / 2 ergibt sich aus den Definitionen von size_t und ptrdiff_t in Ihrer Implementierung, die festlegen, dass die Typen ptrdiff_t und size_t dieselbe Breite haben.

C Standardmandate¹ dass der Typ size_t vorzeichenlos und der Typ ptrdiff_t vorzeichenbehaftet ist.

Das Ergebnis der Differenz zwischen zwei Zeigern wird immer² haben den Typ ptrdiff_t. Das bedeutet, dass bei Ihrer Implementierung die Größe des Objekts auf PTRDIFF_MAX begrenzt werden muss, da sonst eine gültige Differenz zweier Zeiger nicht im Typ ptrdiff_t dargestellt werden könnte, was zu undefiniertem Verhalten führt.

Somit ist der Wert SIZE_MAX / 2 gleich dem Wert PTRDIFF_MAX. Wenn die Implementierung wählt, dass die maximale Objektgröße SIZE_MAX ist, dann müsste die Breite des Typs ptrdiff_t erhöht werden. Aber es ist viel einfacher, die maximale Größe des Objekts auf SIZE_MAX / 2 zu begrenzen, dann ist es so, dass der Typ ptrdiff_t einen größeren oder gleichen positiven Bereich hat als der Typ size_t.

Standard bietet diese an³ Kommentare⁴ zum Thema.

(Zitiert aus ISO/IEC 9899:201x)

¹ (7.19 Allgemeine Definitionen 2)
Die Typen sind
ptrdiff_t
das ist der vorzeichenbehaftete ganzzahlige Typ des Ergebnisses der Subtraktion zweier Zeiger;
Größe_t
Dies ist der vorzeichenlose ganzzahlige Typ des Ergebnisses des sizeof-Operators;

² (6.5.6 Additive Operatoren 9)
Wenn zwei Zeiger subtrahiert werden, zeigen beide auf Elemente desselben Array-Objekts oder einen nach dem letzten Element des Array-Objekts; das Ergebnis ist die Differenz der Indizes der beiden Array-Elemente. Die Größe des Ergebnisses ist implementierungsdefiniert, und sein Typ (ein vorzeichenbehafteter ganzzahliger Typ) ist ptrdiff_t, der im Header definiert ist. Wenn das Ergebnis in einem Objekt dieses Typs nicht darstellbar ist, ist das Verhalten undefiniert.

³ (K.3.4 Integer-Typen 3)
Extrem große Objektgrößen sind häufig ein Zeichen dafür, dass die Größe eines Objekts falsch berechnet wurde. Beispielsweise erscheinen negative Zahlen als sehr große positive Zahlen, wenn sie in einen vorzeichenlosen Typ wie size_t konvertiert werden. Außerdem unterstützen einige Implementierungen keine Objekte, die so groß sind wie der Maximalwert, der durch den Typ size_t dargestellt werden kann.

⁴ (K.3.4 Integer-Typen 4)
Aus diesen Gründen ist es manchmal vorteilhaft, den Bereich der Objektgrößen einzuschränken, um Programmierfehler zu erkennen. Für Implementierungen, die auf Maschinen mit großen Adressräumen abzielen, wird empfohlen, dass RSIZE_MAX als der kleinere Wert aus der Größe des größten unterstützten Objekts oder (SIZE_MAX >> 1) definiert wird, selbst wenn diese Grenze kleiner als die Größe einiger legitimer, aber sehr großer ist groß, Objekte. Implementierungen, die auf Maschinen mit kleinen Adressräumen abzielen, möchten möglicherweise RSIZE_MAX als SIZE_MAX definieren, was bedeutet, dass es keine Objektgröße gibt, die als Verletzung der Laufzeitbeschränkung betrachtet wird.

Die Reichweite size_t garantiert ausreicht, um die Größe des größten von der Implementierung unterstützten Objekts zu speichern. Das Gegenteil gilt nicht: Sie können nicht garantiert ein Objekt erstellen, dessen Größe den gesamten Bereich von ausfüllt size_t.

Unter solchen Umständen ist die Frage: was tut SIZE_MAX stehen für? Die größte unterstützte Objektgröße? Oder der größte darstellbare Wert in size_t? Die Antwort ist: es ist letzteres, dh SIZE_MAX ist (size_t) -1. Es ist nicht garantiert, dass Sie Objekte erstellen können SIZE_MAX Bytes groß.

Der Grund dafür ist, dass zusätzlich zu size_tmüssen Implementierungen ebenfalls bereitstellen ptrdiff_t, die (aber nicht garantiert) den Unterschied zwischen zwei Zeigern speichern soll, die auf dasselbe Array-Objekt zeigen. Da Typ ptrdiff_t unterzeichnet ist, stehen die Implementierungen vor den folgenden Entscheidungen:

1. Array-Objekte der Größe zulassen SIZE_MAX und mache ptrdiff_t breiter als size_t. Es muss mindestens ein Bit breiter sein. Eine solche ptrdiff_t kann jeden Unterschied zwischen zwei Zeigern berücksichtigen, die auf ein Array der Größe zeigen SIZE_MAX oder kleiner.

2. Array-Objekte der Größe zulassen SIZE_MAX und verwenden ptrdiff_t von die gleiche Breite wie size_t. Akzeptieren Sie die Tatsache, dass die Zeigersubtraktion möglich ist Überlauf und verursachen undefiniertes Verhalten, wenn die Zeiger weiter als sind SIZE_MAX / 2 Elemente auseinander. Die Sprachspezifikation verbietet diesen Ansatz nicht.

3. Verwenden ptrdiff_t gleich breit wie size_t und beschränken die maximale Array-Objektgröße von SIZE_MAX / 2. Eine solche ptrdiff_t kann jeden Unterschied zwischen zwei Zeigern berücksichtigen, die auf ein Array der Größe zeigen SIZE_MAX / 2 oder kleiner.

Sie haben es einfach mit einer Implementierung zu tun, die sich für den dritten Ansatz entschieden hat.

Es sieht sehr nach implementierungsspezifischem Verhalten aus.

Ich verwende hier Mac OS und mit gcc 6.3.0 ist die größte Größe, mit der ich Ihre Definition kompilieren kann SIZE_MAX/2; mit SIZE_MAX/2 + 1 es kompiliert nicht mehr.

Auf der anderen Seite ist Witch Clang 4.0.0 das Größte SIZE_MAX/8und SIZE_MAX/8 + 1 geht kaputt.

Nur von Grund auf neu argumentieren, size_t ist ein Typ, der die Größe eines beliebigen Objekts aufnehmen kann. Die Größe jedes Objekts ist durch die Breite des Adressbusses begrenzt (ohne Multiplexing und Systeme, die zB 32- und 64-Bit-Code verarbeiten können, nennen Sie das “Codebreite”). Analog zu MAX_INT welches der größte ganzzahlige Wert ist, SIZE_MAX ist der größte Wert von size_t. Also ein Objekt von Größe SIZE_MAX ist alles adressierbarer Speicher. Es ist vernünftig, dass eine Implementierung dies als Fehler kennzeichnet, aber ich stimme zu, dass es sich nur dann um einen Fehler handelt, wenn ein tatsächliches Objekt zugewiesen wird, sei es auf dem Stapel oder im globalen Speicher. (Ein Anruf bei malloc für diesen Betrag wird sowieso scheitern)