Çfarë kuptohet në gjuhën C me vargje. Operatorët e klasës së vargut

Standardi modern C ++ përcakton një klasë me funksione dhe veti (ndryshore) për organizimin e punës me vargje (në gjuhën klasike C nuk ka vargje si të tilla, ka vetëm vargje char):

#përfshi

#përfshi

#përfshi

Për të punuar me vargjet, duhet gjithashtu të lidhni hapësirën standarde të emrave:

Përdorimi i hapësirës së emrave std;

Përndryshe, do të duhet të specifikoni përshkruesin e klasës std :: string në vend të vargut kudo.

Më poshtë është një shembull i një programi që funksionon me varg (nuk funksionon në përpiluesit e vjetër të përputhshëm me C!):

#përfshi #përfshi #përfshi duke përdorur hapësirën e emrave std; int main () (string s = "Test"; s.insert (1, "!"); cout<< s.c_str() << endl; string *s2 = new string("Hello"); s2->fshij (s2-> fund ()); cout<< s2->c_str (); cin.get (); kthimi 0; )

Karakteristikat kryesore të klasës së vargjeve:

• inicializimi me një grup karakteresh (një varg i tipit të integruar) ose një objekt tjetër të tipit varg. Lloji i integruar nuk ka opsionin e dytë;
• kopjimi i një rreshti në tjetrin. Për një lloj të integruar, duhet të përdorni funksionin strcpy ();
• qasje në karaktere individuale të vargut për lexim dhe shkrim. Në një grup të integruar, kjo bëhet duke përdorur funksionin e marrjes së indeksit ose adresimit indirekt duke përdorur një tregues;
• krahasimi i dy vargjeve për barazi. Për llojet e integruara, përdoren funksionet e familjes strcmp ();
• bashkim (lidhje) i dy vargjeve, duke dhënë rezultatin ose si varg i tretë, ose në vend të njërit prej atyre origjinale. Për një lloj të integruar, përdoret funksioni strcat (), por për të marrë rezultatin në një linjë të re, duhet të përdorni në mënyrë sekuenciale funksionet strcpy () dhe strcat (), dhe gjithashtu të kujdeseni për shpërndarjen e kujtesës;
• mjete të integruara për përcaktimin e gjatësisë së një vargu (funksionet e anëtarit të madhësisë së klasës () dhe gjatësisë l ()). Ju mund ta zbuloni gjatësinë e një vargu të një lloji të integruar vetëm duke llogaritur duke përdorur funksionin strlen ();
• aftësia për të gjetur nëse një varg është bosh.

Le t'i hedhim një vështrim më të afërt këtyre veçorive themelore.

Inicializimi i vargjeve kur përshkruani dhe gjatësia e linjës(duke mos përfshirë terminatorin null përfundimtar):

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

Vargu mund të jepet dhe të zbrazet:

String st2;

Për të kontrolluar nëse a është rreshti bosh, mund ta krahasoni gjatësinë e tij me 0:

Nëse (! St.size ()) // bosh

ose përdorni metodën e zbrazët (), duke e kthyer true për një varg bosh dhe false për një varg jo bosh:

Nëse (st.zbrazët ()) // bosh

Forma e tretë e krijimit të vargut inicializon një objekt të tipit string me një objekt tjetër të të njëjtit lloj:

String st3 (st);

Vargu st3 inicializohet me vargun st. Si mund të sigurohemi që këto vargjet përputhen? Le të përdorim operatorin e krahasimit (==):

Nëse (st == st3) // inicializimi funksionoi

Si kopjoni një rresht në tjetrin? Me operacionin e zakonshëm të caktimit:

St2 = st3; // kopjoni st3 në st2

Për lidhja e vargut përdorni veprimin e mbledhjes (+) ose operacionin e caktimit të mbledhjes (+ =). Le të jepen dy rreshta:

Vargu s1 ("përshëndetje"); vargu s2 ("bota \ n");

Mund të marrim rreshtin e tretë, i përbërë nga lidhja e dy të parave, si kjo:

Vargu s3 = s1 + s2;

Nëse duam të shtojmë s2 në fund të s1, duhet të shkruajmë:

S1 + = s2;

Operacioni i mbledhjes mund të bashkojë objektet e klasës varg jo vetëm mes tyre, por edhe me vargje të tipit të integruar. Ju mund ta rishkruani shembullin e mësipërm në mënyrë që karakteret speciale dhe shenjat e pikësimit të përfaqësohen nga lloji i integruar char * dhe fjalët domethënëse të përfaqësohen nga objektet e vargut:

Const char * pc = ","; vargu s1 ("përshëndetje"); vargu s2 ("bota"); vargu s3 = s1 + pc + s2 + "\ n"; cout<< endl << s3;

Shprehje si këto funksionojnë sepse përpiluesi "e di" se si të konvertojë automatikisht objektet e tipit të integruar në objekte të klasës së vargut. Një caktim i thjeshtë i një vargu inline në një objekt vargu është gjithashtu i mundur:

Vargu s1; const char * pc = "një grup karakteresh"; s1 = pc; // djathtas

Në këtë rast, transformimi i kundërt nuk punon... Përpjekja për të bërë inicializimin e mëposhtëm të një vargu të tipit të integruar do të shkaktojë një gabim përpilimi:

Char * str = s1; // gabim përpilimi

Për të kryer këtë konvertim, duhet të thërrisni në mënyrë eksplicite funksionin e anëtarit c_str () ("varg C"):

Const char * str = s1.c_str ();

