Funzioni C per lavorare con le stringhe. Lavorare con le stringhe. Classe di stringa. Costruttori di classi. Le funzioni assign (), append (), insert (), replace (), erase (), find (), rfind (), compare (), c_str (). Esempi. Considera un esempio di dichiarazione e visualizzazione di stringhe

Una stringa è una sequenza di caratteri ASCII o UNICODE. Stringhe in C.come nella maggior parte dei linguaggi di programmazione di alto livello sono considerati come un tipo separato, incluso nel sistema dei tipi di base del linguaggio. Poiché il linguaggio C per la sua origine è un linguaggio di programmazione di sistema, non vi è alcun tipo di dati stringa in quanto tale e gli array di caratteri ordinari vengono utilizzati come stringhe in C.
Storicamente, ci sono state due rappresentazioni del formato stringa:
1. Formato ANSI;
2. stringhe con terminazione null (utilizzate in SI).

Il formato ANSI afferma che il valore della prima posizione in una stringa è la sua lunghezza, seguita dai caratteri nella stringa. Ad esempio, la rappresentazione di stringa "La mia stringa!" sarà il seguente:
11 "M" o "" I "" "s" "t" "p" "o" "a" "a" "!"
Nelle stringhe con terminazione , i caratteri significativi nella stringa vengono specificati nella prima posizione e il terminatore della stringa è zero. La rappresentazione della stringa precedentemente considerata in questo formato è:
'M' 'o' 'io' '' '' '' t '' 'p' 'o' 'a' 'a' '!' 0

Dichiarazione di stringhe in SI

