Ce se înțelege prin șiruri de caractere în limbajul C? Operatori de clasă String

ÎN standard modern C++ definește o clasă cu funcții și proprietăți (variabile) pentru organizarea muncii cu șiruri de caractere (în limbajul clasic Nu există șiruri ca atare, există doar matrice de caractere char):

#include

#include

#include

Pentru a lucra cu șiruri, trebuie, de asemenea, să conectați un spațiu de nume standard:

Utilizarea namespace std;

În caz contrar, va trebui să specificați descriptorul clasei std::string peste tot în loc de string .

Mai jos este un exemplu de program care funcționează cu șir (nu funcționează în compilatoarele mai vechi compatibile cu C!):

#include #include #include folosind namespace std; int main() ( șir s = "Test"; s.insert(1,"!"); cout<< s.c_str() << endl; string *s2 = new string("Hello"); s2->erase(s2->end()); cout<< s2->c_str(); cin.get(); întoarce 0; )

Principalele caracteristici pe care le are clasa string:

• inițializare cu o matrice de caractere (un tip șir încorporat) sau alt obiect de tip șir . Un tip încorporat nu are a doua capacitate;
• copierea unei linii pe alta. Pentru un tip încorporat trebuie să utilizați funcția strcpy();
• Acces la personaje individuale rânduri de citit și scris. Într-o matrice încorporată, acest lucru se face folosind o operație de index sau adresare indirectă folosind un pointer;
• comparând două șiruri de caractere pentru egalitate. Pentru un tip încorporat, sunt utilizate funcțiile familiei strcmp();
• concatenarea (concatenarea) a două șiruri, producând rezultatul fie ca un al treilea șir, fie în locul unuia dintre cele originale. Pentru un tip încorporat, se folosește funcția strcat(), dar pentru a obține rezultatul linie nouă, trebuie să utilizați secvențial funcțiile strcpy() și strcat() și, de asemenea, să aveți grijă de alocarea memoriei;
• mijloace încorporate de determinare a lungimii unui șir (funcțiile membre ale clasei size() și l ength()). Singura modalitate de a afla lungimea unui șir de tip încorporat este prin calcularea acestuia folosind funcția strlen();
• capacitatea de a afla dacă un șir este gol.

Să ne uităm la acestea capabilități de bază in detalii.

Inițializarea șirurilor când descrie şi lungimea șirului(fără a include terminatorul nul de terminare):

String st("Șirul meu\n"); cout<< "Длина " << st << ": " << st.size() << " символов, включая символ новой строки\n";

Șirul poate fi, de asemenea, gol:

St2 șir;

Pentru a verifica asta este linia goală, puteți compara lungimea sa cu 0:

Dacă (! st.size()) // gol

sau utilizați metoda empty(), care returnează true pentru un șir gol și false pentru unul nevid:

Dacă (st.empty()) // gol

A treia formă de creare a șirului inițializează un obiect de tip șir cu un alt obiect de același tip:

St3 st3(st);

Șirul st3 este inițializat cu șirul st . Cum ne putem asigura că acestea liniile se potrivesc? Să folosim operatorul de comparație (==):

Dacă (st == st3) // inițializarea a funcționat

Cum copiați o linie pe alta? Folosind operatorul normal de atribuire:

St2 = st3; // copiați st3 în st2

Pentru concatenare de șiruri se utilizează operatorul de adăugare (+) sau operatorul de adăugare plus atribuire (+=). Să fie date două linii:

String s1 ("bună ziua, "); șir s2(„lume\n”);

Putem obține un al treilea șir format dintr-o concatenare a primelor două, astfel:

Șirul s3 = s1 + s2;

Dacă vrem să adăugăm s2 la sfârșitul lui s1, ar trebui să scriem:

S1 += s2;

Operația de adăugare poate concatena obiecte de clasă şir nu numai între ele, ci și cu șiruri de tip încorporate. Puteți rescrie exemplul de mai sus, astfel încât caracterele speciale și semnele de punctuație să fie reprezentate de tipul încorporat char *, iar cuvintele semnificative să fie reprezentate de obiecte din șirul clasei:

Const char *pc = ", "; șir s1 ("bună ziua"); șir s2(„lume”); șir s3 = s1 + pc + s2 + "\n"; cout<< endl << s3;

Astfel de expresii funcționează deoarece compilatorul „știe” cum să convertească automat obiectele de tip încorporat în obiecte din clasa șir. De asemenea, este posibil să atribuiți pur și simplu un șir încorporat unui obiect șir:

Șirul s1; const char *pc = "o matrice de caractere"; s1 = pc; // Dreapta

Transformarea inversă în acest caz nu funcționează. Încercarea de a efectua următoarea inițializare a șirurilor de tip încorporat va cauza o eroare de compilare:

Char *str = s1; // eroare de compilare

Pentru a efectua această conversie, trebuie să apelați în mod explicit o funcție membru numită c_str() ("șir C"):

Const char *str = s1.c_str();

