Warum sind Arrays mit variabler Länge nicht Teil des C ++ - Standards?

Ich habe C in den letzten Jahren nicht sehr oft benutzt. Als ich diese Frage heute las , stieß ich auf eine C-Syntax, mit der ich nicht vertraut war.

Anscheinend ist in C99 die folgende Syntax gültig:

void foo(int n) {
    int values[n]; //Declare a variable length array
}

Dies scheint eine ziemlich nützliche Funktion zu sein. Gab es jemals eine Diskussion darüber, es dem C ++ - Standard hinzuzufügen, und wenn ja, warum wurde es weggelassen?

Einige mögliche Gründe:

• Haarig für Compiler-Anbieter zu implementieren
• Inkompatibel mit einem anderen Teil des Standards
• Die Funktionalität kann mit anderen C ++ - Konstrukten emuliert werden

Der C ++ - Standard besagt, dass die Arraygröße ein konstanter Ausdruck sein muss (8.3.4.1).

Ja, natürlich ist mir klar, dass man im Spielzeugbeispiel verwenden könnte std::vector<int> values(m);, aber dies ordnet Speicher vom Heap und nicht vom Stapel zu. Und wenn ich ein mehrdimensionales Array möchte wie:

void foo(int x, int y, int z) {
    int values[x][y][z]; // Declare a variable length array
}

Die vectorVersion wird ziemlich ungeschickt:

void foo(int x, int y, int z) {
    vector< vector< vector<int> > > values( /* Really painful expression here. */);
}

Die Slices, Zeilen und Spalten werden möglicherweise auch über den gesamten Speicher verteilt.

Wenn man sich die Diskussion anschaut comp.std.c++, ist klar, dass diese Frage mit einigen sehr schwergewichtigen Namen auf beiden Seiten des Arguments ziemlich kontrovers ist. Es ist sicherlich nicht offensichtlich, dass a std::vectorimmer eine bessere Lösung ist.

Vor kurzem gab es eine Diskussion darüber, die im Usenet gestartet wurde: Warum keine VLAs in C ++ 0x .

Ich stimme den Leuten zu, die der Meinung zu sein scheinen, dass es nicht gut ist, ein potenziell großes Array auf dem Stapel zu erstellen, für das normalerweise nur wenig Speicherplatz verfügbar ist. Das Argument ist, wenn Sie die Größe vorher kennen, können Sie ein statisches Array verwenden. Und wenn Sie die Größe vorher nicht kennen, schreiben Sie unsicheren Code.

