# C/Appendice/Librerie standard/string.h

C
Copertina Tutti i moduli · Sviluppo
* LinguaggioC/Linguaggio
** PanoramicaC/Linguaggio/Panoramica
** Struttura del linguaggioC/Linguaggio/Struttura del linguaggio
* Variabili, operatori e costantiC/Variabili, operatori e costanti
** VariabiliC/Variabili, operatori e costanti/Variabili
** Operatori aritmeticiC/Variabili, operatori e costanti/Operatori aritmetici
** Operatori sui bitC/Variabili, operatori e costanti/Operatori sui bit
** CostantiC/Variabili, operatori e costanti/Costanti
* Blocchi e funzioniC/Blocchi e funzioni
** Blocchi if e switchC/Blocchi e funzioni/Blocchi if e switch
** Operatori logiciC/Blocchi e funzioni/Operatori logici
** CicliC/Blocchi e funzioni/Cicli
** FunzioniC/Blocchi e funzioni/Funzioni
** mainC/Blocchi e funzioni/main
** LibrerieC/Blocchi e funzioni/Librerie
** RicorsivitàC/Blocchi e funzioni/Ricorsività
* Vettori e puntatoriC/Vettori e puntatori
** VettoriC/Vettori e puntatori/Vettori
** PuntatoriC/Vettori e puntatori/Puntatori
** Interscambiabilità tra puntatori e vettoriC/Vettori e puntatori/Interscambiabilità tra puntatori e vettori
* StringheC/Variabili, operatori e costanti/Stringhe
* Enumerazioni, strutture e unioniC/Enumerazioni, strutture e unioni
** EnumerazioniC/Enumerazioni, strutture e unioni/Enumerazioni
** StruttureC/Enumerazioni, strutture e unioni/Strutture
** UnioniC/Enumerazioni, strutture e unioni/Unioni
* Conversioni di tipoC/Conversioni di tipo
* Lettura e scrittura su fileC/Lettura e scrittura su file
** File di TestoC/Lettura e scrittura su file/File di Testo
** File BinariC/Lettura e scrittura su file/File Binari
* Compilatore e precompilatoreC/Compilatore e precompilatore
** CompilatoreC/Compilatore e precompilatore/Compilatore
** DirettiveC/Compilatore e precompilatore/Direttive
** HeaderC/Compilatore e precompilatore/Header
* VisibilitàC/Visibilità
* Gestione della memoriaC/Gestione della memoria
* Le applicazioni CGIC/Le applicazioni CGI
* Appendice
** Librerie standardC/Appendice/Librerie standard
*** assert.hC/Appendice/Librerie standard/assert.h
*** ctype.hC/Appendice/Librerie standard/ctype.h
*** errno.hC/Appendice/Librerie standard/errno.h
*** float.hC/Appendice/Librerie standard/float.h
*** limits.hC/Appendice/Librerie standard/limits.h
*** locale.hC/Appendice/Librerie standard/locale.h
*** math.hC/Appendice/Librerie standard/math.h
*** setjmp.hC/Appendice/Librerie standard/setjmp.h
*** signal.hC/Appendice/Librerie standard/signal.h
*** stdarg.hC/Appendice/Librerie standard/stdarg.h
*** stddef.hC/Appendice/Librerie standard/stddef.h
*** stdio.hC/Appendice/Librerie standard/stdio.h
*** stdlib.hC/Appendice/Librerie standard/stdlib.h
*** string.hC/Appendice/Librerie standard/string.h
*** time.hC/Appendice/Librerie standard/time.h
** StrumentiC/Appendice/Strumenti
*** InstallerC/Appendice/Strumenti/Installer
** Librerie esterneC/Appendice/Librerie esterne
* Bibliografia
    IndiceC/Indice
Modifica il sommario
string.h è l'header file della libreria standard del C che contiene definizioni di macro, costanti e dichiarazioni di funzioni e tipi usati non solo nella manipolazione delle stringhe ma anche nella manipolazione della memoria.

## Costanti e tipi

| Nome | Descrizione |
| NULL | Una macro che rappresenta la costante puntatore nullo; in altre parole, una costante che rappresenta un valore che è garantito essere l'indirizzo di una posizione non valida nella memoria. |
| size_t | Un intero senza segno restituito dell'operatore sizeof. |

## Funzioni