Le stringhe vengono implementate utilizzando matrici di caratteri. Pertanto, una dichiarazione di stringa ASCII ha la seguente sintassi:
nome del carattere [lunghezza]; Anno Domini stringhe in si ha la stessa sintassi di una dichiarazione di matrice di caratteri unidimensionale. La lunghezza della stringa deve essere un valore intero (nello standard C89 è una costante, nello standard C99 può essere un'espressione). La lunghezza della stringa è specificata con un carattere per memorizzare lo zero terminale, quindi importo massimo i caratteri significativi in \u200b\u200buna stringa sono uno in meno della sua lunghezza. Ad esempio, una stringa può contenere un massimo di venti caratteri se viene dichiarata in questo modo:
char str; L'inizializzazione della stringa in C viene eseguita quando viene dichiarata utilizzando la seguente sintassi:
char str [lunghezza] \u003d stringa letterale; Una stringa letterale è una stringa di caratteri ASCII racchiusi tra virgolette doppie. Esempi di dichiarazione di stringhe con inizializzazione:
char str1 \u003d "Immettere un valore:", str2 \u003d ""; Esempio:
const char message \u003d "Messaggio di errore!";

Lavorare con le stringhe in SI

Poiché le stringhe C sono matrici di caratteri, puoi fare riferimento a qualsiasi carattere nella stringa tramite il suo indice. Per questo, viene utilizzata la sintassi per accedere a un elemento dell'array, quindi il primo carattere nella stringa ha un indice zero. Ad esempio, nel seguente frammento di codice, str sostituisce tutti i caratteri "a" con caratteri "A" e viceversa.
for (int i \u003d 0; str [i]! \u003d 0; i ++)
{
if (str [i] \u003d\u003d 'a') str [i] \u003d 'A';
altrimenti se (str [i] \u003d\u003d "A") str [i] \u003d "a";
}

Array di stringhe C.

È anche possibile dichiarare array di stringhe nel linguaggio C. Per questo, vengono utilizzati array di caratteri bidimensionali, che hanno la seguente sintassi:
nome del carattere [importo] [lunghezza]; La prima dimensione della matrice indica il numero di righe nell'array e la seconda - la lunghezza massima (tenendo conto dello zero terminale) di ciascuna riga. Ad esempio, una dichiarazione di matrice di cinque stringhe con una lunghezza massima di 30 caratteri significativi sarebbe:
char strs; Quando si dichiarano array di stringhe, è possibile eseguire l'inizializzazione:
nome del carattere [importo] [lunghezza] \u003d
(stringa letterale # 1, ... stringa letterale #N); Il numero di stringhe letterali deve essere minore o uguale al numero di stringhe nella matrice. Se il numero di stringhe letterali è inferiore alla dimensione dell'array, tutti gli altri elementi vengono inizializzati in stringhe vuote. La lunghezza di ogni stringa letterale deve essere strettamente inferiore al valore della lunghezza della stringa (per scrivere un valore nullo di terminazione).
Per esempio:
char giorni \u003d (
"Gennaio febbraio marzo Aprile Maggio",
"Giugno", "luglio", "agosto", "settembre", "ottobre",
"Novembre dicembre"
}; Quando si dichiarano array di stringhe con inizializzazione, è consentito non specificare il numero di stringhe tra parentesi quadre. In questo caso, il numero di righe nell'array sarà determinato automaticamente dal numero di stringhe letterali inizializzate.
Ad esempio, un array di sette righe:
char giorni \u003d (
"Lunedì martedì mercoledì giovedì",
"Venerdì sabato domenica"
};

Funzioni per lavorare con le stringhe in SI

Tutte le funzioni di libreria per lavorare con le stringhe possono essere suddivise in tre gruppi:
1. input e output di stringhe;
2. conversione di stringhe;
3. elaborazione delle stringhe.

Input e output di stringhe in SI

È possibile utilizzare le funzioni di input e output formattato (printf e scanf) per immettere e visualizzare informazioni sulla stringa. Per fare ciò, è necessario specificare l'identificatore di tipo% s nella stringa di formato quando si immette o si invia una variabile di stringa. Ad esempio, l'input e il successivo output di una variabile stringa sarebbero:
char str \u003d "";
printf ("Immettere la stringa:");
scanf ("% 30s", str);
printf ("Hai inserito:% s", str); Lo svantaggio della funzione scanf quando si immettono dati di stringa è che i delimitatori di questa funzione sono:
1.linea feed,
2. tabulazione;
3.spazio.
Pertanto, utilizzando questa funzione è impossibile inserire una stringa contenente più parole separate da spazi o tabulazioni. Ad esempio, se nel programma precedente l'utente inserisce la riga: "Messaggio di più parole", sullo schermo verrà visualizzato solo "Messaggio".
La libreria stdio.h contiene le funzioni specializzate gets e put per l'input e l'output di stringhe.

La funzione gets serve per l'inserimento di stringhe e ha il seguente titolo:
char * gets (char * buffer);

La funzione put è progettata per generare stringhe e ha la seguente intestazione:
int mette (const char * stringa); Il programma più semplice: l'input e l'output di una stringa utilizzando le funzioni gets e put sarà simile a questo:
char str \u003d "";
printf ("Immettere la stringa:"); ottiene (str);
printf ("Hai inserito:");
mette (str); Oltre alle funzioni per l'input e l'output nei flussi, la libreria stdio.h contiene funzioni per l'input e l'output formattati in stringhe. La funzione di input formattata dalla stringa ha la seguente intestazione:
int sscanf (const char * restringere il buffer, const char * restringere la stringa, ...); L'output formattato nelle funzioni stringa ha le seguenti intestazioni:
int sprintf (char * limita buffer,

int snprintf (char * limita buffer, size_t maxsize,
const char * restringere il formato, ...);

Conversione di stringhe

C per convertire stringhe contenenti numeri in valori numerici nella libreria stdlib.h
viene fornito il seguente insieme di funzioni:
double atof (const char * string); // converte una stringa in un double
int atoi (const char * string); // converte una stringa in un numero di tipo int
long int atol (const char * string); // converte una stringa in un long int
long long int atoll (const char * string); // converte una stringa in un numero di tipo long long int La corretta rappresentazione di un numero reale in una stringa di testo deve seguire il formato:
[(+ | -)] [cifre] [. cifre] [(e | E) [(+ | -)] cifre]

Dopo i caratteri E, e, è indicato l'ordine del numero. La corretta rappresentazione di un numero intero in una stringa di testo deve seguire il formato:
[(+ | -)] cifre

Oltre alle funzioni di cui sopra, la libreria stdlib.h fornisce anche le seguenti funzioni per convertire le stringhe in numeri reali:
float strtof (const char * restringere la stringa, char ** restringere endptr);
double strtod (const char * restringere la stringa, char ** restringere endptr);
long double strtold (const char * restringere la stringa, char ** limitare endptr);

Esistono funzioni simili per convertire le stringhe in valori interi:
long int strtol (const char * restringere la stringa,

unsigned long strtoul (const char * restringere la stringa,
char ** restringere endptr, int base);
long long int strtoll (const char * restringere la stringa,
char ** restringere endptr, int base);
unsigned long long strtoull (const char * restringere la stringa, char ** limitare endptr, int base);

Le funzioni di conversione inversa (valori numerici in stringhe) sono presenti nella libreria stdlib.h, ma non sono regolate dallo standard e non verranno prese in considerazione. Le funzioni sprintf e snprintf sono più convenienti per convertire i valori numerici in stringhe.

Elaborazione di stringhe

La libreria string.h contiene funzioni per varie azioni sulle stringhe.
Funzione di calcolo della lunghezza della stringa:
size_t strlen (const char * string); Esempio:
char str \u003d "1234";
int n \u003d strlen (str); // n \u003d\u003d 4 Funzioni di copia delle stringhe:
char * strcpy (char * restringere dst, const char * restringere src);
char * strncpy (char * restringere dst, const char * restringere src, size_t num); Funzioni di confronto tra stringhe:
int strcmp (const char * string1, const char * string2);
int strncmp (const char * string1, const char * string2, size_t num); Le funzioni confrontano le stringhe in ordine alfabetico e restituiscono:
valore positivo - se stringa1 è maggiore di stringa2;
valore negativo - se stringa1 è minore di stringa2;
valore nullo - se stringa1 è uguale a stringa2;

Funzioni di concatenazione (concatenazione) di stringhe:
char * strcat (char * restringere dst, const char * restringere src);
char * strncat (char * restringere dst, const char * restringere src, size_t num);

Funzioni per la ricerca di un carattere in una stringa:
char * strchr (const char * string, int c);
char * strrchr (const char * string, int c);

Funzione di ricerca stringa nella stringa:
char * strstr (const char * str, const char * substr);

Esempio:
char str \u003d "Stringa di ricerca";
char * str1 \u003d strstr (str, "for"); // str1 \u003d\u003d "per cercare"

Funzione di ricerca per il primo carattere in una stringa da un determinato set di caratteri:
size_t strcspn (const char * str, const char * charset);

Funzioni per trovare il primo carattere in una stringa che non appartiene a un determinato set di caratteri:
size_t strspn (const char * str, const char * charset);

Funzioni per trovare il primo carattere in una stringa da un determinato set di caratteri:
char * strpbrk (const char * str, const char * charset);

Funzione di ricerca per il successivo letterale nella stringa:
char * strtok (char * restringere la stringa, const char * restringere il set di caratteri);

Lavorare con le stringhe. Classe di stringa. Costruttori di classi. Le funzioni assign (), append (), insert (), replace (), erase (), find (), rfind (), compare (), c_str (). Esempi di

1. Qual è lo scopo della classe string nei programmi C ++?

La classe string è progettata per funzionare con stringhe di tipo char *, che sono stringhe con terminazione null. La classe string è stata introdotta come alternativa per lavorare con stringhe di tipo char *. Righe che terminano con un carattere ‘\0’ chiamate anche stringhe C. Poiché la stringa è una classe, puoi dichiarare gli oggetti di questa classe.

2. Quali moduli (librerie) devono essere collegati per utilizzare le capacità della classe stringa in MS Visual Studio C ++?

Per utilizzare le funzionalità della classe string in MS Visual Studio (C ++), è necessario connettere la libreria e lo spazio dei nomi std.

#includere using namespace std;

3. Come viene dichiarata una variabile di tipo stringa? Esempi di

La dichiarazione di una variabile di tipo stringa viene eseguita allo stesso modo di una variabile regolare. Possibile dichiarazione di inizializzazione simultanea.

// stringa tipo stringa s1; // variabile denominata s1 di tipo stringa string s2 \u003d "Questa è una variabile stringa"; // dichiarazione con inizializzazione // utilizzando una variabile di tipo stringa con l'operatore di assegnazione s1 \u003d s2; // s1 \u003d "Questa è una variabile stringa" s2 \u003d "Nuovo testo";

4. Quali sono i vantaggi e gli svantaggi dell'utilizzo della classe string rispetto al tipo char *?

La creazione del nuovo tipo di stringa era dovuta alle carenze del lavoro con le stringhe di caratteri, dimostrate dal tipo char *. Rispetto al tipo char *, il tipo stringa presenta i seguenti vantaggi principali:

la capacità di elaborare stringhe utilizzando operatori C ++ standard ( = , + , = = , <> eccetera.). Come sapete, quando si utilizza il tipo char *, anche le operazioni più semplici con le stringhe sembravano complicate e richiedevano la scrittura di codice di programmazione eccessivo;
garantendo una migliore affidabilità (sicurezza) del codice del programma. Ad esempio, quando si copiano stringhe, il tipo di stringa fornisce le azioni appropriate che possono verificarsi se la stringa di origine ha taglia più grande rispetto alla stringa di destinazione;
fornendo una stringa come tipo di dati indipendente. La dichiarazione del tipo di stringa come stringa è la stessa per tutte le variabili nel programma, il che garantisce la coerenza dei dati.

Lo svantaggio principale del tipo stringa rispetto al tipo char * è la velocità di elaborazione dei dati più lenta. Questo perché il tipo di stringa è effettivamente una classe contenitore. E lavorare con una classe richiede un'implementazione aggiuntiva del codice del programma, che a sua volta richiede tempo extra.

5. Quali operatori possono essere utilizzati con gli oggetti stringa?

La classe string è comoda in quanto consente di manipolare comodamente le stringhe utilizzando operatori standard (sovraccaricati).

I seguenti operatori possono essere utilizzati con gli oggetti della classe string

= - Incarico
+ - concatenazione (concatenazione di stringhe)
+= - assegnazione con concatenazione
== - uguaglianza
!= - disuguaglianza
< - Di meno
<= - inferiore o uguale
> - Di Più
>= - più o uguale
- indicizzazione

Esempio, che dimostra l'uso degli operatori di cui sopra

// tipo di stringa, operazioni sulle stringhe stringa s1 \u003d "s-1"; stringa s2 \u003d "s-2"; stringa s3; bool b; // operazione "\u003d" (assegnazione di stringhe) s3 \u003d s1; // s3 \u003d "s-1" // operazione "+" - concatenazione di stringhe s3 \u003d s3 + s2; // s3 \u003d "s-1s-2" // operazione "+ \u003d" - assegnazione con concatenazione s3 \u003d "s-3"; s3 + \u003d "abc"; // s3 \u003d "s-3abc" // operazione "\u003d\u003d" - confronto tra stringhe b \u003d s2 \u003d\u003d s1; // b \u003d falso b \u003d s2 \u003d\u003d "s-2"; // b \u003d true // operazione "! \u003d" - confronto tra stringhe (non uguale) s1 \u003d "s1"; s2 \u003d "s2"; b \u003d s1! \u003d s2; // b \u003d true // operazioni "<" и ">"- confronto tra stringhe s1 \u003d "abcd"; s2 \u003d "de"; b \u003d s1\u003e s2; // b \u003d falso b \u003d s1< s2; // b = true // operazioni "<=" и ">\u003d "- confronto tra stringhe (minore o uguale, maggiore o uguale) s1 \u003d "abcd"; s2 \u003d "ab"; b \u003d s1\u003e \u003d s2; // b \u003d vero b \u003d s1<= s2; // b = false b = s2 >\u003d "ab"; // b \u003d true // operazione - indicizzazione char c; s1 \u003d "abcd"; c \u003d s1; // c \u003d "c" c \u003d s1; // c \u003d "a"

6. La classe string contiene costruttori?

Come ogni classe, la classe string ha un numero di costruttori. I principali sono i seguenti:

Corda (); stringa (const char * str); string (const string & str);

7. Esempi di inizializzazione utilizzando i costruttori

Di seguito sono riportati esempi di inizializzazione di variabili di tipo stringa

Stringa s1 ("Ciao!"); string s2 \u003d "Ciao!" ; // inizializzazione - stringa del costruttore (const char * str) char * ps \u003d "Hello"; stringa s3 (ps); // stringa di inizializzazione s4 (s3); // inizializzazione - stringa del costruttore (const string & str) stringa s5; // inizializzazione - stringa di costruzione ()

8. Assegnazione di stringhe. Funzione Assign (). Esempi di

Per assegnare una stringa a un'altra, puoi utilizzare uno dei due metodi:

usa operatore di assegnazione ‘=’ ;
utilizzare la funzione assign () dalla classe string.

La funzione assign () ha diverse implementazioni sovraccaricate.

La prima opzione è chiamare una funzione senza parametri

String & assign (void);

In questo caso, c'è una semplice assegnazione di una stringa a un'altra.

La seconda opzione ti consente di copiare un dato numero di caratteri da una stringa:

String & assegna (const string & s, size_type st, size_type num);

s - l'oggetto da cui viene presa la stringa sorgente;
st - indice (posizione) nella stringa da cui iniziare a copiare num caratteri;
num - il numero di caratteri da copiare dalla posizione st;
size_type - tipo ordinale dati.

La terza variante della funzione assign () copia i primi num caratteri della stringa s nel chiamante:

Stringa & assegna (const char * s, size_type num);

s - una stringa terminata con un carattere ‘\0’ ;
num è il numero di caratteri che vengono copiati nel chiamante. Vengono copiati i primi num caratteri dalla stringa s.

Di seguito è riportato un esempio con diverse implementazioni della funzione assign ().

Esempio.

// assegnazione di stringhe, funzione assign () stringa s1 \u003d "sito"; stringa s2; stringa s3; char * ps \u003d "sito"; s3 \u003d s1; // s3 \u003d "site" s2.assign (s1); // s2 \u003d "site" s2.assign (s1, 0, 4); // s2 \u003d "best" s2.assign (ps, 8); // s2 \u003d "bestprog"

9. Concatenazione di stringhe. Funzione Append (). Esempio

La funzione append () viene utilizzata per concatenare le stringhe. È inoltre possibile utilizzare l'operazione per aggiungere righe ‘+’ , per esempio:

String s1; stringa s2; s1 \u003d "abc"; s2 \u003d "def"; s1 \u003d s1 + s2; // s1 \u003d "abcdef"

Tuttavia, la funzione append () è utile se è necessario aggiungere parte di una stringa.

La funzione ha le seguenti opzioni di implementazione:

String & append (const string & s, size_type start); stringa e aggiungi (const char * s, size_type num);

Nella prima implementazione, la funzione riceve un collegamento a un oggetto stringa s che viene aggiunto al chiamante. Nella seconda implementazione, la funzione riceve un puntatore a una stringa const char *, che termina con il carattere "\\ 0".

Esempio. Dimostrazione della funzione append ().

String s1 \u003d "abcdef"; s2 \u003d "1234567890"; append (s2, 3, 4); // s1 \u003d "abcdef4567" char * ps \u003d "1234567890"; s1 \u003d "abcdef"; s1.append (ps, 3); // s1 \u003d "abcdef123"

10. Inserimento di caratteri in una riga. Funzione Insert (). Esempio

Per inserire una riga in una data posizione di un'altra riga, è necessario utilizzare la funzione insert (), che ha diverse opzioni di implementazione.

La prima versione della funzione permette di inserire l'intera stringa s nella data posizione iniziale della linea chiamante (oggetto chiamante):

String & insert (size_type start, const string & s);

La seconda versione della funzione consente di inserire una parte (insStart, num parametri) della stringa s nella posizione iniziale data della stringa chiamante:

String & insert (size_type start, const string & s, size_type insStart, size_type num);

Nelle funzioni precedenti:

s - la stringa da inserire nella stringa chiamante;
start - la posizione nella linea chiamante da cui inserire la stringa s;
insStart - la posizione nella stringa s da cui inserire;
num è il numero di caratteri nella stringa s che vengono inseriti dalla posizione insStart.

stringa s1 \u003d "abcdef"; stringa s2 \u003d "1234567890"; s1.insert (3, s2); // s1 \u003d "abc" + "1234567890" + "def" \u003d "abc1234567890def" s2.insert (2, s1, 1, 3); // s2 \u003d "12bcd34567890"

11. Sostituzione di caratteri in una stringa. Funzione di sostituzione (). Esempio

La funzione replace () sostituisce i caratteri nella stringa chiamante. La funzione ha le seguenti opzioni di implementazione:

Stringa e sostituisci (size_type start, size_type num, const string & s); stringa e sostituisci (size_type start, size_type num, const string & s, size_type replStart, size_type replNum);

Nella prima implementazione, la stringa chiamante viene sostituita con la stringa s. È possibile impostare la posizione (inizio) e il numero di caratteri (num) nella linea chiamante, che deve essere sostituita con la stringa s.

La seconda versione della funzione replace () differisce dalla prima in quanto consente di sostituire la stringa chiamante con solo una parte della stringa s. In questo caso, due parametri aggiuntivi: la posizione di replStart e il numero di caratteri nella stringa s che formano la sottostringa che sostituisce la stringa chiamante.

Esempio. Dimostrazione della funzione replace ().

String s1 \u003d "abcdef"; stringa s2 \u003d "1234567890"; s2. sostituire (2, 4, s1); // s2 \u003d "12abcdef7890" s2 \u003d "1234567890"; s2. sostituire (3, 2, s1); // s2 \u003d "123abcdef67890" s2 \u003d "1234567890"; s2. sostituire (5, 1, s1); // s2 \u003d "12345abcdef7890" // sostituire i caratteri, sostituire la funzione () stringa s1 \u003d "abcdef"; stringa s2 \u003d "1234567890"; s2. sostituire (2, 4, s1); // s2 \u003d "12abcdef7890" s2 \u003d "1234567890"; s2. sostituire (3, 2, s1); // s2 \u003d "123abcdef67890" s2 \u003d "1234567890"; s2. sostituire (5, 1, s1); // s2 \u003d "12345abcdef7890" s2 \u003d "1234567890"; s2. sostituire (5, 1, s1, 2, 3); // s2 \u003d "12345cde7890" s2 \u003d "1234567890"; s2. sostituire (4, 2, s1, 0, 4); // s2 \u003d "1234abcd7890"

12. Rimozione del numero di caratteri specificato dalla stringa. Funzione Cancella (). Esempio

Per rimuovere caratteri dalla stringa chiamante, usa la funzione erase ():

String & cancella (size_type index \u003d 0, size_type num \u003d npos);

index - index (posizione), a partire dal quale si desidera rimuovere i caratteri nella riga chiamante;
num è il numero di caratteri da rimuovere.

Esempio.

String s \u003d "01234567890"; s.erase (3, 5); // s \u003d "012890" s \u003d "01234567890"; s.erase (); // s \u003d ""

13. Cerca un carattere in una stringa. Funzioni Find () e rfind (). Esempi di

Nella classe string, la ricerca di una stringa in una sottostringa può essere eseguita in due modi, che differiscono nella direzione della ricerca:

osservando la stringa dall'inizio alla fine utilizzando la funzione find ();
osservando la stringa dalla fine all'inizio con rfind ().

Il prototipo della funzione find () è:

Size_type find (const string & s, size_type start \u003d 0) const;

s è la sottostringa che viene cercata nella stringa che chiama la funzione data. La funzione cerca la prima occorrenza della stringa s. Se la sottostringa s si trova nella stringa che ha chiamato la funzione data, viene restituita la posizione della prima occorrenza. Altrimenti viene restituito -1;

Il prototipo della funzione rfind () è:

Size_type rfind (const string & s, size_type start \u003d npos) const;

s è la sottostringa da cercare nella stringa chiamante. La ricerca di una sottostringa in una stringa viene eseguita dall'inizio alla fine. Se la sottostringa s si trova nella stringa chiamante, la funzione restituisce la posizione della prima occorrenza. Altrimenti, la funzione restituisce -1;
npos - posizione dell'ultimo carattere della linea chiamante;
inizio: la posizione da cui viene eseguita la ricerca.

Esempio 1. Un frammento di codice che dimostra il risultato della funzione find ()

// tipo di stringa, funzione find () stringa s1 \u003d "01234567890"; stringa s2 \u003d "345"; string s3 \u003d "abcd"; int pos; pos \u003d s1. trovare (s2); // pos \u003d 3 pos \u003d s1.find (s2, 1); // pos \u003d 3 pos \u003d s1.find ("jklmn", 0); // pos \u003d -1 pos \u003d s1.find (s3); // pos \u003d -1 pos \u003d s2.find (s1); // pos \u003d -1

Esempio 2. Dimostrazione della funzione rfind ().

// tipo di stringa, funzioni find () e rfind () stringa s1 \u003d "01234567890"; stringa s2 \u003d "345"; string s3 \u003d "abcd"; string s4 \u003d "abcd --- abcd"; int pos; pos \u003d s1.rfind (s2); // pos \u003d 3 pos \u003d s1.rfind (s2, 12); // pos \u003d 3 pos \u003d s1.rfind (s2, 3); // pos \u003d 3 pos \u003d s1.rfind (s2, 2); // pos \u003d -1 pos \u003d s2.rfind (s1); // pos \u003d -1 pos \u003d s1.rfind (s3, 0); // pos \u003d -1 // differenza tra le funzioni find () e rfind () pos \u003d s4.rfind (s3); // pos \u003d 7 pos \u003d s4.find (s3); // pos \u003d 0

14. Confronto di parti di stringhe. Funzione Compare (). Esempio

Poiché il tipo di stringa è una classe, per confrontare due stringhe, è possibile utilizzare l'operazione ‘= =’ ... Se le due stringhe sono uguali, il confronto sarà vero. In caso contrario, il confronto sarà falso.

Ma se è necessario confrontare parte di una stringa con un'altra, viene fornita la funzione compare ().

Il prototipo della funzione compare ():

int compare (size_type start, size_type num, const string & s) const;

s - la stringa da confrontare con la stringa chiamante;
start - posizione (indice) nella stringa s, da cui iniziare a visualizzare i caratteri della stringa per il confronto;
num è il numero di caratteri nella stringa s da confrontare con la stringa chiamante.

La funzione funziona come segue. Se la stringa chiamante è minore della stringa s, la funzione restituisce -1 (valore negativo). Se la stringa chiamante è maggiore della stringa s, la funzione restituisce 1 (valore positivo). Se le due stringhe sono uguali, la funzione restituisce 0.

Esempio... Dimostrazione della funzione compare ():

// tipo di stringa, funzione compare () stringa s1 \u003d "012345"; stringa s2 \u003d "0123456789"; int res; res \u003d s1.compare (s2); // res \u003d -1 res \u003d s1.compare ("33333"); // res \u003d -1 res \u003d s1.compare ("012345"); // res \u003d 0 res \u003d s1.compare ("345"); // res \u003d -1 res \u003d s1.compare (0, 5, s2); // res \u003d -1 res \u003d s2.compare (0, 5, s1); // res \u003d -1 res \u003d s1.compare (0, 5, "012345"); // res \u003d -1 res \u003d s2.compare (s1); // res \u003d 1 res \u003d s2.compare ("456"); // res \u003d -1 res \u003d s2.compare ("000000"); // res \u003d 1

15. Ottenere una stringa con il carattere di fine riga "\\ 0" (char *). Funzione C_str (). Esempio

Per ottenere una stringa che termina con un carattere ‘\0’ viene utilizzata la funzione c_str ().

Prototipo di funzione:

const char * c_str () const;

La funzione viene dichiarata con il modificatore const. Ciò significa che la funzione non può modificare il chiamante (stringa).

Esempio 1... Conversione di una stringa in const char *.

string s \u003d "abcdef"; const char * ps; ps \u003d s.c_str (); // ps \u003d "abcdef"

Esempio 2.

Di seguito viene illustrata la conversione di una stringa da stringa al tipo System :: String per visualizzarla in un controllo Label per le applicazioni dell'applicazione Windows Form.

// tipo di stringa, funzione c_str () string s \u003d "abcdef"; String ss; ss \u003d gcnew String (s.c_str ()); // convert label1-\u003e Text \u003d ss; // visualizzazione nel modulo

Habra, ciao!

Non molto tempo fa, ho avuto un incidente piuttosto interessante in cui è stato coinvolto uno degli insegnanti di un college di informatica.

La conversazione sulla programmazione Linux si è spostata lentamente al punto in cui quest'uomo ha sostenuto che la complessità della programmazione dei sistemi era in realtà grossolanamente esagerata. Che il linguaggio C sia semplice come un abbinamento, infatti, come il kernel Linux (nelle sue parole).

Avevo con me un laptop Linux con un set di strumenti di sviluppo C per gentiluomini (gcc, vim, make, valgrind, gdb). Non ricordo più quale obiettivo ci eravamo prefissati allora, ma dopo un paio di minuti il \u200b\u200bmio avversario si è ritrovato dietro questo portatile, completamente pronto a risolvere il problema.

E letteralmente nelle primissime righe, ha commesso un grave errore nell'allocazione della memoria per ... una riga.

Char * str \u003d (char *) malloc (sizeof (char) * strlen (buffer));
buffer è una variabile dello stack in cui sono stati scritti i dati dalla tastiera.

Penso che ci saranno sicuramente persone che chiederanno: "Potrebbe esserci qualcosa che non va qui?"
Credimi, può.

E cosa esattamente - leggi sul taglio.

Un po 'di teoria - una specie di FaceBez.

Se lo sai, scorri fino all'intestazione successiva.

Una stringa in C è un array di caratteri, che in modo amichevole dovrebbe sempre terminare con "\\ 0" - il carattere di fine riga. Le stringhe nello stack (statiche) vengono dichiarate in questo modo:

Char str [n] \u003d (0);
n è la dimensione della matrice di caratteri, la stessa della lunghezza della stringa.

Assegnazione (0) - "annullamento" della stringa (opzionale, è possibile dichiararla senza di essa). Il risultato è lo stesso delle funzioni memset (str, 0, sizeof (str)) e bzero (str, sizeof (str)). Utilizzato per evitare la spazzatura in variabili non inizializzate.

Sempre nello stack, puoi inizializzare immediatamente la riga:

Char buf \u003d "testo del buffer predefinito \\ n";
Inoltre, una stringa può essere dichiarata puntatore e assegnata memoria sull'heap:

Char * str \u003d malloc (dimensione);
size - il numero di byte che assegniamo per la stringa. Tali stringhe sono chiamate dinamiche (poiché la dimensione richiesta viene calcolata dinamicamente + la dimensione della memoria allocata può essere aumentata in qualsiasi momento utilizzando la funzione realloc ()).

Nel caso di una variabile di stack, ho usato la notazione n per determinare la dimensione dell'array, nel caso di una variabile sull'heap, ho usato la notation size. E questo riflette perfettamente la vera essenza della differenza tra una dichiarazione sullo stack e una dichiarazione con allocazione di memoria sull'heap, perché n viene solitamente utilizzato quando si parla del numero di elementi. E le dimensioni sono una storia completamente diversa ...

Valgrind ci aiuterà

Nel mio precedente articolo, l'ho anche menzionato. Valgrind (, due - piccolo come fare) - molto programma utileche aiuta il programmatore a rintracciare perdite di memoria ed errori di contesto: queste sono le cose che emergono più spesso quando si lavora con le stringhe.

Diamo un'occhiata a un piccolo elenco, che implementa qualcosa di simile al programma che ho citato, ed eseguiamolo tramite valgrind:

#includere #includere #includere #define HELLO_STRING "Hello, Habr! \\ n" void main () (char * str \u003d malloc (sizeof (char) * strlen (HELLO_STRING)); strcpy (str, HELLO_STRING); printf ("-\u003e \\ t% s" , str); free (str);)
E, infatti, il risultato del programma:

$ gcc main.c $ ./a.out -\u003e Ciao, Habr!
Finora niente di insolito. Ora eseguiamo questo programma con valgrind!

$ valgrind --tool \u003d memcheck ./a.out \u003d\u003d 3892 \u003d\u003d Memcheck, un rilevatore di errori di memoria \u003d\u003d 3892 \u003d\u003d Copyright (C) 2002-2015 e GNU GPL "d, di Julian Seward et al. \u003d\u003d 3892 \u003d\u003d Utilizzo di Valgrind-3.12.0 e LibVEX; riesegui con -h per informazioni sul copyright \u003d\u003d 3892 \u003d\u003d Comando: ./a.out \u003d\u003d 3892 \u003d\u003d \u003d\u003d 3892 \u003d\u003d Scrittura non valida di dimensione 2 \u003d\u003d 3892 \u003d \u003d a 0x4005B4: main (in /home/indever/prg/C/public/a.out) \u003d\u003d 3892 \u003d\u003d L'indirizzo 0x520004c è di 12 byte all'interno di un blocco di dimensione 13 alloc "d \u003d\u003d 3892 \u003d\u003d a 0x4C2DB9D: malloc (vg_replace_malloc.c: 299) \u003d\u003d 3892 \u003d\u003d di 0x400597: main (in /home/indever/prg/C/public/a.out) \u003d\u003d 3892 \u003d\u003d \u003d\u003d 3892 \u003d\u003d Lettura della dimensione 1 non valida \u003d\u003d 3892 \u003d\u003d a 0x4C30BC4: strlen (vg_replace_strmem.c: 454) \u003d\u003d 3892 \u003d\u003d da 0x4E89AD0: vfprintf (in /usr/lib64/libc-2.24.so) \u003d\u003d 3892 \u003d\u003d da 0x4E90718: printf (in / usr / lib64 / libc-2.24.so) \u003d\u003d 3892 \u003d\u003d di 0x4005CF: main (in /home/indever/prg/C/public/a.out) \u003d\u003d 3892 \u003d\u003d L'indirizzo 0x520004d è 0 byte dopo un blocco di dimensione 13 alloc "d \u003d\u003d 3892 \u003d\u003d a 0x4C2DB9D: malloc (vg_replace_malloc.c: 299) \u003d\u003d 3892 \u003d\u003d da 0x400597: main (in / home / indever / prg / C / public / a.out) \u003d\u003d 3892 \u003d\u003d -\u003e Ciao, Habr! \u003d\u003d 3892 \u003d\u003d \u003d\u003d 3892 \u003d\u003d SOMMARIO HEAP: \u003d\u003d 3892 \u003d\u003d in uso all'uscita: 0 byte in 0 blocchi \u003d\u003d 3892 \u003d\u003d utilizzo totale dell'heap: 2 allocazioni, 2 liberazioni, 1.037 byte allocati \u003d\u003d 3892 \u003d \u003d \u003d\u003d 3892 \u003d\u003d Tutti i blocchi di heap sono stati liberati - non sono possibili perdite \u003d\u003d 3892 \u003d\u003d \u003d\u003d 3892 \u003d\u003d Per i conteggi degli errori rilevati e soppressi, rieseguire con: -v \u003d\u003d 3892 \u003d\u003d SOMMARIO DEGLI ERRORI: 3 errori da 2 contesti (soppresso: 0 da 0)
\u003d\u003d 3892 \u003d\u003d Tutti i blocchi di heap sono stati liberati - non sono possibili perdite - non ci sono perdite e piace. Ma vale la pena abbassare gli occhi un po 'più in basso (anche se, voglio sottolineare, questo è solo un riassunto, le informazioni di base sono un po' altrove):

\u003d\u003d 3892 \u003d\u003d SOMMARIO ERRORI: 3 errori da 2 contesti (soppressi: 0 da 0)
3 errori. In 2 contesti. In un programma così semplice. Come!?

È molto semplice. L'intero "trucco" è che la funzione strlen non tiene conto del carattere di fine riga - "\\ 0". Anche se lo specifichi esplicitamente nella riga di input (#define HELLO_STRING "Hello, Habr! \\ N \\ 0"), verrà ignorato.

Leggermente sopra il risultato dell'esecuzione del programma, righe -\u003e Ciao, Habr! c'è un rapporto dettagliato su cosa non è piaciuto alla nostra preziosa Valgrind e dove. Ti suggerisco di guardare tu stesso queste righe e di trarre conclusioni.

In realtà, la versione corretta del programma sarà simile a questa:

#includere #includere #includere #define HELLO_STRING "Hello, Habr! \\ n" void main () (char * str \u003d malloc (sizeof (char) * (strlen (HELLO_STRING) + 1)); strcpy (str, HELLO_STRING); printf ("-\u003e \\ Esaminiamo valgrind:
{!LANG-4b2ee5de0e69e468c3855f7e241415cc!}

$ valgrind --tool \u003d memcheck ./a.out -\u003e Ciao, Habr! \u003d\u003d 3435 \u003d\u003d \u003d\u003d 3435 \u003d\u003d SOMMARIO HEAP: \u003d\u003d 3435 \u003d\u003d in uso all'uscita: 0 byte in 0 blocchi \u003d\u003d 3435 \u003d\u003d utilizzo totale dell'heap: 2 allocazioni, 2 liberazioni, 1.038 byte allocati \u003d\u003d 3435 \u003d \u003d \u003d\u003d 3435 \u003d\u003d Tutti i blocchi heap sono stati liberati - non sono possibili perdite \u003d\u003d 3435 \u003d\u003d \u003d\u003d 3435 \u003d\u003d Per i conteggi degli errori rilevati e soppressi, rieseguire con: -v \u003d\u003d 3435 \u003d\u003d SOMMARIO ERRORI: 0 errori da 0 contesti (soppresso: 0 da 0)
Bene. Nessun errore, +1 byte di memoria allocata ha aiutato a risolvere il problema.

È interessante notare che, nella maggior parte dei casi, sia il primo che il secondo programma funzioneranno allo stesso modo, ma se la memoria allocata per la riga, in cui il carattere finale non rientrava, non era vuota, la funzione printf (), quando si stampa tale riga, visualizzerà anche tutta la spazzatura dopo di questa riga - tutto verrà visualizzato fino a quando il carattere di fine riga non appare nel percorso printf ().

Tuttavia, sai, (strlen (str) + 1) è una tale soluzione. Ci troviamo di fronte a 2 problemi:

Ma cosa succede se abbiamo bisogno di allocare memoria per una stringa formata usando, ad esempio, s (n) printf (..)? Non supportiamo gli argomenti.
Aspetto. La riga di dichiarazione della variabile sembra semplicemente orribile. Alcuni ragazzi riescono anche a scopare (char *) con malloc, come se scrivessero sotto i vantaggi. In un programma in cui è necessario elaborare regolarmente stringhe, ha senso trovare una soluzione più elegante.

Troviamo una soluzione che soddisfi sia noi che Valgrind.

snprintf ()

int snprintf (char * str, size_t size, const char * format, ...); - funzione - estensione sprintf, che formatta una stringa e la scrive nel puntatore passato come primo argomento. È diverso da sprintf () in quanto str non contiene più byte della dimensione.

La funzione ha una caratteristica interessante: restituisce comunque la dimensione della stringa generata (escluso il carattere di fine riga). Se la stringa è vuota, viene restituito 0.

Uno dei problemi che ho descritto con l'utilizzo di strlen è relativo alle funzioni sprintf () e snprintf (). Supponiamo di dover scrivere qualcosa in str. La stringa finale contiene i valori di altre variabili. La nostra voce dovrebbe essere qualcosa del genere:

Char * str \u003d / * alloca la memoria qui * /; sprintf (str, "Hello,% s \\ n", "Habr!");
Sorge la domanda: come determinare la quantità di memoria da allocare per la stringa str?

Char * str \u003d malloc (sizeof (char) * (strlen (str, "Hello,% s \\ n", "Habr!") + 1)); - non andrà. Il prototipo della funzione strlen () ha questo aspetto:

#includere size_t strlen (const char * s);
const char * s non implica che la stringa passata a s possa essere una stringa di formato con un numero variabile di argomenti.

È qui che l'utile proprietà della funzione snprintf (), che ho menzionato sopra, ci aiuterà. Diamo un'occhiata al codice prossimo programma:

#includere #includere #includere void main () (/ * Poiché snprintf () non tiene conto del carattere di fine riga, aggiungi la sua dimensione al risultato * / size_t needed_mem \u003d snprintf (NULL, 0, "Hello,% s! \\ n", "Habr") + sizeof ("\\ 0"); char * str \u003d malloc (needed_mem); snprintf (str, needed_mem, "Hello,% s! \\ n", "Habr"); printf ("-\u003e \\ t% s", str); free (str);)
Esegui il programma in valgrind:

$ valgrind --tool \u003d memcheck ./a.out -\u003e Ciao, Habr! \u003d\u003d 4132 \u003d\u003d \u003d\u003d 4132 \u003d\u003d HEAP SUMMARY: \u003d\u003d 4132 \u003d\u003d in uso all'uscita: 0 byte in 0 blocchi \u003d\u003d 4132 \u003d\u003d utilizzo totale dell'heap: 2 allocazioni, 2 liberazioni, 1.041 byte allocati \u003d\u003d 4132 \u003d \u003d \u003d\u003d 4132 \u003d\u003d Tutti i blocchi heap sono stati liberati - non sono possibili perdite \u003d\u003d 4132 \u003d\u003d \u003d\u003d 4132 \u003d\u003d Per i conteggi degli errori rilevati e soppressi, rieseguire con: -v \u003d\u003d 4132 \u003d\u003d SOMMARIO ERRORI: 0 errori da 0 contesti (soppresso: 0 da 0) $
Bene. Abbiamo supporto per gli argomenti. A causa del fatto che passiamo zero come secondo argomento alla funzione snprintf (), scrivere con un puntatore nullo non porterà mai a Seagfault. Tuttavia, nonostante ciò, la funzione restituirà comunque la dimensione richiesta per la stringa.

Ma d'altra parte, abbiamo dovuto aggiungere un'ulteriore variabile e la costruzione

Size_t needed_mem \u003d snprintf (NULL, 0, "Hello,% s! \\ N", "Habr") + sizeof ("\\ 0");
sembra anche peggio di strlen ().

In generale, + sizeof ("\\ 0") può essere rimosso specificando esplicitamente "\\ 0" alla fine della stringa di formato (size_t needed_mem \u003d snprintf (NULL, 0, "Hello,% s! \\ N \0 "," Habr ");), ma questo non è sempre possibile (a seconda del meccanismo di elaborazione delle stringhe, possiamo allocare un byte extra).

Qualcosa deve essere fatto. Ho riflettuto un po 'e ho deciso che ora è giunta l'ora di fare appello alla saggezza degli antichi. Descriviamo una funzione macro che chiamerà snprintf () con un puntatore nullo come primo argomento e nullo come secondo. E non dimentichiamoci della fine della linea!

#define strsize (args ...) snprintf (NULL, 0, args) + sizeof ("\\ 0")
Sì, potrebbe essere una novità per qualcuno, ma le macro in C supportano un numero variabile di argomenti e i puntini di sospensione indicano al preprocessore che l'argomento specificato della funzione macro (nel nostro caso sono argomenti) corrisponde a diversi argomenti reali.

Controlliamo la nostra soluzione in pratica:

#includere #includere #includere #define strsize (args ...) snprintf (NULL, 0, args) + sizeof ("\\ 0") void main () (char * str \u003d malloc (strsize ("Hello,% s \\ n", "Habr! ")); sprintf (str," Hello,% s \\ n "," Habr! "); printf (" -\u003e \\ t% s ", str); free (str);)
Corri con valgrund:

$ valgrind --tool \u003d memcheck ./a.out -\u003e Ciao, Habr! \u003d\u003d 6432 \u003d\u003d \u003d\u003d 6432 \u003d\u003d SOMMARIO HEAP: \u003d\u003d 6432 \u003d\u003d in uso all'uscita: 0 byte in 0 blocchi \u003d\u003d 6432 \u003d\u003d utilizzo totale dell'heap: 2 allocazioni, 2 liberi, 1.041 byte allocati \u003d\u003d 6432 \u003d \u003d \u003d\u003d 6432 \u003d\u003d Tutti i blocchi di heap sono stati liberati - non sono possibili perdite \u003d\u003d 6432 \u003d\u003d \u003d\u003d 6432 \u003d\u003d Per i conteggi degli errori rilevati e soppressi, rieseguire con: -v \u003d\u003d 6432 \u003d\u003d SOMMARIO ERRORI: 0 errori da 0 contesti (soppresso: 0 da 0)
Sì, non ci sono errori. Tutto è corretto. E Valgrind è felice e il programmatore può finalmente andare a dormire.

Ma, alla fine, dirò ancora una cosa. Nel caso in cui abbiamo bisogno di allocare memoria per qualsiasi stringa (anche con argomenti) ce n'è già perfettamente funzionante soluzione pronta .

È sulla funzione asprintf:

#define _GNU_SOURCE / * Vedi feature_test_macros (7) * / #include int asprintf (char ** strp, const char * fmt, ...);
Accetta un puntatore a una stringa (** strp) come primo argomento e alloca la memoria al puntatore dereferenziato.

Il nostro programma asprintf () sarebbe simile a questo:

#includere #includere #includere void main () (char * str; asprintf (& str, "Hello,% s! \\ n", "Habr"); printf ("-\u003e \\ t% s", str); free (str);)
E, infatti, in valgrind:

$ valgrind --tool \u003d memcheck ./a.out -\u003e Ciao, Habr! \u003d\u003d 6674 \u003d\u003d \u003d\u003d 6674 \u003d\u003d SOMMARIO HEAP: \u003d\u003d 6674 \u003d\u003d in uso all'uscita: 0 byte in 0 blocchi \u003d\u003d 6674 \u003d\u003d utilizzo totale dell'heap: 3 allocazioni, 3 liberi, 1.138 byte allocati \u003d\u003d 6674 \u003d \u003d \u003d\u003d 6674 \u003d\u003d Tutti i blocchi di heap sono stati liberati - non sono possibili perdite \u003d\u003d 6674 \u003d\u003d \u003d\u003d 6674 \u003d\u003d Per i conteggi degli errori rilevati e soppressi, rieseguire con: -v \u003d\u003d 6674 \u003d\u003d SOMMARIO ERRORI: 0 errori da 0 contesti (soppresso: 0 da 0)
Va tutto bene, ma, come puoi vedere, è stata allocata più memoria in totale, e ora ci sono tre allocazioni, non due. Su sistemi embedded deboli, questa funzione è indesiderabile.
Inoltre, se scriviamo man asprintf nella console, vedremo:

CONFORME A Queste funzioni sono estensioni GNU, non in C o POSIX. Sono disponibili anche con * BSD. L'implementazione di FreeBSD imposta strp su NULL in caso di errore.

Quindi è chiaro che questa funzione disponibile solo nei sorgenti GNU.

Conclusione

In conclusione, voglio dire che lavorare con le stringhe in C è un argomento molto complesso che ha una serie di sfumature. Ad esempio, per scrivere codice "sicuro" per l'allocazione dinamica della memoria, si consiglia comunque di utilizzare la funzione calloc () invece di malloc () - calloc intasa la memoria allocata con zeri. Bene, o dopo aver allocato la memoria, usa la funzione memset (). In caso contrario, la spazzatura che originariamente si trovava nell'area di memoria allocata può causare domande durante il debug e talvolta quando si lavora con una stringa.

Più della metà dei miei colleghi programmatori in C (la maggior parte sono principianti) che, su mia richiesta, hanno risolto il problema dell'allocazione della memoria per le stringhe, lo hanno fatto in modo tale che alla fine ha portato a errori di contesto. In un caso, anche a una perdita di memoria (beh, una persona si è dimenticata di liberare (str), a cui non capita). In effetti, questo mi ha spinto a creare questa creazione, che hai appena letto.

Spero che qualcuno trovi utile questo articolo. Perché ho contrattato tutto questo - nessuna lingua è semplice. Ovunque ha le sue sottigliezze. E più sottigliezze della lingua conosci, migliore è il tuo codice.

Credo che dopo aver letto questo articolo, il tuo codice sarà leggermente migliore :)
Buona fortuna, Habr!

La libreria di funzioni C e C ++ include un ricco set di funzioni per la gestione di stringhe e caratteri. Le funzioni stringa operano su matrici di caratteri con terminazione null. Nel linguaggio C, per utilizzare le funzioni stringa, è necessario includere un file di intestazione all'inizio del modulo del programma e per simbolico - file di intestazione ... Il C ++ utilizza le intestazioni per lavorare con le funzioni di stringa e carattere e rispettivamente. Questo capitolo utilizza i nomi delle intestazioni C per semplicità.

Poiché i linguaggi C e C ++ non controllano automaticamente la violazione dei loro limiti quando si eseguono operazioni con gli array, l'intera responsabilità per l'overflow degli array ricade sulle spalle del programmatore. Trascurare queste sottigliezze può causare il crash del programma.

In C e C ++, i caratteri stampabili sono quelli visualizzati sul terminale. Negli ambienti ASCII, si trovano tra uno spazio (0x20) e una tilde (OxFE). I caratteri di controllo hanno valori compresi tra zero e Ox1F; questi includono anche il simbolo DEL (Ox7F).

Storicamente, gli argomenti delle funzioni simboliche sono valori interi, di cui viene utilizzato solo il byte meno significativo. Le funzioni simboliche convertono automaticamente i loro argomenti in caratteri senza segno. Naturalmente, sei libero di chiamare queste funzioni con argomenti simbolici, poiché i simboli vengono automaticamente elevati al rango di numeri interi quando viene chiamata la funzione.

Nel titolo viene definito il tipo size_t, che è il risultato dell'operatore sizeof ed è una sorta di numero intero senza segno.

C99 ha aggiunto il qualificatore di restrizione ad alcuni parametri di diverse funzioni originariamente definite in C89. Ciascuna di queste funzioni sarà rivista con il suo prototipo utilizzato nell'ambiente C89 (così come nell'ambiente C ++), e i parametri con l'attributo limits saranno annotati nella descrizione di questa funzione.

Elenco delle caratteristiche

Verifica l'appartenenza

isalnum - Controlla se un carattere è alfanumerico
isalpha - Controlla se un carattere appartiene a lettere
isblank: verifica la presenza di un carattere vuoto
iscntrl - Controlla se un simbolo appartiene al controllo
isdigit - Controlla se un personaggio è digitale
isgraph - Controlla se un carattere è stampabile ma non uno spazio
islower - Controlla se un carattere è minuscolo
isprint - Controlla se un carattere è stampabile
ispunct - Controlla se un carattere appartiene ai segni di punteggiatura
isspace - Controlla se un carattere è uno spazio bianco
isupper - Controlla se un carattere è maiuscolo
isxdigit - Controlla se un carattere è esadecimale

Lavorare con array di caratteri

memchr: scorre l'array per trovare la prima occorrenza di un carattere
memcmp - Confronta un numero specificato di caratteri in due array
memcpy - Copia i caratteri da un array a un altro
memmove - Copia i caratteri da un array a un altro, tenendo conto degli array sovrapposti
memset - Riempie un numero specificato di caratteri in un array con un dato

Manipolazione delle stringhe

strcat: aggiunge una copia di una stringa al file
strchr - Restituisce un puntatore alla prima occorrenza del byte meno significativo del parametro dato
strcmp - Confronta lessicograficamente due stringhe
strcoll - Confronta una stringa con un'altra in base a setlocale
strcpy - Copia il contenuto di una stringa in un'altra
strcspn - Restituisce una stringa senza caratteri specificati
strerror - Restituisce un puntatore a una stringa contenente messaggio di sistema sull'errore
strlen - Restituisce la lunghezza di una stringa con terminazione null