Funksioni c_str () kthen një tregues në një grup karakteresh që përmban vargun e objektit të vargut siç do të ishte në një lloj vargu të integruar. Fjala kyçe const këtu parandalon "të rrezikshmen" në mjediset moderne vizuale mundësinë e modifikimit të drejtpërdrejtë të përmbajtjes së një objekti përmes një treguesi.

TE personazhe individuale një objekt i tipit string, si një tip i integruar, mund të aksesohet duke përdorur funksionin e marrjes së indeksit. Për shembull, këtu është një copë kodi që zëvendëson të gjitha pikat me nënvizat:

String str ("www.disney.com"); madhësia int = str.madhësia (); për (int i = 0; i< size; i++) if (str[i] == ".") str[ i ] = "_"; cout << str;

Replace (rr.fillim (), str.fund (), ".", "_");

Vërtetë, nuk përdoret metoda e zëvendësimit të klasës së vargut, por algoritmi me të njëjtin emër:

#përfshi

Për shkak se objekti i vargut sillet si një enë, algoritme të tjera mund të aplikohen në të. Kjo ju lejon të zgjidhni probleme që nuk zgjidhen drejtpërdrejt nga funksionet e klasës së vargut.

Më poshtë është një përshkrim i shkurtër i operatorëve dhe funksioneve kryesore të klasës së vargjeve, lidhjet në tabelë çojnë në përshkrime në gjuhën ruse në internet. Për një listë më të plotë të aftësive të klasës së vargjeve, shihni, për shembull, Wikipedia ose cplusplus.com.

Vargjet. Linjat I/O. I/O i formatuar. Përpunimi i vargjeve duke përdorur funksionet standarde C. Puna me memorie.

1.1. Deklarimi dhe inicializimi i vargjeve.

Një varg është një grup karakteresh që përfundon me karakterin bosh '\ 0'. Vargu deklarohet si një grup karakteresh të rregullt, për shembull

char s1; // varg i gjatë nëntë karaktere

char * s2; // tregues për vargun

Dallimi midis s1 dhe s2 është se s1 është një konstante e emërtuar dhe s2 është një ndryshore.

Konstantet e vargut janë të mbyllura në thonjëza të dyfishta, në krahasim me karakteret që janë të mbyllura në thonjëza të vetme. Për shembull,

"Ky është një varg."

Gjatësia e një konstante vargu nuk mund të kalojë 509 karaktere sipas standardit. Megjithatë, shumë zbatime lejojnë vargje më të gjata.

Gjatë inicializimit të vargjeve, është më mirë të mos specifikoni dimensionin e vargut; përpiluesi do ta bëjë këtë duke llogaritur gjatësinë e vargut dhe duke shtuar një në të. Për shembull,

char s1 = "Ky është një varg.";

Në gjuhën e programimit C, ka një numër të madh funksionesh për të punuar me vargje, prototipet e të cilave përshkruhen në skedarët e kokës stdlib.h dhe string.h. Puna me këto funksione do të diskutohet në paragrafët e mëposhtëm.

1.2. Linjat I/O.

Për të futur një varg nga tastiera, përdorni funksionin

char * merr (char * str);

i cili shkruan një varg në str dhe kthen adresën e vargut të futur. Funksioni ndalon hyrjen kur ndeshet me karakterin '\ n' ose EOF (fundi i skedarit). Karakteri i linjës së re nuk kopjohet. Një bajt zero vendoset në fund të rreshtit të leximit. Në rast të suksesit, funksioni kthen një tregues në vargun e lexuar, dhe në rast dështimi, NULL.

Për të nxjerrë një linjë në tastierë, përdorni funksionin standard

int puts (const char * s);

i cili kthen një numër jo negativ për suksesin dhe EOF në dështim.

Prototipet e funksionit merr dhe vendos përshkruhen në skedarin e kokës stdio.h.

#përfshi

printf ("Vargu i hyrjes:");

1.3. I/O i formatuar.

Për futjen e të dhënave të formatuara nga tastiera, përdorni funksionin

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

i cili, nëse është i suksesshëm, kthen numrin e njësive të të dhënave të lexuara, dhe nëse jo, kthen EOF. Parametri i formatit duhet të tregojë në një varg të formatuar që përmban specifikimet e formateve hyrëse. Numri dhe llojet e argumenteve që ndjekin vargun e formatit duhet të përputhen me numrin dhe llojet e formateve hyrëse të specifikuara në vargun e formatit. Nëse ky kusht nuk plotësohet, atëherë rezultati i funksionit është i paparashikueshëm.

Hapësira, karakteret "\ t" ose "\ n" në vargun e formatit përshkruajnë një ose më shumë karaktere boshe në rrjedhën hyrëse, të cilat përfshijnë karaktere: hapësirë, '\ t', '\ n', '\ v', '\ f'. Funksioni i skanimit kapërcen karakteret bosh në rrjedhën e hyrjes.

Karakteret literale në vargun e formatit, me përjashtim të karakterit %, kërkojnë saktësisht të njëjtat karaktere që të shfaqen në rrjedhën hyrëse. Nëse nuk ka një karakter të tillë, atëherë scanf ndalon hyrjen. Funksioni scanf kapërcen karakteret fjalë për fjalë.

Në përgjithësi, specifikimi i formatit të hyrjes është:

Lloji % [*] [width] [modifikuesit]

Karakteri '*' tregon kapërcimin kur futet në një fushë të përcaktuar nga ky specifikim;

- "gjerësia" përcakton numrin maksimal të karaktereve të futura sipas këtij specifikimi;

Lloji mund të marrë vlerat e mëposhtme:

c - grup karakteresh,

s - varg karakteresh, vargjet ndahen me karaktere bosh,

d - numër i plotë i nënshkruar në 10 s / s,

i është një numër i plotë i nënshkruar, sistemi i numrave varet nga dy shifrat e para,