| Nome | Descrizione |
| void *memcpy(void *dest, const void *src, size_t n); | Copia n bytes tra due aree di memoria che non devono sovrapporsi. |
| void *memmove(void *dest, const void *src, size_t n); | Copia n bytes tra due aree di memoria; a differenza di memcpy le aree di memoria possono sovrapporsi. |
| void *memchr(const void *s, int c, size_t n); | Ritorna un puntatore alla prima occorrenza di c in s, o NULL se c non compare tra i primi n caratteri di s. |
| int memcmp(const void *s1, const void *s2, size_t n); | Confronta i primi n caratteri di s1 con s2. |
| void *memset(void *s, int c, size_t n); | Colloca c nei primi n caratteri di s. |
| char *strcat(char *dest, const char *src); | Concatena src alla stringa dest. |
| char *strncat(char *dest, const char *src, size_t n); | Concatena al massimo n caratteri src alla stringa dest. |
| char *strchr(const char *s, int c); | Restituisce un puntatore alla prima occorrenza di c in s. |
| char *strrchr(const char *s, int c); | Restituisce un puntatore all'ultima occorrenza di c in s. |
| int strcmp(const char *s1, const char *s2); | Confronta la stringa s1 con s2 (case sensitive). |
| int strncmp(const char *, const char *, size_t); | Confronta al massimo n caratteri della stringa s1 con s2 (case sensitive). |
| int strcasecmp(const char *s1, const char *s2); | Confronta la stringa s1 con s2 (case insensitive). |
| int strcasencmp(const char *, const char *, size_t); | Confronta al massimo n caratteri della stringa s1 con s2 (case insensitive). |
| int strcoll(const char *, const char *); | Confronta due stringhe utilizzando l'ordine lessicografico stabilito dalla localizzazione utilizzata |
| char *strcpy(char *s1, const char *s2); | Copia la stringa s2 nella stringa s1, incluso il carattere di terminazione \0. |
| char *strncpy(char *s1, const char *s2, size_t n); | Copia al massimo n caratteri della stringa s2 in s1. |
| char *strerror(int n); | Restituisce un puntatore alla stringa che corrisponde all'errore n. |
| size_t strlen(const char *s); | Restituisce la lunghezza della stringa s. |
| size_t strspn(const char *s, const char *accept); | Restituisce la lunghezza della porzione iniziale della stringa s di lunghezza massima composta esattamente dai caratteri della stringa accept |
| size_t strcspn(const char *s, const char *reject); | Restituisce la lunghezza della porzione iniziale della stringa s di lunghezza massima composta esattamente da caratteri diversi da quelli della stringa reject |
| char *strpbrk(const char *s, const char *accept); | Restituisce la prima occorrenza di un carattere presente nella stringa s che sia uguale ad un qualsiasi carattere presente nella stringa accept |
| char *strstr(const char *haystack, const char *needle); | Trova la prima occorrenza della stringa needle all'interno della stringa haystack |
| char *strtok(char *s, const char *delimiters); | Spezza la stringa s in una serie di stringhe chiamate [token] in corrispondenza dei carattere delimitatore delimiters |
| size_t strxfrm(char *dest, const char *src, size_t n); | Trasforma la stringa puntata da src secondo la localizzazione in uso e e copia i primi n caratteri di src nella stringa dest |

### memcpy

Esegue la copia delle porzioni di memoria a cui si riferiscono i suoi argomenti. La funzione memcpy è implementata per copiare zone di memoria non sovrapposte; se c'è sovrapposizione il comportamento della funzione è indefinito.
Sintassi:
* dst_buf punta all'indirizzo di memoria in cui copiare i dati;
* src_buf punta all'indirizzo di memoria che contiene i dati da copiare;
* n è la dimensione in bytes dei dati da copiare;
È da notare che la funzione memcpy è una funzione generica, ovvero in grado di copiare qualsiasi tipo di dato. Questo è reso possibile dal fatto che i puntatori alle zone di memoria da manipolare siano di tipo void. Il linguaggio C permette che vengano passati puntatori di qualsiasi tipo come parametri di ingresso ad una funzione che richieda puntatori void*.
La funzione memcpy restituisce dst_buf. Non sono definiti valori di ritorno in caso di errore. La funzione non effettua alcun controllo nel caso in cui si verifichi un overflow della zona di memoria di destinazione; o nel caso in cui le due regioni di memoria siano sovrapposte.

#### Esempio
### strlen

Restituisce la lunghezza di una stringa.
Può essere implementata in diversi modi. Usualmente le funzioni di libreria sono estremamente efficienti, tuttavia nessuna ottimizzazione può rendere strlen significativamente veloce per input molto grandi; è pertanto consigliata la soluzione di memorizzare la lunghezza delle stringhe alla loro creazione e modifica. Un buon compilatore ottimizzerà le chiamate a strlen su stringhe costanti, calcolandone la lunghezza a tempo di compilazione.
La versione 6.2 di FreeBSD implementa strlen nel seguente modo (successivamente è stata modificata):

### strtok

Viene usata per estrarre da una stringa una serie di sottostringhe dividendola tramite dei caratteri separatori. Le sottostringhe sono chiamate token, cioè sequenze di caratteri separati da uno o più caratteri specificati nel campo dei separatori.
Per utilizzare correttamente la funzione strtok occorre distinguere due momenti:
* Prima chiamata - Alla prima chiamata della funzione bisogna passare il puntatore alla stringa s; la funzione anzitutto esamina la stringa per identificare il primo carattere di s non contenuto nella lista dei separatori - chiamiamo questa posizione "inizio del token". Partendo da questo punto, la funzione prosegue la lettura di s fino a trovare un carattere corrispondente ad uno dei token. Il carattere viene sostituito con NULL (zero) e la funzione termina restituendo "inizio del token".
* Chiamate successive - Nelle chiamate successive invece la funzione attende in ingresso un puntatore NULL ed usa la posizione a destra dell'ultimo token trovato come inizio della ricerca del token successivo. strtok ritorna il puntatore all'ultimo token trovato.
Se non vengono trovati token, la funzione ritorna il valore NULL.
Fare molta attenzione perché la stringa originale viene modificata dalla funzione, infatti questa sostituisce i caratteri di separazione con caratteri di terminazione stringa.

#### Esempi di codice

Output del programma sopra:
Un altro esempio:
Output del programma sopra:

## Note

* ↑ (EN) strlen.c Revisione 1.4, su freebsd.org. URL consultato il 6-11-2009.
* ↑ (EN) strlen.c Revisione 1.6, su freebsd.org. URL consultato il 6-11-2009.