Perché le matrici C non possono avere lunghezza 0?

Lo standard C11 afferma che gli array, sia di dimensioni che di lunghezza variabile "devono avere un valore maggiore di zero". Qual è la giustificazione per non consentire una lunghezza di 0?

Soprattutto per array di lunghezza variabile ha perfettamente senso avere una dimensione di zero ogni tanto. È anche utile per le matrici statiche quando le loro dimensioni provengono da un'opzione di configurazione macro o build.

È interessante notare che GCC (e clang) forniscono estensioni che consentono matrici di lunghezza zero. Java consente anche matrici di lunghezza zero.

Il problema che vorrei scommettere è che le matrici C sono solo dei puntatori all'inizio di un pezzo di memoria allocato. Avere una dimensione 0 significherebbe che hai un puntatore a ... niente? Non puoi avere nulla, quindi ci sarebbe dovuto essere una scelta arbitraria. Non puoi usarlo null, perché allora i tuoi array di lunghezza 0 sembrerebbero puntatori nulli. E a quel punto ogni diversa implementazione sceglierà comportamenti arbitrari diversi, portando al caos.

Diamo un'occhiata a come un array è in genere disposto in memoria:

         +----+
arr[0] : |    |
         +----+
arr[1] : |    |
         +----+
arr[2] : |    |
         +----+
          ...
         +----+
arr[n] : |    |
         +----+

Si noti che non esiste un oggetto separato denominato arrche memorizza l'indirizzo del primo elemento; quando una matrice appare in un'espressione, C calcola l'indirizzo del primo elemento secondo necessità.

Quindi, cerchiamo di pensare a questo: un array di 0 elementi non avrebbe nessun deposito insieme a parte per esso, il che significa non c'è niente da calcolare l'indirizzo di matrice da (in altre parole, non c'è alcun mapping oggetto per l'identificatore). È come dire "Voglio creare unint variabile che non occupi memoria". È un'operazione senza senso.

modificare

Gli array Java sono animali completamente diversi dagli array C e C ++; non sono un tipo primitivo, ma un tipo di riferimento derivatoObject .

Modifica ²

Un punto evidenziato nei commenti seguenti: il vincolo "maggiore di 0" si applica solo agli array in cui la dimensione è specificata tramite un'espressione costante ; a un VLA è consentito avere una lunghezza 0 Dichiarare un VLA con un'espressione non costante a valore 0 non costituisce una violazione del vincolo, ma invoca un comportamento indefinito.

È chiaro che i VLA sono animali diversi dalle normali matrici e la loro implementazione può consentire una taglia 0 . Non possono essere dichiarati statico nell'ambito del file, poiché la dimensione di tali oggetti deve essere nota prima dell'avvio del programma.

Inoltre, non vale nulla che a partire dal C11, le implementazioni non sono necessarie per supportare i VLA.

Solitamente si vorrebbe che l'array di dimensioni zero (in realtà variabile) ne conoscesse le dimensioni in fase di esecuzione. Quindi impacchettalo in a structe usa membri di array flessibili , come ad esempio:

struct my_st {
   unsigned len;
   double flexarray[]; // of size len
};

Ovviamente il membro flessibile dell'array deve essere l'ultimo nella sua struct e deve avere qualcosa prima. Spesso ciò sarebbe correlato alla lunghezza effettiva occupata dal runtime di quel membro flessibile dell'array.

Naturalmente assegneresti:

 unsigned len = some_length_computation();
 struct my_st*p = malloc(sizeof(struct my_st)+len*sizeof(double));
 if (!p) { perror("malloc my_st"); exit(EXIT_FAILURE); };
 p->len = len;
 for (unsigned ix=0; ix<len; ix++)
    p->flexarray[ix] = log(3.0+(double)ix);

AFAIK, questo era già possibile in C99 ed è molto utile.

A proposito, i membri flessibili dell'array non esistono in C ++ (perché sarebbe difficile definire quando e come dovrebbero essere costruiti e distrutti). Vedi comunque il futuro std :: dynarray