u - numër i plotë i panënshkruar në 10 s/s,

o - numër i plotë i panënshkruar në 8 s/s,

x, X - numër i plotë i panënshkruar në 16 s / s,

e, E, f, g, G - numër lundrues,

p është një tregues për një tregues,

n është një tregues për një numër të plotë,

[...] - grup karakteresh të skanuar, për shembull,.

Në rastin e fundit, vetëm karakteret e mbyllura në kllapa katrore do të futen nga rrjedha e hyrjes. Nëse karakteri i parë brenda kllapave katrore është '^', atëherë futen vetëm ato karaktere që nuk janë në grup. Gama e karaktereve në grup specifikohet duke përdorur simbolin '-'. Kur futni karaktere, futen edhe boshllëqet kryesore dhe bajt-i null përfundimtar i vargut.

Modifikuesit mund të marrin vlerat e mëposhtme:

h - numër i plotë i shkurtër,

l, L - numër i plotë i gjatë ose notues,

dhe përdoren vetëm për numra të plotë ose notues.

Shembulli i mëposhtëm tregon rastet e përdorimit për funksionin scanf. Vini re se ka një hapësirë ​​përpara specifikuesit të formatit, duke filluar me hyrjen e numrit lundrues.

#përfshi

printf ("Fut një numër të plotë:");

scanf ("% d", & n);

printf ("Fut një double:");

scanf ("% lf", & d);

printf ("Fut një char:");

scanf ("% c", & c);

printf ("Fut një varg:");

scanf ("% s", & s);

Vini re se në këtë program inicializohet numri i pikës lundruese. Kjo bëhet në mënyrë që përpiluesi të përfshijë bibliotekën për të mbështetur punën me numrat lundrues. Dështimi për ta bërë këtë do të rezultojë në një gabim në kohën e ekzekutimit kur futni një numër lundrues.

Për dalje të formatuar në tastierë, përdorni funksionin

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

i cili, nëse është i suksesshëm, kthen numrin e njësive të daljes së të dhënave, dhe nëse jo, kthen EOF. Parametri i formatit është një varg i formatuar që përmban specifikime për formatet e daljes. Numri dhe llojet e argumenteve që ndjekin vargun e formatit duhet të përputhen me numrin dhe llojet e specifikimeve të formatit të daljes të dhëna në vargun e formatit. Në përgjithësi, specifikimi i formatit të daljes është:

% [flamujt] [gjerësia] [. saktësi] [modifikuesit] lloji

- "flamujt" janë simbole të ndryshme që specifikojnë formatin e daljes;

- "gjerësia" përcakton numrin minimal të karaktereve të shfaqura sipas këtij specifikimi;

- '.precision' përcakton numrin maksimal të karaktereve që do të shfaqen;

- 'modifikuesit' specifikojnë llojin e argumenteve;

- 'lloji' përcakton llojin e argumentit.

Numrat e plotë të nënshkruar dalin në formatin e mëposhtëm:

% [-] [+ | hapësirë] [gjerësia] [l] d

- - shtrirje në të majtë, si parazgjedhje - në të djathtë;

+ - shfaqet shenja '+', vini re se për numrat negativë shfaqet gjithmonë shenja '-';

'Hapësirë' - një hapësirë ​​shfaqet në pozicionin e karakterit;

d - lloji i të dhënave int.

Formati i mëposhtëm i daljes përdoret për të nxjerrë numra të plotë të panënshkruar:

% [-] [#] [gjerësia] [l]

# - fillestari 0 shfaqet për numrat në 8 c / s, ose fillestari 0x ose 0X për numrat në 16 c / s,

l - modifikues i llojit të të dhënave të gjata;

u - numër i plotë në 10c / s,

o - numër i plotë në 8 s / s,

x, X është një numër i plotë prej 16 s / s.

Për numrat me pikë lundruese, përdoret formati i mëposhtëm i daljes:

% [-] [+ | hapësirë] [gjerësia] [. saktësi]

"precision" tregon numrin e shifrave pas pikës dhjetore për formatet f, e dhe E, ose numrin e shifrave domethënëse për formatet g dhe G. Numrat janë të rrumbullakosura. Parazgjedhja është gjashtë shifra dhjetore;

f - numri i pikës fikse,

e - një numër në formë eksponenciale, eksponenti shënohet me shkronjën "e",

E - një numër në formë eksponenciale, eksponenti shënohet me shkronjën "E",

g - më i shkurtri nga formatet f ose g,

G është më i shkurtri nga formatet f ose 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);

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

1.4. Formatimi i vargjeve.

Ekzistojnë variante të funksioneve scanf dhe printf për formatimin e vargjeve dhe quhen përkatësisht sscanf dhe sprintf.

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

lexon të dhënat nga vargu i specifikuar nga parametri str sipas vargut të formatit të specifikuar nga parametri i formatit. Rikthen sasinë e të dhënave të lexuara për suksesin dhe EOF për dështimin. Për shembull,

#përfshi

char str = "a 10 1.2 String Nuk ka hyrje";

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

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

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

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

printf ("% s \ n", s); // printime: Varg

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

formaton vargun sipas formatit të specifikuar nga parametri i formatit dhe e shkruan rezultatin në buferin e grupit të karaktereve. Funksioni kthen numrin e karaktereve të shkruara në buferin e grupit të karaktereve, duke përjashtuar bajtin null përfundimtar. Për shembull,

#përfshi

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

char s = "Ky është një varg.";

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

printf ("% s \ n", buffer); // printon: c = c, n = 10, d = 1.200000, s = Ky është një varg

1.5. Konvertimi i vargjeve në të dhëna numerike.