Funcția c_str() returnează un pointer către o matrice de caractere care conține șirul obiectului șir așa cum ar apărea în tipul șir încorporat. Cuvântul cheie const aici previne posibilitatea „periculoasă” în mediile vizuale moderne de a modifica direct conținutul unui obiect prin intermediul unui pointer.

LA personaje individuale Un obiect de tip șir, cum ar fi un tip încorporat, poate fi accesat utilizând operația index. De exemplu, iată o bucată de cod care înlocuiește toate punctele cu caractere de subliniere:

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

Înlocuiește(str.begin(), str.end(), ".", "_");

Adevărat, nu metoda de înlocuire a clasei de șiruri este folosită aici, ci algoritmul cu același nume:

#include

Deoarece obiectul șir se comportă ca un container, îi pot fi aplicați alți algoritmi. Acest lucru vă permite să rezolvați probleme care nu sunt rezolvate direct de funcțiile clasei șir.

Mai jos este o descriere succintă a principalelor operatori și funcții ale clasei șir de caractere; legăturile din tabel duc la descrieri în limba rusă de pe Internet. O listă mai completă a capabilităților clasei șir poate fi găsită, de exemplu, pe Wikipedia sau pe site-ul web cplusplus.com.

Linii. Intrare/ieșire șir. I/O formatat. Procesarea șirurilor folosind funcții standard ale limbajului C. Lucrul cu memoria.

1.1. Declararea și inițializarea șirurilor de caractere.

Un șir este o matrice de caractere care se termină cu caracterul gol „\0”. Șirul este declarat ca o matrice obișnuită de caractere, de exemplu,

char s1; // șir lung de nouă caractere

char *s2; // pointer către șir

Diferența dintre pointerii s1 și s2 este că pointerul s1 este o constantă numită, iar pointerul s2 este o variabilă.

Constantele șirurilor de caractere sunt cuprinse între ghilimele duble, spre deosebire de caracterele, care sunt cuprinse între ghilimele simple. De exemplu,

„Acesta este un șir.”

Lungimea unei constante șir nu poate depăși 509 caractere conform standardului. Cu toate acestea, multe implementări permit lungimi mai mari ale șirurilor.

La inițializarea șirurilor, este mai bine să nu specificați dimensiunea matricei; compilatorul va face acest lucru calculând lungimea șirului și adăugând unul la acesta. De exemplu,

char s1 = „Acesta este un șir.”;

În limbajul de programare C, există un număr mare de funcții pentru lucrul cu șiruri de caractere, ale căror prototipuri sunt descrise în fișierele de antet stdlib.h și string.h. Lucrul cu aceste funcții va fi discutat în paragrafele următoare.

1.2. Intrare/ieșire șir.

Pentru a introduce un șir din consolă, utilizați funcția

char* gets(char *str);

care scrie un șir la adresa str și returnează adresa șirului introdus. Funcția oprește introducerea dacă întâlnește un caracter „\n” sau EOF (sfârșitul fișierului). Caracterul newline nu este copiat. Un octet zero este plasat la sfârșitul liniei de citire. Dacă are succes, funcția returnează un pointer la linia citită, iar dacă nu are succes, NULL.

Pentru a scoate un șir în consolă, utilizați funcția standard

int pune (const char *s);

care, dacă are succes, returnează un număr nenegativ, iar dacă nu are succes, returnează EOF.

Prototipurile funcțiilor gets and puts sunt descrise în fișierul antet stdio.h.

#include

printf("Șir de intrare: ");

1.3. I/O formatat.

Pentru introducerea datelor formatate din consolă, utilizați funcția

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

care, dacă are succes, returnează numărul de unități de date citite, iar dacă nu are succes, returnează EOF. Parametrul format trebuie să indice șirul de formatat, care conține specificațiile formatului de intrare. Numărul și tipurile de argumente care urmează șirul de format trebuie să se potrivească cu numărul și tipurile de formate de intrare specificate în șirul de format. Dacă această condiție nu este îndeplinită, atunci rezultatul funcției este imprevizibil.

Un spațiu, „\t” sau „\n” într-un șir de format descrie unul sau mai multe caractere goale din fluxul de intrare, care includ caracterele: spațiu, „\t”, „\n”, „\v”, '\f'. Funcția scanf omite caracterele goale din fluxul de intrare.

Caracterele literale dintr-un șir de format, cu excepția caracterului %, necesită ca exact aceleași caractere să apară în fluxul de intrare. Dacă nu există un astfel de caracter, funcția scanf se oprește. Funcția scanf omite caracterele literale.

În general, specificația formatului de intrare arată astfel:

%[*] [lățime] [modificatoare].

Simbolul „*” denotă omisiune la introducerea unui câmp definit de această specificație;

- ‘lățime’ definește numărul maxim de caractere introduse conform acestei specificații;

Tipul poate lua următoarele valori:

c – matrice de caractere,

s – un șir de caractere, liniile sunt separate prin caractere goale,

d – întreg cu semn de 10 s/s,

i – întreg cu semn, sistemul numeric depinde de primele două cifre,

