Vă rugăm să întrerupeți AdBlock pe acest site.

Deci, șiruri în limbaj C. Nu au un tip de date separat, așa cum se face în multe alte limbaje de programare. În limbajul C, un șir este o matrice de caractere. Pentru a marca sfârșitul unui rând, se folosește caracterul „\0”, despre care am vorbit în ultima parte a acestei lecții. Nu este afișat în niciun fel pe ecran, așa că nu va funcționa să îl priviți.

Crearea și inițializarea unui șir

Deoarece un șir este o matrice de caractere, declararea și inițializarea unui șir este similară cu operațiuni similare cu matrice unidimensionale.

Următorul cod ilustrează diferite moduri de inițializare a șirurilor.

Listarea 1.

Charstr; char str1 = ("Y","o","n","g","C","o","d","e","r","\0"); char str2 = „Bună ziua!”; char str3 = "Bună ziua!";

Fig.1 Declarația și inițializarea șirurilor de caractere

În prima linie, pur și simplu declarăm o matrice de zece caractere. Nu este chiar o sfoară, pentru că îi lipsește caracterul nul \0 , atâta timp cât este doar un set de caractere.

A doua linie. Cel mai simplu mod de a inițializa în frunte. Declaram fiecare simbol separat. Principalul lucru aici este să nu uitați să adăugați caracterul nul \0 .

A treia linie este similară cu a doua linie. Fii atent la imagine. pentru că sunt mai puține caractere în șirul din dreapta decât sunt elemente în matrice, elementele rămase vor fi umplute cu \0 .

A patra linie. După cum puteți vedea, dimensiunea nu este setată aici. Programul îl va calcula automat și va crea o matrice de caractere de lungimea necesară. Aceasta va insera ultimul caracter nul \0.

Cum se scoate un șir

Să adăugăm codul de mai sus la un program cu drepturi depline care va afișa șirurile generate pe ecran.

Lista 2.

#include int main(void) ( char str; char str1 = ("Y","o","n","g","C","o","d","e","r","r"," \0"); char str2 = "Bună!"; char str3 = "Bună!"; for(int i = 0; i< 10; i = i + 1) printf("%c\t",str[i]); printf("\n"); puts(str1); printf("%s\n",str2); puts(str3); return 0; }

Fig. 2 Diferite moduri de a afișa un șir pe ecran

După cum puteți vedea, există mai multe modalități de bază de a afișa un șir pe ecran.

• utilizați funcția printf cu specificatorul %s
• utilizați funcția puts
• utilizați funcția fputs, specificând stdout ca al doilea parametru.

Singura avertizare sunt funcțiile put și fputs. Rețineți că funcția puts împachetează ieșirea la următoarea linie, dar funcția fputs nu.

După cum puteți vedea, rezultatul este destul de simplu.

Introducerea șirurilor

Cu intrarea de șir, lucrurile sunt puțin mai complicate decât cu ieșirea. Cea mai simplă cale ar fi următoarea:

Lista 3.

#include int main(void) (car str; gets(str); puts(str); return 0; )

Funcția gets întrerupe programul, citește un șir de caractere introdus de la tastatură și îl plasează într-o matrice de caractere, al cărui nume este transmis funcției ca parametru.
Funcția gets se termină cu caracterul corespunzător tastei enter și scris în șir ca un caracter nul.
Ai observat pericolul? Dacă nu, atunci compilatorul vă va avertiza cu amabilitate despre asta. Acest lucru se datorează faptului că funcția gets iese numai atunci când utilizatorul apasă tasta Enter. Acest lucru este plin de faptul că putem merge dincolo de matrice, în cazul nostru - dacă sunt introduse mai mult de 20 de caractere.
Apropo, erorile anterioare de depășire a tamponului au fost considerate cel mai comun tip de vulnerabilitate. Ele se găsesc și astăzi, dar a devenit mult mai dificil să le folosești pentru a sparge programe.

Deci ce avem. Avem o sarcină: scriem un șir într-o matrice de dimensiune limitată. Adică trebuie să controlăm cumva numărul de caractere introduse de utilizator. Și aici funcția fgets vine în ajutor:

Lista 4.

#include int main(void) (char str; fgets(str, 10, stdin); puts(str); return 0; )

Funcția fgets ia trei argumente ca intrare: o variabilă pentru a scrie șirul, dimensiunea șirului de scris și numele fluxului de unde să obțineți datele de scris în șir, în acest caz, stdin . După cum știți deja din lecția 3, stdin este fluxul de intrare standard, de obicei asociat cu tastatura. Nu este necesar ca datele să provină din fluxul stdin, în viitor vom folosi și această funcție pentru a citi datele din fișiere.

Dacă în timpul execuției acestui program introducem un șir mai mare de 10 caractere, doar 9 caractere de la început și caracterul de ruptură de linie va fi în continuare scris în tablou, fgets va „taia” șirul la lungimea necesară.

Rețineți că funcția fgets nu citește 10 caractere, ci 9 ! După cum ne amintim, în șiruri de caractere ultimul caracter este rezervat caracterului nul.

Hai să verificăm. Să rulăm programul din ultima listă. Și introduceți șirul 1234567890 . Șirul 123456789 va fi afișat pe ecran.

Fig.3 Un exemplu de funcționare a funcției fgets

Se pune întrebarea. Unde s-a dus al zecelea personaj? Și voi răspunde. Nu a mers nicăieri, a rămas în fluxul de intrare. Rulați următorul program.

Lista 5.

#include int main(void) (car str; fgets(str, 10, stdin); puts(str); int h = 99; printf("do %d\n", h); scanf("%d",&h) ; printf(„după %d\n”, h); return 0; )

Iată rezultatul muncii ei.

Fig.4 Buffer stdin non-gol

Lasă-mă să explic ce s-a întâmplat. Am numit funcția fgets. Ea a deschis fluxul de intrare și a așteptat să introducem datele. Am introdus 1234567890\n de la tastatură (\n înseamnă Enter ). Acesta a mers la fluxul de intrare stdin . Funcția fgets, așa cum era de așteptat, a luat primele 9 caractere 123456789 din fluxul de intrare, a adăugat caracterul nul \0 și a scris acest lucru în șirul str . Au mai rămas 0\n în fluxul de intrare.

În continuare, declarăm variabila h . Îi afișăm valoarea pe ecran. Apoi numim funcția scanf. Aici este de așteptat să putem introduce ceva, dar de când 0\n se blochează în fluxul de intrare, apoi funcția scanf ia aceasta ca intrare și scrie 0 în variabila h . Apoi, îl afișăm pe ecran.

Acesta, desigur, nu este tocmai comportamentul la care ne așteptăm. Pentru a rezolva această problemă, este necesar să ștergem buffer-ul de intrare după ce am citit din acesta șirul introdus de utilizator. Pentru a face acest lucru, utilizați funcția specială fflush . Are un singur parametru - fluxul care trebuie șters.

Să reparăm ultimul exemplu, astfel încât funcționarea lui să fie previzibilă.

Lista 6.

#include int main(void) (car str; fgets(str, 10, stdin); fflush(stdin); // șterge fluxul de intrare puts(str); int h = 99; printf("do %d\n", h) ; scanf(„%d”,&h); printf(„după %d\n”, h); return 0; )

Acum programul va funcționa așa cum ar trebui.

Fig.4 Spălarea tamponului stdin cu funcția fflush

În concluzie, se pot remarca două fapte. Primul. În prezent, este nesigur să utilizați funcția gets, așa că este recomandat să folosiți funcția fgets peste tot.

Al doilea. Nu uitați să ștergeți tamponul de intrare dacă utilizați funcția fgets.