Prototipet e funksioneve për konvertimin e vargjeve në të dhëna numerike jepen në skedarin e kokës stdlib.h, i cili duhet të përfshihet në program.

Për të kthyer një varg në një numër të plotë, përdorni funksionin

int atoi (const char * str);

char * str = “-123”;

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

Për të kthyer një varg në një numër të plotë të gjatë, përdorni funksionin

gjatë int atolit (const char * str);

i cili, nëse është i suksesshëm, kthen një numër të plotë në të cilin është konvertuar vargu str, dhe nëse 0 dështon, për shembull,

char * str = “-123”;

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

Për të kthyer një varg në një të dyfishtë, përdorni funksionin

atof i dyfishtë (const char * str);

i cili, nëse është i suksesshëm, kthen një numër lundrues të tipit double, në të cilin është konvertuar vargu str, dhe nëse 0 dështon, për shembull,

char * str = “-123,321”;

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

Funksionet e mëposhtme kryejnë veprime të ngjashme me funksionet atoi, atol, atof, por ofrojnë veçori më të avancuara.

gjatë int strtol (konst char * str, char ** endptr, bazë int);

konverton vargun str në një int të gjatë, të cilin e kthen. Parametrat e këtij funksioni kanë kuptimin e mëposhtëm.

Nëse baza është 0, atëherë konvertimi varet nga dy karakteret e para të str:

Nëse karakteri i parë është një shifër nga 1 në 9, atëherë supozohet se numri përfaqësohet në 10 s / s;

Nëse karakteri i parë është një shifër 0 dhe e dyta është një shifër nga 1 në 7, atëherë supozohet se numri përfaqësohet në 8 c / s;

Nëse karakteri i parë është 0 dhe i dyti është "X" ose "x", supozohet se numri përfaqësohet në 16 c / s.

Nëse baza është një numër midis 2 dhe 36, atëherë kjo vlerë merret si bazë e bazës dhe çdo karakter jashtë kësaj baze ndalon konvertimin. Baza 11 deri në 36 përdor karakteret 'A' në 'Z' ose 'a' në 'z' për të paraqitur numrat.

Argumenti endptr vendoset nga funksioni strtol. Kjo vlerë përmban një tregues për karakterin që ndaloi konvertimin e str. Nëse është i suksesshëm, funksioni strtol kthen numrin e konvertuar dhe nëse dështon, kthen 0. Për shembull,

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

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

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

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

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

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

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

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

i panënshkruar i gjatë int strtol (const char * str, char ** endptr, int bazë);

funksionon në mënyrë të ngjashme me strtol, por konverton paraqitjen e karaktereve të një numri në një int të gjatë të panënshkruar.

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

konverton paraqitjen e karaktereve të një numri në një dyfish.

Të gjitha funksionet e renditura në këtë paragraf ndalojnë punën e tyre kur ndeshen me karakterin e parë që nuk i përshtatet formatit të numrit në fjalë.

Përveç kësaj, nëse vlera e karakterit të një numri tejkalon diapazonin e vlerave të vlefshme për llojin përkatës të të dhënave, atëherë funksionet atof, strtol, strtoul, strtod vendosin vlerën e ndryshores errno në ERANGE. Ndryshorja errno dhe konstanta ERANGE përcaktohen në skedarin e kokës math.h. Në këtë rast, funksionet atof dhe strtod kthejnë vlerën HUGE_VAL, funksioni strtol kthen vlerën LONG_MAX ose LONG_MIN dhe funksioni strtoul kthen vlerën ULONG_MAX.

Funksionet jo standarde itoa, ltoa, utoa, ecvt, fcvt dhe gcvt mund të përdoren për të kthyer të dhënat numerike në vargje karakteresh. Por është më mirë të përdorni funksionin standard sprintf për këto qëllime.

1.6. Funksionet standarde për të punuar me vargje.

Ky seksion përshkruan funksionet për të punuar me vargje, prototipet e të cilave përshkruhen në vargun e skedarit të kokës.h.

1. Krahasimi i vargjeve. Funksionet strcmp dhe strncmp përdoren për të krahasuar vargjet.

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

krahason leksikografikisht str1, str2 dhe kthen –1, 0, ose 1 nëse str1 është, përkatësisht, më e vogël, e barabartë me, ose më e madhe se str2.

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

Krahason leksikografikisht më së shumti n karaktere të para nga str1 dhe str2. Funksioni kthen -1, 0 ose 1 nëse n karakteret e para nga vargu str1 janë përkatësisht më të vogla, të barabarta ose më të mëdha se n karakteret e para nga vargu str2.

// shembull i krahasimit të vargjeve

#përfshi

#përfshi

char str1 = "aa bb";

char str2 = "aa aa";

char str3 = "aa bb cc";

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

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

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

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

2. Linjat e kopjimit. Funksionet strcpy dhe strncpy përdoren për të kopjuar vargjet.

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

kopjon vargun str2 në vargun str1. I gjithë vargu str2 kopjohet, duke përfshirë bajtin null fundor. Funksioni kthen një tregues në str1. Nëse linjat mbivendosen, rezultati është i paparashikueshëm.

char * strncpy (char * str1, const char * str2, madhësia_t n);

kopjon n karaktere nga vargu str2 në vargun str1. Nëse vargu str2 përmban më pak se n karaktere, atëherë bajti i fundit null kopjohet aq herë sa nevojitet për të zgjeruar vargun str2 në n karaktere. Funksioni kthen një tregues në vargun str1.

char str2 = "Kopjo vargun.";

strcpy (str1, str2);

printf (str1); // printime: Kopjo vargun.