C99-VLAs könnten einen kleinen Vorteil darin haben, kleine Arrays erstellen zu können, ohne Speicherplatz zu verschwenden oder Konstruktoren für nicht verwendete Elemente aufzurufen, aber sie führen zu ziemlich großen Änderungen am Typsystem (Sie müssen in der Lage sein, Typen abhängig von den Laufzeitwerten anzugeben - dies existiert in aktuellem C ++ noch nicht, außer für newOperator-Typ-Spezifizierer, aber sie werden speziell behandelt, damit die Laufzeit nicht dem Bereich des newOperators entgeht.

Sie können verwenden std::vector, aber es ist nicht ganz dasselbe, da es dynamischen Speicher verwendet, und es ist nicht gerade einfach, den eigenen Stapelzuweiser zu verwenden (auch die Ausrichtung ist ein Problem). Es löst auch nicht das gleiche Problem, da ein Vektor ein Container mit veränderbarer Größe ist, während VLAs eine feste Größe haben. Mit dem Vorschlag für ein dynamisches C ++ - Array soll eine bibliotheksbasierte Lösung als Alternative zu einer sprachbasierten VLA eingeführt werden. Soweit ich weiß, wird es jedoch nicht Teil von C ++ 0x sein.

(Hintergrund: Ich habe einige Erfahrung mit der Implementierung von C- und C ++ - Compilern.)

Arrays mit variabler Länge in C99 waren im Grunde ein Fehltritt. Um VLAs zu unterstützen, musste C99 dem gesunden Menschenverstand folgende Zugeständnisse machen:

• sizeof xist nicht mehr immer eine Kompilierungszeitkonstante; Der Compiler muss manchmal Code generieren, um einen sizeofAusdruck zur Laufzeit auszuwerten .

• Das Zulassen von zweidimensionalen VLAs ( int A[x][y]) erforderte eine neue Syntax zum Deklarieren von Funktionen, die 2D-VLAs als Parameter verwenden : void foo(int n, int A[][*]).

• In der C ++ - Welt weniger wichtig, aber für Cs Zielgruppe von Programmierern für eingebettete Systeme äußerst wichtig, bedeutet das Deklarieren einer VLA, einen beliebig großen Teil Ihres Stapels zu zerlegen . Dies ist ein garantierter Stapelüberlauf und Absturz. (Jedes Mal int A[n], wenn Sie deklarieren , behaupten Sie implizit, dass Sie 2 GB Stack übrig haben. Wenn Sie wissen, dass " nhier definitiv weniger als 1000 sind", deklarieren Sie dies einfach int A[1000]. Das Ersetzen der 32-Bit-Ganzzahl ndurch 1000ist eine Zulassung dass Sie keine Ahnung haben, wie sich Ihr Programm verhalten soll.)

Okay, lassen Sie uns jetzt über C ++ sprechen. In C ++ haben wir die gleiche starke Unterscheidung zwischen "Typsystem" und "Wertesystem" wie in C89 ... aber wir haben wirklich begonnen, uns auf eine Weise darauf zu verlassen, die C nicht hat. Zum Beispiel:

template<typename T> struct S { ... };
int A[n];
S<decltype(A)> s;  // equivalently, S<int[n]> s;

Wenn nes keine Kompilierungszeitkonstante gäbe (dh wenn Asie vom variabel modifizierten Typ wäre), was um alles in der Welt wäre dann der Typ S? Würde S‚s Art auch nur zur Laufzeit ermittelt?

Was ist damit:

template<typename T> bool myfunc(T& t1, T& t2) { ... };
int A1[n1], A2[n2];
myfunc(A1, A2);

Der Compiler muss Code für eine Instanziierung von generieren myfunc. Wie sollte dieser Code aussehen? Wie können wir diesen Code statisch generieren, wenn wir den Typ nicht kennen?A1 beim Kompilieren ?

Schlimmer noch, was ist, wenn sich zur Laufzeit herausstellt n1 != n2, dass !std::is_same<decltype(A1), decltype(A2)>()? In diesem Fall sollte der Aufruf von myfunc nicht einmal kompiliert werden , da der Abzug des Vorlagentyps fehlschlagen sollte! Wie könnten wir dieses Verhalten möglicherweise zur Laufzeit emulieren?

Grundsätzlich bewegt sich C ++ in die Richtung, immer mehr Entscheidungen in die Kompilierungszeit zu verschieben : Generierung von Vorlagencode, constexprFunktionsbewertung usw. In der Zwischenzeit war C99 damit beschäftigt, traditionell Entscheidungen zur Kompilierungszeit (z. B. sizeof) in die Laufzeit zu verschieben . Ist es in diesem Sinne überhaupt sinnvoll, Anstrengungen zu unternehmen , um VLAs im C99-Stil in C ++ zu integrieren?

Wie jeder andere Antwortende bereits betont hat, bietet C ++ viele Heap-Zuweisungsmechanismen ( std::unique_ptr<int[]> A = new int[n];oder std::vector<int> A(n);die offensichtlichen), wenn Sie wirklich die Idee vermitteln möchten: "Ich habe keine Ahnung, wie viel RAM ich möglicherweise benötige." Und C ++ bietet ein geschicktes Modell für die Ausnahmebehandlung, um die unvermeidliche Situation zu bewältigen, dass die benötigte RAM-Größe größer ist als die vorhandene RAM-Größe. Aber hoffentlich gibt Ihnen diese Antwort eine gute Vorstellung davon, warum VLAs im C99-Stil nicht gut zu C ++ passen - und nicht einmal wirklich gut zu C99. ;)

Weitere Informationen zu diesem Thema finden Sie in N3810 "Alternativen für Array-Erweiterungen" , Bjarne Stroustrups Artikel über VLAs vom Oktober 2013. Bjarnes POV unterscheidet sich sehr von meinem; N3810 konzentriert sich mehr darauf, eine gute C ++ - Ish- Syntax für die Dinge zu finden und die Verwendung von Raw-Arrays in C ++ zu unterbinden, während ich mich mehr auf die Auswirkungen auf die Metaprogrammierung und das Typensystem konzentrierte. Ich weiß nicht, ob er die Auswirkungen der Metaprogrammierung / des Typensystems für gelöst, lösbar oder nur uninteressant hält.

Ein guter Blog-Beitrag, der viele dieser Punkte trifft, ist "Legitime Verwendung von Arrays mit variabler Länge" (Chris Wellons, 27.10.2019).

Sie können jederzeit alloca () verwenden, um zur Laufzeit Speicher auf dem Stapel zuzuweisen, wenn Sie dies wünschen:

void foo (int n)
{
    int *values = (int *)alloca(sizeof(int) * n);
}

Die Zuweisung auf dem Stapel bedeutet, dass er automatisch freigegeben wird, wenn der Stapel abgewickelt wird.

Kurzer Hinweis: Wie in der Mac OS X-Manpage für alloca (3) erwähnt, "ist die alloca () -Funktion maschinen- und compilerabhängig; ihre Verwendung wird nicht empfohlen." Nur damit du es weißt.

In meiner eigenen Arbeit habe ich festgestellt, dass es mir jedes Mal, wenn ich etwas wie automatische Arrays mit variabler Länge oder alloca () wollte, egal war, dass sich der Speicher physisch auf dem CPU-Stapel befand, nur dass er von dort stammte Einige Stapelzuweiser, die keine langsamen Fahrten zum allgemeinen Haufen verursachten. Ich habe also ein Pro-Thread-Objekt, das Speicher besitzt, aus dem Puffer mit variabler Größe gepusht / eingeblendet werden können. Auf einigen Plattformen lasse ich dies über mmu wachsen. Andere Plattformen haben eine feste Größe (normalerweise wird dies auch von einem CPU-Stapel mit fester Größe begleitet, da keine mmu vorhanden sind). Eine Plattform, mit der ich arbeite (eine Handheld-Spielekonsole), hat ohnehin einen wertvollen kleinen CPU-Stapel, da sie sich in einem knappen, schnellen Speicher befindet.

Ich sage nicht, dass es niemals erforderlich ist, Puffer variabler Größe auf den CPU-Stapel zu verschieben. Ehrlich gesagt war ich überrascht, als ich herausfand, dass dies kein Standard war, da das Konzept sicherlich gut genug in die Sprache passt. Für mich sind die Anforderungen "variable Größe" und "muss sich physisch auf dem CPU-Stapel befinden" jedoch nie zusammengekommen. Es ging um Geschwindigkeit, also habe ich meinen eigenen "parallelen Stapel für Datenpuffer" erstellt.

Es gibt Situationen, in denen das Zuweisen von Heapspeicher im Vergleich zu den ausgeführten Vorgängen sehr teuer ist. Ein Beispiel ist die Matrixmathematik. Wenn Sie mit kleinen Matrizen arbeiten, z. B. 5 bis 10 Elemente, und viel rechnen, ist der Malloc-Overhead sehr bedeutend. Gleichzeitig erscheint es sehr verschwenderisch und unflexibel, die Größe zu einer Kompilierungszeitkonstante zu machen.