Se l'espressione type name[count]è scritta in qualche funzione, si dice al compilatore C di allocare sizeof(type)*countbyte sullo stack frame e calcolare l'indirizzo del primo elemento nell'array.

Se l'espressione type name[count]è scritta al di fuori di tutte le funzioni e definisce le definizioni, allora si dice al compilatore C di allocare sui sizeof(type)*countbyte del segmento di dati e calcolare l'indirizzo del primo elemento nell'array.

namein realtà è un oggetto costante che memorizza l'indirizzo del primo elemento nella matrice e ogni oggetto che memorizza un indirizzo di una certa memoria è chiamato puntatore, quindi questa è la ragione che trattate namecome un puntatore piuttosto che una matrice. Si noti che le matrici in C sono accessibili solo tramite puntatori.

Se countè un'espressione costante che restituisce zero, si dice al compilatore C di allocare zero byte sul frame dello stack o sul segmento di dati e restituire l'indirizzo del primo elemento nell'array, ma il problema nel fare ciò è che il primo elemento di array di lunghezza zero non esiste e non è possibile calcolare l'indirizzo di qualcosa che non esiste.

Questo è razionale quell'elemento n. count+1non esiste countnell'array -length, quindi questo è il motivo per cui il compilatore C proibisce di definire l'array a lunghezza zero come variabile dentro e fuori una funzione, perché qual è il contenuto di nameallora? Quale indirizzoname memorizza esattamente?

Se pè un puntatore, l'espressione p[n]è equivalente a*(p + n)

Dove l'asterisco * nell'espressione giusta è un'operazione di dereference del puntatore, che significa accedere alla memoria puntata p + no accedere alla memoria il cui indirizzo è memorizzato p + n, dove p + nè l'espressione del puntatore, prende l'indirizzo di pe aggiunge a questo indirizzo il numero nmoltiplica il dimensione del tipo di puntatore p.

È possibile aggiungere un indirizzo e un numero?

Sì, è possibile, poiché l'indirizzo è un numero intero senza segno comunemente rappresentato in notazione esadecimale.

Se si desidera un puntatore a un indirizzo di memoria, dichiararne uno. Un array in realtà punta a un pezzo di memoria che hai prenotato. Le matrici decadono ai puntatori quando passano alle funzioni, ma se la memoria a cui puntano è nell'heap, nessun problema. Non vi è alcun motivo per dichiarare un array di dimensioni zero.

Dai tempi del C89 originale, quando uno standard C specificava che qualcosa aveva un comportamento indefinito, ciò significava "Fare qualunque cosa renderebbe un'implementazione su una particolare piattaforma di destinazione più adatta allo scopo previsto". Gli autori dello standard non volevano provare a indovinare quali comportamenti potrebbero essere più adatti per uno scopo particolare. Le implementazioni C89 esistenti con estensioni VLA potrebbero avere avuto comportamenti diversi, ma logici, quando le loro dimensioni erano pari a zero (ad esempio, alcuni potrebbero aver trattato l'array come un'espressione di indirizzo che produce NULL, mentre altri lo trattano come un'espressione di indirizzo che potrebbe eguagliare l'indirizzo di un'altra variabile arbitraria, ma potrebbe tranquillamente aggiungervi zero senza intrappolare). Se un codice avesse fatto affidamento su un comportamento così diverso, gli autori dello Standard non avrebbero "

Invece di provare a indovinare cosa potrebbero fare le implementazioni, o suggerendo che qualsiasi comportamento debba essere considerato superiore a qualsiasi altro, gli autori dello Standard hanno semplicemente permesso agli implementatori di usare il giudizio nel gestire quel caso nel modo che ritengono più opportuno. Le implementazioni che usano malloc () dietro le quinte potrebbero trattare l'indirizzo dell'array come NULL (se malloc size-zero produce null), quelle che usano i calcoli di stack-address potrebbero produrre un puntatore che corrisponde all'indirizzo di qualche altra variabile, e alcune altre implementazioni potrebbero fare altre cose. Non credo che si aspettassero che gli autori di compilatori avrebbero fatto di tutto per far sì che il case d'angolo a dimensione zero si comportasse in modo deliberatamente inutile.