4. Lidhja e vargjeve. Funksionet strcat dhe strncat përdoren për të lidhur vargjet në një varg.

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

shton vargun str2 në vargun str1, me bajtin null përfundimtar të vargut str1 të fshirë. Funksioni kthen një tregues në vargun str1.

char * strncat (char * str1, const char * str2, madhësia_t n);

shton n karaktere nga vargu str2 në vargun str1 dhe bajt-i null përfundimtar i vargut str1 fshihet. Funksioni kthen një tregues në vargun str1. nëse gjatësia e vargut str2 është më e vogël se n, atëherë bashkohen vetëm karakteret e përfshira në vargun str2. Pas bashkimit të vargjeve, një bajt zero i shtohet gjithmonë str1. Funksioni kthen një tregues në vargun str1.

#përfshi

#përfshi

char str1 = "String";

char str2 = "catenation";

char str3 = "Po Jo";

strcat (str1, str2);

printf ("% s \ n", str1); // printime: Katenacioni i vargut

strncat (str1, str3, 3);

printf ("% s \ n", str1); // printime: Katenacioni i vargut Po

5. Kërkoni për një karakter në një varg. Funksionet strchr, strrchr, strspn, strcspn dhe strpbrk përdoren për të kërkuar një karakter në një varg.

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

kërkon shfaqjen e parë të karakterit të specifikuar nga parametri c në vargun str. Në rast të suksesit, funksioni kthen një tregues në karakterin e parë të gjetur dhe në rast dështimi, NULL.

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

kërkon shfaqjen e fundit të karakterit të specifikuar nga parametri c në vargun str. Nëse është i suksesshëm, funksioni kthen një tregues në karakterin e fundit të gjetur, dhe nëse nuk ka sukses, ai kthen NULL.

#përfshi

#përfshi

char str = "Kërkimi i karaktereve";

printf ("% s \ n", strchr (str, "r")); // printime: r kërkim

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

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

kthen indeksin e karakterit të parë nga vargu str1 që nuk është në vargun str2.

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

kthen indeksin e karakterit të parë nga vargu str1 që shkon në vargun str2.

char str = "123 abc";

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

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

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

gjen karakterin e parë në vargun str1 që është i barabartë me një nga karakteret në vargun str2. Në rast të suksesit, funksioni kthen një tregues në këtë karakter, dhe në rast dështimi, NULL.

char str = "123 abc";

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

6. Krahasimi i vargjeve. Funksioni strstr përdoret për të krahasuar vargjet.

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

gjen shfaqjen e parë të vargut str2 (pa bajt të pavlefshëm pasues) në vargun str1. Në rast të suksesit, funksioni kthen një tregues në nënvargun e gjetur, dhe në rast dështimi, NULL. Nëse treguesi str1 tregon një varg me gjatësi zero, funksioni kthen treguesin str1.

char str = "123 abc 456;

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

7. Parimi i vargut në shenja. Funksioni strtok përdoret për të analizuar një varg në shenja.

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

kthen një tregues në shenjën (fjalën) tjetër në vargun str1, në të cilin shenjat kufizohen me karaktere nga vargu str2. Nëse leksema mbarojnë, funksioni kthen NULL. Në thirrjen e parë në funksionin strtok, parametri str1 duhet të tregojë një varg që analizohet në token, dhe në thirrjet pasuese, ky parametër duhet të vendoset në NULL. Pas gjetjes së tokenit, funksioni strtok shkruan një bajt zero pas këtij tokeni në vend të ndarësit.

#përfshi

#përfshi

char str = "12 34 ab cd";

p = strtok (rr, "");

printf ("% s \ n", p); // printon në një kolonë vlerat: 12 34 ab cd

p = strtok (NULL, "");

8. Përcaktimi i gjatësisë së vargut. Funksioni strlen përdoret për të përcaktuar gjatësinë e një vargu.

madhësia_t strlen (konst char * str);

kthen gjatësinë e vargut, duke përjashtuar bajtin e fundit null. Për shembull,

char str = "123";

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

1.7. Funksionet për të punuar me kujtesën.

Skedari i kokës string.h përshkruan gjithashtu funksione për të punuar me blloqe memorie, të cilat janë të ngjashme me funksionet përkatëse për punën me vargjet.

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

kërkon shfaqjen e parë të karakterit të specifikuar nga parametri c në n bajt të str.

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

krahason n bajtin e parë të str1 dhe str2.

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

kopjon n bajtin e parë nga vargu str1 në vargun str2.

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

kopjon n bajtin e parë nga vargu str1 në vargun str2, duke siguruar që vargjet e mbivendosura të trajtohen në mënyrë korrekte.

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

kopjon karakterin e specifikuar nga parametri c në n bajtin e parë të str.

--- C # Manual --- Strings

Për sa i përket programimit të rregullt, vargu lloji i të dhënave të vargutështë një nga më të rëndësishmet në C #. Ky lloj përcakton dhe mbështet vargjet e karaktereve. Në një numër të gjuhëve të tjera programimi, një varg është një grup karakteresh. Dhe në C #, vargjet janë objekte. Prandaj, lloji i vargut është një lloj referimi.

Ndërtimi i vargjeve

Mënyra më e lehtë për të ndërtuar një varg karakteresh është përdorimi i një vargu literal. Për shembull, linja e mëposhtme e kodit cakton variablin e referencës së vargut str në referencën literale të vargut:

String str = "Starg mostër";

Në këtë rast, ndryshorja str inicializohet me sekuencën e karaktereve "Shargu Shembull". Ju gjithashtu mund të krijoni një objekt të tipit varg nga një grup i tipit char. Për shembull:

Char chararray = ("e", "x", "a", "m", "p", "l", "e"); string str = varg i ri (chararray);

