Cosa si intende nel linguaggio C per stringhe. Operatori di classe stringa

Il moderno standard C++ definisce una classe con funzioni e proprietà (variabili) per organizzare il lavoro con le stringhe (nel linguaggio C classico, non ci sono stringhe in quanto tali, ci sono solo array di caratteri):

#includere

#includere

#includere

Per lavorare con le stringhe, devi anche connettere lo spazio dei nomi standard:

Usando lo spazio dei nomi std;

Altrimenti, dovrai specificare il descrittore di classe std :: string invece di string ovunque.

Di seguito è riportato un esempio di un programma che funziona con le stringhe (non funziona nei vecchi compilatori compatibili con C!):

#includere #includere #includere usando lo spazio dei nomi std; int main() (string s = "Test"; s.insert (1, "!"); cout<< s.c_str() << endl; string *s2 = new string("Hello"); s2->cancella (s2-> end()); cout<< s2->c_str(); cin.get (); restituisce 0; )

Le caratteristiche principali della classe stringa:

• inizializzazione con un array di caratteri (una stringa di tipo predefinito) o un altro oggetto di tipo stringa. Il tipo integrato non ha la seconda opzione;
• copiando una riga in un'altra. Per un tipo integrato, devi usare la funzione strcpy();
• accesso ai singoli caratteri della stringa per la lettura e la scrittura. In un array integrato, questo viene fatto usando l'operazione di prendere l'indice o l'indirizzamento indiretto usando un puntatore;
• confronto di due stringhe per l'uguaglianza. Per un tipo predefinito, vengono utilizzate le funzioni della famiglia strcmp();
• concatenazione (concatenazione) di due stringhe, dando il risultato o come terza stringa, o invece di una delle originali. Per un tipo predefinito, viene utilizzata la funzione strcat(), ma per ottenere il risultato su una nuova riga, è necessario utilizzare in sequenza le funzioni strcpy() e strcat() e occuparsi anche dell'allocazione della memoria;
• mezzi incorporati per determinare la lunghezza di una stringa (funzioni membro della classe size () e length ()). È possibile scoprire la lunghezza di una stringa di tipo built-in solo mediante calcolo utilizzando la funzione strlen();
• la capacità di scoprire se una stringa è vuota.

Diamo un'occhiata più da vicino a queste caratteristiche di base.

Inizializzazione delle stringhe quando si descrive e lunghezza della linea(escluso il terminatore nullo di terminazione):

Stringa st ("La mia stringa \ n"); cout<< "Длина " << st << ": " << st.size() << " символов, включая символ новой строки\n";

La stringa può essere data e vuota:

Stringa st2;

Per verificare se la riga è vuota?, puoi confrontare la sua lunghezza con 0:

If (! St.size()) // vuoto

oppure usa il metodo empty(), restituendo true per una stringa vuota e false per una stringa non vuota:

If (st.empty()) // vuoto

La terza forma di creazione di stringhe inizializza un oggetto di tipo stringa con un altro oggetto dello stesso tipo:

Stringa st3 (st);

La stringa st3 viene inizializzata con la stringa st. Come possiamo assicurarci che questi le stringhe corrispondono? Usiamo l'operatore di confronto (==):

If (st == st3) // l'inizializzazione ha funzionato

Come copia una riga in un'altra? Con la consueta operazione di assegnazione:

St2 = st3; // copia st3 in st2

Per concatenazione di stringhe utilizzare l'operazione di addizione (+) o l'operazione di assegnazione di addizione (+ =). Siano date due righe:

Stringa s1 ("ciao,"); stringa s2 ("mondo \ n");

Possiamo ottenere la terza riga, costituita dalla concatenazione delle prime due, in questo modo:

Stringa s3 = s1 + s2;

Se vogliamo aggiungere s2 alla fine di s1, dobbiamo scrivere:

S1 + = s2;

L'operazione di addizione può concatenare oggetti di classe corda non solo tra di loro, ma anche con stringhe di tipo incorporato. Puoi riscrivere l'esempio precedente in modo che i caratteri speciali e i segni di punteggiatura siano rappresentati dal tipo char * incorporato e le parole significative siano rappresentate da oggetti stringa:

Const char * pc = ","; stringa s1 ("ciao"); stringa s2 ("mondo"); stringa s3 = s1 + pc + s2 + "\ n"; cout<< endl << s3;

Espressioni come queste funzionano perché il compilatore "sa" come convertire automaticamente gli oggetti del tipo built-in in oggetti della classe stringa. È anche possibile una semplice assegnazione di una stringa in linea a un oggetto stringa:

Stringa s1; const char * pc = "un array di caratteri"; s1 = pc; // Giusto

In questo caso, la trasformazione inversa non funziona... Il tentativo di eseguire la seguente inizializzazione di una stringa di tipo integrato genererà un errore di compilazione:

Char * str = s1; // errore di compilazione

Per eseguire questa conversione, è necessario chiamare in modo esplicito la funzione membro c_str() ("stringa C"):

Const char * str = s1.c_str ();

La funzione c_str() restituisce un puntatore a un array di caratteri contenente la stringa dell'oggetto stringa come sarebbe in un tipo stringa incorporato. La parola chiave const qui impedisce alla "pericolosa" nei moderni ambienti visivi la possibilità di modificare direttamente il contenuto di un oggetto tramite un puntatore.

A singoli caratteriè possibile accedere a un oggetto di tipo stringa, come un tipo predefinito, utilizzando l'operazione di acquisizione dell'indice. Ad esempio, ecco un frammento di codice che sostituisce tutti i punti con i trattini bassi:

Stringa str ("www.disney.com"); int size = str.size (); per (int i = 0; i< size; i++) if (str[i] == ".") str[ i ] = "_"; cout << str;

Sostituisci (str.begin (), str.end (), ".", "_");

È vero, qui non viene utilizzato il metodo replace della classe string, ma l'algoritmo con lo stesso nome:

#includere

Poiché l'oggetto stringa si comporta come un contenitore, è possibile applicarvi altri algoritmi. Ciò consente di risolvere problemi che non vengono risolti direttamente dalle funzioni della classe string.

Di seguito è riportata una breve descrizione dei principali operatori e funzioni della classe stringa, i collegamenti nella tabella portano a descrizioni in lingua russa su Internet. Per un elenco più completo delle capacità della classe stringa, vedere, ad esempio, Wikipedia o cplusplus.com.

Stringhe. Linee I/O. I/O formattato. Elaborazione di stringhe utilizzando funzioni standard C. Lavorare con la memoria.

1.1. Dichiarazione e inizializzazione delle stringhe.

Una stringa è un array di caratteri che termina con il carattere vuoto '\ 0'. La stringa viene dichiarata come un normale array di caratteri, ad esempio

carattere s1; // stringa lunga nove caratteri

carattere * s2; // puntatore a stringa

La differenza tra s1 e s2 è che s1 è una costante denominata e s2 è una variabile.

Le costanti stringa sono racchiuse tra virgolette, al contrario dei caratteri racchiusi tra virgolette singole. Ad esempio,

"Questa è una stringa."

La lunghezza di una costante stringa non può superare i 509 caratteri secondo lo standard. Tuttavia, molte implementazioni consentono stringhe più lunghe.

Quando si inizializzano le stringhe, è meglio non specificare la dimensione dell'array; il compilatore lo farà calcolando la lunghezza della stringa e aggiungendone una. Ad esempio,

char s1 = “Questa è una stringa.”;

Nel linguaggio di programmazione C esiste un gran numero di funzioni per lavorare con le stringhe, i cui prototipi sono descritti nei file header stdlib.he string.h. L'utilizzo di queste funzioni sarà discusso nei paragrafi seguenti.

1.2. Linee I/O.

Per inserire una stringa dalla console, usa la funzione

char * ottiene (char * str);

che scrive una stringa in str e restituisce l'indirizzo della stringa immessa. La funzione interrompe l'input quando incontra il carattere '\ n' o EOF (fine del file). Il carattere di nuova riga non viene copiato. Un byte zero viene posizionato alla fine della riga di lettura. In caso di successo, la funzione restituisce un puntatore alla stringa letta e, in caso di errore, NULL.

Per inviare una linea alla console, utilizzare la funzione standard

int puts (const char * s);

che restituisce un numero non negativo in caso di successo e EOF in caso di fallimento.

I prototipi delle funzioni gets e puts sono descritti nel file header stdio.h.

#includere

printf ("Stringa di input:");

1.3. I/O formattato.

Per l'immissione di dati formattati dalla console, utilizzare la funzione

int scanf (const char * formato, ...);

che, in caso di successo, restituisce il numero di unità di dati letti e, in caso negativo, restituisce EOF. Il parametro format deve puntare a una stringa formattata che contiene le specifiche dei formati di input. Il numero e i tipi di argomenti che seguono la stringa di formato devono corrispondere al numero e ai tipi di formati di input specificati nella stringa di formato. Se questa condizione non è soddisfatta, il risultato della funzione è imprevedibile.

Spazio, caratteri "\ t" o "\ n" nella stringa di formato descrivono uno o più caratteri vuoti nel flusso di input, che includono caratteri: spazio, '\ t', '\ n', '\ v', '\ f'. La funzione scanf salta i caratteri vuoti nel flusso di input.

I caratteri letterali nella stringa di formato, ad eccezione del carattere%, richiedono esattamente gli stessi caratteri per apparire nel flusso di input. Se non esiste tale carattere, scanf interrompe l'input. La funzione scanf salta i caratteri letterali.

In generale, la specifica del formato di input è:

% [*] [larghezza] [modificatori] tipo

Il carattere '*' indica il salto quando si entra in un campo definito da questa specifica;

- 'larghezza' definisce il numero massimo di caratteri inseriti secondo questa specifica;

Il tipo può assumere i seguenti valori:

c - matrice di caratteri,

s - stringa di caratteri, le stringhe sono separate da caratteri vuoti,

d - intero con segno in 10 s / s,

i è un intero con segno, il sistema numerico dipende dalle prime due cifre,

u - intero senza segno a 10 s / s,

o - intero senza segno in 8 s / s,

x, X - intero senza segno in 16 s / s,

e, E, f, g, G - numero mobile,

p è un puntatore a un puntatore,

n è un puntatore a un numero intero,

[...] - array di caratteri scansionati, ad esempio.

In quest'ultimo caso, dal flusso di input verranno immessi solo i caratteri racchiusi tra parentesi quadre. Se il primo carattere all'interno delle parentesi quadre è "^", vengono inseriti solo i caratteri che non sono nell'array. L'intervallo di caratteri nell'array viene specificato utilizzando il simbolo '-'. Quando si immettono i caratteri, vengono inseriti anche gli spazi iniziali e il byte nullo finale della stringa.

I modificatori possono assumere i seguenti valori:

h - intero breve,

l, L - intero lungo o float,

e sono usati solo per numeri interi o float.

L'esempio seguente mostra i casi d'uso per la funzione scanf. Nota che c'è uno spazio davanti all'identificatore di formato, che inizia con l'input del numero mobile.

#includere

printf ("Inserisci un numero intero:");

scanf ("% d", & n);

printf ("Inserisci un doppio:");

scanf ("% lf", & d);

printf ("Inserisci un carattere:");

scanf ("% c", & c);

printf ("Inserisci una stringa:");

scanf ("% s", & s);

Notare che in questo programma viene inizializzato il numero in virgola mobile. Questo viene fatto affinché il compilatore includa la libreria per supportare il lavoro con i numeri mobili. In caso contrario, si verificherà un errore in fase di esecuzione durante l'immissione di un numero mobile.

Per l'output formattato sulla console, utilizzare la funzione

int printf (const char * formato, ...);

che, in caso di successo, restituisce il numero di unità di dati in uscita e, in caso negativo, restituisce EOF. Il parametro format è una stringa formattata che contiene le specifiche per i formati di output. Il numero e i tipi di argomenti che seguono la stringa di formato devono corrispondere al numero e ai tipi delle specifiche del formato di output fornite nella stringa di formato. In generale, la specifica del formato di output è:

% [flag] [larghezza] [.precisione] [modificatori] tipo

- i "flag" sono vari simboli che specificano il formato di output;

- "larghezza" definisce il numero minimo di caratteri visualizzati secondo questa specifica;

- '.precision' definisce il numero massimo di caratteri da visualizzare;

- i "modificatori" specificano il tipo di argomenti;

- 'tipo' definisce il tipo dell'argomento.

Gli interi con segno vengono emessi nel seguente formato:

% [-] [+ | spazio] [larghezza] [l] d

- - allineamento a sinistra, per impostazione predefinita - a destra;

+ - viene visualizzato il segno '+', si noti che per i numeri negativi viene sempre visualizzato il segno '-';

'Spazio' - viene visualizzato uno spazio nella posizione del carattere;

d - tipo di dati int.

Il seguente formato di output viene utilizzato per l'output di interi senza segno:

% [-] [#] [larghezza] [l]

# - lo 0 iniziale viene visualizzato per i numeri in 8 c / s, o l'iniziale 0x o 0X per i numeri in 16 c / s,

l - modificatore del tipo di dati lungo;

u - intero in 10c / s,

o - intero in 8 s / s,

x, X è un numero intero di 16 s / s.

Per i numeri in virgola mobile, viene utilizzato il seguente formato di output:

% [-] [+ | spazio] [larghezza] [.precisione]

"precisione" indica il numero di cifre dopo la virgola per i formati f, e ed E, o il numero di cifre significative per i formati g e G. I numeri sono arrotondati. L'impostazione predefinita è sei cifre decimali;

f - numero a punto fisso,

e - un numero in forma esponenziale, l'esponente è indicato dalla lettera "e",

E - un numero in forma esponenziale, l'esponente è indicato dalla lettera "E",

g - il più corto dei formati f o g,

G è il più corto dei formati f o G.

printf ("n =% d \ n f =% f \ n e =% e \ n E =% E \ n f =% .2f", -123, 12.34, 12.34, 12.34, 12.34);

// stampa: n = 123 f = 12,340000 e = 1,234000e + 001 E = 1,234000E + 001 f = 12,34

1.4. Stringhe di formattazione.

Esistono varianti delle funzioni scanf e printf per la formattazione delle stringhe e sono chiamate rispettivamente sscanf e sprintf.

int sscanf (const char * str, const char * formato, ...);

legge i dati dalla stringa specificata dal parametro str in base alla stringa di formato specificata dal parametro format. Restituisce la quantità di dati letti in caso di successo e EOF in caso di errore. Ad esempio,

#includere

char str = "a 10 1.2 Stringa Nessun input";

sscanf (str, "% c% d% lf% s", & c, & n, & d, s);

printf ("% c \ n", c); // stampa: a

printf ("% d \ n", n); // stampe: 10

printf ("% f \ n", d); // stampe: 1.20000

printf ("% s \ n", s); // stampa: String

int sprintf (char * buffer, const char * formato, ...);

formatta la stringa in base al formato specificato dal parametro format e scrive il risultato nel buffer dell'array di caratteri. La funzione restituisce il numero di caratteri scritti nel buffer dell'array di caratteri, escludendo il byte nullo di terminazione. Ad esempio,

#includere

char str = "c =% c, n =% d, d =% f, s =% s";

char s = "Questa è una stringa.";

sprintf (buffer, str, c, n, d, s);

printf ("% s \ n", buffer); // stampa: c = c, n = 10, d = 1.200000, s = questa è una stringa

1.5. Conversione di stringhe in dati numerici.

I prototipi di funzioni per la conversione di stringhe in dati numerici sono riportati nel file di intestazione stdlib.h, che deve essere incluso nel programma.

Per convertire una stringa in un intero, usa la funzione

int atoi (const char * str);

carattere * str = “-123”;

n = atoi (str); //n = -123

Per convertire una stringa in un intero lungo, usa la funzione

long int atol (const char * str);

che, in caso di successo, restituisce un intero in cui è stata convertita la stringa str, e se fallisce 0, ad esempio,

carattere * str = “-123”;

n = atolo (str); //n = -123

Per convertire una stringa in un doppio, usa la funzione

double atof (const char * str);

che, in caso di successo, restituisce un numero mobile di tipo double, in cui è stata convertita la stringa str, e se fallisce 0, ad esempio,

carattere * str = “-123.321”;

n = atof (str); //n = -123.321

Le seguenti funzioni eseguono azioni simili alle funzioni atoi, atol, atof, ma forniscono funzionalità più avanzate.

long int strtol (const char * str, char ** endptr, int base);

converte la stringa str in un long int, che restituisce. I parametri di questa funzione hanno il seguente significato.

Se base è 0, la conversione dipende dai primi due caratteri di str:

Se il primo carattere è una cifra da 1 a 9, si presume che il numero sia rappresentato in 10 s / s;

Se il primo carattere è una cifra 0 e il secondo è una cifra da 1 a 7, si presume che il numero sia rappresentato in 8 c / s;

Se il primo carattere è 0 e il secondo è 'X' o 'x', si presume che il numero sia rappresentato in 16 c / s.

Se base è un numero compreso tra 2 e 36, questo valore viene preso come base della base e qualsiasi carattere al di fuori di questa base interrompe la conversione. Le basi da 11 a 36 utilizzano i caratteri da "A" a "Z" o da "a" a "z" per rappresentare i numeri.

L'argomento endptr è impostato dalla funzione strtol. Questo valore contiene un puntatore al carattere che ha interrotto la conversione di str. In caso di successo, la funzione strtol restituisce il numero convertito e, in caso di errore, restituisce 0. Ad esempio,

n = strtolo ("12a", & p, 0);

printf ("n =% ld,% stop =% c, n, * p); // n = 12, stop = a

n = strtolo ("012b", & p, 0);

printf ("n =% ld,% stop =% c, n, * p); // n = 10, stop = b

n = strtol (“0x12z”, & p, 0);

printf ("n =% ld,% stop =% c, n, * p); // n = 18, stop = z

n = strtolo ("01117", & p, 0);

printf ("n =% ld,% stop =% c, n, * p); // n = 7, arresto = 7

unsigned long int strtol (const char * str, char ** endptr, int base);

funziona in modo simile a strtol, ma converte la rappresentazione del carattere di un numero in un int long senza segno.

double strtod (const char * str, char ** endptr);

converte la rappresentazione del carattere di un numero in un doppio.

Tutte le funzioni elencate in questo paragrafo smettono di funzionare quando incontrano il primo carattere che non rientra nel formato del numero in questione.

Inoltre, se il valore del carattere di un numero supera l'intervallo di valori validi per il tipo di dati corrispondente, le funzioni atof, strtol, strtoul, strtod impostano il valore della variabile errno su ERANGE. La variabile errno e la costante ERANGE sono definite nel file di intestazione math.h. Le funzioni atof e strtod restituiscono il valore HUGE_VAL, la funzione strtol restituisce il valore LONG_MAX o LONG_MIN e la funzione strtoul restituisce il valore ULONG_MAX.

Le funzioni non standard itoa, ltoa, utoa, ecvt, fcvt e gcvt possono essere utilizzate per convertire dati numerici in stringhe di caratteri. Ma è meglio usare la funzione sprintf standard per questi scopi.

1.6. Funzioni standard per lavorare con le stringhe.

Questa sezione descrive le funzioni per lavorare con le stringhe, i cui prototipi sono descritti nel file di intestazione string.h.

1. Confronto di stringhe. Le funzioni strcmp e strncmp vengono utilizzate per confrontare le stringhe.

int strcmp (const char * str1, const char * str2);

confronta lessicograficamente str1, str2 e restituisce -1, 0 o 1 se str1 è, rispettivamente, minore, uguale o maggiore di str2.

int strncmp (const char * str1, const char * str2, size_t n);

confronta lessicograficamente al massimo n primi caratteri da str1 e str2. La funzione restituisce -1, 0 o 1 se i primi n caratteri della stringa str1 sono rispettivamente minori, uguali o maggiori dei primi n caratteri della stringa str2.

// esempio di confronto di stringhe

#includere

#includere

char str1 = "aa bb";

char str2 = "aa aa";

char str3 = "aa bb cc";

printf ("% d \ n", strcmp (str1, str3)); // stampa: -1

printf ("% d \ n", strcmp (str1, str1)); // stampa: -0

printf ("% d \ n", strcmp (str1, str2)); // stampe: 1

printf ("% d \ n", strncmp (str1, str3, 5)); // stampa: 0

2. Copiare le righe. Le funzioni strcpy e strncpy vengono utilizzate per copiare le stringhe.

char * strcpy (char * str1, const char * str2);

copia la stringa str2 nella stringa str1. Viene copiata l'intera stringa str2, incluso il byte null di terminazione. La funzione restituisce un puntatore a str1. Se le linee si sovrappongono, il risultato è imprevedibile.

char * strncpy (char * str1, const char * str2, size_t n);

copia n caratteri dalla stringa str2 alla stringa str1. Se la stringa str2 contiene meno di n caratteri, l'ultimo byte nullo viene copiato tutte le volte necessarie per espandere la stringa str2 a n caratteri. La funzione restituisce un puntatore alla stringa str1.

char str2 = "Copia stringa.";

strcpy (str1, str2);

printf (str1); // stampa: copia la stringa.

4. Concatenazione di stringhe. Le funzioni strcat e strncat vengono utilizzate per concatenare le stringhe in un'unica stringa.

char * strcat (char * str1, const char * str2);

aggiunge la stringa str2 alla stringa str1, con il byte nullo di terminazione della stringa str1 cancellato. La funzione restituisce un puntatore alla stringa str1.

char * strncat (char * str1, const char * str2, size_t n);

aggiunge n caratteri dalla stringa str2 alla stringa str1 e il byte nullo di terminazione della stringa str1 viene cancellato. La funzione restituisce un puntatore alla stringa str1. se la lunghezza della stringa str2 è minore di n, vengono aggiunti solo i caratteri inclusi nella stringa str2. Dopo aver concatenato le stringhe, a str1 viene sempre aggiunto un byte zero. La funzione restituisce un puntatore alla stringa str1.

#includere

#includere

char str1 = "Stringa";

char str2 = "catenazione";

char str3 = "Sì No";

strcat (str1, str2);

printf ("% s \ n", str1); // stampa: catenazione della stringa

strncat (str1, str3, 3);

printf ("% s \ n", str1); // stampa: Catenazione della stringa Sì

5. Cerca un carattere in una stringa. Le funzioni strchr, strrchr, strspn, strcspn e strpbrk vengono utilizzate per cercare un carattere in una stringa.

char * strchr (const char * str, int c);

cerca la prima occorrenza del carattere specificato dal parametro c nella stringa str. In caso di successo, la funzione restituisce un puntatore al primo carattere trovato e, in caso di errore, NULL.

char * strrchr (const char * str, int c);

cerca l'ultima occorrenza del carattere specificato dal parametro c nella stringa str. In caso di successo, la funzione restituisce un puntatore all'ultimo carattere trovato e, in caso di fallimento, restituisce NULL.

#includere

#includere

char str = "Ricerca caratteri";

printf ("% s \ n", strchr (str, "r")); // stampa: r ricerca

printf ("% s \ n", strrchr (str, "r")); // stampa: rch

size_t strspn (const char * str1, const char * str2);

restituisce l'indice del primo carattere dalla stringa str1 che non è nella stringa str2.

size_t strcspn (const char * str1, const char * str2);

restituisce l'indice del primo carattere dalla stringa str1 che va nella stringa str2.

char str = "123 abc";

printf ("n =% d \ n", strspn (str, "321"); // stampa: n = 3

printf ("n =% d \ n", strcspn (str, "cba"); // stampa: n = 4

char * strpbrk (const char * str1, const char * str2);

trova il primo carattere nella stringa str1 che è uguale a uno dei caratteri nella stringa str2. In caso di successo, la funzione restituisce un puntatore a questo carattere e, in caso di errore, NULL.

char str = "123 abc";

printf ("% s \ n", strpbrk (str, "bca")); // stampa: abc

6. Confronto di stringhe. La funzione strstr viene utilizzata per confrontare le stringhe.

char * strstr (const char * str1, const char * str2);

trova la prima occorrenza della stringa str2 (nessun byte nullo finale) nella stringa str1. In caso di successo, la funzione restituisce un puntatore alla sottostringa trovata e, in caso di errore, NULL. Se il puntatore str1 punta a una stringa di lunghezza zero, la funzione restituisce il puntatore str1.

char str = "123 abc 456;

printf ("% s \ n", strstr (str, "abc"); // print: abc 456

7. Analizzare la stringa in token. La funzione strtok viene utilizzata per analizzare una stringa in token.

char * strtok (char * str1, const char * str2);

restituisce un puntatore al token successivo (parola) nella stringa str1, in cui i token sono delimitati dai caratteri della stringa str2. Se i lessemi sono finiti, la funzione restituisce NULL. Nella prima chiamata alla funzione strtok, il parametro str1 deve puntare a una stringa che viene analizzata in token e nelle chiamate successive questo parametro deve essere impostato su NULL. Dopo aver trovato il token, la funzione strtok scrive un byte zero dopo questo token al posto del separatore.

#includere

#includere

char str = "12 34 ab cd";

p = strtok (str, "");

printf ("% s \ n", p); // stampa in una colonna i valori: 12 34 ab cd

p = strtok (NULL, "");

8. Determinazione della lunghezza della stringa. La funzione strlen viene utilizzata per determinare la lunghezza di una stringa.

size_t strlen (const char * str);

restituisce la lunghezza della stringa, escludendo l'ultimo byte nullo. Ad esempio,

carattere str = "123";

printf ("len =% d \ n", strlen (str)); // stampa: len = 3

1.7. Funzioni per lavorare con la memoria.

Il file di intestazione string.h descrive anche le funzioni per lavorare con i blocchi di memoria, che sono simili alle funzioni corrispondenti per lavorare con le stringhe.

void * memchr (const void * str, int c, size_t n);

cerca la prima occorrenza del carattere specificato dal parametro c in n byte di str.

int memcmp (const void * str1, const void * str2, size_t n);

confronta i primi n byte di str1 e str2.

void * memcpy (const void * str1, const void * str2, size_t n);

copia i primi n byte dalla stringa str1 alla stringa str2.

void * memmove (const void * str1, const void * str2, size_t n);

copia i primi n byte dalla stringa str1 alla stringa str2, assicurandosi che le stringhe sovrapposte vengano gestite correttamente.

void * memset (const void * str, int c, size_t n);

copia il carattere specificato dal parametro c nei primi n byte di str.

--- C# Manuale --- Stringhe

In termini di programmazione regolare, la stringa tipo di dati stringaè uno dei più importanti in C#. Questo tipo definisce e supporta le stringhe di caratteri. In molti altri linguaggi di programmazione, una stringa è un array di caratteri. E in C #, le stringhe sono oggetti. Pertanto, il tipo stringa è un tipo di riferimento.

Costruire stringhe

Il modo più semplice per creare una stringa di caratteri consiste nell'utilizzare una stringa letterale. Ad esempio, la seguente riga di codice assegna la variabile di riferimento stringa str al riferimento letterale stringa:

String str = "Stringa di esempio";

In questo caso, la variabile str viene inizializzata con la sequenza di caratteri "Stringa di esempio". Puoi anche creare un oggetto di tipo string da un array di tipo char. Ad esempio:

Char chararray = ("e", "x", "a", "m", "p", "l", "e"); stringa str = nuova stringa (chararray);

Una volta creato un oggetto di tipo stringa, può essere utilizzato ovunque sia richiesta una stringa di testo tra virgolette.

Persistenza delle stringhe

Stranamente, il contenuto di un oggetto di tipo stringa non può essere modificato. Ciò significa che una volta creata, la sequenza dei caratteri non può essere modificata. Ma questa limitazione contribuisce a un'implementazione più efficiente delle stringhe di caratteri. Pertanto, questo, a prima vista, evidente svantaggio si trasforma in realtà in un vantaggio. Quindi, se è richiesta una stringa come variazione di una stringa esistente, a questo scopo dovrebbe essere creata una nuova stringa contenente tutte le modifiche necessarie. E poiché gli oggetti stringa inutilizzati vengono automaticamente raccolti nella spazzatura, non devi nemmeno preoccuparti del destino delle stringhe non necessarie.

Va sottolineato, tuttavia, che i riferimenti a stringhe variabili (ovvero oggetti di tipo stringa) sono soggetti a modifiche e quindi possono fare riferimento a un altro oggetto. Ma il contenuto dell'oggetto stringa stesso non cambia dopo la sua creazione.

Consideriamo un esempio:

Static void addNewString() (string s = "Questo è il mio tratto"; s = "Questo è un nuovo tratto";)

Compiliamo l'applicazione e carichiamo l'assembly risultante nell'utility ildasm.exe. La figura mostra il codice CIL che verrà generato per il metodo void addNewString():

Nota che ci sono più chiamate all'opcode ldstr (line load). Questo codice operativo CIL ldstr indica di caricare un nuovo oggetto stringa nell'heap gestito. Di conseguenza, l'oggetto precedente che conteneva il valore "Questo è il mio tratto" verrà infine eliminato.

Lavorare con le stringhe

In classe System.String viene fornito un insieme di metodi per determinare la lunghezza dei dati carattere, trovare una sottostringa nella stringa corrente, convertire i caratteri da maiuscolo a minuscolo e viceversa, ecc. Vedremo questa classe in modo più dettagliato in seguito.

Campo stringa, indicizzatore e proprietà

La classe String ha un singolo campo definito:

Stringa pubblica di sola lettura statica Vuoto;

Il campo Vuoto denota una stringa vuota, ad es. una stringa che non contiene caratteri. Questo è in contrasto con un riferimento String vuoto, che viene semplicemente fatto a un oggetto inesistente.

Inoltre, la classe String definisce un singolo indicizzatore di sola lettura:

Pubblico char this (get;)

Questo indicizzatore ti consente di ottenere il carattere all'indice specificato. L'indicizzazione delle stringhe, come gli array, inizia da zero. Gli oggetti String sono persistenti e immutabili, quindi ha senso che la classe String supporti un indicizzatore di sola lettura.

Infine, la classe String definisce una singola proprietà di sola lettura:

Lunghezza int pubblico (ottieni;)

La proprietà Length restituisce il numero di caratteri in una stringa. L'esempio seguente mostra l'uso di un indicizzatore e della proprietà Length:

Utilizzo del sistema; class Esempio (static void Main() (string str = "Simple string"; // Ottieni la lunghezza della stringa e il sesto carattere nella stringa utilizzando l'indicizzatore Console.WriteLine ("La lunghezza della stringa è (0), il sesto carattere è" (1) "" , str.Length, str;))

Operatori di classe stringa

La classe String esegue l'overload dei due operatori seguenti: == e! =. L'operatore == viene utilizzato per verificare l'uguaglianza di due stringhe di caratteri. Quando l'operatore == viene applicato ai riferimenti agli oggetti, di solito controlla se entrambi i riferimenti sono fatti allo stesso oggetto. E quando l'operatore == viene applicato ai riferimenti a oggetti di tipo String, il contenuto delle stringhe stesse viene confrontato per l'uguaglianza. Lo stesso vale per l'operatore! =. Quando applicato a riferimenti a oggetti di tipo String, il contenuto delle stringhe stesse viene confrontato per la disuguaglianza. Allo stesso tempo, altri operatori relazionali, incluso =, confrontano i riferimenti a oggetti di tipo String allo stesso modo degli oggetti di altri tipi. E per verificare se una stringa è più grande di un'altra, dovresti chiamare il metodo Compare(), che è definito nella classe String.

Come risulterà chiaro, molti confronti di stringhe di caratteri utilizzano informazioni culturali. Ma questo non si applica agli operatori == e!=. Dopotutto, confrontano semplicemente i valori ordinali dei caratteri nelle stringhe. (In altre parole, confrontano i valori dei caratteri binari che non sono culturalmente modificati, cioè colti.) Pertanto, questi operatori eseguono confronti di stringhe in modo insensibile alle maiuscole e alle impostazioni cultura.

Metodi di classe stringa

La tabella seguente elenca alcuni dei metodi più interessanti di questa classe, raggruppati per scopo:

Il seguente esempio di programma utilizza diversi dei metodi sopra indicati:

Utilizzo del sistema; utilizzando System.Collections.Generic; utilizzando System.Linq; utilizzando System.Text; namespace ConsoleApplication1 (class Program (static void Main (string args) (// Confronta le prime due righe) string s1 = "questa è una stringa"; string s2 = "questo è testo e questa è una stringa"; if (String. CompareOrdinal (s1, s2) ! = 0) Console.WriteLine ("Le stringhe s1 e s2 non sono uguali"); if (String.Compare (s1, 0, s2, 13, 10, true) == 0) Console.WriteLine ("Inoltre, hanno lo stesso testo "); // Concatenazione di stringhe Console.WriteLine (String.Concat (" \ n "+" Uno, due "," tre, quattro ")); // Cerca in una stringa // Prima occorrenza di una sottostringa if (s2. IndexOf ("this")! = -1) Console.WriteLine ("La parola \" this \ "è stata trovata nella riga, è" + "at: (0) position" , s2.IndexOf ("this")); // Ultima occorrenza della sottostringa if (s2.LastIndexOf ("this")! = -1) Console.WriteLine ("L'ultima occorrenza della parola \" this \ "è " + "alla posizione (0)", s2.LastIndexOf ("questo" )); // Cerca da un array di caratteri char myCh = ("Y", "x", "t"); if (s2.IndexOfAny (myCh)! = -1) Console.WriteLine ("Uno dei caratteri dell'array ch "+" trovato nel riga alla posizione (0) ", s2.IndexOfAny (myCh)); // Determina se la stringa inizia con una data sottostringa if (s2.StartsWith ("questo è testo") == true) Console.WriteLine ("Sottostringa trovata!"); // Determina se la stringa contiene una sottostringa // utilizzando l'esempio di definizione della stringa del sistema operativo dell'utente myOS = Environment.OSVersion.ToString (); if (myOS.Contains ("NT 5.1")) Console.WriteLine ("Il tuo sistema operativo è Windows XP"); else if (myOS.Contains ("NT 6.1")) Console.WriteLine ("Il tuo sistema operativo Windows 7"); Console.ReadLine (); )))

Un po 'di confronto tra stringhe in C #

Di tutte le operazioni di elaborazione delle stringhe di caratteri, è probabile che una stringa venga confrontata con un'altra. Prima di considerare qualsiasi metodo per confrontare le stringhe, è necessario sottolineare quanto segue: i confronti di stringhe possono essere eseguiti in .NET Framework in due modi principali:

In primo luogo, il confronto può riflettere i costumi e le norme di un particolare ambiente culturale, che spesso sono ambienti culturali che entrano in vigore quando il programma viene eseguito. Questo è un comportamento standard per alcuni, ma non tutti, i metodi di confronto.

E in secondo luogo, il confronto può essere eseguito indipendentemente dalle impostazioni dell'ambiente culturale solo dai valori ordinali dei caratteri che compongono la stringa. In generale, i confronti di stringhe culturalmente trascurati utilizzano l'ordine lessicografico (e considerazioni linguistiche) per determinare se una stringa è maggiore, minore o uguale a un'altra stringa. In un confronto ordinale, le stringhe vengono semplicemente ordinate in base al valore invariato di ciascun carattere.

A causa dei diversi metodi di confronto culturali e ordinali per i confronti di stringhe e delle implicazioni di ciascuno di questi confronti, si consiglia vivamente di seguire le procedure consigliate attualmente offerte da Microsoft. Dopotutto, scegliere il modo sbagliato per confrontare le stringhe può portare a un funzionamento errato del programma quando viene utilizzato in un ambiente diverso da quello in cui è stato sviluppato.

La scelta di come confrontare le stringhe di caratteri è una decisione molto importante. Come regola generale e senza eccezioni, il confronto di stringhe culturalmente appropriato dovrebbe essere scelto se ha lo scopo di mostrare il risultato all'utente (ad esempio, per visualizzare una serie di stringhe ordinate in ordine lessicografico). Tuttavia, se le stringhe contengono informazioni fisse che non devono essere modificate per adattarsi alle differenze culturali, come un nome file, una parola chiave, un indirizzo del sito Web o un valore di sicurezza, è necessario scegliere un confronto di stringhe ordinali. Naturalmente, le specifiche di una particolare applicazione in fase di sviluppo detteranno la scelta di un modo appropriato per confrontare le stringhe di caratteri.

La classe String fornisce una varietà di metodi di confronto delle stringhe, elencati nella tabella sopra. Il più versatile di questi è il metodo Compare(). Consente di confrontare due stringhe in tutto o in parte, case sensitive o case insensitive, la modalità di confronto definita dal parametro type Confronto di stringhe così come le informazioni sulla cultura fornite con un parametro di tipo CulturaInfo.

Gli overload di Compare() che non contengono un parametro di tipo StringComparison eseguono un confronto delle stringhe di caratteri con distinzione tra maiuscole e minuscole e con distinzione delle impostazioni cultura. E in quelle varianti di overload che non contengono un parametro di tipo CultureInfo, le informazioni sulle impostazioni cultura sono determinate dal runtime corrente.

Il tipo StringComparison è un'enumerazione che definisce i valori mostrati nella tabella sottostante. Usando questi valori, puoi organizzare i confronti di stringhe in base alle esigenze della tua particolare applicazione. Pertanto, l'aggiunta di un parametro di tipo StringComparison estende il metodo Compare() e altri metodi di confronto come Equals(). Consente inoltre di indicare in modo univoco come si suppone che le stringhe vengano confrontate.

A causa delle differenze tra i confronti di stringhe sensibili alle impostazioni cultura e i confronti ordinali, è molto importante essere il più precisi possibile a questo proposito.

In entrambi i casi, il metodo Compare() restituisce un valore negativo se la prima stringa confrontata è minore della seconda; valore positivo se la prima stringa confrontata è maggiore della seconda; e infine zero se entrambe le stringhe confrontate sono uguali. Sebbene il metodo Compare() restituisca zero se le stringhe confrontate sono uguali, in genere è preferibile utilizzare il metodo Equals() o l'operatore == per determinare se le stringhe di caratteri sono uguali.

Il punto è che il metodo Compare() determina l'uguaglianza delle stringhe confrontate in base al loro ordinamento. Ad esempio, se si confrontano stringhe in base alle impostazioni cultura, entrambe le stringhe potrebbero essere uguali nell'ordine in cui sono ordinate, ma non sostanzialmente uguali. Per impostazione predefinita, l'uguaglianza delle stringhe è determinata nel metodo Equals() in base ai valori dei caratteri ordinali ed è culturalmente insensibile. Pertanto, per impostazione predefinita, entrambe le stringhe vengono confrontate in questo metodo per l'uguaglianza assoluta, carattere per carattere, proprio come nell'operatore ==.

Sebbene il metodo Compare() sia più versatile, è più semplice utilizzare il metodo CompareOrdinal() per semplici confronti ordinali di stringhe di caratteri. Infine, tieni presente che il metodo CompareTo() confronta solo le stringhe relative alle impostazioni cultura.

Il programma seguente mostra l'uso dei metodi Compare(), Equals(), CompareOrdinal() e degli operatori == e! = per confrontare le stringhe di caratteri. Si noti che i primi due esempi di confronto illustrano la differenza tra i confronti di stringhe culturalmente sensibili e i confronti ordinali in inglese:

Utilizzo del sistema; class Esempio (static void Main() (string str1 = "alpha"; string str2 = "Alpha"; string str3 = "Beta"; string str4 = "alpha"; string str5 = "alpha, beta"; int risultato; / / Innanzitutto, dimostra la differenza tra il confronto di stringhe sensibile alle impostazioni cultura e il risultato del confronto ordinale = String.Compare (str1, str2, StringComparison.CurrentCulture); Console.Write ("Confronto di stringhe sensibile alle impostazioni cultura:"); if (result 0 ) Console .WriteLine (str1 + "maggiore di" + str2); else Console.WriteLine (str1 + "uguale" + str2); result = String.Compare (str1, str2, StringComparison.Ordinal); Console.Write ("Linee di confronto ordinali : "); if (risultato 0) Console.WriteLine (str1 +" maggiore di "+ str2); else Console.WriteLine (str1 +" uguale a "+ str4); // Utilizza il metodo CompareOrdinal() risultato = String. CompareOrdinal ( str1, str2); Console.Write ("Confronta stringhe utilizzando il metodo CompareOrdinal (): \ n"); if (risultato 0) Console.WriteLine (str1 + "more" + str2); else Console.WriteLine (str 1 + "uguale" + str4); Console.WriteLine (); // Determina l'uguaglianza delle stringhe utilizzando l'operatore == // Questo è un confronto ordinale di stringhe di caratteri if (str1 == str4) Console.WriteLine (str1 + "==" + str4); // Determina la disuguaglianza delle stringhe utilizzando l'operatore! = If (str1! = Str3) Console.WriteLine (str1 + "! =" + Str3); if (str1! = str2) Console.WriteLine (str1 + "! =" + str2); Console.WriteLine (); // Esegue un confronto ordinale di stringhe senza distinzione tra maiuscole e minuscole // utilizzando il metodo Equals () if (String.Equals (str1, str2, StringComparison.OrdinalIgnoreCase)) Console.WriteLine ("Confronto di stringhe utilizzando il metodo Equals () con" + "Parametro OrdinalIgnoreCase: \ n "+ str1 +" è uguale a "+ str2); Console.WriteLine (); // Confronta parti di stringhe if (String.Compare (str2, 0, str5, 0, 3, StringComparison.CurrentCulture)> 0) (Console.WriteLine ("Confronta stringhe in base alle impostazioni cultura correnti:" + "\ n3 primi caratteri della riga "+ str2 +" è maggiore dei primi 3 caratteri della stringa "+ str5);)))

L'esecuzione di questo programma produce il seguente risultato: