Was macht “[*]” (Sternmodifikator) bedeutet in C? [duplicate]

Beim Versuch, einen C11-Parser (für Bildungszwecke) zu implementieren, fand ich das in C11 (S. 470) sondern auch drin C99 (S. 412) (danke Johannes!), die direkter Erklärer ist definiert als:

(6.7.6) direct-declarator:  
    direct-declarator [ type-qualifier-list? * ]

Zuerst dachte ich, dies sei ein Fehler in der Grammatik (die Typenliste sollte nicht optional sein). Als ich dies jedoch in meinem Referenzcompiler (clang) ausprobierte, erhielt ich einen ziemlich unerwarteten Fehler:

int array[*] = { 1, 2, 3 };
// error: star modifier used outside of function prototype

Anscheinend heißt das also (im Klang). Sternmodifikator.

Ich habe schnell gelernt, dass sie nur in Funktionssignaturen verwendet werden können:

void foobar(int array[*])

Sie können jedoch nur in der Deklaration verwendet werden. Der Versuch, es in einer Funktionsdefinition zu verwenden, führt ebenfalls zu einem Fehler:

void foobar(int array[*]) {
    // variable length array must be bound in function definition
}

Soweit ich das beurteilen kann, ist das beabsichtigte Verhalten die Verwendung [*] in der Funktionsdeklaration und verwenden Sie dann eine feste Zahl in der Funktionsdefinition.

// public header
void foobar(int array[*]);

// private implementation
void foobar(int array[5]) {

}

Ich habe es jedoch noch nie gesehen und verstehe den Zweck auch nicht ganz.

1. Was ist ihr Zweck, warum wurde sie hinzugefügt?
2. Was ist der Unterschied zu int[]?
3. Was ist der Unterschied zu int *?

Was ist ihr Zweck, warum wurde sie hinzugefügt?

Zweck wird gesehen, wenn ein zweidimensionales Array variabler Länge als Funktionsparameter verwendet wird. Die Funktion

int foo(int n, int m, int a[n][m])  {...}   

kann wie folgt prototypisiert werden

int foo(int , int, int [][*]);
int foo(int , int, int a[*][*]);
int foo(int , int, int (*a)[*]);
int foo(int n, int, int a[n][*]);
int foo(int , int m, int a[*][m]);
int foo(int , int m, int (*a)[m]);
int foo(int n, int m, int a[n][m]); 

Im Falle eines zweidimensionalen Arrays, wenn es als Funktionsparameter verwendet wird, kann die Größe der zweiten Dimension nicht weggelassen werden. Wenn der Name der ersten Variablen im Funktionsprototypen weggelassen wird, wäre es nicht möglich, die Länge (zweite Dimension) des Arrays anzugeben. Das * gibt den Hinweis, dass die Länge des Arrays durch den zweiten Parameter bestimmt wird.

Was ist der Unterschied zu int[]?
Was ist der Unterschied zu int *?

Im Falle eines 1D-Arrays für die Funktionsdefinition

int bar(int n, int a[n]} {...}  

jeder der folgenden Prototypen ist gültig

int bar (int , int *);
int bar (int , int [*]);
int bar (int , int []);
int bar (int n, int a[]);
int bar (int n, int a[n]);
int bar (int n, int [n]);   

In diesem Fall auch nicht * Noch n ist notwendig, da der Compiler beide behandelt int [*] und int [n] wie int *. Bei einem eindimensionalen Array können Sie also keinen großen Unterschied feststellen.

HINWEIS: Wenn Sie ein Array mit variabler Länge als Funktionsparameter verwenden, ist die Reihenfolge der Parameter wichtig. Reihenfolge der Parameter für die ersten vier Prototypen von bar kann umgeschaltet werden, aber in den letzten beiden darf der erste Parameter nicht das Array selbst sein.

int bar (int a[n], int n);  //Wrong. Compiler has not yet seen 'n'.
  

Das C-Begründungsdokument für C99 sagt

Ein Funktionsprototyp kann Parameter haben, die Array-Typen mit variabler Länge (§6.7.5.2) haben, wobei eine spezielle Syntax wie in verwendet wird

int minimum(int, int [*][*]);

Dies steht im Einklang mit anderen C-Prototypen, bei denen der Name des Parameters nicht angegeben werden muss.

Was ist der Unterschied zu int[]

Was ist der Unterschied zu int *.

Ich denke, es ist einfach so, dass diese Typen in einem Funktionsprototyp “Zeiger” bedeuten, während a [*] in einer Nicht-Spitzenposition (int[*] immer noch gleich int[] Ich denke, in einem Funktionsprototypen) ist tatsächlich gültig und meint Reihe

// not recommended though: it is now unclear what the parameters
// mean to human callers!
void f(int, int [][*]);

void f(int n, int x[][n]) {
    x[1][0] = 1;
}

int main() {
   int a[2][1];
   f(1, a);
   printf("%d\n", a[1][0]);
}

Zu diesem Zweck muss der Compiler beim Indizieren des Arrays in der Funktionsdefinition wissen, wie viele Ganzzahlen des nächsten Indexes übersprungen werden müssen, wenn der erste Index angegeben wird (x[i] springt i * n ganze Zahlen ein f Oben). Diese Informationen werden jedoch in der nicht definierenden Prototypdeklaration nicht benötigt, daher können sie weggelassen und durch ersetzt werden *.