Genera avviso del compilatore se manca la virgola di inizializzazione const char * array

Sto usando molto le tabelle letterali di stringa nel mio codice C. Queste tabelle sembrano tutte più o meno così:

static const char* const stateNames[STATE_AMOUNT] =
{
    "Init state",
    "Run state",
    "Pause state",
    "Error state",
};

Il problema con il codice sopra è se la tabella si allunga e viene modificata durante lo sviluppo, di tanto in tanto dimentico una virgola. Il codice viene compilato senza problemi con una virgola mancante, ma il mio programma termina in modo anomalo quando viene impostata l'ultima stringa NULL. Ho usato i compilatori MinGW e Keil per verificare.

C'è un modo per generare un avviso del compilatore per la mia inizializzazione se manca la virgola?

Il confezionamento const char*di una coppia tra parentesi dovrebbe risolvere il problema, come mostrato nel frammento seguente:

static const char* const stateNames[5] =
{
    ("Init state"),
    ("Run state"),
    ("Pause state")     //comma missing
    ("Pause state3"),
    ("Error state")
};

Se dimentichi una virgola, otterrai un errore di compilazione simile a: error: called object is not a function or function pointer

DIMOSTRAZIONE DAL VIVO

Si noti che se si dimentica la virgola, ciò che accade effettivamente è che C concatenerà effettivamente le due (o più) stringhe fino alla virgola successiva o alla fine dell'array. Ad esempio diciamo che hai dimenticato la virgola come mostrato di seguito:

static const char* const stateNames[] =
{
    "Init state",
    "Run state",
    "Pause state" //comma missing
    "Pause state3" //comma missing
    "Error state"
};

int main(void)
{  
    printf("%s\n", stateNames[0]);
    return 0;    
}

Questo è ciò che gcc-9.2genera (altri compilatori generano codice simile):

.LC0:
        .string "Init state"
        .string "Run state"
        .string "Pause statePause state3Error state" ; oooops look what happened
        .quad   .LC0
        .quad   .LC1
        .quad   .LC2
main:
        push    rbp
        mov     rbp, rsp
        mov     eax, OFFSET FLAT:.LC0
        mov     rdi, rax
        call    puts
        mov     eax, 0
        pop     rbp
        ret

È chiaro che le ultime tre stringhe sono concatenate e l'array non è la lunghezza che ci si aspetterebbe.

È possibile consentire al compilatore di contare l'array e generare un messaggio di errore in caso di risultati imprevisti:

enum { STATE_AMOUNT = 4 };

static const char* const stateNames[] =
{
    "Init state",
    "Run state",
    "Pause state"    // <--- missing comma
    "Error state",
};

_Static_assert( sizeof stateNames / sizeof *stateNames == STATE_AMOUNT,
        "oops, missed a comma" );

Vedi questo thread per idee da implementare _Static_assertse il tuo compilatore è molto vecchio e non lo supporta.

Come bonus, questo può aiutare anche quando aggiungi nuovi stati ma dimentichi di aggiornare la tabella delle stringhe. Ma potresti voler esaminare anche X Macro.

Ho sempre usato un riferimento a un array di dimensioni esplicite per risolvere questo problema.

// no explicit size here
static const char* const stateNames[] =
{
    "Init state",
    "Run state",
    "Pause state",
    "Error state",
};
static const char* const (&stateNameVerifier)[STATE_AMOUNT] = stateNames;

http://coliru.stacked-crooked.com/a/593fc2eac80782a6

main.cpp:10:32: error: reference to type 'const char *const [5]' could not bind to an lvalue of type 'const char *const [4]'
static const char* const (&stateNameVerifier)[STATE_AMOUNT] = stateNames;

Questo non porta il compilatore ad aiutarti, ma trovo che scriverlo come sotto sia più facile per gli umani non rilasciare una virgola:

static const char* const stateNames[STATE_AMOUNT] =
{
      "Init state"
    , "Run state"
    , "Pause state"
    , "Error state"
};