Utilizzo di snprintf in un'applicazione multipiattaforma

Question

Sto scrivendo un programma C che dovrebbe essere compilato con tutti i principali compilatori. Attualmente sto sviluppando su GCC su una macchina Linux e compilerò su MSVC prima di eseguire il codice. Per semplificare la compilazione incrociata, compilo con le bandiere -ansi e -pedantic. Questo ha funzionato bene fino a quando ho iniziato a utilizzare snprintf che non è disponibile nello standard C89. GCC può compilare questo senza lo switch ma MSVC fallirà sempre in quanto non ha il supporto C99.

Così ho fatto qualcosa di simile,

#ifdef WIN32 
#define snprintf sprintf_s 
#endif 

Questo funziona bene perché snprintf e sprintf_s ha le stesse firme. Mi chiedo se questo è l'approccio corretto?

Answer 1

No. Il tuo approccio è destinato a fallire.

sqrt e cos hanno lo stesso prototipo. Pensi di poterli scambiare in un programma e ottenere lo stesso comportamento prima/dopo la modifica?

---

Probabilmente dovrebbe scrivere il proprio snprintf, o scaricare un'implementazione da internet (google is your friend) e l'uso che sia in Linux e Windows.

Answer 2

Ho trovato this sull'utilizzo di _snprintf() in alternativa e i trucchi coinvolti se la protezione da sovraccarico del buffer si attiva effettivamente. Da quello che ho potuto vedere a una rapida occhiata, simili avvertimenti si applicano a sprintf_s.

Riesci a vedere il problema? Nella versione Linux, l'output è sempre terminato da null. In MSVC, non lo è.

Ancora più sottile è la differenza tra il parametro size in Linux e il parametro count in MSVC. Il primo è la dimensione del buffer di output incluso il null che termina e il secondo è il numero massimo di caratteri da memorizzare, il che esclude il null terminante.

Oh, e non dimenticare di inviare una mail a Microsoft chiedendo di supportare gli attuali standard linguistici. (So ​​che hanno già annunciato che non hanno intenzione di supportare C99, ma lo infastidiscono comunque. Lo meritano.)

In conclusione, se vuoi giocare davvero sicuro, dovrai fornire il tuo snprintf() (un wrapper attorno a _snprintf() o sprintf_s() che recupera il loro comportamento non standard) per MSVC.

Answer 3

la risposta più completa (si può migliorare, se lo si desidera), che mettere in un adesivo

#if __PLATFORM_WIN_ZERO_STANDARD__ 

    static inline 
    int LIBSYS_SNPRINTF(char * str, size_t size, const char * format, ...) 
    { 
     int retval; 
     va_list ap; 
     va_start(ap, format); 
     retval = _vsnprintf(str, size, format, ap); 
     va_end(ap); 
     return retval; 
    } 

    static inline 
    int LIBSYS_VASPRINTF(char **ret, char * format, va_list ap) 
    { 
     int wanted = vsnprintf(*ret = NULL, 0, format, ap); 
     if((wanted > 0) && ((*ret = LIBSYS_MALLOC(1 + wanted)) != NULL)) { 
      return vsprintf(*ret, format, ap); 
     } 
     return wanted; 
    } 

    static inline 
    int LIBSYS_ASPRINTF(char **ret, char * format, ...) 
    { 
     int retval; 
     va_list ap; 
     va_start(ap, format); 
     retval = LIBSYS_VASPRINTF(ret, format, ap); 
     va_end(ap); 
     return retval; 
    } 

#else 
    #define LIBSYS_SNPRINTF snprintf 
    #define LIBSYS_VASPRINTF vasprintf 
    #define LIBSYS_ASPRINTF asprintf 
#endif 

Answer 4

La proposta può funzionare se si sta prestando attenzione.Il problema è che sia la funzione si comportano un po 'diverso, se questo non è un problema per voi, vi sono buone per andare, altrimenti pensare a una funzione wrapper:

Differenze tra MSVCs _snprintf e ufficiale C99 (gcc, clang) snprintf:

valore

di ritorno:

• MSVC: ritorno -1 se la dimensione del buffer non è sufficiente per scrivere tutto
• GCC (non compreso di terminazione nullo!): restituisce il numero di caratteri che sarebbe stato scritto se il buffer di grandi dimensioni abbastanza

byte scritte:

• MSVC: scrivere il più possibile, non scrivere NULL alla fine se c'è spazio lasciato
• GCC: scrivere il più possibile, sempre scrivere di terminazione NULL (eccezione : buffer_size = 0)

Interessante %n sottigliezza: Se si utilizza %n nel codice, MSVC lascerà non inizializzate! se smette di parsing perché la dimensione del buffer è troppo piccola, GCC scriverà sempre il numero di byte che sarebbero stati scritti se il buffer fosse stato sufficientemente grande.

Quindi la mia proposta sarebbe quello di scrivere la propria funzione involucro mysnprintf utilizzando vsnprintf/_vsnprintf che dà i valori stessi di ritorno e scrive le stesse byte su entrambe le piattaforme (attenzione: %n è più difficile da risolvere).

Answer 5

È possibile aprire il file speciale NUL per MSVC e scrivere su quello. Ti dirà sempre quanti byte sono necessari e non scriverà nulla. Mi piace così:

int main (int argc, char* argv[]) { 
    FILE* outfile = fopen("nul", "wb"); 
    int written; 

    if(outfile == NULL) { 
    fputs ("could not open 'nul'", stderr); 
    } 
    else { 
    written = fprintf(outfile, "redirect to /dev/null"); 
    fclose(outfile); 
    fprintf(stdout, "didn't write %d characters", written); 
    } 

    return 0; 
} 

Si dovrebbe quindi sapere quanti byte allocare per utilizzare sprintf con successo.