u – întreg fără semn la 10 s/s,

o – întreg fără semn în 8 s/s,

x, X – întreg fără semn la 16 s/s,

e, E, f, g, G – număr flotant,

p – pointer la pointer,

n – pointer către un număr întreg,

[…] – o serie de caractere scanate, de exemplu, .

În acest din urmă caz, din fluxul de intrare vor fi introduse numai caracterele cuprinse între paranteze drepte. Dacă primul caracter din paranteze pătrate este „^”, atunci sunt introduse numai acele caractere care nu sunt în matrice. Intervalul de caractere din matrice este specificat folosind simbolul „-”. Când introduceți caractere, sunt introduse și caracterele goale de început și octetul nul final al șirului.

Modificatorii pot lua următoarele valori:

h – număr întreg scurt,

l, L – întreg lung sau flotant,

și sunt folosite numai pentru numere întregi sau flotante.

Următorul exemplu arată utilizări ale funcției scanf. Rețineți că specificatorul de format, începând cu introducerea numărului flotant, este precedat de un caracter spațiu.

#include

printf("Introduceți un număr întreg: ");

scanf("%d", &n);

printf("Introduceți un dublu: ");

scanf(" %lf", &d);

printf("Introduceți un caracter: ");

scanf(" %c", &c);

printf("Introduceți un șir: ");

scanf(" %s", &s);

Rețineți că în acest program numărul în virgulă mobilă este inițializat. Acest lucru se face astfel încât compilatorul să includă biblioteca pentru a sprijini lucrul cu numere flotante. Dacă nu se face acest lucru, va apărea o eroare în timpul rulării la introducerea unui număr flotant.

Pentru ieșirea formatată a datelor către consolă, utilizați funcția

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

care, dacă are succes, returnează numărul de unități de date de ieșire, iar dacă nu are succes, returnează EOF. Parametrul format este un șir de format care conține specificații pentru formatele de ieșire. Numărul și tipurile de argumente care urmează șirul de format trebuie să se potrivească cu numărul și tipurile de specificații de format de ieșire specificate în șirul de format. În general, specificația formatului de ieșire arată astfel:

%[steaguri] [lățime] [.precizie] [modificatoare].

- ‘steaguri’ sunt diferite simboluri care specifică formatul de ieșire;

- „lățimea” definește numărul minim de caractere ieșite conform acestei specificații;

- ‘.precision’ definește numărul maxim de caractere afișate;

- ‘modificatorii’ specifică tipul de argumente;

- „tip” specifică tipul argumentului.

Pentru a scoate numere întregi cu semn, se folosește următorul format de ieșire:

%[-] [+ | spațiu] [lățime] [l] d

- – aliniere stânga, implicit – dreapta;

+ – este afișat semnul ‘+’, rețineți că pentru numerele negative este afișat întotdeauna semnul ‘-’;

‘spațiu’ – un spațiu este afișat la poziția caracterului;

d – int tipul de date.

Pentru a scoate numere întregi fără semn, utilizați următorul format de ieșire:

%[-] [#] [lățime] [l]

# – 0 inițial este afișat pentru numerele din 8 c/c sau inițial 0x sau 0X pentru numerele din 16 c/c,

l – modificator de tip de date lung;

u – întreg în 10c/c,

o – întreg în 8 c/c,

x, X – întreg la 16 c/c.

Următorul format de ieșire este utilizat pentru a afișa numere în virgulă mobilă:

%[-] [+ | spațiu] [lățime] [.precizie]

„precizie” - indică numărul de cifre după virgulă pentru formatele f, e și E sau numărul de cifre semnificative pentru formatele g și G. Numerele sunt rotunjite. Precizia implicită este de șase cifre zecimale;

f – numărul punctului fix,

e – un număr în formă exponențială, exponentul este notat cu litera „e”,

E – un număr în formă exponențială, exponentul este notat cu litera „E”,

g – cel mai scurt dintre formatele f sau g,

G – cel mai scurt dintre formatele f sau 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);

// afișează: n = 123 f = 12,340000 e = 1,234000e+001 E = 1,234000E+001 f = 12,34

1.4. Formatarea șirurilor.

Există variante ale funcțiilor scanf și printf care sunt concepute pentru a formata șiruri și sunt numite sscanf și, respectiv, sprintf.

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

citește datele din șirul specificat de str, conform șirului de format specificat de format. Dacă are succes, returnează numărul de date citite, iar dacă nu are succes, returnează EOF. De exemplu,

#include

char str = "a 10 1.2 String Nicio intrare";

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

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

printf("%d\n", n); // imprimări: 10

printf("%f\n", d); // imprimări: 1,200000

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

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

formatează șirul în conformitate cu formatul specificat de parametrul format și scrie rezultatul rezultat în tamponul matricei de caractere. Funcția returnează numărul de caractere scrise în bufferul matricei de caractere, excluzând octetul nul final. De exemplu,

#include

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

char s = „Acesta este un șir.”;

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

printf("%s\n", buffer); // afișează: c = c, n = 10, d = 1,200000, s = Acesta este un șir

1.5. Convertiți șirurile de caractere în date numerice.

Prototipurile de funcții pentru conversia șirurilor de caractere în date numerice sunt date în fișierul antet stdlib.h, care trebuie inclus în program.

Pentru a converti un șir într-un număr întreg, utilizați funcția

int atoi (const char *str);

char *str = „-123”;

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

Pentru a converti un șir într-un număr întreg lung, utilizați funcția

long int atol (const char *str);

care, dacă are succes, returnează întregul în care este convertit șirul str, iar dacă nu are succes, returnează 0. De exemplu,

char *str = „-123”;

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

Pentru a converti un șir într-un număr dublu, utilizați funcția

double atof(const char *str);

care, dacă are succes, returnează un număr flotant de tip double, în care este convertit șirul str, iar dacă nu are succes, returnează 0. De exemplu,

char *str = „-123.321”;

n = atof(str); // n = -123,321

Următoarele funcții îndeplinesc funcții similare cu atoi, atol, atof, dar oferă funcționalități mai avansate.

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

convertește șirul str într-un număr int lung, pe care îl returnează. Parametrii acestei funcții au următoarele scopuri.

Dacă baza este 0, atunci conversia depinde de primele două caractere ale str:

Dacă primul caracter este un număr de la 1 la 9, atunci se presupune că numărul este reprezentat în 10 c/c;

Dacă primul caracter este cifra 0 și al doilea caracter este o cifră de la 1 la 7, atunci se presupune că numărul este reprezentat în 8 c/c;

Dacă primul caracter este 0 și al doilea este „X” sau „x”, atunci se presupune că numărul este reprezentat în 16 c/c.

Dacă baza este un număr între 2 și 36, atunci acea valoare este considerată baza sistemului numeric și orice caracter din afara sistemului numeric încetează conversia. În sistemele numerice de la baza 11 la baza 36, ​​simbolurile „A” la „Z” sau „a” la „z” sunt folosite pentru a reprezenta cifre.

Valoarea argumentului endptr este stabilită de funcția strtol. Această valoare conține un indicator către caracterul care a oprit conversia șirului de caractere. Funcția strtol returnează numărul convertit dacă are succes și 0 dacă nu are succes. De exemplu,

n = strtol („12a”, &p, 0);

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

n = strtol ("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 = strtol („01117”, &p, 0);

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

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

funcționează similar cu funcția strtol, dar convertește reprezentarea simbolică a unui număr într-un număr de tip unsigned long int.

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

Transformă reprezentarea simbolică a unui număr într-un dublu.

Toate funcțiile enumerate în acest paragraf nu mai funcționează atunci când întâlnesc primul caracter care nu se potrivește cu formatul numărului în cauză.

În plus, dacă valoarea caracterului unui număr depășește intervalul de valori acceptabile pentru tipul de date corespunzător, atunci funcțiile atof, strtol, strtoul, strtod setează valoarea variabilei errno la ERANGE. Variabila errno și constanta ERANGE sunt definite în fișierul antet math.h. În acest caz, funcțiile atof și strtod returnează valoarea HUGE_VAL, funcția strtol returnează valoarea LONG_MAX sau LONG_MIN, iar funcția strtoul returnează valoarea ULONG_MAX.

Funcțiile non-standard itoa, ltoa, utoa, ecvt, fcvt și gcvt pot fi utilizate pentru a converti datele numerice în șiruri de caractere. Dar este mai bine să folosiți funcția standard sprintf în aceste scopuri.

1.6. Funcții standard pentru lucrul cu șiruri.

Această secțiune discută funcțiile pentru lucrul cu șiruri de caractere, ale căror prototipuri sunt descrise în fișierul antet string.h.

1. Comparație de șiruri. Funcțiile strcmp și strncmp sunt folosite pentru a compara șiruri.

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

compară lexicografic șirurile str1, str2 și returnează –1, 0 sau 1 dacă str1 este, respectiv, mai mic, egal sau mai mare decât str2.

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

compară lexicografic cel mult primele n caractere din șirurile str1 și str2. Funcția returnează -1, 0 sau 1 dacă primele n caractere din str1 sunt, respectiv, mai mici, egale sau mai mari decât primele n caractere din str2.

// exemplu de comparare a șirurilor

#include

#include

char str1 = "aa bb";

char str2 = "aa aa";

char str3 = "aa bb cc";

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

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

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

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

2. Copierea liniilor. Funcțiile strcpy și strncpy sunt folosite pentru a copia șiruri.

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

copiează șirul str2 în șirul str1. Întregul șir str2 este copiat, inclusiv octetul nul final. Funcția returnează un pointer către str1. Dacă liniile se suprapun, rezultatul este imprevizibil.

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

copiază n caractere din șirul str2 în șirul str1. Dacă str2 conține mai puțin de n caractere, atunci ultimul octet zero este copiat de câte ori este necesar pentru a extinde str2 la n caractere. Funcția returnează un pointer către șirul str1.

char str2 = "Copiați șirul.";

strcpy(str1, str2);

printf(str1); // imprimă: Copiați șirul.

4. Corzi de legătură. Funcțiile strcat și strncat sunt folosite pentru a concatena șiruri într-un singur șir.

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

adaugă șirul str2 la șirul str1, cu octetul zero final al șirului str1 șters. Funcția returnează un pointer către șirul str1.

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

adaugă n caractere din șirul str2 la șirul str1, cu octetul zero de la urmă al șirului str1 șters. Funcția returnează un pointer către șirul str1. dacă lungimea șirului str2 este mai mică decât n, atunci sunt atașate numai caracterele incluse în șirul str2. După concatenarea șirurilor, un octet nul este întotdeauna adăugat la str1. Funcția returnează un pointer către șirul str1.

#include

#include

char str1 = „Șir”;

char str2 = "catenare";

char str3 = "Da Nu";

strcat(str1, str2);

printf("%s\n", str1); // printează: String catenation

strncat(str1, str3, 3);

printf("%s\n", str1); // imprimă: String catenation Da

5. Căutați un caracter într-un șir. Pentru a căuta un caracter într-un șir, utilizați funcțiile strchr, strrchr, strspn, strcspn și strpbrk.

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

caută prima apariție a caracterului specificat de c în șirul str. Dacă are succes, funcția returnează un pointer la primul caracter găsit, iar dacă nu are succes, NULL.

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

caută ultima apariție a caracterului specificat de c în șirul str. Dacă are succes, funcția returnează un pointer la ultimul caracter găsit, iar dacă nu are succes, NULL.

#include

#include

char str = "Căutare Char";

printf("%s\n", strchr(str, "r")); // imprimă: r căutare

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

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

returnează indexul primului caracter din str1 care nu este în str2.

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

returnează indexul primului caracter din str1 care apare în str2.

char str = "123 abc";

printf ("n = %d\n", strspn (str, "321"); // afișează: n = 3

printf ("n = %d\n", strcspn (str, "cba"); // afișează: n = 4

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

găsește primul caracter din șirul str1 care este egal cu unul dintre caracterele din șirul str2. Dacă are succes, funcția returnează un pointer la acest caracter, iar dacă nu are succes, NULL.

char str = "123 abc";

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

6. Comparație de șiruri. Funcția strstr este folosită pentru a compara șiruri.

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

găsește prima apariție a lui str2 (fără octetul nul final) în str1. Dacă are succes, funcția returnează un pointer către subșirul găsit, iar dacă nu are succes, NULL. Dacă pointerul str1 indică un șir de lungime zero, atunci funcția returnează pointerul str1.

char str = "123 abc 456;

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

7. Analizarea unui șir în jetoane. Funcția strtok este folosită pentru a analiza un șir în token-uri.

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

returnează un pointer la următorul token (cuvânt) din șirul str1, în care delimitatorii jetonului sunt caractere din șirul str2. Dacă nu mai există jetoane, funcția returnează NULL. La primul apel la funcția strtok, parametrul str1 trebuie să indice un șir care este tokenizat, iar la apelurile ulterioare acest parametru trebuie setat la NULL. După găsirea unui token, funcția strtok scrie un octet nul după acest token în locul delimitatorului.

#include

#include

char str = "12 34 ab cd";

p = strtok(str, " ");

printf("%s\n", p); // tipărește valorile într-o coloană: 12 34 ab cd

p = strtok(NULL, " ");

8. Determinarea lungimii unui șir. Funcția strlen este utilizată pentru a determina lungimea unui șir.

size_t strlen (const char *str);

returnează lungimea șirului, ignorând ultimul octet nul. De exemplu,

char str = "123";

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

1.7. Funcții pentru lucrul cu memoria.

Fișierul antet string.h descrie, de asemenea, funcții pentru lucrul cu blocuri de memorie, care sunt similare cu funcțiile corespunzătoare pentru lucrul cu șiruri.

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

caută prima apariție a caracterului specificat de c în n octeți ai șirului str.

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

compară primii n octeți ai șirurilor str1 și str2.

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

copiază primii n octeți din șirul str1 în șirul str2.

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

copiează primii n octeți de la str1 la str2, asigurându-se că șirurile care se suprapun sunt gestionate corect.

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

copiază caracterul specificat de c în primii n octeți ai str.

--- Ghid C# --- Strings

Din punct de vedere al programării obișnuite, șir tipul de date șir este una dintre cele mai importante din C#. Acest tip definește și acceptă șiruri de caractere. Într-un număr de alte limbaje de programare, un șir este o matrice de caractere. Și în C#, șirurile sunt obiecte. Prin urmare, tipul șir este un tip de referință.

Construirea corzilor

Cel mai simplu mod de a construi un șir de caractere este să utilizați un șir literal. De exemplu, următoarea linie de cod atribuie variabilei de referință șir str o referință la un literal șir:

String str = „Exemplu șir”;

În acest caz, variabila str este inițializată cu secvența de caractere „Example String”. Un obiect de tip șir poate fi creat și dintr-o matrice de tip char. De exemplu:

Char chararray = ("e", "x", "a", "m", "p", "l", "e"); șir str = șir nou (chararray);

Odată ce un obiect șir este creat, acesta poate fi folosit oriunde aveți nevoie de un șir de text cuprins între ghilimele.

Persistența șirului

În mod ciudat, conținutul unui obiect de tip șir nu poate fi modificat. Aceasta înseamnă că odată ce o secvență de caractere a fost creată, aceasta nu poate fi modificată. Dar această limitare contribuie la o implementare mai eficientă a șirurilor de caractere. Prin urmare, acest dezavantaj aparent evident se transformă de fapt într-un avantaj. Astfel, dacă un șir este necesar ca o variație a unui șir existent, atunci în acest scop ar trebui creat un șir nou care să conțină toate modificările necesare. Și, deoarece obiectele șir neutilizate sunt colectate automat ca gunoi, nici nu trebuie să vă faceți griji cu privire la soarta șirurilor inutile.

Trebuie subliniat, totuși, că referințele variabile la șiruri de caractere (adică obiecte de tip șir) sunt supuse modificării și, prin urmare, se pot referi la un alt obiect. Dar conținutul obiectului șir în sine nu se schimbă după ce este creat.

Să ne uităm la un exemplu:

Static void addNewString() ( șir s = „Acesta este accidentul vascular cerebral”; s = „Acesta este un accident vascular cerebral nou”; )

Să compilam aplicația și să încărcăm ansamblul rezultat în utilitarul ildasm.exe. Figura arată codul CIL care va fi generat pentru metoda void addNewString():

Rețineți că există numeroase apeluri la codul operațional ldstr (încărcare șir). Acest opcode CIL ldstr efectuează încărcarea unui nou obiect șir în heap-ul gestionat. Drept urmare, obiectul anterior care conținea valoarea „Acesta este lovitura mea” va fi în cele din urmă colectat de gunoi.

Lucrul cu șiruri

In clasa System.String este furnizat un set de metode pentru determinarea lungimii datelor de caractere, căutarea unui subșir în șirul curent, conversia caracterelor din majuscule în litere mici și invers etc. În continuare ne vom uita la această clasă mai detaliat.

Proprietatea de clasă Field, Indexer și String

Clasa String definește un singur câmp:

Șir public static numai pentru citire Gol;

Câmpul Gol denotă un șir gol, de exemplu. un șir care nu conține niciun caracter. Aceasta este diferită de o referință String goală, care este pur și simplu făcută la un obiect inexistent.

În plus, clasa String definește un singur indexator numai pentru citire:

Public Char this ( obține; )

Acest indexator vă permite să obțineți un caracter la un index specificat. Indexarea șirurilor de caractere, ca și tablourile, începe de la zero. Obiectele String sunt persistente și nu se modifică, așa că are sens ca clasa String să accepte un indexator doar pentru citire.

În cele din urmă, clasa String definește o singură proprietate numai pentru citire:

Public int Lungime ( get; )

Proprietatea Length returnează numărul de caractere din șir. Exemplul de mai jos arată utilizarea indexatorului și a proprietății Length:

Utilizarea sistemului; clasă Exemplu ( static void Main() ( string str = "Șir simplu"; // Obține lungimea șirului și al 6-lea caracter din linie folosind indexerul Console.WriteLine ("Lungimea șirului este (0), 6th caracterul este "(1)"" , str.Length, str); ))

Operatori de clasă String

Clasa String supraîncarcă următorii doi operatori: == și !=. Operatorul == este folosit pentru a testa două șiruri de caractere pentru egalitate. Când operatorul == este aplicat referințelor la obiect, de obicei testează dacă ambele referințe sunt făcute la același obiect. Și când operatorul == este aplicat referințelor la obiecte de tip String, conținutul șirurilor în sine este comparat pentru egalitate. Același lucru este valabil și pentru operatorul !=. Când este aplicat referințelor la obiecte de tip String, conținutul șirurilor în sine este comparat pentru inegalitate. Cu toate acestea, alți operatori relaționali, inclusiv =, compară referințele la obiecte de tip String în același mod în care compară referințele la obiecte de alte tipuri. Și pentru a verifica dacă un șir este mai mare decât altul, ar trebui să apelați metoda Compare() definită în clasa String.

După cum va deveni clar, multe tipuri de comparații de șiruri de caractere se bazează pe informații culturale. Dar acest lucru nu se aplică operatorilor == și !=. La urma urmei, pur și simplu compară valorile ordinale ale caracterelor din șiruri. (Cu alte cuvinte, ei compară valorile binare ale caracterelor care nu au fost modificate de normele culturale, adică standardele locale.) Prin urmare, acești operatori efectuează comparații de șiruri într-o manieră insensibilă la majuscule și la cultură.

Metode ale clasei de șiruri

Următorul tabel listează unele dintre cele mai interesante metode din această clasă, grupate după scop:

Următorul exemplu de program utilizează mai multe dintre metodele de mai sus:

Utilizarea sistemului; folosind System.Collections.Generic; folosind System.Linq; folosind System.Text; namespace ConsoleApplication1 ( clasa Program ( static void Main(string args) ( // Compara primele două linii șir s1 = „acesta este un șir"; șir s2 = „acesta este text și acesta este un șir"; if (String. CompareOrdinal(s1, s2) != 0) Console.WriteLine(„Șirurile s1 și s2 nu sunt egale”); if (String.Compare(s1, 0, s2, 13, 10, true) == 0) Console.WriteLine ("Totuși, acestea conțin același text"); // Concatenarea șirurilor de caractere Console.WriteLine(String.Concat("\n" + "One, two ","trei, patru")); // Căutare într-un șir / / Prima apariție a unui subșir dacă (s2. IndexOf(„this”) != -1) Console.WriteLine(„Cuvântul \”acest\” găsit în linie, acesta „+ ”este la: (0) poziția” , s2.IndexOf("this")); / / Ultima apariție a subșirului if (s2.LastIndexOf("this") != -1) Console.WriteLine("Ultima apariție a cuvântului \"this\" este " + "la (0) poziție", s2.LastIndexOf("this" )); // Căutare dintr-o matrice de caractere char myCh = ("ы","x","t"); if (s2.IndexOfAny (myCh) != -1) Console.WriteLine("Unul dintre caracterele din tabloul ch "+ "găsit în linia curentă la poziția (0)", s2.IndexOfAny(myCh)); // Determinați dacă linia începe cu subșirul dat if (s2.StartsWith("acesta este text") == true) Console.WriteLine("Subșir găsit!"); // Determinați dacă șirul conține un subșir // folosind exemplul de determinare a șirului de sistem de operare al utilizatorului myOS = Environment.OSVersion.ToString(); if (myOS.Contains ("NT 5.1")) Console.WriteLine ("Sistemul dvs. de operare este Windows XP"); else if (myOS.Contains ("NT 6.1")) Console.WriteLine ("Sistemul dvs. de operare este Windows 7"); Console.ReadLine(); ) ) )

Câteva despre compararea șirurilor în C#

Probabil cea mai comună dintre toate operațiunile cu șir de caractere este compararea unui șir cu altul. Înainte de a analiza orice metode de comparare a șirurilor, merită să subliniem următoarele: Comparațiile de șiruri pot fi făcute în .NET Framework în două moduri principale:

În primul rând, comparația poate reflecta obiceiurile și normele unui anumit mediu cultural, care sunt adesea cadre culturale care intră în joc atunci când programul este implementat. Acesta este un comportament standard pentru unele metode de comparare, dar nu pentru toate.

Și în al doilea rând, comparația se poate face indiferent de setările culturale doar prin valorile ordinale ale personajelor care alcătuiesc șirul. În general, comparațiile non-culturale ale șirurilor folosesc ordinea lexicografică (și caracteristicile lingvistice) pentru a determina dacă un șir este mai mare decât, mai mic sau egal cu un alt șir. În comparație ordinală, șirurile sunt pur și simplu ordonate pe baza valorii nemodificate a fiecărui caracter.

Din cauza diferențelor în modul în care diferă comparațiile de șiruri culturale și comparațiile ordinale și din cauza consecințelor fiecărei astfel de comparații, vă recomandăm insistent să urmați cele mai bune practici oferite în prezent de Microsoft. La urma urmei, alegerea unei metode greșite de comparare a șirurilor poate duce la funcționarea incorectă a programului atunci când acesta este operat într-un mediu diferit de cel în care a fost dezvoltat.

Alegerea modului de comparare a șirurilor de caractere este o decizie foarte importantă. Ca regulă generală și fără excepție, ar trebui să alegeți să comparați șirurile într-o manieră sensibilă din punct de vedere cultural dacă acest lucru este făcut în scopul de a afișa rezultatul utilizatorului (de exemplu, pentru a afișa o serie de șiruri sortate în ordine lexicografică). Dar dacă șirurile conțin informații fixe care nu sunt destinate să fie modificate pentru diferențele culturale, cum ar fi un nume de fișier, un cuvânt cheie, o adresă de site web sau o valoare de securitate, atunci ar trebui să alegeți compararea șirurilor ordinale. Desigur, caracteristicile aplicației particulare dezvoltate vor dicta alegerea unei metode adecvate pentru compararea șirurilor de caractere.

Clasa String oferă o varietate de metode de comparare a șirurilor, care sunt enumerate în tabelul de mai sus. Cea mai universală dintre ele este metoda Compare(). Permite compararea a două șiruri de caractere în întregime sau parțial, diferențiat de majuscule sau minuscule, într-un mod specificat de parametrul tip StringComparison, precum și informațiile culturale furnizate de parametrul tip CultureInfo.

Acele supraîncărcări ale metodei Compare() care nu includ un parametru de tip StringComparison efectuează o comparație a șirurilor de caractere care ține cont de majuscule și cultură. Și în acele variante supraîncărcate care nu conțin un parametru de tip CultureInfo, informațiile despre mediul cultural sunt determinate de mediul de rulare curent.

Tipul StringComparison este o enumerare care definește valorile prezentate în tabelul de mai jos. Folosind aceste valori, puteți crea comparații de șiruri care se potrivesc nevoilor aplicației dvs. specifice. Prin urmare, adăugarea unui parametru de tip StringComparison extinde capacitățile metodei Compare() și ale altor metode de comparare, cum ar fi Equals(). Acest lucru face, de asemenea, posibilă indicarea fără ambiguitate a modului în care se intenționează să fie comparate șirurile.

Din cauza diferențelor dintre comparațiile de șiruri sensibile din punct de vedere cultural și comparațiile ordinale, este important să fim cât mai precis posibil în acest sens.

În orice caz, metoda Compare() returnează o valoare negativă dacă primul șir comparat este mai mic decât al doilea; pozitiv dacă primul șir comparat este mai mare decât al doilea; și, în final, zero dacă ambele șiruri comparate sunt egale. Deși metoda Compare() returnează zero dacă șirurile comparate sunt egale, în general este mai bine să folosiți metoda Equals() sau operatorul == pentru a determina dacă șirurile de caractere sunt egale.

Faptul este că metoda Compare() determină egalitatea șirurilor comparate pe baza ordinii lor de sortare. Astfel, dacă se face o comparație culturală între șiruri, ambele șiruri pot ajunge să fie aceleași în ordinea lor de sortare, dar să nu fie egale în substanță. În mod implicit, egalitatea șirurilor este determinată în metoda Equals(), pe baza valorilor ordinale ale caracterelor și fără a ține cont de mediul cultural. Prin urmare, în mod implicit, ambele șiruri sunt comparate în această metodă pentru egalitate absolută, caracter cu caracter, similar cu modul în care se face în operatorul ==.

În ciuda versatilității mari a metodei Compare(), pentru comparații ordinale simple ale șirurilor de caractere este mai ușor să se folosească metoda CompareOrdinal(). În cele din urmă, rețineți că metoda CompareTo() efectuează doar comparații de șiruri sensibile din punct de vedere cultural.

Următorul program demonstrează utilizarea metodelor Compare(), Equals(), CompareOrdinal() și a operatorilor == și != pentru a compara șirurile de caractere. Rețineți că primele două exemple de comparație demonstrează în mod clar diferențele dintre comparațiile de șiruri sensibile din punct de vedere cultural și comparațiile ordinale într-un mediu vorbitor de limba engleză:

Utilizarea sistemului; Exemplu de clasă ( static void Main() ( șir str1 = "alfa"; șir str2 = "Alfa"; șir str3 = "Beta"; șir str4 = "alfa"; șir str5 = "alfa, beta"; rezultat int; / / Mai întâi, demonstrează diferențele dintre comparația de șiruri sensibilă la cultură // și rezultatul comparației ordinale = String.Compare(str1, str2, StringComparison.CurrentCulture); Console.Write("Comparație de șiruri sensibile la cultură: "); if (rezultat 0) ) Console.WriteLine(str1 + " mai mare decât " + str2); altfel Console.WriteLine(str1 + " egal cu " + str2); rezultat = String.Compare(str1, str2, StringComparison.Ordinal); Console.Write(" Linii de comparație ordinale: "); if (rezultat 0) Console.WriteLine(str1 + "mai mare decât " + str2); else Console.WriteLine(str1 + " egal cu " + str4); // Utilizați rezultatul metodei CompareOrdinal() = String.CompareOrdinal( str1, str2); Console.Write("Compararea șirurilor folosind metoda CompareOrdinal():\n"); if (rezultat 0) Console.WriteLine(str1 + " mai mare decât " + str2); else Console .WriteLine(str1 + " egal cu " + str4); Console.WriteLine(); // Determinați egalitatea șirurilor folosind operatorul == // Aceasta este o comparație ordinală a șirurilor de caractere if (str1 == str4) Console.WriteLine(str1 + " == " + str4); // Definiți inegalitatea liniilor folosind operatorul != if(str1 != str3) Console.WriteLine(str1 + " != " + str3); if(str1 != str2) Consola.WriteLine(str1 + " != " + str2); Console.WriteLine(); // Efectuați o comparație ordinală a șirurilor de caractere care nu ține seama de majuscule // folosind metoda Equals() if(String.Equals(str1, str2, StringComparison.OrdinalIgnoreCase)) Console.WriteLine("Comparație de șiruri folosind metoda Equals() cu " + "Parametrul OrdinalIgnoreCase: \n" + str1 + " este egal cu " + str2); Console.WriteLine(); // Comparați părți ale șirurilor de caractere if(String.Compare(str2, 0, str5, 0, 3, StringComparison.CurrentCulture) > 0) ( Console.WriteLine("Comparați șirurile ținând cont de mediul cultural actual:" + "\n3 primele caractere ale șirului " + str2 + " mai mult decât primele 3 caractere ale liniei " + str5); ) ) )

Rularea acestui program produce următorul rezultat: