Linijos. Styginių įvestis/išvestis. Suformatuotas I/O. Stygų apdorojimas naudojant standartines C kalbos funkcijas.Darbas su atmintimi.

1.1. Eilučių deklaravimas ir inicijavimas.

Eilutė yra simbolių masyvas, kuris baigiasi tuščiu simboliu „\0“. Eilutė deklaruojama kaip įprastas simbolių masyvas, pavyzdžiui,

char s1; // devynių simbolių ilgio eilutė

char *s2; // rodyklė į eilutę

Skirtumas tarp rodyklių s1 ir s2 yra tas, kad rodyklė s1 yra pavadinta konstanta, o rodyklė s2 yra kintamasis.

Eilučių konstantos yra įtrauktos į dvigubas kabutes, o ne simboliai, kurie yra įterpti į vienvietes kabutes. Pavyzdžiui,

"Tai yra eilutė."

Pagal standartą eilutės konstantos ilgis negali viršyti 509 simbolių. Tačiau daugelis įgyvendinimų leidžia ilgesnius eilutes.

Inicijuojant eilutes masyvo dydžio geriau nenurodyti, kompiliatorius tai padarys apskaičiuodamas eilutės ilgį ir pridėdamas prie jos vieną. Pavyzdžiui,

char s1 = "Tai yra eilutė.";

C programavimo kalboje yra daug funkcijų, skirtų darbui su eilutėmis, kurių prototipai aprašyti antraštės failuose stdlib.h ir string.h. Darbas su šiomis funkcijomis bus aptartas tolesnėse pastraipose.

1.2. Styginių įvestis/išvestis.

Norėdami įvesti eilutę iš konsolės, naudokite funkciją

char* gets(char *str);

kuri įrašo eilutę adresu str ir grąžina įvestos eilutės adresą. Funkcija sustabdo įvestį, jei susiduria su simboliu „\n“ arba EOF (failo pabaiga). Naujos eilutės simbolis nenukopijuotas. Nulinis baitas dedamas skaitymo eilutės pabaigoje. Jei pavyksta, funkcija grąžina rodyklę į nuskaitytą eilutę, o jei nepavyksta – NULL.

Norėdami išvesti eilutę į konsolę, naudokite standartinę funkciją

int įdeda (const char *s);

kuri, jei pavyks, grąžina neneigiamą skaičių, o jei nepavyksta, grąžina EOF.

Funkcijos Gets ir puts prototipai aprašyti stdio.h antraštės faile.

#įtraukti

printf ("Įvesties eilutė:");

1.3. Suformatuotas I/O.

Norėdami įvesti formatuotus duomenis iš konsolės, naudokite funkciją

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

kuri, jei pavyks, grąžina perskaitytų duomenų vienetų skaičių, o jei nepavyksta, grąžina EOF. Formato parametras turi nurodyti formatuojamą eilutę, kurioje yra įvesties formato specifikacijos. Argumentų, einančių po formato eilutės, skaičius ir tipai turi atitikti įvesties formatų skaičių ir tipus, nurodytus formato eilutėje. Jei ši sąlyga neįvykdyta, funkcijos rezultatas yra nenuspėjamas.

Tarpas, „\t“ arba „\n“ simbolis formato eilutėje apibūdina vieną ar daugiau tuščių simbolių įvesties sraute, kurie apima tokius simbolius: tarpas, „\t“, „\n“, „\v“, '\f'. Funkcija scanf praleidžia tuščius simbolius įvesties sraute.

Pažodiniai simboliai formato eilutėje, išskyrus % simbolį, reikalauja, kad įvesties sraute būtų rodomi lygiai tokie patys simboliai. Jei tokio simbolio nėra, funkcija scanf nustoja įvesti. Funkcija scanf praleidžia pažodinius simbolius.

Apskritai įvesties formato specifikacija atrodo taip:

%[*] [plotis] [modifikatoriai] tipas

Simbolis „*“ reiškia praleidimą įvedant šioje specifikacijoje apibrėžtą lauką;

- „plotis“ apibrėžia didžiausią įvestų simbolių skaičių pagal šią specifikaciją;

Tipas gali turėti šias reikšmes:

c – simbolių masyvas,

s – simbolių eilutė, eilutės atskirtos tuščiais simboliais,

d – 10 s/s sveikasis ženklas,

i – sveikasis skaičius, skaičių sistema priklauso nuo pirmųjų dviejų skaitmenų,

u – beženklis sveikasis skaičius 10 s/s,

o – beženklis sveikasis skaičius 8 s/s,

x, X – sveikasis skaičius be ženklų, esant 16 s/s,

e, E, f, g, G – slankusis skaičius,

p – rodyklė prie žymeklio,

n – rodyklė į sveikąjį skaičių,

[…] – nuskaitytų simbolių masyvas, pavyzdžiui, .

Pastaruoju atveju iš įvesties srauto bus įvesti tik laužtiniuose skliaustuose esantys simboliai. Jei pirmasis simbolis laužtiniuose skliaustuose yra „^“, įvedami tik tie simboliai, kurių nėra masyve. Simbolių diapazonas masyve nurodomas naudojant simbolį „-“. Kai įvedate simbolius, taip pat įvedami pirmieji tušti simboliai ir eilutės galinis nulinis baitas.

Modifikatoriai gali turėti šias reikšmes:

h – trumpas sveikasis skaičius,

l, L – ilgas sveikasis skaičius arba slankusis skaičius,

ir naudojami tik sveikiesiems arba slankiiesiems skaičiams.

Toliau pateiktame pavyzdyje parodytas Scanf funkcijos naudojimas. Atminkite, kad prieš formato specifikaciją, pradedant slankiojo skaičiaus įvestimi, yra tarpo simbolis.

#įtraukti

printf("Įveskite sveikąjį skaičių: ");

scanf("%d", &n);

printf("Įveskite dvigubą: ");

scanf(" %lf", &d);

printf("Įveskite ženklą: ");

scanf(" %c", &c);

printf("Įveskite eilutę: ");

scanf(" %s", &s);

Atkreipkite dėmesį, kad šioje programoje inicijuojamas slankaus kablelio skaičius. Tai daroma taip, kad kompiliatoriuje būtų biblioteka, padedanti dirbti su slankiaisiais skaičiais. Jei to nepadarysite, vykdymo metu įvedant slankųjį skaičių įvyks klaida.

Norėdami suformatuoti duomenis į konsolę, naudokite funkciją

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

kuri, jei pavyks, grąžina duomenų išvesties vienetų skaičių, o jei nepavyksta, grąžina EOF. Formato parametras yra formato eilutė, kurioje yra išvesties formatų specifikacijos. Argumentų, einančių po formato eilutės, skaičius ir tipai turi atitikti formato eilutėje nurodytų išvesties formato specifikacijų skaičių ir tipus. Apskritai išvesties formato specifikacija atrodo taip:

%[flags] [width] [.precision] [modifiers] tipas

- „vėliavos“ yra įvairūs simboliai, nurodantys išvesties formatą;

- „plotis“ apibrėžia minimalų išvestų simbolių skaičių pagal šią specifikaciją;

- „.precision“ apibrėžia didžiausią rodomų simbolių skaičių;

- „modifikatoriai“ nurodo argumentų tipą;

- "tipas" nurodo argumento tipą.

Norint išvesti sveikuosius ženklus, naudojamas šis išvesties formatas:

%[-] [+ | tarpas] [plotis] [l] d

- – lygiavimas į kairę, numatytasis – dešinėn;

+ – rodomas „+“ ženklas, atkreipkite dėmesį, kad neigiamiems skaičiams visada rodomas „-“ ženklas;

‘tarpas’ – simbolio vietoje rodomas tarpas;

d – int duomenų tipas.

Norėdami išvesti sveikuosius skaičius be ženklų, naudokite šį išvesties formatą:

%[-] [#] [plotis] [l]

# – pradinis 0 išvedamas skaičiams 8 c/c arba pradinis 0x arba 0X skaičiams 16 c/c,

l – ilgojo duomenų tipo modifikatorius;

u – sveikas skaičius 10c/c,

o – sveikas skaičius 8 c/c,

x, X – sveikasis skaičius esant 16 c/c.

Slankaus kablelio skaičiams rodyti naudojamas šis išvesties formatas:

%[-] [+ | tarpas] [plotis] [.tikslumas]

„tikslumas“ – nurodo skaitmenų skaičių po kablelio f, e ir E formatams arba reikšminių skaitmenų skaičių g ir G formatams. Skaičiai suapvalinami. Numatytasis tikslumas yra šeši skaitmenys po kablelio;

f – fiksuoto taško numeris,

e – eksponentinės formos skaičius, rodiklis žymimas raide „e“,

E – eksponentinės formos skaičius, rodiklis žymimas raide „E“,

g – trumpiausias iš f arba g formatų,

G – trumpiausias iš f arba G formatų.

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

// spausdina: n = 123 f = 12.340000 e = 1.234000e+001 E = 1.234000E+001 f = 12.34

1.4. Stygų formatavimas.

Yra „scanf“ ir „printf“ funkcijų variantai, kurie yra skirti formatuoti eilutes ir vadinami atitinkamai „sscanf“ ir „sprintf“.

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

nuskaito duomenis iš str nurodytos eilutės pagal formato eilutę, nurodytą formatu. Jei pasiseka, grąžina perskaitytų duomenų skaičių, o jei nepavyksta, grąžina EOF. Pavyzdžiui,

#įtraukti

char str = "10 1,2 eilutė Nėra įvesties";

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

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

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

printf("%f\n", d); // spaudiniai: 1.200000

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

int sprintf (char *buferis, const char *formatas, ...);

suformatuoja eilutę pagal formato parametro nurodytą formatą ir gautą rezultatą įrašo į simbolių masyvo buferį. Funkcija grąžina simbolių, įrašytų į simbolių masyvo buferį, skaičių, neįskaitant baigiamojo nulinio baito. Pavyzdžiui,

#įtraukti

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

char s = "Tai yra eilutė.";

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

printf("%s\n", buferis); // spausdina: c = c, n = 10, d = 1,200000, s = Tai eilutė

1.5. Konvertuokite eilutes į skaitmeninius duomenis.

Eilučių konvertavimo į skaitmeninius duomenis funkcijų prototipai pateikti stdlib.h antraštės faile, kuris turi būti įtrauktas į programą.

Norėdami konvertuoti eilutę į sveikąjį skaičių, naudokite funkciją

int atoi (const char *str);

char *str = "-123";

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

Norėdami konvertuoti eilutę į ilgą sveikąjį skaičių, naudokite funkciją

long int atol (const char *str);

kuri, jei sėkminga, grąžina sveikąjį skaičių, į kurį konvertuojama eilutė str, o jei nepavyksta, grąžina 0. Pavyzdžiui,

char *str = "-123";

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

Norėdami konvertuoti eilutę į dvigubą skaičių, naudokite funkciją

double atof(const char *str);

kuris sėkmės atveju grąžina slankųjį skaičių tipo double, į kurį konvertuojama eilutė str, o nesėkmės atveju – 0. Pavyzdžiui,

char *str = "-123.321";

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

Toliau pateiktos funkcijos atlieka panašias funkcijas kaip atoi, atol, atof, tačiau suteikia daugiau pažangių funkcijų.

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

paverčia eilutę str į ilgą int skaičių, kurį grąžina. Šios funkcijos parametrai turi šiuos tikslus.

Jei bazė yra 0, tada konversija priklauso nuo pirmųjų dviejų str simbolių:

Jei pirmasis simbolis yra skaičius nuo 1 iki 9, tada laikoma, kad skaičius vaizduojamas 10 c/c;

Jei pirmasis simbolis yra skaitmuo 0, o antrasis simbolis yra skaitmuo nuo 1 iki 7, tada laikoma, kad skaičius pavaizduotas 8 c/c;

Jei pirmasis simbolis yra 0, o antrasis yra "X" arba "x", tada laikoma, kad skaičius yra vaizduojamas 16 c/c.

Jei bazė yra skaičius nuo 2 iki 36, tada ši reikšmė laikoma skaičių sistemos pagrindu, o bet koks simbolis, esantis už skaičių sistemos ribų, nustoja konvertuoti. Skaičių sistemose nuo 11 iki 36 bazinių skaičių sistemose simboliai „A“ iki „Z“ arba „a“ iki „z“ naudojami skaitmenims žymėti.

Endptr argumento reikšmę nustato funkcija strtol. Šioje reikšmėje yra žymeklis į simbolį, kuris sustabdė eilutės str konvertavimą. Funkcija strtol grąžina konvertuotą skaičių, jei sėkminga, ir 0, jei nepavyksta. Pavyzdžiui,

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, sustojimas = 7

nepasirašytas ilgas int strtol (const char *str, char **endptr, int base);

veikia panašiai kaip strtol funkcija, bet paverčia simbolinį skaičiaus atvaizdavimą į skaičių be ženklo ilgio int.

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

Paverčia simbolinę skaičiaus atvaizdą į dvigubą.

Visos šioje pastraipoje išvardytos funkcijos nustoja veikti, kai aptinkamas pirmasis simbolis, kuris neatitinka atitinkamo skaičiaus formato.

Be to, jei skaičiaus simbolio reikšmė viršija atitinkamo duomenų tipo priimtinų reikšmių diapazoną, funkcijos atof, strtol, strtoul, strtod nustato errno kintamojo reikšmę į ERANGE. Errno kintamasis ir ERANGE konstanta yra apibrėžti math.h antraštės faile. Šiuo atveju funkcijos atof ir strtod grąžina reikšmę HUGE_VAL, funkcija strtol – LONG_MAX arba LONG_MIN, o funkcija strtoul – ULONG_MAX reikšmę.

Nestandartinės funkcijos itoa, ltoa, utoa, ecvt, fcvt ir gcvt gali būti naudojamos skaitmeniniams duomenims konvertuoti į simbolių eilutes. Tačiau šiems tikslams geriau naudoti standartinę sprintf funkciją.

1.6. Standartinės funkcijos dirbant su stygomis.

Šiame skyriuje aptariamos funkcijos, skirtos darbui su eilutėmis, kurių prototipai aprašyti antraštės faile string.h.

1. Stygų palyginimas. Funkcijos strcmp ir strncmp naudojamos eilutėms palyginti.

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

leksikografiškai lygina eilutes str1, str2 ir grąžina –1, 0 arba 1, jei str1 yra atitinkamai mažesnis, lygus arba didesnis už str2.

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

leksikografiškai lygina daugiausia pirmųjų n simbolių iš eilučių str1 ir str2. Funkcija grąžina -1, 0 arba 1, jei pirmieji n simbolių iš str1 yra atitinkamai mažesni, lygūs arba didesni už pirmuosius n simbolių iš str2.

// eilučių palyginimo pavyzdys

#įtraukti

#įtraukti

char str1 = "aa bb";

char str2 = "aa aa";

char str3 = "aa bb cc";

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

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

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

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

2. Eilučių kopijavimas. Strcpy ir strncpy funkcijos naudojamos eilutėms kopijuoti.

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

nukopijuoja eilutę str2 į eilutę str1. Nukopijuojama visa str2 eilutė, įskaitant baigiamąjį nulinį baitą. Funkcija grąžina rodyklę į str1. Jei linijos sutampa, rezultatas yra nenuspėjamas.

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

nukopijuoja n simbolių iš eilutės str2 į eilutę str1. Jei str2 yra mažiau nei n simbolių, paskutinis nulinis baitas nukopijuojamas tiek kartų, kiek reikia norint išplėsti str2 iki n simbolių. Funkcija grąžina rodyklę į eilutę str1.

char str2 = "Kopijuoti eilutę.";

strcpy(str1, str2);

printf(str1); // spausdina: kopijuoti eilutę.

4. Sujungimo stygos. Funkcijos strcat ir strncat naudojamos eilutėms sujungti į vieną eilutę.

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

prideda eilutę str2 prie eilutės str1, ištrinant str1 eilutės nulinį baitą. Funkcija grąžina rodyklę į eilutę str1.

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

prideda n simbolių iš eilutės str2 prie eilutės str1, ištrinant str1 eilutės nulinį baitą. Funkcija grąžina rodyklę į eilutę str1. jei eilutės str2 ilgis yra mažesnis nei n, tada pridedami tik į eilutę str2 įtraukti simboliai. Sujungus eilutes, prie str1 visada pridedamas nulinis baitas. Funkcija grąžina rodyklę į eilutę str1.

#įtraukti

#įtraukti

char str1 = "Eilutė";

char str2 = "katenacija";

char str3 = "Taip Ne";

strcat(str1, str2);

printf("%s\n", str1); // spausdina: Stygos katenacija

strncat(str1, str3, 3);

printf("%s\n", str1); // spausdina: String catenation Taip

5. Ieškokite simbolio eilutėje. Norėdami ieškoti simbolio eilutėje, naudokite funkcijas strchr, strrchr, strspn, strcspn ir strpbrk.

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

ieško pirmojo simbolio, nurodyto c eilutėje str. Jei pavyksta, funkcija grąžina žymeklį į pirmąjį rastą simbolį, o jei nepavyksta, NULL.

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

ieško paskutinio simbolio, nurodyto c eilutėje str. Jei pavyksta, funkcija grąžina žymeklį į paskutinį rastą simbolį, o jei nepavyksta – NULL.

#įtraukti

#įtraukti

char str = "Char paieška";

printf("%s\n", strchr(str, "r")); // spausdina: r paieška

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

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

grąžina pirmojo simbolio iš str1, kurio nėra str2, indeksą.

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

grąžina pirmojo simbolio rodyklę iš str1, esančio str2.

char str = "123 abc";

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

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

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

randa pirmąjį eilutės str1 simbolį, kuris yra lygus vienam iš eilutės str2 simbolių. Jei pavyksta, funkcija grąžina žymeklį į šį simbolį, o jei nepavyksta, NULL.

char str = "123 abc";

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

6. Stygų palyginimas. Funkcija strstr naudojama eilutėms palyginti.

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

randa pirmąjį str2 atvejį (be nulinio baito) str1. Jei pavyksta, funkcija grąžina rodyklę į rastą poeilelę, o jei nepavyksta, NULL. Jei str1 rodyklė nukreipia į nulinio ilgio eilutę, funkcija grąžina str1 rodyklę.

char str = "123 abc 456;

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

7. Eilutės analizavimas į žetonus. Funkcija strtok naudojama eilutei išanalizuoti į žetonus.

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

grąžina žymeklį į kitą žetoną (žodį) eilutėje str1, kurioje žetono skyrikliai yra simboliai iš eilutės str2. Jei žetonų daugiau nėra, funkcija grąžina NULL. Pirmą kartą iškvietus funkciją strtok, parametras str1 turi nukreipti į eilutę, kuri yra tokenizuota, o vėlesnių iškvietimų metu šis parametras turi būti nustatytas į NULL. Suradusi žetoną, funkcija strtok po šio žetono įrašo nulinį baitą vietoje skyriklio.

#įtraukti

#įtraukti

char str = "12 34 ab cd";

p = strtok(str, " ");

printf("%s\n", p); // spausdina reikšmes stulpelyje: 12 34 ab cd

p = strtok(NULL, " ");

8. Stygos ilgio nustatymas. Strlen funkcija naudojama eilutės ilgiui nustatyti.

size_t strlen (const char *str);

grąžina eilutės ilgį, nepaisydamas paskutinio nulinio baito. Pavyzdžiui,

char str = "123";

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

1.7. Funkcijos, skirtos darbui su atmintimi.

Antraštės faile string.h taip pat aprašomos darbo su atminties blokais funkcijos, kurios yra panašios į atitinkamas darbo su eilutėmis funkcijas.

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

ieško pirmojo simbolio, nurodyto c, pasireiškimo n baitų eilutės str.

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

lygina pirmuosius n baitų eilučių str1 ir str2.

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

nukopijuoja pirmuosius n baitų iš str1 į str2 eilutę.

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

nukopijuoja pirmuosius n baitų iš str1 į str2, užtikrinant, kad persidengiančios eilutės būtų tvarkomos teisingai.

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

nukopijuoja c nurodytą simbolį į pirmuosius n str. baitų.

--- C# vadovas --- Stygos

Įprasto programavimo požiūriu, eilutė eilutės duomenų tipas yra vienas iš svarbiausių C#. Šis tipas apibrėžia ir palaiko simbolių eilutes. Daugelyje kitų programavimo kalbų eilutė yra simbolių masyvas. Ir C #, eilutės yra objektai. Todėl eilutės tipas yra nuorodos tipas.

Statybinės stygos

Paprasčiausias būdas sukurti simbolių eilutę yra naudoti eilutės literalą. Pavyzdžiui, ši kodo eilutė eilutės nuorodos kintamajam str priskiria nuorodą į eilutės literalą:

String str = "Eilutės pavyzdys";

Šiuo atveju kintamasis str inicijuojamas simbolių seka „Example String“. String tipo objektas taip pat gali būti sukurtas iš char tipo masyvo. Pavyzdžiui:

Chararray = („e“, „x“, „a“, „m“, „p“, „l“, „e“); string str = nauja eilutė(chararray);

Sukūrus eilutės objektą, jį galima naudoti bet kur, kur reikia teksto eilutės su kabutėmis.

Styginių atkaklumas

Kaip bebūtų keista, eilutės tipo objekto turinio pakeisti negalima. Tai reiškia, kad sukūrus simbolių seką, jos pakeisti negalima. Tačiau šis apribojimas prisideda prie efektyvesnio simbolių eilučių įgyvendinimo. Todėl šis iš pažiūros akivaizdus trūkumas iš tikrųjų virsta privalumu. Taigi, jei eilutė reikalinga kaip esamos eilutės variantas, šiuo tikslu reikia sukurti naują eilutę, kurioje būtų visi reikalingi pakeitimai. Ir kadangi nepanaudoti stygų objektai automatiškai surenkami kaip šiukšlės, jums net nereikia jaudintis dėl nereikalingų stygų likimo.

Tačiau reikia pabrėžti, kad kintamųjų nuorodos į eilutes (ty eilutės tipo objektus) gali keistis, todėl jos gali nurodyti kitą objektą. Tačiau paties eilutės objekto turinys po jo sukūrimo nesikeičia.

Pažiūrėkime į pavyzdį:

Static void addNewString() ( string s = "Tai mano potėpis"; s = "Tai naujas potėpis"; )

Sukompiliuokime programą ir gautą rinkinį įkelkime į ildasm.exe įrankį. Paveikslėlyje parodytas CIL kodas, kuris bus sugeneruotas negaliojančiam addNewString() metodui:

Atkreipkite dėmesį, kad yra daug iškvietimų į ldstr (eilutės įkrovos) opcode. Šis CIL ldstr opkodas įkelia naują eilutės objektą į valdomą krūvą. Dėl to ankstesnis objektas, kuriame buvo reikšmė „Tai mano potėpis“, ilgainiui bus surinktas.

Darbas su stygomis

Klasėje Sistema.Styga pateikiamas metodų rinkinys, leidžiantis nustatyti simbolių duomenų ilgį, ieškoti poeilutės esamoje eilutėje, konvertuoti simbolius iš didžiųjų į mažąsias ir atvirkščiai ir kt. Toliau mes apžvelgsime šią klasę išsamiau.

Lauko, rodyklės ir eilutės klasės ypatybė

Styginių klasė apibrėžia vieną lauką:

Vieša statinė tik skaitoma eilutė Tuščia;

Laukas Empty žymi tuščią eilutę, t.y. eilutė, kurioje nėra jokių simbolių. Tai skiriasi nuo tuščios eilutės nuorodos, kuri tiesiog daroma į neegzistuojantį objektą.

Be to, eilutės klasė apibrėžia vieną tik skaitomą indeksatorių:

Viešai paženklink tai ( gauti; )

Šis indeksavimo įrankis leidžia gauti simbolį nurodytoje rodyklėje. Eilučių, kaip ir masyvų, indeksavimas prasideda nuo nulio. Styginių objektai yra patvarūs ir nesikeičia, todėl logiška, kad Styginių klasė palaiko tik skaitymo indeksavimo priemonę.

Galiausiai, eilutės klasė apibrėžia vieną tik skaitymo ypatybę:

Viešas int Ilgis (gauti; )

Savybė Length grąžina simbolių skaičių eilutėje. Toliau pateiktame pavyzdyje parodytas rodyklės ir ilgio savybės naudojimas:

Sistemos naudojimas; class Pavyzdys ( static void Main() ( string str = "Paprasta eilutė"; // Gaukite eilutės ilgį ir 6-ąjį ženklą eilutėje naudodami indeksavimo priemonę Console.WriteLine("Eilutės ilgis yra (0), 6th simbolis yra "(1)"" , str.Length, str); ) )

Styginių klasės operatoriai

Styginių klasė perkrauna šiuos du operatorius: == ir !=. == operatorius naudojamas dviejų simbolių eilučių lygybei patikrinti. Kai objektų nuorodoms taikomas operatorius ==, jis paprastai patikrina, ar abi nuorodos daromos į tą patį objektą. O kai == operatorius taikomas nuorodoms į String tipo objektus, lygybės lygybei lyginamas pačių eilučių turinys. Tas pats pasakytina ir apie operatorių !=. Kai jis taikomas nuorodoms į String tipo objektus, pačių eilučių turinys lyginamas dėl nelygybės. Tačiau kiti reliaciniai operatoriai, įskaitant =, lygina nuorodas į String tipo objektus taip pat, kaip lygina nuorodas į kitų tipų objektus. Ir norėdami patikrinti, ar viena eilutė yra didesnė už kitą, turėtumėte iškviesti Palyginti () metodą, apibrėžtą eilutės klasėje.

Kaip paaiškės, daugelis simbolių eilučių palyginimo tipų remiasi kultūrine informacija. Bet tai netaikoma == ir != operatoriams. Galų gale, jie tiesiog lygina eilučių simbolių reikšmes. (Kitaip tariant, jie lygina dvejetaines simbolių reikšmes, kurios nebuvo modifikuotos kultūros normų, ty lokalių standartų.) Todėl šie operatoriai atlieka eilučių palyginimus nejausdami didžiųjų ir mažųjų raidžių ir kultūrai.

Styginių klasės metodai

Šioje lentelėje pateikiami kai kurie įdomiausi šios klasės metodai, sugrupuoti pagal paskirtį:

Toliau pateiktoje pavyzdinėje programoje naudojami keli iš pirmiau minėtų metodų:

Sistemos naudojimas; naudojant System.Collections.Generic; naudojant System.Linq; naudojant System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args)) ( // Palyginkite pirmas dvi eilutes string s1 = "tai yra eilutė"; string s2 = "tai tekstas, o tai yra eilutė"; if (String. CompareOrdinal(s1, s2) != 0) Console.WriteLine("Stygos s1 ir s2 nėra lygios"); if (String.Compare(s1, 0, s2, 13, 10, true) == 0) Console.WriteLine ("Tačiau juose yra tas pats tekstas"); // Eilučių sujungimas Console.WriteLine(String.Concat("\n" + "One, two ","tree, four")); // Ieškokite eilutėje / / Pirmasis poeilutės įvykis if (s2. IndexOf("this") != -1) Console.WriteLine("Žodis \"this\" rastas eilutėje, jis "+ "yra: (0) pozicijoje" , s2.IndexOf("this")); / / Paskutinis poeilutės įvykis if (s2.LastIndexOf("this") != -1) Console.WriteLine("Paskutinis žodžio \"this\" įvykis yra " + "(0) pozicijoje", s2.LastIndexOf("this" )); // Ieškokite iš simbolių masyvo char myCh = ("ы","x", "t"); if (s2.IndexOfAny (myCh) != -1) Console.WriteLine("Vienas iš simbolių iš masyvo ch "+ "rastas dabartinėje eilutėje pozicijoje (0)", s2.IndexOfAny(myCh)); // Nustatykite, ar eilutė prasideda duota eilute if (s2.StartsWith("tai tekstas") == true) Console.WriteLine("Poeilutė rasta!"); // Nustatykite, ar eilutėje yra poeilutė // naudodamiesi vartotojo OS eilutės nustatymo pavyzdžiu myOS = Environment.OSVersion.ToString(); if (myOS.Contains("NT 5.1")) Console.WriteLine("Jūsų operacinė sistema yra Windows XP"); else if (myOS.Contains("NT 6.1")) Console.WriteLine("Jūsų operacinė sistema yra Windows 7"); Console.ReadLine(); ) ) )

Šiek tiek apie eilučių palyginimą C#

Turbūt labiausiai paplitusi iš visų simbolių eilučių operacijų yra vienos eilutės palyginimas su kita. Prieš nagrinėjant bet kokius eilučių palyginimo metodus, verta pabrėžti šiuos dalykus: Eilučių palyginimas .NET Framework gali būti atliekamas dviem pagrindiniais būdais:

Pirma, palyginimas gali atspindėti tam tikros kultūrinės aplinkos papročius ir normas, kurios dažnai yra kultūrinės aplinkybės, kurios atsiranda įgyvendinant programą. Tai yra standartinė kai kurių, bet ne visų palyginimo metodų elgsena.

Antra, palyginimas gali būti atliekamas nepriklausomai nuo kultūrinių aplinkybių tik pagal eilutę sudarančių simbolių eilės vertes. Paprastai kalbant, nekultūriniuose eilučių palyginimuose naudojama leksikografinė tvarka (ir kalbiniai bruožai), siekiant nustatyti, ar viena eilutė yra didesnė, mažesnė už kitą eilutę ar lygi jai. Palyginus eilės tvarka, eilutės tiesiog išdėstomos pagal nepakeistą kiekvieno simbolio reikšmę.

Dėl skirtingų kultūrinių eilučių palyginimų ir eilinių palyginimų skirtumų ir kiekvieno tokio palyginimo pasekmių primygtinai rekomenduojame vadovautis geriausios praktikos pavyzdžiais, kuriuos šiuo metu siūlo „Microsoft“. Galų gale, pasirinkus netinkamą eilučių palyginimo metodą, programa gali veikti netinkamai, kai ji veikia kitoje aplinkoje, nei buvo sukurta.

Pasirinkimas, kaip palyginti simbolių eilutes, yra labai svarbus sprendimas. Paprastai ir be išimties turėtumėte pasirinkti lyginti eilutes kultūriškai jautriu būdu, jei tai daroma siekiant vartotojui parodyti rezultatą (pavyzdžiui, kad būtų rodoma eilučių serija, surūšiuota leksikografine tvarka). Tačiau jei eilutėse yra fiksuotos informacijos, kurios neketinama keisti atsižvelgiant į kultūrinius skirtumus, pvz., failo pavadinimas, raktinis žodis, svetainės adresas arba saugos reikšmė, turėtumėte pasirinkti eilinių eilučių palyginimą. Žinoma, konkrečios kuriamos programos charakteristikos lems tinkamo metodo simbolių eilučių palyginimui pasirinkimą.

Styginių klasėje pateikiami įvairūs eilučių palyginimo metodai, kurie išvardyti aukščiau esančioje lentelėje. Universaliausias iš jų yra Compare() metodas. Tai leidžia visiškai arba iš dalies palyginti dvi eilutes, skiriant didžiąsias ir mažąsias arba neskiriančias didžiąsias ir mažąsias raides, tipo parametro nurodytu būdu Styginių palyginimas, taip pat tipo parametro teikiama kultūrinė informacija Kultūros informacija.

Tos Compare() metodo perkrovos, kurios neapima StringComparison tipo parametro, atlieka simbolių eilučių palyginimą pagal didžiąsias ir mažąsias raides ir kultūrą. O tuose perkrautuose variantuose, kuriuose nėra CultureInfo tipo parametro, informaciją apie kultūrinę aplinką lemia esama vykdymo aplinka.

„StringComparison“ tipas yra sąrašas, apibrėžiantis reikšmes, parodytas toliau esančioje lentelėje. Naudodami šias reikšmes galite sukurti eilučių palyginimus, atitinkančius jūsų konkrečios programos poreikius. Todėl, pridėjus StringComparison tipo parametrą, išplečiamos Compare() metodo ir kitų palyginimo metodų, tokių kaip Equals(), galimybės. Tai taip pat leidžia vienareikšmiškai nurodyti, kaip eilutes ketinama palyginti.

Dėl kultūriškai jautrių eilučių palyginimų ir eilinių palyginimų skirtumų svarbu šiuo atžvilgiu būti kuo tikslesni.

Bet kuriuo atveju metodas Compare() grąžina neigiamą reikšmę, jei pirmoji palyginta eilutė yra mažesnė už antrąją; teigiamas, jei pirmoji palyginta eilutė yra didesnė už antrąją; ir galiausiai nulis, jei abi lyginamos eilutės yra lygios. Nors metodas Compare() grąžina nulį, jei lyginamos eilutės yra lygios, paprastai geriau naudoti Equals() metodą arba == operatorių, kad nustatytų, ar simbolių eilutės yra lygios.

Faktas yra tai, kad Compare() metodas nustato lyginamų eilučių lygybę pagal jų rūšiavimo tvarką. Taigi, jei stygų kultūrinis palyginimas atliekamas, abi eilutės gali būti vienodos savo rūšiavimo tvarka, bet nevienodos iš esmės. Pagal numatytuosius nustatymus eilučių lygybė nustatoma naudojant Equals() metodą, remiantis simbolių eilės reikšmėmis ir neatsižvelgiant į kultūrinę aplinką. Todėl pagal numatytuosius nustatymus abi eilutės lyginamos šiuo metodu, siekiant absoliučios lygybės po simbolius, panašiai kaip tai daroma naudojant operatorių ==.

Nepaisant didelio Compare() metodo universalumo, paprastam simbolių eilučių eiliniam palyginimui lengviau naudoti CompareOrdinal() metodą. Galiausiai atminkite, kad CompareTo() metodas atlieka tik kultūriškai jautrių eilučių palyginimus.

Toliau pateiktoje programoje parodytas Compare(), Equals(), CompareOrdinal() metodų ir == ir != operatorių naudojimas simbolių eilutėms palyginti. Atkreipkite dėmesį, kad pirmieji du palyginimo pavyzdžiai aiškiai parodo skirtumus tarp kultūriškai jautrių eilučių palyginimų ir eilinių palyginimų angliškai kalbančioje aplinkoje:

Sistemos naudojimas; class Pavyzdys ( static void Main() ( string str1 = "alpha"; string str2 = "Alpha"; string str3 = "Beta"; string str4 = "alpha"; string str5 = "alfa, beta"; int rezultatas; / / Pirmiausia pademonstruokite skirtumus tarp kultūrai jautrių eilučių palyginimo // ir eilės palyginimo rezultato = String.Compare(str1, str2, StringComparison.CurrentCulture); Console.Write("Kultūriškai jautrių eilučių palyginimas: "); if (rezultatas 0 ) Console.WriteLine(str1 + " didesnis nei " + str2); else Console.WriteLine(str1 + " lygus " + str2); rezultatas = String.Compare(str1, str2, StringComparison.Ordinal); Console.Write(" Eilinės palyginimo eilutės: "); if (0 rezultatas) Console.WriteLine(str1 + " didesnis nei " + str2); else Console.WriteLine(str1 + " lygus " + str4); // Naudokite CompareOrdinal() metodo rezultatą = String.CompareOrdinal( str1, str2); Console.Write("Eilučių palyginimas naudojant CompareOrdinal() metodą:\n"); if (0 rezultatas) Console.WriteLine(str1 + " didesnis nei " + str2); else Console .WriteLine(str1 + " lygus " + str4); Console.WriteLine(); // Eilučių lygybės nustatymas naudojant operatorių == // Tai eilinis simbolių eilučių palyginimas if (str1 == str4) Console.WriteLine(str1 + " == " + str4); // Apibrėžkite linijų nelygybę naudodami operatorių != if(str1 != str3) Console.WriteLine(str1 + " != " + str3); if(str1 != str2) Console.WriteLine(str1 + " != " + str2); Console.WriteLine(); // Atlikite raidžių nejautrų eilučių eilinių skaičių palyginimą // naudodami Equals() metodą if(String.Equals(str1, str2, StringComparison.OrdinalIgnoreCase)) Console.WriteLine("Eilų palyginimas naudojant Equals() metodą su " + "Parametras OrdinalIgnoreCase: \n" + str1 + " lygus " + str2); Console.WriteLine(); // Palyginti eilučių dalis if(String.Compare(str2, 0, str5, 0, 3, StringComparison.CurrentCulture) > 0) ( Console.WriteLine("Palyginkite eilutes atsižvelgdami į esamą kultūrinę aplinką:" + "\n3 pirmieji eilutės " + str2 + " simboliai daugiau nei pirmieji 3 eilutės simboliai " + str5); ) ) )

Vykdant šią programą gaunama tokia išvestis:

Šioje pamokoje aptarsime C stiliaus eilutes; galbūt jau matėte šias eilutes mūsų svetainėje ar bet kuriame kitame vadovėlyje. Tiesą sakant, C eilutės yra tik simbolių masyvai, tačiau jie turi savo specifiką, todėl visada žinome, kur yra eilutės pabaiga. Šiame straipsnyje apžvelgsime keletą funkcijų, skirtų darbui su eilutėmis, pavyzdžiui, jūs - nukopijuokite, sujunkite, gaukite eilutės ilgį.

Kas yra stygos?

Atkreipkite dėmesį, kad kartu su C stiliaus eilutėmis, kurios iš esmės yra paprasti masyvai, yra ir eilučių literalai, tokie kaip šis "literalas" . Tiesą sakant, ir eilutės, ir literalai yra tiesiog simbolių rinkiniai, esantys greta kompiuterio atmintyje. Tačiau vis dar yra skirtumas tarp masyvų ir literalų: literalų pakeisti negalima, o eilučių galima.

Bet kuri funkcija, kuri paima C stiliaus eilutę, taip pat gali būti parašyta kaip parametras. Taip pat yra keletas C elementų, kurie gali atrodyti kaip eilutės, nors iš tikrųjų taip nėra. Aš dabar kalbu apie simbolius, jie yra įterpti į pavienes kabutes, čia yra pavyzdys - "a", kaip matote, tai nėra eilutė. Simbolis tam tikroje vietoje gali būti priskirtas eilutei, tačiau simboliai negali būti apdorojami kaip eilutė. Jei prisimenate, masyvai veikia kaip rodyklės, taigi, jei į eilutę įvesite vieną simbolį, tai bus laikoma klaida.

Iš to, kas išdėstyta pirmiau, turėjote suprasti, kad eilutės yra simbolių masyvai, o eilučių literalai yra žodžiai, apsupti dvigubomis kabutėmis. Štai dar vienas pažodinio žodžio pavyzdys:

"Tai yra statinė eilutė"

Ar pamiršote apie stygų specifiką, kuri buvo paminėta kiek aukščiau? Taigi, C eilutės visada turi baigtis nuliniu simboliu, pažodžiui „\0“. Todėl, norėdami paskelbti eilutę, susidedančią iš 49 raidžių, turite rezervuoti papildomą langelį nuliniam simboliui:

Char myString;

Kaip matote iš pavyzdžio, masyvo ilgis yra 50 simbolių, iš kurių 49 bus eilutė ir vienas, paskutinis bus nulinis simbolis. Svarbu atsiminti, kad C eilučių pabaigoje visada turi būti nulinis simbolis, kaip ir kiekvieno sakinio pabaigoje yra taškas. Nors išvedant eilutę nulinis simbolis nerodomas, jis vis tiek užima vietos atmintyje. Taigi techniškai penkiasdešimties elementų masyve galėtumėte saugoti tik 49 raides, nes norint užbaigti eilutę reikalingas paskutinis simbolis. Be to, rodyklės taip pat gali būti naudojamos kaip eilutė. Jei perskaitėte straipsnį apie , galite padaryti kažką panašaus:

Char *myString; // char tipo rodyklė myString = malloc(sizeof(*myString) * 64); // atminties paskirstymas

Šiame pavyzdyje mes skyrėme 64 atminties vietas myString masyvei. Norėdami atlaisvinti atminties, naudokite funkciją free().

Nemokama(myString);

Stygų naudojimas

Stygos yra naudingos, kai reikia atlikti įvairias operacijas su tekstine informacija. Pavyzdžiui, jei norite, kad vartotojas įvestų pavadinimą į programą, turėtumėte naudoti eilutę. Funkcijos scanf() naudojimas eilutei įvesti veikia, bet gali sukelti buferio perpildymą. Galų gale, įvesties eilutė gali būti didesnė nei buferinės eilutės dydis. Yra keletas būdų, kaip išspręsti šią problemą, tačiau paprasčiausias būdas yra naudoti , kuris yra nurodytas antraštės faile .

Skaitydamas vartotojo įvestį, jis skaitys visus simbolius, išskyrus paskutinį. Po to skaitymo eilutės pabaigoje bus dedamas nulinis terminatorius. Fgets() funkcija skaitys simbolius, kol vartotojas paspaus Enter. Pažiūrėkime, kaip naudoti fgets ():

#įtraukti int main() ( char myString; // long string printf("Įveskite ilgą eilutę: "); fgets(myString, 100, stdin); // nuskaitykite eilutę iš įvesties srauto printf("Įvedėte šią eilutę: %s", myString); getchar (); )

Pirmasis fgets() parametras yra eilutė, antrasis parametras yra eilutės dydis, o trečiasis parametras yra įvesties duomenų srauto rodyklė.

Programos rezultatas:

<ВВОД>...

Kaip matote, iš programos išvesties į įvesties eilutę pateko naujos eilutės simbolis - "\n". Taip atsitiko, nes fgets() įskaičiavo Enter mygtuko paspaudimą į eilutę myString ir baigė savo darbą. Tai reiškia, kad jums gali tekti rankiniu būdu pašalinti naujos eilutės simbolį. Vienas iš būdų tai padaryti yra surašymas po simbolio. Pakeiskime programą ir pašalinkime naujos eilutės simbolį:

#įtraukti int main() ( char myString; // long string printf("Įveskite ilgą eilutę: "); fgets(myString, 100, stdin); // nuskaitykite eilutę iš įvesties srauto int i; for (i = 0; i< 100; i++) { if (myString[i] == "\n") { myString[i] = "\0"; break; } } printf("Вы ввели следующую строку: %s", myString); getchar(); }

Atminkite, kad jei įvesties eilutėje yra mažiau nei 100 simbolių, į eilutę taip pat bus įtrauktas naujos eilutės simbolis. Todėl šį simbolį galime pašalinti naudodami paprastą brutalią jėgą. Prie programos pridėjome kilpą, kurioje perjungiame eilutės simbolius, 12-19 eilutės. Ir kai susiduriame su naujos eilutės simboliu, pakeičiame jį nuliniu simboliu, 16 eilutė. Programos rezultatas:

Įveskite ilgą eilutę: Likimas palieka savo pėdsaką Įvedėte šią eilutę: Likimas palieka savo pėdsaką Norėdami uždaryti šį langą, spustelėkite<ВВОД>...

Tai kol kas viskas. Kitame straipsnyje papasakosiu apie specialias darbo su stygomis funkcijas.

P.S.: Visi mėgstame žiūrėti įvairius vaizdo įrašus, tačiau kartais nutinka taip, kad ne visada pavyksta paleisti kai kuriuos vaizdo failų formatus. Taigi, šią problemą galite išspręsti naudodami programą - xilisoft converter ultimate. Galite lengvai greitai konvertuoti vaizdo įrašus iš vieno formato į kitą. Be to, ši programa taip pat gali konvertuoti garso failus ir animuotus vaizdus.

Šiuolaikinis C++ standartas apibrėžia klasę su funkcijomis ir savybėmis (kintamaisiais), skirtomis darbui su eilutėmis organizuoti (klasikinėje C kalboje eilučių nėra, yra tik simbolių masyvai):

#įtraukti

#įtraukti

#įtraukti

Norėdami dirbti su eilutėmis, taip pat turite prijungti standartinę vardų erdvę:

Vardų erdvės naudojimas std;

Kitu atveju turėsite visur nurodyti std::string klasės deskriptorių, o ne eilutę .

Žemiau pateikiamas programos, veikiančios su eilute, pavyzdys (neveikia senesniuose su C suderinamuose kompiliatoriuose!):

#įtraukti #įtraukti #įtraukti naudojant vardų sritį std; int main() ( string s = "Test"; s.insert(1,"!"); cout<< s.c_str() << endl; string *s2 = new string("Hello"); s2->trinti(s2->pabaiga()); cout<< s2->c_str(); cin.get(); grąžinti 0; )

Pagrindinės stygų klasės savybės:

• inicijavimas naudojant simbolių masyvą (įtaisytasis eilutės tipas) arba kitu objektu, kurio tipas yra eilutė . Integruotas tipas neturi antrosios galimybės;
• kopijuoti vieną eilutę į kitą. Integruotam tipui turite naudoti strcpy() funkciją;
• prieiga prie atskirų eilutės simbolių skaitymui ir rašymui. Integruotame masyve tai atliekama naudojant indekso operaciją arba netiesioginį adresavimą naudojant žymeklį;
• lyginant dvi lygybės eilutes. Integruotam tipui naudojamos strcmp() šeimos funkcijos;
• dviejų eilučių sujungimas (sujungimas), sukuriant rezultatą arba kaip trečią eilutę, arba vietoj vienos iš pirminių. Integruotam tipui naudojama strcat() funkcija, tačiau norint gauti rezultatą naujoje eilutėje, reikia nuosekliai naudoti funkcijas strcpy() ir strcat(), taip pat pasirūpinti atminties paskirstymu;
• įmontuotos eilutės ilgio nustatymo priemonės (klasės nario funkcijos size() ir l ength()). Vienintelis būdas sužinoti įtaisytosios tipo eilutės ilgį yra ją apskaičiuoti naudojant strlen() funkciją;
• galimybė sužinoti, ar eilutė tuščia.

Pažvelkime į šias pagrindines savybes išsamiau.

Stygų inicijavimas aprašant ir stygos ilgis(neįskaitant baigiamojo nulinio terminatoriaus):

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

Eilutė taip pat gali būti tuščia:

Styga st2;

Norėdami tai patikrinti ar eilutė tuščia, galite palyginti jo ilgį su 0:

Jei (! st.size()) // tuščias

arba naudokite tuščią () metodą, kuris grąžina teisingą tuščią eilutę ir false, jei eilutė nėra tuščia:

If (st.empty()) // tuščias

Trečioji eilutės kūrimo forma inicijuoja eilutės tipo objektą su kitu to paties tipo objektu:

Styga st3(st);

Eilutė st3 inicijuojama su eilute st . Kaip galime tai užtikrinti linijos sutampa? Naudokime palyginimo operatorių (==):

If (st == st3) // inicijavimas veikė

Kaip nukopijuokite vieną eilutę į kitą? Naudojant įprastą priskyrimo operatorių:

St2 = st3; // nukopijuokite st3 į st2

Dėl stygų sujungimas naudojamas sudėjimo operatorius (+) arba pridėjimo plius priskyrimo operatorius (+=). Pateikiame dvi eilutes:

Styga s1("labas, "); string s2("pasaulis\n");

Mes galime gauti trečią eilutę, sudarytą iš pirmųjų dviejų sujungimo, tokiu būdu:

Styga s3 = s1 + s2;

Jei norime pridėti s2 prie s1 pabaigos, turėtume parašyti:

S1 += s2;

Sudėjimo operacija gali sujungti klasės objektus styga ne tik tarpusavyje, bet ir su įmontuotomis tipo stygomis. Aukščiau pateiktą pavyzdį galite perrašyti taip, kad specialieji simboliai ir skyrybos ženklai būtų vaizduojami integruotu char * tipu, o reikšmingi žodžiai – klasės eilutės objektai:

Const char *pc = ", "; eilutė s1 ("labas"); string s2("pasaulis"); eilutė s3 = s1 + pc + s2 + "\n"; cout<< endl << s3;

Tokios išraiškos veikia, nes kompiliatorius „žino“, kaip automatiškai konvertuoti integruoto tipo objektus į eilučių klasės objektus. Taip pat galima tiesiog priskirti įmontuotą eilutę eilutės objektui:

Styga s1; const char *pc = "simbolių masyvas"; s1 = kompiuteris; // Teisingai

Šiuo atveju atvirkštinė transformacija neveikia. Bandant atlikti toliau pateiktą integruoto tipo eilutės inicijavimą, sukels kompiliavimo klaida:

Char * str = s1; // kompiliavimo klaida

Norėdami atlikti šią konversiją, turite aiškiai iškviesti nario funkciją, vadinamą c_str() ("C eilutė"):

Const char *str = s1.c_str();

Funkcija c_str() grąžina žymeklį į simbolių masyvą, kuriame yra eilutės objekto eilutė, kaip ji atrodytų įtaisytajame eilutės tipe. Raktinis žodis const užkerta kelią „pavojingai“ galimybei šiuolaikinėje vaizdinėje aplinkoje tiesiogiai keisti objekto turinį naudojant žymeklį.

KAM atskiri personažai Objektą, kurio tipas yra eilutė, kaip ir įtaisytąjį tipą, galima pasiekti naudojant indekso operaciją. Pavyzdžiui, čia yra kodo dalis, kuri visus taškus pakeičia apatiniais brūkšniais:

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

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

Tiesa, čia naudojamas ne eilučių klasės pakeitimo metodas, o to paties pavadinimo algoritmas:

#įtraukti

Kadangi eilutės objektas elgiasi kaip konteineris, jam gali būti taikomi kiti algoritmai. Tai leidžia išspręsti problemas, kurių tiesiogiai neišsprendžia eilutės klasės funkcijos.

Žemiau yra trumpas pagrindinių stygų klasės operatorių ir funkcijų aprašymas, nuorodos lentelėje veda į aprašymus rusų kalba internete. Išsamesnį eilučių klasės galimybių sąrašą galima rasti, pavyzdžiui, Vikipedijoje arba svetainėje cplusplus.com.