Quick strlen question

Question

Sono venuto a disturbare tutti con un'altra domanda C probabilmente molto semplice.

utilizzando il seguente codice:

int get_len(char *string){ 

    printf("len: %lu\n", strlen(string)); 

    return 0; 
} 

int main(){ 

    char *x = "test"; 
    char y[4] = {'t','e','s','t'}; 

    get_len(x); // len: 4 
    get_len(y); // len: 6 

    return 0; 
} 

2 domande. Perché sono diversi e perché è 6? Grazie ragazzi.

EDIT: Scusa, so cosa aggiustarlo, volevo solo capire cosa stava succedendo. Quindi strlen continua a inoltrare il punto fino a quando non trova un \ 0? Anche quando ho eseguito il comando nella funzione principale invece che nella funzione get_len, entrambi erano 4. Era solo una coincidenza?

Answer 1

non è terminato con null. strlen() conta i caratteri finché non raggiunge un carattere null. Il tuo è successo a trovarne uno dopo il 6, ma potrebbe essere un qualsiasi numero. Prova questo:

char y[] = {'t','e','s','t', '\0'};

Ecco cosa un'implementazione di strlen() potrebbe assomigliare (la parte superiore della mia testa - non hanno il mio K & R libro a portata di mano, ma credo che ci sia un'implementazione dato lì) :

size_t strlen(const char* s) 
{ 
    size_t result = 0; 
    while (*s++) ++result; 
    return result; 
} 

Answer 2

È necessario annullare l'operazione y.

int get_len(char *string){ 

    printf("len: %lu\n", strlen(string)); 

    return 0; 
} 

int main(){ 

    char *x = "test"; 
    char y[5] = {'t','e','s','t','\0'}; 

    get_len(x); // len: 4 
    get_len(y); // len: 4 

    return 0; 
} 

strlen() prende in pratica il puntatore si dà e conta il numero di byte fino alla prossima NULL in memoria. E 'successo che ci fosse un NULL a due byte più tardi nella tua memoria.

Answer 3

Questo

char y[4] = {'t','e','s','t'}; 

non è una corretta terminata da zero s tring. È una serie di quattro caratteri, senza il '\0' terminante. strlen() conta semplicemente i caratteri finché non raggiunge lo zero. Con y conta semplicemente oltre la fine dell'array finché non trova accidentalmente un byte zero.
In questo modo si sta invocando un comportamento non definito. Il codice potrebbe anche formattare il tuo disco rigido.

È possibile evitare questo utilizzando la sintassi speciale per l'inizializzazione array di caratteri:

char y[] = "test"; 

Questo inizializza y con cinque personaggi, dal momento che aggiunge automaticamente un '\0'.
Nota che ho anche lasciato le dimensioni dell'array non specificato. Il compilatore lo calcola da solo, e automaticamente ridimensiona se cambio la lunghezza della stringa.

proposito, ecco una semplice applicazione strlen():

size_t strlen(const char* p) 
{ 
    size_t result = 0; 
    while(*p++) ++result; 
    return result; 
} 

implementazioni moderni probabilmente non prendere singoli byte o anche utilizzare intrinseci della CPU, ma questo è l'algoritmo di base.

Answer 4

che segue non è un nullo terminata array di caratteri:

char y[4] = {'t','e','s','t'}; 

Parte del contratto strlen() s' è che sia dotata di un puntatore a una stringa terminata nullo. Dal momento che ciò non accade con strlen(y), si ottiene un comportamento non definito. Nel tuo caso specifico, viene restituito 6, ma può accadere di tutto, incluso un arresto anomalo del programma.

Da 7.1.1 "Definizione dei termini" di C99:

Un stringa è una sequenza contigua di caratteri terminati da e comprendente il primo carattere nullo .

Answer 5

char y[5] = {'t','e','s','t','\0'}; 

sarebbe lo stesso di

char *x = "test"; 

Answer 6

strlen opere con stringhe. La stringa è definita come una sequenza (matrice) di caratteri terminata con il carattere \0.

I tuoi x indicano una stringa. Così, strlen funziona bene con x come argomento.

Il tuo non è una stringa. Per questo motivo, passando y a strlen risultati in un comportamento indefinito. Il risultato è privo di significato e imprevedibile.

Answer 7

Una stringa di tipo C effettiva è più grande del numero dei suoi caratteri, poiché ha bisogno di un carattere nullo di fine.

Pertanto, char y[4] = {'t','e','s','t'}; non forma una stringa, poiché è composta da quattro caratteri. char y[] = "test"; o char y[5] = "test"; formerebbero una stringa, da quando erano hanno un array di caratteri di cinque caratteri che terminano con il terminatore null-byte.

Answer 8

Come altri hanno già detto, è necessario assicurarsi di terminare una stringa con il carattere 0 o '\ 0'. Come nota a margine, puoi verificarlo: http://bstring.sourceforge.net/. Ha una funzione di lunghezza della stringa O (1), a differenza dello strlen C/C++ che è soggetto a errori e lento a O (N), dove N è il numero di caratteri non nulli. Non ricordo l'ultima volta in cui ho usato strlen e sono amici. Vai al sicuro & veloce funzioni/classi!