Ich denke, dass C ++ an sich so unsicher ist, dass das Argument, "nicht mehr unsichere Funktionen hinzuzufügen", nicht sehr stark ist. Auf der anderen Seite, da C ++ wohl die laufzeiteffizienteste Programmiersprachenfunktion ist, die es immer nützlicher macht: Leute, die leistungskritische Programme schreiben, werden C ++ in großem Umfang verwenden und sie benötigen so viel Leistung wie möglich. Das Verschieben von Sachen vom Haufen zum Stapel ist eine solche Möglichkeit. Das Reduzieren der Anzahl von Heap-Blöcken ist eine andere. Das Zulassen von VLAs als Objektmitglieder wäre eine Möglichkeit, dies zu erreichen. Ich arbeite an einem solchen Vorschlag. Die Implementierung ist zwar etwas kompliziert, scheint aber durchaus machbar.

Scheint, dass es in C ++ 14 verfügbar sein wird:

https://en.wikipedia.org/wiki/C%2B%2B14#Runtime-sized_one_dimensional_arrays

Update: Es hat es nicht in C ++ 14 geschafft.

Dies wurde für die Aufnahme in C ++ / 1x in Betracht gezogen, wurde jedoch gestrichen (dies ist eine Korrektur zu dem, was ich zuvor gesagt habe).

In C ++ wäre es sowieso weniger nützlich, da wir std::vectordiese Rolle bereits ausfüllen müssen.

Verwenden Sie dazu std :: vector. Zum Beispiel:

std::vector<int> values;
values.resize(n);

Der Speicher wird auf dem Heap zugewiesen, dies hat jedoch nur einen geringen Leistungsnachteil. Darüber hinaus ist es ratsam, dem Stapel keine großen Datenblöcke zuzuweisen, da seine Größe eher begrenzt ist.

C99 erlaubt VLA. Und es gibt einige Einschränkungen für die Deklaration von VLA. Einzelheiten finden Sie in 6.7.5.2 des Standards. C ++ verbietet VLA. Aber g ++ erlaubt es.

Arrays wie dieses sind Teil von C99, aber nicht Teil von Standard-C ++. Wie andere gesagt haben, ist ein Vektor immer eine viel bessere Lösung, weshalb Arrays mit variabler Größe wahrscheinlich nicht im C ++ - Standard (oder im vorgeschlagenen C ++ 0x-Standard) enthalten sind.

Übrigens, für Fragen zum "Warum" des C ++ - Standards ist die moderierte Usenet-Newsgroup comp.std.c ++ der richtige Ort.

Wenn Sie den Wert zur Kompilierungszeit kennen, können Sie Folgendes tun:

template <int X>
void foo(void)
{
   int values[X];

}

Bearbeiten: Sie können einen Vektor erstellen, der einen Stapelzuweiser (Alloca) verwendet, da der Allokator ein Vorlagenparameter ist.

Ich habe eine Lösung, die tatsächlich für mich funktioniert hat. Ich wollte wegen der Fragmentierung einer Routine, die viele Male ausgeführt werden musste, keinen Speicher zuweisen. Die Antwort ist äußerst gefährlich. Verwenden Sie sie daher auf eigenes Risiko. Sie nutzt jedoch die Montage, um Platz auf dem Stapel zu reservieren. In meinem folgenden Beispiel wird ein Zeichenarray verwendet (offensichtlich würde eine Variable anderer Größe mehr Speicher benötigen).

void varTest(int iSz)
{
    char *varArray;
    __asm {
        sub esp, iSz       // Create space on the stack for the variable array here
        mov varArray, esp  // save the end of it to our pointer
    }

    // Use the array called varArray here...  

    __asm {
        add esp, iSz       // Variable array is no longer accessible after this point
    } 
}

Die Gefahren hier sind vielfältig, aber ich werde einige erklären: 1. Eine Änderung der Variablengröße auf halbem Weg würde die Stapelposition zerstören. 2. Ein Überschreiten der Array-Grenzen würde andere Variablen und möglichen Code zerstören. 3. Dies funktioniert nicht in einem 64-Bit build ... brauche eine andere Assembly für diese (aber ein Makro könnte dieses Problem lösen). 4. Compilerspezifisch (kann Probleme beim Wechseln zwischen Compilern haben). Ich habe es nicht versucht, also weiß ich es wirklich nicht.