Pasi të krijohet një objekt i tipit string, ai mund të përdoret kudo ku kërkohet një varg teksti i cituar.

Qëndrueshmëria e vargut

Mjaft e çuditshme, përmbajtja e një objekti të tipit string nuk mund të ndryshohet. Kjo do të thotë që pasi të krijohet, sekuenca e karaktereve nuk mund të ndryshohet. Por ky kufizim kontribuon në një zbatim më efikas të vargjeve të karaktereve. Prandaj, ky, në shikim të parë, disavantazh i dukshëm në fakt kthehet në një avantazh. Pra, nëse kërkohet një varg si variacion i një vargu ekzistues, atëherë për këtë qëllim duhet të krijohet një varg i ri që përmban të gjitha ndryshimet e nevojshme. Dhe meqenëse objektet e vargjeve të papërdorura grumbullohen automatikisht mbeturina, as nuk duhet të shqetësoheni për fatin e vargjeve të panevojshme.

Sidoqoftë, duhet theksuar se referencat e vargut të variablave (d.m.th., objektet e tipit string) janë subjekt ndryshimi dhe për këtë arsye ato mund t'i referohen një objekti tjetër. Por përmbajtja e vetë objektit të vargut nuk ndryshon pas krijimit të tij.

Le të shqyrtojmë një shembull:

Void statik addNewString () (string s = "Kjo është goditja ime"; s = "Kjo është goditje e re";)

Le të përpilojmë aplikacionin dhe të ngarkojmë asamblenë që rezulton në programin ildasm.exe. Figura tregon kodin CIL që do të gjenerohet për metodën void addNewString ():

Vini re se ka thirrje të shumta në kodin optik ldstr (ngarkesa e linjës). Ky kod optik CIL ldstr udhëzon të ngarkojë një objekt të ri vargu në grumbullin e menaxhuar. Si rezultat, objekti i mëparshëm që përmbante vlerën "This is my stroke" përfundimisht do të mblidhet mbeturina.

Puna me vargje

Në klasë Sistemi.String ofrohet një grup metodash për përcaktimin e gjatësisë së të dhënave të karaktereve, gjetjen e një nënvargu në vargun aktual, konvertimin e karaktereve nga shkronja të mëdha në të vogla dhe anasjelltas, etj. Ne do ta shikojmë këtë klasë në më shumë detaje në vijim.

Fusha e vargut, Indeksuesi dhe Vetia

Klasa String ka një fushë të vetme të përcaktuar:

String publik statik vetëm për lexim Bosh;

Fusha Empty tregon një varg bosh, d.m.th. një varg që nuk përmban karaktere. Kjo është në kontrast me një referencë boshe të vargut, e cila thjesht i bëhet një objekti joekzistent.

Përveç kësaj, klasa String përcakton një indeksues të vetëm vetëm për lexim:

Shënoni publikisht këtë (merrni;)

Ky indeksues ju lejon të merrni karakterin në indeksin e specifikuar. Indeksimi i vargjeve, si vargjet, fillon me zero. Objektet e vargut janë të qëndrueshëm dhe të pandryshueshëm, kështu që ka kuptim që klasa String të mbështesë një indeksues vetëm për lexim.

Më në fund, klasa String përcakton një veti të vetme vetëm për lexim:

Gjatësia e inteve publike (merr;)

Vetia Length kthen numrin e karaktereve në një varg. Shembulli i mëposhtëm tregon përdorimin e një indeksuesi dhe vetisë Length:

Përdorimi i Sistemit; Klasa Shembull (static void Main () (string str = "String Simple"; // Merrni gjatësinë e vargut dhe karakterin e 6-të në varg duke përdorur indeksuesin Console.WriteLine ("Gjatësia e vargut është (0), karakteri i 6-të është" (1) "" , str.Gjatësia, str);))

Operatorët e klasës së vargut

Klasa String mbingarkon dy operatorët e mëposhtëm: == dhe! =. Operatori == përdoret për të testuar dy vargje karakteresh për barazi. Kur operatori == aplikohet në referencat e objekteve, ai zakonisht kontrollon për të parë nëse të dy referencat janë bërë në të njëjtin objekt. Dhe kur operatori == zbatohet për referencat e objekteve të tipit String, atëherë përmbajtja e vetë vargjeve krahasohet për barazi. E njëjta gjë vlen edhe për operatorin!=. Kur zbatohet për referenca për objektet e tipit String, përmbajtja e vargjeve në vetvete krahasohet për pabarazi. Në të njëjtën kohë, operatorë të tjerë relacionalë, duke përfshirë =, krahasojnë referencat me objektet e tipit String në të njëjtën mënyrë si me objektet e llojeve të tjera. Dhe për të kontrolluar nëse një varg është më i madh se tjetri, duhet të thërrisni metodën Krahasoni (), e cila përcaktohet në klasën String.

Siç do të bëhet e qartë, shumë krahasime të vargjeve të karaktereve përdorin informacion kulturor. Por kjo nuk vlen për operatorët == dhe! =. Në fund të fundit, ata thjesht krahasojnë vlerat rendore të karaktereve në vargje. (Me fjalë të tjera, ata krahasojnë vlerat binare të karaktereve që nuk janë modifikuar kulturalisht, d.m.th., të kulturuara.) Prandaj, këta operatorë kryejnë krahasime të vargjeve në një mënyrë të pandjeshme ndaj rasteve dhe kulturës.

Metodat e klasës së vargut

Tabela e mëposhtme rendit disa nga metodat më interesante të kësaj klase, të grupuara sipas qëllimit:

Shembulli i mëposhtëm i programit përdor disa nga metodat e mësipërme:

Përdorimi i Sistemit; duke përdorur System.Collections.Generic; duke përdorur System.Linq; duke përdorur System.Text; namespace ConsoleApplication1 (programi i klasës (programi statik i zbrazët (kryesore e vargut) (// Krahasoni dy rreshtat e parë string s1 = "ky është një varg"; vargu s2 = "ky është tekst dhe ky është një varg"; nëse (String. CompareOrdinal (s1, s2) ! = 0) Console.WriteLine ("Strings s1 dhe s2 nuk janë të barabarta"); nëse (String.Compare (s1, 0, s2, 13, 10, true) == 0) Console.WriteLine ("Për më tepër, ata kanë të njëjtin tekst "); // Lidhja e vargjeve Console.WriteLine (String.Concat (" \ n "+" Një, dy "," tre, katër ")); // Kërko në një varg // Shfaqja e parë e një nënvargu if (s2. IndexOf ("this")! = -1) Console.WriteLine ("Fjala \" this \ "u gjet në rresht, është" + "në: (0) pozicion" , s2.IndexOf ("this")); / / Ndodhja e fundit e nënvargut if (s2.LastIndexOf ("this")! = -1) Console.WriteLine ("Ndodhja e fundit e fjalës \" kjo \ "është " + "në (0) pozicion", s2.LastIndexOf ("this" )); // Kërko nga një grup karakteresh char myCh = ("Y", "x", "t"); nëse (s2.IndexOfAny (myCh)! = -1) Console.WriteLine ("Një nga karakteret nga grupi ch "+" i gjetur në aktual rreshti në pozicionin (0) ", s2.IndexOfAny (myCh)); // Përcaktoni nëse vargu fillon me një nënvarg të caktuar if (s2.StartsWith ("ky është tekst") == true) Console.WriteLine ("Substring u gjet!"); // Përcaktoni nëse vargu përmban një nënvarg // duke përdorur shembullin e përcaktimit të vargut të OS të përdoruesit myOS = Environment.OSVersion.ToString (); if (myOS.Contains ("NT 5.1")) Console.WriteLine ("Sistemi juaj operativ është Windows XP"); else if (myOS.Contains ("NT 6.1")) Console.WriteLine ("Sistemi juaj operativ Windows 7"); Console.ReadLine (); )))

Pak për krahasimin e vargjeve në C #

Nga të gjitha operacionet e përpunimit të vargut të karaktereve, ka të ngjarë që një varg të krahasohet me një tjetër. Para se të shqyrtojmë ndonjë metodë për krahasimin e vargjeve, duhet theksuar sa vijon: krahasimet e vargjeve mund të kryhen në .NET Framework në dy mënyra kryesore:

Së pari, krahasimi mund të pasqyrojë zakonet dhe normat e një mjedisi të caktuar kulturor, të cilat shpesh janë mjedise kulturore që hyjnë në fuqi kur programi ekzekutohet. Kjo është sjellje standarde për disa, por jo të gjitha, metodat e krahasimit.

Dhe së dyti, krahasimi mund të bëhet pavarësisht nga cilësimet e mjedisit kulturor vetëm nga vlerat rendore të personazheve që përbëjnë vargun. Në përgjithësi, krahasimet e vargjeve të neglizhuara kulturalisht përdorin rend leksikografik (dhe konsiderata gjuhësore) për të përcaktuar nëse një varg është më i madh, më i vogël ose i barabartë me një varg tjetër. Në një krahasim rendor, vargjet thjesht renditen bazuar në vlerën e pandryshuar të çdo karakteri.

Për shkak të metodave të ndryshme të krahasimit kulturor dhe rendor për krahasimet e vargjeve dhe implikimeve të secilit krahasim të tillë, rekomandohet fuqimisht që të ndiqni praktikat më të mira të ofruara aktualisht nga Microsoft. Në fund të fundit, zgjedhja e mënyrës së gabuar për të krahasuar vargjet mund të çojë në funksionim të gabuar të programit kur përdoret në një mjedis që ndryshon nga ai në të cilin është zhvilluar.

Zgjedhja se si të krahasohen vargjet e karaktereve është një vendim shumë i rëndësishëm. Si rregull i përgjithshëm dhe pa përjashtim, krahasimi i vargjeve kulturalisht i përshtatshëm duhet të zgjidhet nëse është për qëllimin e shfaqjes së rezultatit te përdoruesi (për shembull, për të shfaqur një seri vargjesh të renditura sipas rendit leksikografik). Megjithatë, nëse vargjet përmbajnë informacion fiks që nuk është menduar të modifikohet për të përshtatur dallimet kulturore, të tilla si një emër skedari, fjalë kyçe, adresë uebsajti ose vlerë sigurie, atëherë duhet të zgjidhni një krahasim rendor të vargut. Sigurisht, specifikat e një aplikacioni të caktuar që po zhvillohet do të diktojnë zgjedhjen e një mënyre të përshtatshme për të krahasuar vargjet e karaktereve.

Klasa String ofron një shumëllojshmëri metodash të krahasimit të vargjeve, të cilat janë renditur në tabelën e mësipërme. Më e gjithanshme prej tyre është metoda Krahaso (). Ju lejon të krahasoni dy vargje tërësisht ose pjesërisht, të ndjeshme ndaj shkronjave të vogla ose të pandjeshme, mënyra e krahasimit të përcaktuar nga parametri i tipit Krahasimi i vargjeve si dhe informacioni i kulturës i dhënë me një parametër tipi CultureInfo.

Mbingarkesat e Compare () që nuk përmbajnë një parametër të tipit StringComparison kryejnë një krahasim të ndjeshëm ndaj shkronjave dhe kulturës të vargjeve të karaktereve. Dhe në ato variante të mbingarkuar që nuk përmbajnë një parametër të llojit CultureInfo, informacioni i kulturës përcaktohet nga koha aktuale e ekzekutimit.

Lloji StringComparison është një numërim që përcakton vlerat e paraqitura në tabelën më poshtë. Duke përdorur këto vlera, ju mund të organizoni krahasime të vargjeve për t'iu përshtatur nevojave të aplikacionit tuaj të veçantë. Prandaj, shtimi i një parametri të tipit StringComparison zgjeron metodën Compare () dhe metoda të tjera krahasimi si Equals (). Gjithashtu bën të mundur që të tregohet pa mëdyshje se si supozohet të krahasohen vargjet.

Për shkak të dallimeve midis krahasimeve të vargjeve të ndjeshme ndaj kulturës dhe krahasimeve rendore, është shumë e rëndësishme të jemi sa më të saktë në këtë drejtim.

Në secilin rast, metoda Compare () kthen një vlerë negative nëse vargu i parë që krahasohet është më i vogël se i dyti; vlerë pozitive nëse vargu i parë i krahasuar është më i madh se i dyti; dhe në fund zero nëse të dy vargjet që krahasohen janë të barabartë. Megjithëse metoda Compare () kthen zero nëse vargjet që krahasohen janë të barabarta, në përgjithësi është më mirë të përdoret metoda Equals () ose operatori == për të përcaktuar nëse vargjet e karaktereve janë të barabarta.

Çështja është se metoda Compare () përcakton barazinë e vargjeve të krahasuara bazuar në renditjen e tyre. Për shembull, nëse po i krahasoni vargjet në një mënyrë të ndjeshme ndaj kulturës, atëherë të dy vargjet mund të jenë të njëjta sipas renditjes së tyre, por jo në thelb të barabartë. Si parazgjedhje, barazia e vargut përcaktohet në metodën Equals () bazuar në vlerat rendore të karaktereve dhe është kulturalisht e pandjeshme. Prandaj, si parazgjedhje, të dy vargjet krahasohen në këtë metodë për barazi absolute, karakter pas karakteri, ashtu si në operatorin ==.

Megjithëse metoda Compare () është më e gjithanshme, është më e lehtë të përdoret metoda CompareOrdinal () për krahasime të thjeshta rendore të vargjeve të karaktereve. Së fundi, mbani në mend se metoda CompareTo () krahason vetëm vargjet e kulturës.

Programi i mëposhtëm demonstron përdorimin e metodave Compare (), Equals (), CompareOrdinal () dhe operatorëve == dhe! = për të krahasuar vargjet e karaktereve. Vini re se dy shembujt e parë të krahasimit ilustrojnë ndryshimin midis krahasimeve të vargjeve me ndjeshmëri kulturore dhe krahasimeve rendore në anglisht:

Përdorimi i Sistemit; Klasa Shembull (zbrazëti statike kryesore () (string str1 = "alfa"; vargu str2 = "Alfa"; vargu str3 = "Beta"; vargu str4 = "alfa"; vargu str5 = "alfa, beta"; rezultati int; / / Së pari, demonstroni ndryshimin midis krahasimit të vargjeve të ndjeshme ndaj kulturës dhe rezultatit të krahasimit rendor = String.Compare (str1, str2, StringComparison.CurrentCulture); Console.Write ("Krahasimi i vargjeve të ndjeshme ndaj kulturës:"); nëse (rezultati 0 ) Konsola .WriteLine (str1 + "më e madhe se" + str2); tjetër Console.WriteLine (str1 + "e barabartë me" + str2); rezultat = String.Compare (str1, str2, StringComparison.Ordinal); Console.Write ("Krahasimi rendor rreshtat: "); nëse (rezultati 0) Console.WriteLine (str1 +" më i madh se "+ str2); tjetër Console.WriteLine (str1 +" i barabartë me "+ str4); // Përdorni metodën CompareOrdinal () rezultat = String .CompareOrdinal ( str1, str2); Console.Write ("Krahaso vargjet duke përdorur metodën CompareOrdinal (): \ n"); nëse (rezultati 0) Console.WriteLine (str1 + "më shumë" + str2); tjetër Console.WriteLine ( rr 1 + "e barabartë" + str4); Console.WriteLine (); // Përcaktoni barazinë e vargjeve duke përdorur operatorin == // Ky është një krahasim rendor i vargjeve të karaktereve nëse (str1 == str4) Console.WriteLine (str1 + "==" + str4); // Përcaktoni pabarazinë e vargut duke përdorur operatorin = If (str1! = Str3) Console.WriteLine (str1 + "! =" + Str3); if (str1! = str2) Console.WriteLine (str1 + "! =" + str2); Console.WriteLine (); // Kryeni një krahasim rendor të vargjeve pa ndjeshmëri ndaj shkronjave // ​​duke përdorur metodën Equals () if (String.Equals (str1, str2, StringComparison.OrdinalIgnoreCase)) Console.WriteLine ("Krahasimi i vargjeve duke përdorur metodën Equals () me" + "Parametri OrdinalIgnoreCase: \ n "+ str1 +" është i barabartë me "+ str2); Console.WriteLine (); // Krahasoni pjesët e vargjeve nëse (String.Compare (str2, 0, str5, 0, 3, StringComparison.CurrentCulture)> 0) (Console.WriteLine ("Krahaso vargjet bazuar në kulturën aktuale:" + "\ n3 karakteret e para i rreshtit "+ str2 +" është më i madh se 3 karakteret e para të vargut "+ str5);)))

Ekzekutimi i këtij programi prodhon rezultatin e mëposhtëm: