Dichiarazioni di stringa
Una stringa nel linguaggio C è una matrice unidimensionale di caratteri, il cui ultimo elemento è il carattere di fine riga - zero (una stringa con terminazione null, ovvero una stringa con terminazione NULL).
Ci sono tre modi per dichiarare una variabile di tipo stringa in C, due dei quali inizializzano la stringa al momento della dichiarazione.
Primo modo:
Dichiarazioni di array di caratteri (non dimenticare di aggiungere spazio per il null di terminazione):
Caratteri;
Secondo modo:
Assegnare a una variabile stringa un valore iniziale (in questo caso il compilatore può calcolare la lunghezza della stringa stessa):
Char s = "Esempio di inizializzazione di una stringa";
A destra del segno di assegnazione c'è una costante stringa. Uno zero ('\0') viene aggiunto automaticamente alla fine della stringa. Le costanti della stringa di caratteri vengono inserite in una classe di archiviazione statica.
Terzo modo:
Un'indicazione implicita che viene utilizzato un array. Sul lato sinistro del segno di assegnazione è indicato un puntatore al simbolo:
Char *s="Seconda opzione di inizializzazione";
La variabile s sarà un puntatore alla posizione nella RAM in cui si trova la costante stringa. Questa forma di notazione ha un potenziale errore in quanto un puntatore a un carattere viene spesso indicato come una stringa. La voce seguente è solo un puntatore a un carattere, poiché non c'è spazio per la stringa:
Char*s;
Immissione di una stringa dal dispositivo di input standard (tastiera)
C'è un insieme di funzioni per lavorare con le stringhe. Per l'input dal dispositivo di input standard (tastiera), vengono spesso utilizzate le funzioni di libreria dal modulo di input / output standard: scanf E prende.
Per inserire una stringa utilizzando la funzione scanf, utilizza il formato « %S» e si noti che il simbolo dell'indirizzo non viene utilizzato prima dell'identificatore di riga « & » , poiché un array unidimensionale è già rappresentato da un puntatore al suo inizio:
scanf("%s", s);
Funzione prende() legge i caratteri finché non raggiunge un carattere di nuova riga. La funzione accetta tutti i caratteri fino al carattere di nuova riga escluso. Alla fine della stringa viene aggiunto uno zero finale ("\0"). Funzione prende() inserisce una sequenza di caratteri letti dalla tastiera in un parametro stringa e restituisce un puntatore a quella stringa (se l'operazione è andata a buon fine), oppure NULL (in caso di errore). Nell'esempio seguente, al completamento con successo dell'operazione, sullo schermo verranno visualizzate due righe identiche:
#includere
Di passaggio, notiamo che la funzione gets viene spesso utilizzata per inserire qualsiasi dato dalla tastiera come stringa allo scopo di un'ulteriore conversione da parte della funzione sscanf nel formato desiderato o per l'analisi preliminare dei dati di input, ad esempio:
#includere
Stampa di stringhe sullo standard output (schermo del monitor)
Per emettere le stringhe sullo standard output (schermo del monitor), è possibile utilizzare due funzioni printf E mette. Nella funzione printf, "%s" viene passato come formato. La comodità di utilizzare questa funzione sta nel fatto che, oltre alla stringa, è possibile visualizzare immediatamente dati di altro tipo. caratteristica caratteristica metteè che dopo che la riga è stata emessa, avviene automaticamente il passaggio alla riga successiva.
Funzioni di stringa
Per convertire le stringhe nel linguaggio C, viene fornita la libreria di stringhe. Ognuna delle funzioni ha il proprio formato di registrazione (prototipo).
Le funzioni più utilizzate sono discusse in questo articolo. - Leggere
Un esempio di programmi (lista) che lavorano con le stringhe
34--- Tutorial C# --- Stringhe
In termini di programmazione regolare, string 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 è uno dei tipi di riferimento.
Costruzione di fila
Il modo più semplice per costruire una stringa di caratteri consiste nell'utilizzare una stringa letterale. Ad esempio, nella seguente riga di codice, alla variabile di riferimento stringa str viene assegnato un riferimento a una stringa letterale:
String str = "Stringa di esempio";
In questo caso la variabile str viene inizializzata con la sequenza di caratteri "Example String". Un oggetto di tipo string può anche essere creato da un array di tipo char. Per 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 necessaria 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 che una sequenza di caratteri è stata creata, non può essere modificata. Ma questa limitazione contribuisce a un'implementazione più efficiente delle stringhe di caratteri. Pertanto, questo, a prima vista, un evidente svantaggio si trasforma in realtà in un vantaggio. Quindi, se hai bisogno di una stringa come variazione di una stringa esistente, a questo scopo dovresti creare una nuova stringa contenente tutte le modifiche necessarie. E poiché gli oggetti stringa inutilizzati vengono raccolti automaticamente in "spazzatura", non devi nemmeno preoccuparti del destino delle stringhe non necessarie.
Tuttavia, va sottolineato che le variabili di riferimento stringa (ovvero oggetti di tipo stringa) sono soggette a modifiche e quindi possono fare riferimento ad un altro oggetto. Ma il contenuto dell'oggetto stringa stesso non cambia dopo che è stato creato.
Considera un esempio:
Static void addNewString() ( string s = "Questo è il mio tratto"; s = "Questo è il 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():
Notare le molteplici chiamate al codice operativo ldstr (caricamento stringa). Questo codice operativo ldstr in CIL provoca il caricamento di un nuovo oggetto stringa nell'heap gestito. Di conseguenza, l'oggetto precedente che conteneva il valore "Questo è il mio tratto" verrà infine sottoposto a Garbage Collection.
Lavorare con le stringhe
In classe System.String viene fornito un insieme di metodi per determinare la lunghezza dei dati carattere, ricercare una sottostringa nella stringa corrente, convertire i caratteri da maiuscolo a minuscolo e viceversa, e così via. Vedremo questa classe in modo più dettagliato in seguito.
Campo, indicizzatore e proprietà della classe String
La classe String ha un singolo campo definito:
Stringa di sola lettura statica pubblica Vuoto;
Il campo Vuoto denota una stringa vuota, ad es. una stringa che non contiene caratteri. Questo è diverso da un riferimento String vuoto, che viene semplicemente fatto a un oggetto inesistente.
Inoltre, la classe String definisce un singolo indicizzatore di sola lettura:
Pubblica char this ( get; )
Questo indicizzatore consente di ottenere il carattere all'indice specificato. L'indicizzazione delle stringhe, come gli array, inizia da zero. Gli oggetti stringa sono persistenti e non cambiano, quindi ha senso che la classe String supporti un indicizzatore di sola lettura.
Infine, la classe String definisce una singola proprietà di sola lettura:
Public int Lunghezza ( get; )
La proprietà Length restituisce il numero di caratteri in una stringa. L'esempio seguente mostra l'utilizzo di un indicizzatore e della proprietà Length:
Utilizzando il sistema; class Esempio ( static void Main() ( string str = "Stringa semplice"; // 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.Lunghezza, 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 allo stesso oggetto. E quando l'operatore == viene applicato a riferimenti a oggetti di tipo String, i contenuti delle stringhe stesse vengono confrontati per verificarne l'uguaglianza. Lo stesso vale per l'operatore !=. Quando viene applicato a riferimenti a oggetti di tipo String, i contenuti delle stringhe stesse vengono confrontati 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 è maggiore di un'altra, dovresti chiamare il metodo Compare() definito nella classe String.
Come risulterà chiaro in seguito, molti tipi di confronti tra 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 valori di caratteri binari che non sono stati modificati da norme culturali, ad esempio impostazioni locali.) Pertanto, questi operatori eseguono confronti di stringhe senza distinzione tra maiuscole e minuscole e senza distinzione di cultura.
Metodi della classe stringa
La tabella seguente elenca alcuni dei metodi più interessanti di questa classe, raggruppati per scopo:
| Metodo | Struttura e versioni sovraccariche | Scopo |
|---|---|---|
| Confronto di stringhe | ||
| Confrontare() | public static int Confronta(stringa strA, stringa strB) Public static int Compare(string strA, string strB, bool ignoreCase) Public static int Compare(string strA, string strB, StringComparison comparativeType) Public static int Compare(string strA, string strB, bool ignoreCase, CultureInfo culture) |
Metodo statico, confronta la stringa strA con la stringa strB. Restituisce positivo se strA è maggiore di strB; negativo se strA è minore di strB; e zero se le stringhe strA e strB sono uguali. Il confronto fa distinzione tra maiuscole e minuscole e culturalmente sensibile. Se il parametro ignoreCase è impostato sul valore booleano true, il confronto non tiene conto delle differenze tra lettere maiuscole e minuscole. Altrimenti, queste differenze vengono prese in considerazione. Il parametro comparativeType specifica il modo specifico in cui le stringhe vengono confrontate. La classe CultureInfo è definita nello spazio dei nomi System.Globalization. |
| public static int Compare(string strA, int indexA, string strB, int indexB, int length) Public static int Compare(string strA, int indexA, string strB, int indexB, int length, bool ignoreCase) Public static int Compare(string strA, int indexA, string strB, int indexB, int length, StringComparison comparativeType) Public static int Compare(string strA, int indexA, string strB, int indexB, int length, bool ignoreCase, CultureInfo culture) |
Confronta parti delle stringhe strA e strB. Il confronto inizia con gli elementi stringa strA e strB e include il numero di caratteri specificato dal parametro length. Il metodo restituisce un valore positivo se parte di strA è maggiore di parte di strB; un valore negativo se parte di strA è minore di parte di strB; e zero se le parti confrontate delle stringhe strA e strB sono uguali. Il confronto fa distinzione tra maiuscole e minuscole e culturalmente sensibile. |
|
| confrontaOrdinal() | public static int CompareOrdinal(stringa strA, stringa strB) Public static int CompareOrdinal(string strA, int indexA, string strB, int indexB, int count) |
Funziona come il metodo Compare(), ma senza riguardo alle impostazioni locali |
| Confrontare con() | public int CompareTo(valore oggetto) | Confronta la stringa chiamante con la rappresentazione di stringa dell'oggetto valore. Restituisce un valore positivo se la stringa chiamante è maggiore del valore della stringa; un valore negativo se la stringa chiamante è minore della stringa del valore; e zero se le stringhe confrontate sono uguali |
| public int CompareTo(stringa strB) | Confronta la stringa chiamante con strB |
|
| Equivale() | public override bool Equals(object obj) | Restituisce il valore booleano true se la stringa chiamante contiene la stessa sequenza di caratteri della rappresentazione di stringa di obj. Esegue un confronto ordinale, con distinzione tra maiuscole e minuscole, ma culturalmente insensibile |
| public bool Equals(valore stringa) Public bool Equals(string value, StringComparison comparativeType) |
Restituisce il valore booleano true se la stringa chiamante contiene la stessa sequenza di caratteri del valore stringa. Viene eseguito un confronto ordinale, con distinzione tra maiuscole e minuscole, ma culturalmente insensibile. Il parametro compareType definisce un modo specifico per confrontare le stringhe |
|
| public static bool Equals(stringa a, stringa b) Pubblico static bool Equals(stringa a, stringa b, StringComparison comparativeType) |
Restituisce boolean true se la stringa a contiene la stessa sequenza di caratteri della stringa b . Viene eseguito un confronto ordinale, con distinzione tra maiuscole e minuscole, ma culturalmente insensibile. Il parametro compareType definisce un modo specifico per confrontare le stringhe |
|
| Concatenazione (connessione) di stringhe | ||
| Concat() | stringa statica pubblica Concat(stringa str0, stringa str1); stringa statica pubblica Concat(params string values); |
Combina istanze di stringhe separate in una singola stringa (concatenazione) |
| Cerca in una stringa | ||
| Contiene() | public bool Contiene(valore stringa) | Un metodo che consente di determinare se una stringa contiene una specifica sottostringa (valore) |
| Inizia con() | public bool StartsWith(valore stringa) Public bool StartsWith(string value, StringComparison comparativeType) |
Restituisce il valore booleano true se la stringa chiamante inizia con il valore substring. In caso contrario, viene restituito il valore booleano false. Il parametro comparativeType specifica come deve essere eseguita la ricerca. |
| Finisce con() | public bool EndsWith(valore stringa) Public bool EndsWith(string value, StringComparison comparativeType) |
Restituisce il valore booleano true se la stringa chiamante termina con il valore substring. In caso contrario, restituisce il valore booleano false. Il parametro comparativeType definisce un metodo di ricerca specifico |
| Indice di() | public int IndexOf(valore carattere) Public int IndexOf(valore stringa) |
Trova la prima occorrenza di una determinata sottostringa o carattere in una stringa. Se il carattere o la sottostringa che stai cercando non viene trovato, viene restituito -1. |
| public int IndexOf(valore char, int startIndex) Public int IndexOf(valore stringa, int startIndex) Public int IndexOf(char value, int startIndex, int count) Public int IndexOf(valore stringa, int startIndex, int conteggio) |
Restituisce l'indice della prima occorrenza del carattere o del valore della sottostringa nella stringa chiamante. La ricerca inizia dall'elemento specificato in index startIndex e si estende sul numero di elementi specificato dal parametro count (se specificato). Il metodo restituisce -1 se il carattere o la sottostringa ricercati non vengono trovati |
|
| UltimoIndiceOf() | Le versioni sovraccaricate sono simili al metodo IndexOf() | Uguale a IndexOf, ma trova l'ultima occorrenza di un carattere o di una sottostringa anziché la prima |
| IndexOfAny() | public int IndexOfAny(char anyOf) Public int IndexOfAny(char anyOf, int startIndex) Public int IndexOfAny(char anyOf, int startIndex, int count) |
Restituisce l'indice della prima occorrenza di qualsiasi carattere nell'array anyOf trovato nella stringa chiamante. La ricerca inizia dall'elemento specificato dall'indice startIndex e si estende sul numero di elementi specificato dal parametro count (se presente). Il metodo restituisce -1 se non viene trovata alcuna corrispondenza per nessuno dei caratteri nell'array anyOf. La ricerca viene effettuata in modo ordinale |
| LastIndexOfAny | Le versioni sovraccaricate sono simili al metodo IndexOfAny() | Restituisce l'indice dell'ultima occorrenza di qualsiasi carattere nell'array anyOf trovato nella stringa chiamante |
| Divisione e concatenazione di stringhe | ||
| Diviso | public string Split(parametri separatore di caratteri) Stringa pubblica Split(parametri char separator, int count) |
Un metodo che restituisce un array di stringhe con all'interno le sottostringhe presenti in questa istanza, separate l'una dall'altra da elementi dall'array di caratteri o stringhe specificato. La prima forma del metodo Split() suddivide la stringa chiamante nelle sue parti componenti. Il risultato è un array contenente le sottostringhe recuperate dalla stringa chiamante. I caratteri che delimitano queste sottostringhe vengono passati nell'array separatore. Se l'array separatore è vuoto o fa riferimento a una stringa vuota, viene utilizzato uno spazio come separatore di sottostringhe. E nella seconda forma di questo metodo, viene restituito il numero di sottostringhe determinato dal parametro count. |
| public string Split(params char separator, opzioni StringSplitOptions) Stringa pubblica Split(separatore stringa, opzioni StringSplitOptions) Stringa pubblica Split(params char separator, int count, opzioni StringSplitOptions) Stringa pubblica Split(separatore stringa, conteggio int, opzioni StringSplitOptions) |
Le prime due forme del metodo Split() suddividono la stringa chiamante in parti e restituiscono un array contenente le sottostringhe ottenute dalla stringa chiamante. I caratteri che separano queste sottostringhe vengono passati nell'array separatore. Se l'array separatore è vuoto, viene utilizzato uno spazio come separatore. E nella terza e quarta forma di questo metodo, viene restituito il numero di righe, limitato dal parametro count. Ma in tutte le forme, il parametro options specifica un modo specifico per gestire le stringhe vuote, che vengono generate quando due delimitatori sono adiacenti. L'enumerazione StringSplitOptions definisce solo due valori: Nessuno E RimuoviEmptyEntry. Se il parametro options è None, le stringhe vuote vengono incluse nel risultato finale della divisione della stringa originale. E se il parametro options è impostato su RemoveEmptyEntries, le stringhe vuote vengono escluse dal risultato finale della divisione della stringa originale. |
|
| Giuntura() | stringa statica pubblica Join(separatore stringa, valore stringa) Stringa statica pubblica Join(separatore stringa, valore stringa, int startIndex, int count) |
Costruisce una nuova stringa combinando il contenuto di una matrice di stringhe. La prima forma del metodo Join() restituisce una stringa costituita da sottostringhe concatenate passate nell'array di valori. Anche la seconda forma restituisce una stringa composta dalle sottostringhe passate nell'array di valori, ma sono concatenate un certo numero di conteggi, a partire dall'elemento dell'array di valori. In entrambe le forme, ogni riga successiva è separata dalla riga precedente da una stringa di separazione specificata dal parametro separator. |
| Linee di riempimento e rifilatura | ||
| ordinare() | stringa pubblica Taglia() Stringa pubblica Trim(params char trimChars) |
Un metodo che consente di rimuovere tutte le occorrenze di un set di caratteri specificato dall'inizio e dalla fine della stringa corrente. La prima forma del metodo Trim() rimuove gli spazi iniziali e finali dalla stringa chiamante. E la seconda forma di questo metodo rimuove le occorrenze iniziali e finali nella stringa di caratteri chiamante dall'array trimChars. Entrambe le forme restituiscono la stringa risultante. |
| PadLeft() | stringa pubblica PadLeft(int totalWidth) Stringa pubblica PadLeft(int totalWidth, char paddingChar) |
Consente di riempire la stringa con i caratteri a sinistra. La prima forma del metodo PadLeft() inserisce spazi sul lato sinistro della stringa chiamante in modo che la sua lunghezza totale sia uguale al valore del parametro totalWidth. Nella seconda forma di questo metodo, i caratteri indicati dal parametro paddingChar vengono immessi sul lato sinistro della stringa chiamante in modo che la sua lunghezza totale diventi uguale al valore del parametro totalWidth. Entrambe le forme restituiscono la stringa risultante. Se il valore del parametro totalWidth è inferiore alla lunghezza della stringa chiamante, viene restituita una copia della stringa chiamante non modificata. |
| PadRight() | Simile a PadLeft() | Consente di riempire la stringa con i caratteri a destra. |
| Inserimento, eliminazione e sostituzione di righe | ||
| Inserire() | public string Insert(int startIndex, valore stringa) | Utilizzato per inserire una stringa in un'altra, dove value è la stringa da inserire nella stringa chiamante all'indice startIndex. Il metodo restituisce la stringa risultante. |
| Rimuovere() | stringa pubblica Rimuovi(int startIndex) Stringa pubblica Remove(int startIndex, int count) |
Utilizzato per rimuovere parte di una stringa. Nella prima forma del metodo Remove(), la rimozione viene eseguita a partire dalla posizione specificata dall'indice startIndex e proseguendo fino alla fine della stringa. E nella seconda forma di questo metodo, il numero di caratteri specificato dal parametro count viene rimosso dalla stringa, a partire dalla posizione specificata dall'indice startIndex. |
| Sostituire() | public string Replace(char oldChar, char newChar) Stringa pubblica Sostituisci(stringa vecchioValore, stringa nuovoValore) |
Utilizzato per sostituire parte di una stringa. La prima forma del metodo Replace() sostituisce tutte le occorrenze di oldChar nella stringa chiamante con newChar. E nella seconda forma di questo metodo, tutte le occorrenze della stringa oldValue nella stringa chiamante vengono sostituite dalla stringa newValue. |
| Cambio di caso | ||
| ToUpper() | stringa pubblica ToUpper() | Rende maiuscole tutte le lettere nella stringa chiamante. |
| Ridurre() | stringa pubblica ToLower() | Rende minuscole tutte le lettere nella stringa chiamante. |
| Ottenere una sottostringa da una stringa | ||
| Sottostringa() | stringa pubblica Sottostringa(int startIndex) Stringa pubblica Sottostringa(int startIndex, int lunghezza) |
Nella prima forma del metodo Substring(), la sottostringa viene estratta dalla posizione indicata dal parametro startIndex fino alla fine della stringa chiamante. E nella seconda forma di questo metodo, viene estratta una sottostringa, costituita dal numero di caratteri specificato dal parametro length, a partire dalla posizione indicata dal parametro startIndex. |
L'esempio di programma seguente utilizza diversi dei metodi precedenti:
Utilizzando il sistema; utilizzando System.Collections.Generic; utilizzando System.Linq; utilizzando System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args) ( // Confronta le prime due stringhe string s1 = "questa è una stringa"; string s2 = "questo è testo, 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( "Tuttavia, contengono lo stesso testo"); // Concatenazione di stringhe Console.WriteLine(String.Concat("\n" + "Uno, due ","tre, quattro")); // Cerca nella stringa // Prima occorrenza of substring 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 di \"this\" è " + "at ( 0) position", s2.LastIndexOf("this" )); // Ricerca dall'array di caratteri char myCh = ("S","x","t"); if (s2.IndexOfAny(myCh) != -1) Console.WriteLine("Uno dei caratteri dell'array ch "+" trovato nel file current riga corrente alla posizione (0)", s2.IndexOfAny(myCh)); // Determina se la stringa inizia con la sottostringa data if (s2.StartsWith("this is text") == true) Console.WriteLine("Substring found!"); // Determina se la stringa contiene una sottostringa // utilizzando l'esempio di determinazione 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' sul confronto tra stringhe in C#
Di tutte le operazioni di elaborazione delle stringhe di caratteri, è probabilmente il confronto eseguito più di frequente tra una stringa e un'altra. Prima di esaminare qualsiasi metodo di confronto tra stringhe, è necessario sottolineare quanto segue: il confronto tra stringhe può essere eseguito 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 sono spesso contesti culturali che hanno effetto quando viene eseguito un programma. Questo è un comportamento standard per alcuni metodi di confronto, anche se non per tutti.
E in secondo luogo, il confronto può essere eseguito indipendentemente dalle impostazioni dell'ambiente culturale solo sui valori ordinali dei caratteri che compongono la stringa. In generale, il confronto di stringhe culturalmente insensibile utilizza l'ordine lessicografico (e le caratteristiche 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 non modificato di ciascun carattere.
A causa delle differenze nel modo in cui le stringhe vengono confrontate tra le impostazioni cultura e i confronti ordinali e le implicazioni di ciascuno di questi confronti, si consiglia vivamente di utilizzare le procedure consigliate attualmente offerte da Microsoft. Dopotutto, scegliere il modo sbagliato di confrontare le stringhe può portare a un funzionamento errato del programma quando viene utilizzato in un ambiente diverso da quello in cui è stato sviluppato.
Scegliere come confrontare le stringhe di caratteri è una decisione molto importante. Come regola generale, e senza eccezioni, dovresti scegliere un confronto di stringhe culturalmente sensibile se ha lo scopo di visualizzare il risultato all'utente (ad esempio, per visualizzare una serie di stringhe ordinate in ordine lessicografico). Ma se le stringhe contengono informazioni fisse che non devono essere modificate per differenze culturali, come un nome di file, una parola chiave, un indirizzo di un sito Web o un valore relativo alla sicurezza, allora dovresti scegliere un confronto di stringhe ordinali. Naturalmente, le specifiche della particolare applicazione sviluppata determineranno la scelta di un modo appropriato per confrontare le stringhe di caratteri.
La classe String fornisce una varietà di metodi di confronto tra stringhe, elencati nella tabella precedente. Il più versatile tra questi è il metodo Compare(). Consente di confrontare due stringhe in tutto o in parte, case-sensitive o case-insensitive, in una modalità di confronto determinata dal parametro type Confronto di stringhe, oltre alle informazioni culturali fornite dal parametro type CulturaInfo.
Gli overload del metodo Compare() che non contengono un parametro di tipo StringComparison eseguono un confronto con distinzione tra maiuscole e minuscole e impostazioni cultura delle stringhe di caratteri. E in quelle varianti di overload che non contengono un parametro di tipo CultureInfo, le informazioni sulle impostazioni cultura sono determinate dall'ambiente di runtime corrente.
Il tipo StringComparison è un'enumerazione che definisce i valori mostrati nella tabella sottostante. Usando questi valori, puoi organizzare i confronti tra stringhe che si adattano alle esigenze della tua applicazione. Pertanto, l'aggiunta di un parametro di tipo StringComparison estende le funzionalità del metodo Compare() e di altri metodi di confronto come Equals(). Consente inoltre di specificare in modo univoco come devono essere confrontate le stringhe.
A causa delle differenze tra confronti di stringhe culturalmente sensibili e confronti ordinali, è importante essere il più precisi possibile a questo proposito.
| Senso | Descrizione |
|---|---|
| Cultura attuale | Il confronto tra stringhe viene eseguito utilizzando le impostazioni cultura correnti |
| CurrentCultureIgnoreCase | Il confronto tra stringhe viene eseguito utilizzando le impostazioni cultura correnti, ma non fa distinzione tra maiuscole e minuscole |
| InvariantCulture | Il confronto delle stringhe viene eseguito utilizzando quelli immutabili, ad es. dati universali sull'ambiente culturale |
| InvariantCultureIgnoreCase | Il confronto delle stringhe viene eseguito utilizzando quelli immutabili, ad es. dati culturali universali e senza distinzione tra maiuscole e minuscole |
| Ordinale | Il confronto tra stringhe viene eseguito utilizzando i valori ordinali dei caratteri nella stringa. In questo caso, l'ordine lessicografico può essere violato e le convenzioni adottate in un particolare ambiente culturale vengono ignorate. |
| OrdinalIgnoreCase | Il confronto tra stringhe viene eseguito utilizzando i valori ordinali dei caratteri nella stringa, ma senza distinzione tra maiuscole e minuscole |
In entrambi i casi, il metodo Compare() restituisce un valore negativo se la prima stringa confrontata è minore della seconda; un 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 fatto è che il metodo Compare() determina l'uguaglianza delle stringhe confrontate in base al loro ordinamento. Ad esempio, se le stringhe vengono confrontate culturalmente, entrambe le stringhe possono essere uguali nel loro ordinamento, ma non essenzialmente uguali. Per impostazione predefinita, l'uguaglianza delle stringhe è determinata nel metodo Equals(), in base ai valori ordinali dei caratteri e non culturalmente. Pertanto, per impostazione predefinita, entrambe le stringhe vengono confrontate in questo metodo per l'uguaglianza assoluta carattere per carattere, in modo simile a come avviene nell'operatore ==.
Nonostante la grande versatilità del metodo Compare(), per un semplice confronto ordinale di stringhe di caratteri è più semplice utilizzare il metodo CompareOrdinal(). Infine, tieni presente che il metodo CompareTo() confronta solo le stringhe in modo culturalmente sensibile.
Il programma seguente mostra l'utilizzo dei metodi Compare(), Equals(), CompareOrdinal() e degli operatori == e != per confrontare le stringhe di caratteri. Si noti che i primi due esempi di confronto dimostrano chiaramente le differenze tra confronti di stringhe culturalmente sensibili e confronti ordinali inglesi:
Utilizzando il sistema; class Esempio ( static void Main() ( string str1 = "alpha"; string str2 = "Alpha"; string str3 = "Beta"; string str4 = "alpha"; string str5 = "alpha, beta"; int risultato; / /In primo luogo, dimostrare le differenze tra il confronto di stringhe in base alle impostazioni cultura e il risultato del confronto ordinale = String.Compare(str1, str2, StringComparison.CurrentCulture); Console.Write("Confronto di stringhe in base alle impostazioni cultura: "); if (result 0 ) Console .WriteLine(str1 + " è maggiore di " + str2); else Console.WriteLine(str1 + "è " + str2); result = String.Compare(str1, str2, StringComparison.Ordinal); Console.Write("Confronto ordinale righe: "); if (risultato 0) Console.WriteLine(str1 + " è maggiore di " + str2); else Console.WriteLine(str1 + "è uguale a " + str4); // Usa il risultato del metodo CompareOrdinal() = String.CompareOrdinal( str1, str2); Console.Write("Confronta le stringhe usando CompareOrdinal():\n"); if (risultato 0) Console.WriteLine(str1 + " maggiore di " + str2); else Console.WriteLine (str 1 + "è uguale a " + 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); // Rileva la disuguaglianza di riga utilizzando l'operatore != if(str1 != str3) Console.WriteLine(str1 + " != " + str3); if(str1 != str2) Console.WriteLine(str1 + " != " + str2); Console.WriteLine(); // Esegue un confronto di stringhe ordinali 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 il 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("Confronto di stringhe in base alla cultura corrente:" + "\n3 primi caratteri della stringa " + str2 + " è maggiore dei primi 3 caratteri della stringa " + str5); ) ) )
L'esecuzione di questo programma produce il seguente risultato:
Il moderno standard C++ definisce una classe con funzioni e proprietà (variabili) per organizzare il lavoro con le stringhe (non ci sono stringhe in quanto tali nel linguaggio C classico, ci sono solo array di caratteri):
#includere
#includere#includere
Per lavorare con le stringhe, devi anche includere uno spazio dei nomi standard:
Utilizzo dello spazio dei nomi std;
Altrimenti, dovrai specificare il descrittore di classe std::string invece di string ovunque.
Quello che segue è un esempio di un programma che funziona con le stringhe (non funziona nei vecchi compilatori compatibili con C!):
#includere
Le caratteristiche principali che ha la classe stringa:
- inizializzazione con un array di caratteri (una stringa incorporata) o un altro oggetto di tipo string . Il tipo incorporato non ha la seconda capacità;
- copiando una riga in un'altra. Per un tipo integrato, devi usare la funzione strcpy();
- accesso ai singoli caratteri di una stringa per la lettura e la scrittura. Nell'array integrato, questo viene fatto usando l'operazione sull'indice o l'indirizzamento indiretto usando un puntatore;
- confrontando due stringhe per verificarne l'uguaglianza. Per un tipo integrato, vengono utilizzate le funzioni della famiglia strcmp();
- concatenazione (concatenazione) di due stringhe, fornendo il risultato come terza stringa o al posto di una di quelle originali. Per un tipo integrato, viene utilizzata la funzione strcat(), ma per ottenere il risultato in una nuova riga, è necessario utilizzare le funzioni strcpy() e strcat() in sequenza e occuparsi anche dell'allocazione della memoria;
- mezzi incorporati per determinare la lunghezza di una stringa (funzioni membro della classe size() e l ength()). L'unico modo per scoprire la lunghezza di una stringa di tipo incorporato è calcolarla con la funzione strlen();
- la capacità di scoprire se una stringa è vuota.
Diamo un'occhiata più da vicino a queste caratteristiche di base.
Inizializzazione della stringa quando si descrive e lunghezza della corda(escluso il terminatore null di terminazione):
String st("La mia stringa\n"); cout<< "Длина " << st << ": " << st.size() << " символов, включая символ новой строки\n";
La stringa può anche essere vuota:
Stringa st2;
Per verificare se è la stringa vuota, puoi confrontare la sua lunghezza con 0:
if (!st.size()) // vuoto
oppure usa il metodo empty(), che restituisce true per una stringa vuota e false per una 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) // inizializzazione riuscita
Come copiare una riga in un'altra? Con il solito operatore di assegnazione:
st2 = st3; // copia st3 in st2
Per concatenazione di stringhe viene utilizzato l'operatore di addizione (+) o l'operatore di assegnazione di addizione (+=). Si diano due righe:
Stringa s1("ciao, "); stringa s2("mondo\n");
Possiamo ottenere una terza stringa costituita dalla concatenazione delle prime due, quindi:
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 del tipo incorporato. È possibile riscrivere l'esempio precedente in modo che i caratteri speciali e i segni di punteggiatura siano rappresentati dal tipo integrato char * e le parole significative siano rappresentate da oggetti di classe string:
Const char *pc = ", "; stringa s1("ciao"); stringa s2("mondo"); stringa s3 = s1 + pc + s2 + "\n"; cout<< endl << s3;
Tali espressioni funzionano perché il compilatore "sa" come convertire automaticamente gli oggetti del tipo incorporato in oggetti della classe string . È anche possibile assegnare semplicemente una stringa incorporata a un oggetto stringa:
Stringa s1; const char *pc = "un array di caratteri"; s1=pc; // Giusto
La trasformazione inversa è non funziona. Il tentativo di eseguire la seguente inizializzazione della stringa di tipo incorporata causerà un errore di compilazione:
Car*str = s1; // errore di compilazione
Per eseguire questa conversione, devi chiamare esplicitamente la funzione membro chiamata 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 nel tipo stringa incorporato. La parola chiave const qui impedisce la possibilità "pericolosa" nei moderni ambienti visivi di modificare direttamente il contenuto di un oggetto tramite un puntatore.
A singoli personaggiè possibile accedere a un oggetto di tipo string , come un tipo integrato, utilizzando l'operazione index. Ad esempio, ecco uno snippet di codice che sostituisce tutti i punti con caratteri di sottolineatura:
Stringa str("www.disney.com"); int dimensione = str.dimensione(); per (int i = 0; i< size; i++) if (str[i] == ".") str[ i ] = "_"; cout << str;
Replace(str.begin(), str.end(), ".", "_");
È vero, non è il metodo di sostituzione della classe stringa che viene utilizzato qui, ma l'algoritmo con lo stesso nome:
#includere
Poiché l'oggetto stringa si comporta come un contenitore, gli possono essere applicati altri algoritmi. Ciò consente di risolvere problemi che non sono risolti direttamente dalle funzioni della classe stringa.
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 funzionalità della classe string, vedere, ad esempio, Wikipedia o cplusplus.com.
