null che termina una stringa

gcc 4.4.4 c89null che termina una stringa

Qual è il modo standard per terminare una stringa null? Quando utilizzo lo NULL, ricevo un messaggio di avviso.

*dest++ = 0; 
*dest++ = '\0'; 
*dest++ = NULL; /* Warning: Assignment takes integer from pointer without a cast */

Codice sorgente:

size_t s_strscpy(char *dest, const char *src, const size_t len) 
{ 
    /* Copy the contents from src to dest */ 
    size_t i = 0; 
    for(i = 0; i < len; i++) 
    *dest++ = *src++; 

    /* Null terminate dest */ 
    *dest++ = 0; 

    return i; 
}

Un'altra domanda: ho deliberatamente commentata la linea che nulla termina. Tuttavia, ha ancora correttamente stampato il contenuto del dest. Il chiamante di questa funzione invierebbe la lunghezza della stringa includendo o il NULL incluso. Ad esempio strlen(src) + 1 o stlen(src).

size_t s_strscpy(char *dest, const char *src, const size_t len) 
{ 
    /* Copy the contents from src to dest */ 
    size_t i = 0; 
    /* Don't copy the null terminator */ 
    for(i = 0; i < len - 1; i++) 
    *dest++ = *src++; 

    /* Don't add the Null terminator */ 
    /* *dest++ = 0; */ 

    return i; 
}

fonte

2010-05-26 ant2009

+13

Preferisco '* dest ++ = '\ 0'; dal momento che ''\ 0'' ha il tipo corretto in questo contesto. –

@Paul R: Perché non fai questa risposta? – Lucas

'* dest ++ = 0;' perché post-incrementare il puntatore dopo aver assegnato il valore deferenziato a 0? – Larry

Alla tua prima domanda: Vorrei andare con il commento di Paul R e terminare con '\0'. Ma anche il valore 0 funziona correttamente. Una questione di gusto. Ma non utilizzare MACRO NULL che è pensato per i puntatori.

Alla tua seconda domanda: Se la tua stringa non viene terminata con \0, potrebbe comunque stampare l'output previsto perché seguire la stringa è un carattere non stampabile nella tua memoria. Si tratta di un bug davvero sgradevole, dal momento che potrebbe saltare in aria quando non ci si potrebbe aspettare. Sempre termina una stringa con '\0'.

fonte

2010-05-26 08:20:17 Lucas

'\ 0' è la strada da percorrere. È un carattere, che è ciò che si desidera in una stringa e ha il valore nullo.

Quando si dice stringa terminata null in C/C++, significa veramente "stringa terminata da zero". La macro NULL non è intesa per l'uso nella terminazione di stringhe.

fonte

2010-05-26 08:20:03

''\ 0'', se è un personaggio, è piuttosto grande !. Sono sicuro che oggi sulla maggior parte delle macchine, con un compilatore 'C', hai sizeof ('\ 0') == 4. (Forse i micro-controller 8031 sono un'eccezione?). –

@Joseph.Non sono del tutto sicuro da dove vieni. sizeof ('\ 0') esce come 1 byte sul mio compilatore. Per un carattere a doppio byte, sizeof (L '\ 0') è 2. –

Ho verificato due volte: in un file .c è 4, mentre in un file .cpp, o con g ++, è 1. La domanda era taggato come C, non C++. –

Be very attenzione: NULL è una macro utilizzata principalmente per i puntatori. Il norma modo di terminare una stringa è:

char *buffer; 
... 
buffer[end_position] = '\0';

Questa (sotto) funziona anche, ma non è una grande differenza tra assegnando un valore intero di un/corto lungo matrice int/e assegnando un valore di carattere. Questo è il motivo per cui la prima versione è preferita e personalmente mi piace di più.

buffer[end_position] = 0;

fonte

2010-05-26 08:29:32 INS

''\ 0'' è una costante di tipo 'int'in C. –

Dal comp.lang.c Domanda: http://c-faq.com/null/varieties.html

In sostanza: NULL (macro preprocessore per il puntatore nullo) non è la stessa NUL (il carattere nullo).

fonte

2010-05-26 08:30:32 jamesdlin

+1; mi fa davvero schifo tutte le volte che vedo "stringhe con terminazioni NULL": diamine, il terminatore di stringa non è NULL, è NUL! –

null che termina una stringa

risposta

Problemi correlati