C/Appendice/Librerie standard/string.h

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:

void * memcpy(void * dst_buf, void * src_buf, size_t n);

• 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

#include <string.h>
#include <stdio.h>

int main()
{
    char stringa[] = {"Pippo"};
    char altra_stringa[sizeof(stringa)];  // sizeof(stringa) restituisce la dimensione in bytes di stringa

    memcpy(altra_stringa, stringa, sizeof(stringa));

    printf("%s\n",altra_stringa);  // Se non sono avvenuti errori, la printf stamperà a schermo "Pippo"

    return 0;
}

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 ):

size_t strlen(const char * str)
{
    const char * s = str;
    for (; *s; ++s);
    return(s - str);
}

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

/* Esempio con un carattere separatore */
#include <stdio.h>
#include <string.h>

int main()
{
 char s[] = "aaa,bbb,ccc,ddd,eee";
 char* p;
 printf("Stringa completa: \n %s\nStringa spezzata:\n",s);
 p = strtok(s, ",");
 while (p != NULL)
 {
   printf("%s\n", p);
   p = strtok(NULL, ",");
 }
 return 0;
}

Output del programma sopra:

Stringa completa:
aaa,bbb,ccc,ddd,eee
Stringa spezzata:
aaa
bbb
ccc
ddd
eee

Un altro esempio:

/* Esempio con diversi caratteri separatori */
#include <stdio.h>
#include <string.h>

int main ()
{
  char s[] = " - Questa, è una stringa! Ora è spezzata.";
  char * p;
  printf ("Stringa completa: \n\"%s\ \nStringa spezzata:\n",s);
  p = strtok (s," -,!è.");
  while (p != NULL)
  {
    printf ("%s\n",p);
    p = strtok (NULL, " -,!è.");
  }
  return 0;
}

Output del programma sopra:

Stringa completa:
Questa, è una stringa! Ora è spezzata.
Stringa spezzata:
Questa
una
stringa
Ora
spezzata