Aceasta se încheie conversația despre introducerea șirurilor. Mergi mai departe.

Etichete: linii C. matrice char.

Linii în si. Introducere.

Acesta este un articol introductiv despre șiruri în C. O descriere mai detaliată și exemple vor veni când vom învăța cum să lucrăm cu memoria și pointerii. Într-un computer, toate valorile sunt stocate ca numere. Și linii, de asemenea, nu există simboluri și litere. Termenul este o matrice de numere. Fiecare număr corespunde unui anumit caracter, care este preluat din tabelul de codificare. Când este afișat pe ecran, caracterul este afișat într-un anumit mod.
Matricele de tip char sunt folosite pentru a stoca șiruri. Încă o dată, tipul char este numeric, stochează un octet de date. Dar, conform tabelului de codificare, fiecare dintre aceste numere este asociat cu un caracter. Și în direcția opusă - fiecare caracter este determinat de numărul său de serie din tabelul de codificare.
De exemplu

#include #include void main() (car c = "A"; int i = 65; printf("afișează ca caracter %c\n", c); printf("afișează ca int %d\n", c); printf(" afișare ca caracter %c\n", i); printf("afișare ca caracter %d\n", i); getch(); )

Am creat două variabile, una de tip char, alte int. Litera „A” are valoarea numerică 65. Este un literal, nu un șir, deci este înconjurat de ghilimele simple. O putem imprima ca scrisoare

Printf("afișare ca caracter %c\n", c);

Apoi va ieși
A
Dacă îl scoateți ca număr, atunci va fi
65
Puteți face același lucru cu numărul 65, care este stocat într-o variabilă ca int.
Caracterele speciale au, de asemenea, propriul număr

#include #include void main() (printf("%c", "\a"); printf("%d", "\a"); printf("%c", 7); getch(); )

Aici, mai întâi va fi „afișat” semnalul sonor, apoi valoarea sa numerică, apoi din nou semnalul sonor.
Un șir în C este o matrice de tip char, al cărui ultim element stochează caracterul terminal „\0”. Valoarea numerică a acestui caracter este 0, deci putem spune că tabloul se termină cu zero.
De exemplu

#include #include void main() (cuvânt caracter; cuvânt = "A"; cuvânt = "B"; cuvânt = "C"; cuvânt = "\0"; //cuvânt = 0; echivalent cu printf ("%s", cuvânt) ; getch(); )

Cheia %s a fost folosită pentru ieșire. În acest caz, șirul este tipărit până la primul caracter terminal, deoarece funcția printf nu cunoaște dimensiunea matricei de cuvinte.
Daca in acest exemplu nu puneti

Cuvânt = "\0";

atunci va fi scos un șir de caractere de lungime arbitrară, până când este întâlnit primul octet plin cu zerouri.

#include #include void main() ( cuvântul char = "ABC"; textul caracterului = ("H", "E", "L", "L", "O"); printf ("%s\n", cuvânt); printf ("%s", text); getch(); )

În acest caz, totul este corect. Șirul „ABC” este terminat cu zero și cu acesta inițializam matricea de cuvinte. Textul șirului este inițializat literă cu literă, toate caracterele rămase, după cum urmează din capitolul despre matrice, sunt umplute cu zerouri.

Rânduri de lectură

Pentru a cere utilizatorului un șir, trebuie să creați un buffer. Mărimea tamponului trebuie aleasă în prealabil, astfel încât cuvântul introdus să se potrivească în el. La citirea liniilor, există pericolul ca utilizatorul să introducă mai multe date decât permite tamponul. Aceste date vor fi citite și plasate în memorie și vor suprascrie valorile altor persoane. Astfel, un atac poate fi efectuat prin scrierea octeților necesari, care, de exemplu, conțin o tranziție la o secțiune de cod cu un program rău intenționat, sau înregistrarea datelor.

#include #include void main() (car buffer; scanf("%19s", buffer); printf("%s", buffer); getch(); )

În acest caz, numărul de caractere introduse este limitat la 19, iar dimensiunea tamponului este cu 1 mai mult, deoarece este necesar să stocați caracterul terminal. Să scriem un program simplu care cere utilizatorului un șir și returnează lungimea acestuia.

#include #include void main() ( buffer char; len nesemnat = 0; scanf("%127s", buffer); while (buffer != "\0") (len++; ) printf("lungime(%s) == %d" , buffer, len); getch(); )

Deoarece valoarea numerică a caracterului „\0” este zero, putem scrie

While (buffer != 0) (len++; )

Sau, chiar mai scurt

While (buffer) (len++; )

Acum să scriem un program care cere utilizatorului două cuvinte și le compară.

#include #include /* Rezultatul comparației va fi numărul 0 dacă cuvintele sunt egale cu 1 dacă primul cuvânt este mai mare decât al doilea în ordinea lexicografică -1 dacă al doilea cuvânt este mai mare */ void main() ( char firstWord; // Primul cuvânt char secondWord; //Al doilea cuvânt fără semn i; / /Counter int cmpResult = 0; //Rezultat comparație scanf("%127s", firstWord); scanf ("%127s", secondWord); for (i = 0; i< 128; i++) { if (firstWord[i] >secondWord[i]) ( //Mai mult chiar dacă al doilea cuvânt s-a încheiat deja, deoarece // atunci se termină cu zero cmpResult = 1; break; ) else if (firstWord[i]< secondWord[i]) { cmpResult = -1; break; } } printf("%d", cmpResult); getch(); }

Deoarece fiecare literă are o valoare numerică, acestea pot fi comparate între ele ca numere. În plus, de obicei (dar nu întotdeauna!) Literele din tabelele de codificare sunt aranjate alfabetic. Deci sortarea după valoare numerică va fi și sortată alfabetic.

În această lecție, vom discuta despre șiruri în stil C, este posibil să fi văzut deja aceste șiruri pe site-ul nostru web sau în orice alt manual. De fapt, șirurile c sunt doar matrice de caractere, dar, cu propriile lor specificități, așa că știm întotdeauna unde este sfârșitul șirului. În acest articol, vom analiza mai multe funcții pentru lucrul cu șiruri, de exemplu, tu - copiați, concatenați, obțineți lungimea unui șir.

Ce sunt corzile?

Rețineți că, alături de șirurile de caractere în stil C, care sunt în esență matrice simple, există și literale de șir, cum ar fi acest „literal” . De fapt, atât șirurile, cât și literalele sunt doar seturi de caractere situate unul lângă altul în memoria computerului. Dar există încă o diferență între matrice și literale, literalele nu pot fi modificate, iar șirurile de caractere pot.

Orice funcție care ia un șir în stil C poate lua și un literal ca parametru. Există, de asemenea, unele entități în C care pot arăta ca șiruri, deși nu sunt, de fapt. Vorbesc acum despre caractere, sunt cuprinse între ghilimele simple, iată un exemplu - „a”, după cum puteți vedea, acesta nu este un șir. Un caracter poate fi, într-o locație dată, să fie atribuit unui șir, dar caracterele nu pot fi procesate ca șir. Dacă vă amintiți, matricele funcționează ca indicatori, așa că dacă treceți un caracter unui șir, acesta va fi considerat o eroare.

Din cele de mai sus, ar fi trebuit să înțelegeți că șirurile sunt matrice de caractere, iar literalele șir sunt cuvinte înconjurate de ghilimele duble. Iată un alt exemplu de literal:

„Acesta este un șir static”

Ai uitat de specificul corzilor, care a fost menționat puțin mai sus? Deci, șirurile C trebuie să se termine întotdeauna cu un caracter nul, literalmente - "\0" . Prin urmare, pentru a declara un șir format din 49 de litere, este necesar să rezervați o celulă suplimentară pentru caracterul nul:

Char myString;

După cum puteți vedea din exemplu, lungimea matricei este de 50 de caractere, dintre care 49 vor lua un șir și unul, ultimul va lua un caracter nul. Este important să ne amintim că trebuie să existe întotdeauna un caracter nul la sfârșitul șirurilor C, la fel cum există un punct la sfârșitul fiecărei propoziții. Deși caracterul nul nu este afișat la ieșirea unui șir, totuși ocupă spațiu de memorie. Deci, din punct de vedere tehnic, într-o matrice de cincizeci de elemente, puteți stoca doar 49 de litere, deoarece ultimul caracter este necesar pentru a termina șirul. În plus, pointerii pot fi folosiți și ca șir. Dacă citești articolul despre , poți face așa ceva:

Char *myString; // pointer de tip char myString = malloc(sizeof(*myString) * 64); // alocare de memorie

În acest exemplu, am alocat 64 de locații în memorie pentru matricea myString. Utilizați funcția free() pentru a elibera memoria.

Gratuit(myString);

Folosind șiruri

Șirurile de caractere sunt utile atunci când trebuie să efectuați diverse operații asupra informațiilor textuale. De exemplu, dacă doriți ca utilizatorul să introducă un nume într-un program, veți folosi un șir. Folosirea funcției scanf() pentru a introduce un șir funcționează, dar poate duce la o depășire a memoriei tampon. La urma urmei, șirul de intrare poate fi mai mare decât dimensiunea șirului tampon. Există mai multe modalități de a rezolva această problemă, dar cea mai ușoară este să utilizați fișierul , care este declarat în fișierul antet. .

Când citește intrarea de la utilizator, va citi toate caracterele, cu excepția ultimului. După aceea, un terminator nul va fi plasat la sfârșitul liniei de citire. Funcția fgets() va citi caractere până când utilizatorul apasă Enter . Să vedem un exemplu folosind fgets() :

#include int main() ( char myString; // șir lung printf("Introduceți șirul lung: "); fgets(myString, 100, stdin); // citiți șirul din fluxul de intrare printf("Ați introdus următorul șir: %s" , myString); getchar(); )

Primul parametru al fgets() este un șir, al doilea parametru este lungimea șirului, iar al treilea parametru este un pointer către fluxul de intrare.

Rezultatul programului:

<ВВОД>...

După cum puteți vedea, de la ieșirea programului, un caracter newline - „\n” a intrat în șirul de intrare. Acest lucru sa întâmplat deoarece fgets() a citit apăsarea butonului Enter în șirul myString și a ieșit. Aceasta înseamnă că poate fi necesar să eliminați manual caracterul nou-linie. O modalitate de a face acest lucru este prin iterația caracterului. Să modificăm programul și să eliminăm caracterul newline:

#include int main() ( char myString; // șir lung printf("Introduceți șirul lung: "); fgets(myString, 100, stdin); // citește șirul din fluxul de intrare int i; pentru (i = 0; i< 100; i++) { if (myString[i] == "\n") { myString[i] = "\0"; break; } } printf("Вы ввели следующую строку: %s", myString); getchar(); }

Rețineți că dacă șirul de intrare conține mai puțin de 100 de caractere, atunci și caracterul de linie nouă va fi inclus în șir. Prin urmare, putem elimina acest caracter folosind o enumerare simplă. Am adăugat o buclă la program, în care iterăm peste caracterele șirului, rândurile 12-19. Și când întâlnim un caracter de nouă linie, îl înlocuim cu un caracter nul, linia 16. Rezultatul programului:

Introduceți un rând lung: Soarta își lasă amprenta Ați introdus următorul șir: Soarta își lasă amprenta Faceți clic pentru a închide această fereastră<ВВОД>...

Asta este tot pentru acum. În articolul următor, vă voi spune despre funcții speciale pentru lucrul cu șiruri.

P.S.: Tuturor ne place să urmărim diferite înregistrări video, dar uneori se întâmplă să nu fie întotdeauna posibilă redarea unor formate de fișiere video. Deci, puteți rezolva această problemă cu ajutorul programului - xilisoft converter ultimate. Puteți converti cu ușurință videoclipuri dintr-un format în altul rapid. În plus, acest program poate converti și fișiere audio și imagini animate.

Declarații cu șiruri

Un șir în limbajul C este o matrice unidimensională de caractere, ultimul element al căruia este caracterul de sfârșit de linie - zero (un șir terminat cu nul, adică șir terminat cu NULL).

Există trei moduri de a declara o variabilă de tip șir în C, dintre care două inițializează șirul în momentul declarării.

Prima cale:

Declarații de matrice de caractere (nu uitați să adăugați spațiu pentru nulul final):

Caractere;

A doua cale:

Atribuiți unei variabile șir o valoare inițială (în acest caz, compilatorul poate calcula însuși lungimea șirului):

Char s = „Exemplu de inițializare șir”;

În dreapta semnului de atribuire este o constantă șir. Un zero ('\0') este adăugat automat la sfârșitul șirului. Constantele șirurilor de caractere sunt plasate într-o clasă de stocare statică.

A treia cale:

O indicație implicită că este utilizată o matrice. În partea stângă a semnului de atribuire, este indicat un indicator către simbol:

Char *s="A doua opțiune de inițializare";

Variabila s va fi un pointer către locația din RAM în care se află constanta șir. Această formă de notație are o potențială eroare prin aceea că un pointer către un caracter este adesea denumit șir. Intrarea de mai jos este doar un indicator către un caracter, deoarece nu există spațiu pentru șir:

Char*s;

Introducerea unui șir de la dispozitivul de intrare standard (tastatură)

Există un set de funcții pentru lucrul cu șiruri. Pentru intrarea de la dispozitivul de intrare standard (tastatură), funcțiile de bibliotecă din modulul de intrare/ieșire standard sunt cel mai des utilizate: scanfși devine.

Pentru a introduce un șir folosind funcția scanf, folosește formatul « %s» , și rețineți că semnul adresei nu este folosit înaintea identificatorului de rând « & » , deoarece o matrice unidimensională este deja reprezentată printr-un pointer către începutul său:

scanf("%s", s);

Funcţie devine() citește caractere până când ajunge la un caracter newline. Funcția acceptă toate caracterele până la, dar fără a include caracterul de nouă linie. Un zero final ('\0') este adăugat la sfârșitul șirului. Funcţie devine() pune o secvență de caractere citite de la tastatură într-un parametru șir și returnează un pointer către acel șir (dacă operația a avut succes) sau NULL (în cazul unei erori). În exemplul de mai jos, după finalizarea cu succes a operațiunii, pe ecran vor fi afișate două linii identice:

#include int main() ( char s; char *p; p=gets(s); printf(" \n Șirul %s introdus. ",s); if (p) printf(" \n Șirul %s introdus. ", p); returnează 0;)

În treacăt, observăm că funcția gets este adesea folosită pentru a introduce orice date de la tastatură ca șir în scopul conversiei ulterioare de către funcția sscanf în formatul dorit sau pentru analiza preliminară a datelor de intrare, de exemplu:

#include #include #include int main() (car s; int x, err; do (printf(" \n Introduceți un număr întreg -> "); gets(s); err=sscanf(s, "%d",&x); if (err !=1) printf(" \n Eroare de intrare. "); ) while (err!=1); printf("\n Întregul introdus -> %d", x); return 0; )

Imprimarea șirurilor la ieșirea standard (ecranul monitorului)

Pentru a scoate șiruri de caractere la ieșirea standard (ecran de monitor), puteți utiliza două funcții printfși pune. În funcția printf, „%s” este transmis ca format. Comoditatea utilizării acestei funcții constă în faptul că, pe lângă șir, puteți afișa imediat date de alte tipuri. caracteristică caracteristică pune este că după ce linia este scoasă, trecerea la următoarea linie are loc automat.

Funcții șiruri

Pentru a converti șiruri în limbajul C, este furnizată biblioteca de șiruri. Fiecare dintre funcții are propriul format de înregistrare (prototip).

Cele mai utilizate funcții sunt discutate în acest articol. - citit

Un exemplu de programe (listări) care lucrează cu șiruri

Ultima actualizare: 31.10.2015

Concatenare

Concatenarea sau concatenarea șirurilor se poate face fie cu operatorul +, fie cu metoda Concat:

String s1 = „bună ziua”; șir s2 = „lume”; șir s3 = s1 + " " + s2; // rezultat: string "hello world" string s4 = String.Concat(s3, "!!!"); // rezultat: șir „bună lume!!!” Consola WriteLine(s4);

Metoda Concat este o metodă statică a clasei String care ia ca parametri două șiruri. Există și alte versiuni ale metodei care iau un număr diferit de parametri.

Metoda Join poate fi folosită și pentru a concatena șiruri:

String s5 = „măr”; șir s6 = „o zi”; șir s7 = „păstrează”; șir s8 = „doctor”; șir s9 = „departe”; valorile șirului = șir nou ( s5, s6, s7, s8, s9 ); String s10 = String.Join(" ", valori); // rezultat: șirul „un măr pe zi ține un doctor departe”

Metoda Join este, de asemenea, statică. Versiunea metodei folosite mai sus ia doi parametri: un șir delimitator (în acest caz, un spațiu) și o matrice de șiruri care vor fi concatenate și separate de delimitator.

Comparație de șiruri

Pentru a compara șirurile de caractere, utilizați metoda de comparare statică:

String s1 = „bună ziua”; șir s2 = „lume”; int rezultat = String.Compare(s1, s2); dacă (rezultat<0) { Console.WriteLine("Строка s1 перед строкой s2"); } else if (result >0) ( Console.WriteLine("Linia s1 vine după linia s2"); ) else ( Console.WriteLine ("Liniile s1 și s2 sunt identice"); ) // rezultatul va fi "Linia s1 vine înaintea liniei s2"

Această versiune a metodei Compare are două șiruri de caractere și returnează un număr. Dacă primul șir este alfabetic mai mare decât al doilea, atunci este returnat un număr mai mic decât zero. În caz contrar, se returnează un număr mai mare decât zero. Și al treilea caz - dacă șirurile sunt egale, atunci numărul 0 este returnat.

În acest caz, deoarece caracterul h este alfabetic mai mare decât caracterul w, prima linie va fi de asemenea mai mare.

Căutați într-un șir

Folosind metoda IndexOf, putem determina indexul primei apariții a unui singur caracter sau subșir dintr-un șir:

String s1 = „bună lume”; char ch = "o"; int indexOfChar = s1.IndexOf(ch); // este egal cu 4 Console.WriteLine(indexOfChar); șir subString = „wor”; int indexOfSubstring = s1.IndexOf(subString); // este egal cu 6 Console.WriteLine(indexOfSubstring);

Metoda LastIndexOf funcționează într-un mod similar, găsește doar indexul ultimei apariții a unui caracter sau subșir dintr-un șir.

Un alt grup de metode vă permite să aflați dacă un șir începe sau se termină cu un anumit subșir. Pentru asta sunt metodele StartsWith și EndsWith. De exemplu, avem o sarcină de a elimina toate fișierele cu extensia .exe dintr-un folder:

Calea șirului = @"C:\SomeDir"; fișiere șir = Directory.GetFiles(cale); pentru (int i = 0; i< files.Length; i++) { if(files[i].EndsWith(".exe")) File.Delete(files[i]); }

Divizarea liniei

Cu funcția Split, putem împărți un șir într-o matrice de subșiruri. Ca parametru, funcția Split ia o matrice de caractere sau șiruri de caractere, care vor servi drept separatori. De exemplu, să numărăm numărul de cuvinte dintr-un termen împărțindu-l la caractere cu spații albe:

String text = „Și de aceea s-a întâmplat totul”; cuvinte șir = text.Split(car nou (" " )); foreach (șir de caractere în cuvinte) ( Console.WriteLine(s); )

Aceasta nu este cea mai bună modalitate de a împărți după spații, deoarece am putea avea mai multe spații consecutive în șirul de intrare, iar spațiile ar intra și în tabloul final, deci este mai bine să folosiți o versiune diferită a metodei:

String words = text.Split(new char ( " " ), StringSplitOptions.RemoveEmptyEntries);

Al doilea parametru StringSplitOptions.RemoveEmptyEntries spune să eliminați toate subșirurile goale.

Tăierea unei sfori

Pentru a decupa caracterele de început sau de sfârșit, utilizați funcția Trim:

String text = „bună lume”; text = text.Trim(); // rezultat "hello world" text = text.Trim(new char ("d", "h" )); // rezultat „ello lume”

Funcția Trim fără parametri decupează spațiile de început și de final și returnează șirul tăiat. Pentru a specifica în mod explicit caracterele de început și de sfârșit de tăiat, putem trece o matrice din acele caractere funcției.

Această funcție are analogi parțial: funcția TrimStart decupează caracterele de început, iar funcția TrimEnd decupează caracterele de sfârșit.

Funcția Substring vă permite să tăiați o anumită parte a unui șir:

String text = „O zi bună”; // tăiați începând de la al treilea caracter text = text.Substring(2); // rezultat „o zi bună” Console.WriteLine(text); // tăiați primul la ultimele două caractere text = text.Substring(0, text.Length - 2); // rezultatul este „bun de” Console.WriteLine(text);

Funcția Substring returnează și șirul tăiat. Ca parametru, prima versiune folosită folosește indexul din care să tăiați șirul. A doua versiune folosește doi parametri - indicele începutului de tăiere și lungimea părții tăiate a șirului.

Introduce

Pentru a insera un rând în altul, utilizați funcția Inserare:

String text = „O zi bună”; string subString = „minunat”; text = text.Insert(8, subString); Console.WriteLine(text);

Primul parametru din funcția Insert este indexul la care se inserează subșirul, iar al doilea parametru este subșirul în sine.

Eliminarea rândurilor

Metoda Remove ajută la eliminarea unei părți a unui șir:

String text = „O zi bună”; // indexul ultimului caracter int ind = text.Lungime - 1; // decupează ultimul caracter text = text.Remove(ind); Console.WriteLine(text); // decupează primele două caractere text = text.Remove(0, 2);

Prima versiune a metodei Remove preia un index în șir din care să elimine toate caracterele. A doua versiune necesită încă un parametru - câte caractere trebuie eliminate.

Înlocuire

Pentru a înlocui un caracter sau subșir cu altul, utilizați metoda Înlocuire:

String text = „o zi bună”; text = text.Inlocuire("bine", "rau"); Console.WriteLine(text); text = text.Replace("o", ""); Console.WriteLine(text);

În al doilea caz de utilizare a funcției Înlocuire, un șir de un caracter „o” este înlocuit cu un șir gol, adică este de fapt eliminat din text. Într-un mod similar, este ușor să ștergeți un anumit text în rânduri.

Schimbarea cazului

Pentru a converti un șir în majuscule și minuscule, sunt utilizate funcțiile ToUpper() și, respectiv, ToLower():

String hello = „Bună lume!”; Console.WriteLine(hello.ToLower()); // Salut Lume! Console.WriteLine(hello.ToUpper()); // SALUT LUME!