itthon / Tanács/ Számítástechnikai szakdolgozatok, laboratóriumi dolgozatok és oklevelek.

Számítástechnikai szakdolgozatok, laboratóriumi dolgozatok és diplomák.

Munka húrokkal. Vonós osztály. Osztálykonstruktorok. A hozzárendelés (), hozzáfűzés (), beszúrás (), csere (), törlés (), keresés (), rfind (), összehasonlítás (), c_str () függvények. Példák

1. Mi a célja a karakterlánc osztálynak a C ++ programokban?

A karakterlánc-osztályt úgy tervezték, hogy működjön a char * típusú karakterláncokkal, amelyek null-végződésű karakterláncok. A vonós osztályt úgy vezették be Alternatív lehetőség char * típusú karakterláncokkal való munkához. Karakterrel végződő sorok ‘\0’ más néven C-stringek. Mivel a string egy osztály, deklarálhatja ennek az osztálynak az objektumait.

2. Milyen modulokat (könyvtárakat) kell csatlakoztatni ahhoz, hogy az MS Visual Studio C ++-ban használhassuk a karakterlánc-osztály képességeit?

A karakterlánc-osztály képességeinek használatához az MS Visual Studio (C ++) programban, bele kell foglalnia a könyvtárat és az std névteret.

#beleértve névtér használata std;

3. Hogyan történik egy karakterlánc típusú változó deklarálása? Példák

A string típusú változó deklarálása ugyanúgy történik, mint egy normál változóé. Lehetséges változat egyidejű inicializálási deklarációk.

// string típusú string s1; // karakterlánc típusú s1 nevű változó string s2 = "Ez egy karakterlánc-változó"; // deklaráció inicializálással // string típusú változó használatával hozzárendelési operátorral s1 = s2; // s1 = "Ez egy karakterlánc változó" s2 = "Új szöveg";

4. Milyen előnyei és hátrányai vannak a karakterlánc-osztály használatának a char *-hoz képest?

Az új karakterlánctípus létrehozását a karakterláncokkal való munka hiányosságai okozták, amit a char * típus mutatott be. A char * típushoz képest a karakterlánc típusnak a következő fő előnyei vannak:

a karakterláncok feldolgozásának képessége szabványos C ++ operátorokkal ( = , + , = = , <> stb.). Mint tudod, a char * típus használatakor a legegyszerűbb karakterláncokkal végzett műveletek is bonyolultnak tűntek, és túlzott írást igényeltek. programkód;
a programkód legjobb megbízhatóságának (biztonságának) biztosítása. Például karakterláncok másolásakor a karakterlánctípus megfelelő műveleteket biztosít, amelyek akkor fordulhatnak elő, ha a forrás karakterlánc nagyobb, mint a cél karakterlánc;
egy karakterláncot biztosít független adattípusként. A karakterlánc típus karakterláncként való deklarálása a program összes változója esetében azonos, ami biztosítja az adatok konzisztenciáját.

A karakterlánc típus fő hátránya a char * típushoz képest a lassabb adatfeldolgozási sebesség. Ez azért van, mert a karakterlánc típus valójában egy konténerosztály. Az osztállyal való munkavégzés pedig a programkód további implementációját igényli, ami viszont több időt vesz igénybe.

5. Milyen operátorok használhatók a string osztály objektumaihoz?

A karakterlánc-osztály kényelmes, mivel lehetővé teszi a karakterláncok kényelmes kezelését szabványos (túlterhelt) operátorok használatával.

A következő operátorok használhatók a string osztály objektumaival

= - feladat
+ - összefűzés (sztring összefűzés)
+= - hozzárendelés összefűzéssel
== - egyenlőség
!= - egyenlőtlenség
< - kisebb
<= - kisebb vagy egyenlő
> - több
>= - több vagy egyenlő
- indexelés

Példa, amely bemutatja a fenti operátorok használatát

// karakterlánc típusa, műveletek karakterláncokkal string s1 = "s-1"; string s2 = "s-2"; string s3; bool b; // művelet "=" (karakterláncok hozzárendelése) s3 = s1; // s3 = "s-1" // művelet "+" - karakterlánc összefűzése s3 = s3 + s2; // s3 = "s-1s-2" // művelet "+ =" - hozzárendelés összefűzéssel s3 = "s-3"; s3 + = "abc"; // s3 = "s-3abc" // művelet "==" - karakterlánc összehasonlítás b = s2 = = s1; // b = hamis b = s2 == "s-2"; // b = igaz // művelet "! =" - karakterlánc-összehasonlítás (nem egyenlő) s1 = "s1"; s2 = "s2"; b = s1 = s2; // b = igaz // tevékenységek "<" и ">"- karakterlánc összehasonlítás s1 = "abcd"; s2 = "de"; b = s1>s2; // b = hamis b = s1< s2; // b = true // tevékenységek "<=" и ">= "- karakterlánc-összehasonlítás (kisebb vagy egyenlő, nagyobb vagy egyenlő) s1 = "abcd"; s2 = "ab"; b = s1> = s2; // b = igaz b = s1<= s2; // b = false b = s2 >= "ab"; // b = igaz // művelet - indexelés char c; s1 = "abcd"; c = s1; // c = "c" c = s1; // c = "a"

6. Tartalmaz-e a string osztály konstruktorokat?

Mint minden osztálynak, a karakterlánc osztálynak is számos konstruktora van. A főbbek a következők:

Húr (); karakterlánc (const char * str); string (const string & str);

7. Példák konstruktorokkal történő inicializálásra

Az alábbiakban példákat láthatunk a string típusú változók inicializálására

String s1 ("Helló!"); string s2 = "Helló!" ; // inicializálás - konstruktor karakterlánc (const char * str) char * ps = "Szia"; string s3 (ps); // inicializálási karakterlánc s4 (s3); // inicializálás - konstruktor karakterlánc (const string & str) string s5; // inicializálás - konstruktor karakterlánc ()

8. A karakterláncok hozzárendelése. () függvény hozzárendelése. Példák

Egy karakterlánc másikhoz rendeléséhez két módszer egyikét használhatja:

hozzárendelési operátor használata ‘=’ ;
használja az assign () függvényt a karakterlánc osztályból.

Az assign () függvénynek több túlterhelt megvalósítása van.

Az első lehetőség egy függvény meghívása paraméterek nélkül.

Karakterlánc és hozzárendelés (void);

Ebben az esetben az egyik karakterlánc egyszerű hozzárendelése a másikhoz.

A második lehetőség lehetővé teszi, hogy adott számú karaktert másoljon egy karakterláncból:

String & assign (const string & s, size_type st, size_type num);

s - az objektum, amelyből a forráskarakterlánc származik;
st - index (pozíció) a karakterláncban, ahonnan el kell kezdeni a num karakterek másolását;
szám - az st pozícióból másolandó karakterek száma;
A size_type egy sorszámú adattípus.

Az assign () függvény harmadik változata az s karakterlánc első num karaktereit másolja a hívóhoz:

String & assign (const char * s, size_type num);

s - karakterrel végződő karakterlánc ‘\0’ ;
A szám a hívó félhez másolt karakterek száma. Az s karakterlánc első num karakterei másolásra kerülnek.

Az alábbiakban egy példa látható a hozzárendelés () függvény különböző megvalósításaira.

Példa.

// karakterláncok hozzárendelése, függvény hozzárendelése () string s1 = "webhely"; string s2; string s3; char * ps = "webhely"; s3 = s1; // s3 = "hely" s2.assign (s1); // s2 = "hely" s2.assign (s1, 0, 4); // s2 = "legjobb" s2.assign (ps, 8); // s2 = "bestprog"

9. Karakterláncok összefűzése. Hozzáfűzés () függvény. Példa

Az append () függvény a karakterláncok összefűzésére szolgál. A műveletet sorok hozzáadására is használhatja ‘+’ , például:

String s1; string s2; s1 = "abc"; s2 = "def"; s1 = s1 + s2; // s1 = "abcdef"

Az append () függvény azonban jó, ha egy karakterlánc egy részét kell hozzáfűzni.

A funkciónak a következő megvalósítási lehetőségei vannak:

String & append (const string & s, size_type start); string & append (const char * s, size_type num);

Az első megvalósításban a függvény egy string objektumra mutató hivatkozást kap s amely hozzáadódik a hívóhoz. A második megvalósításban a függvény egy mutatót kap egy const char * karakterláncra, amely '\ 0' karakterrel végződik.

Példa. Az append () függvény bemutatása.

String s1 = "abcdef"; s2 = "1234567890"; hozzáfűz (s2, 3, 4); // s1 = "abcdef4567" char * ps = "1234567890"; s1 = "abcdef"; s1.hozzáfűzés (ps, 3); // s1 = "abcdef123"

10. Karakterek beszúrása egy sorba. () függvény beszúrása. Példa

Egy sor beszúrásához egy másik sor adott helyére a beszúrás () függvényt kell használni, amelynek több megvalósítási lehetősége is van.

A függvény első verziója lehetővé teszi, hogy a teljes s karakterláncot a hívó vonal (hívó objektum) adott kezdőpozíciójába illessze be:

String & insert (size_type start, const string & s);

A függvény második változata lehetővé teszi az s karakterlánc egy részének (insStart, num paraméterek) beszúrását a hívó karakterlánc adott kezdőpozíciójába:

String & insert (size_type start, const string & s, size_type insStart, size_type num);

A fenti funkciókban:

s - a hívó karakterláncba beillesztendő karakterlánc;
start - az a pozíció a hívósorban, ahonnan be kell szúrni az s karakterláncot;
insStart - az s karakterlánc pozíciója, ahonnan be kell szúrni;
A szám az insStart pozícióból beszúrandó karakterek száma az s karakterláncban.

string s1 = "abcdef"; string s2 = "1234567890"; s1.beszúrás (3, s2); // s1 = "abc" + "1234567890" + "def" = "abc1234567890def" s2.beszúrás (2, s1, 1, 3); // s2 = "12bcd34567890"

11. Karakterek cseréje egy karakterláncban. Csere () függvény. Példa

A helyettesítő () függvény lecseréli a karaktereket a hívó karakterláncban. A funkciónak a következő megvalósítási lehetőségei vannak:

Karakterlánc és csere (size_type start, size_type num, const string & s); karakterlánc és csere (size_type start, size_type num, const string & s, size_type replStart, size_type replNum);

Az első megvalósításban a hívó karakterláncot az s karakterláncra cseréljük. Lehetőség van a hívó sorban a pozíció (kezdet) és a karakterek számának (szám) beállítására, amelyet az s karakterláncra kell cserélni.

A helyettesítő () függvény második verziója abban különbözik az elsőtől, hogy lehetővé teszi, hogy a hívó karakterláncot az s karakterlánc egy részével cserélje le. Ebben az esetben kettő további paraméterek: a replStart pozíciója és a hívó karakterláncot helyettesítő részstringet alkotó s karakterek száma.

Példa. A helyettesítő () függvény bemutatása.

String s1 = "abcdef"; string s2 = "1234567890"; s2.replace (2, 4, s1); // s2 = "12abcdef7890" s2 = "1234567890"; s2.csere (3, 2, s1); // s2 = "123abcdef67890" s2 = "1234567890"; s2.replace (5, 1, s1); // s2 = "12345abcdef7890" // karakterek cseréje, csere () függvény string s1 = "abcdef"; string s2 = "1234567890"; s2.replace (2, 4, s1); // s2 = "12abcdef7890" s2 = "1234567890"; s2.csere (3, 2, s1); // s2 = "123abcdef67890" s2 = "1234567890"; s2.replace (5, 1, s1); // s2 = "12345abcdef7890" s2 = "1234567890"; s2.csere (5, 1, s1, 2, 3); // s2 = "12345cde7890" s2 = "1234567890"; s2.replace (4, 2, s1, 0, 4); // s2 = "1234abcd7890"

12. Eltávolítás adott összeget karakterek a karakterláncból. Törlés () függvény. Példa

Karakterek eltávolításához a hívó karakterláncból használja a törlés () funkciót:

String & erase (mérettípus index = 0, mérettípus szám = npos);

index - index (pozíció), amelytől kezdve el kívánja távolítani a karaktereket a hívó vonalból;
A szám az eltávolítandó karakterek száma.

Példa.

s karakterlánc = "01234567890"; s.erase (3, 5); // s = "012890" s = "01234567890"; s.erase (); // s = ""

13. Keressen egy karaktert egy karakterláncban. Find () és rfind () függvények. Példák

A string osztályban a karakterlánc keresése egy részkarakterláncban kétféleképpen történhet, amelyek a keresés irányában különböznek:

a karakterlánc elejétől a végéig történő megnézésével a find () függvény segítségével;
úgy, hogy a karakterláncot a végétől az elejéig az rfind () karakterlánccal pásztázza.

A find () függvény prototípusa így néz ki:

Méret_típus keresése (const string & s, size_type start = 0) const;

s - a karakterláncban keresett részkarakterlánc, ami okozza ezt a funkciót... A függvény az s karakterlánc első előfordulását keresi. Ha az adott függvényt meghívó karakterláncban található az s részkarakterlánc, akkor az első előfordulás helye kerül visszaadásra. Ellenkező esetben -1 kerül visszaadásra;

Az rfind () függvény prototípusa:

Size_type rfind (const string & s, size_type start = npos) const;

s az a karakterlánc, amelyet a hívó karakterláncban kell keresni. A karakterláncban lévő részkarakterlánc keresése a végétől az elejéig történik. Ha az s részkarakterlánc megtalálható a hívó karakterláncban, akkor a függvény az első előfordulás pozícióját adja vissza. Ellenkező esetben a függvény -1;
npos - a hívó vonal utolsó karakterének pozíciója;
start - az a pozíció, ahonnan a keresést végrehajtják.

1. példa Egy kódrészlet, amely bemutatja a find () függvény eredményét

// karakterlánc típusa, find () függvény string s1 = "01234567890"; string s2 = "345"; string s3 = "abcd"; int pos; pos = s1.find (s2); // poz = 3 poz = s1.find (s2, 1); // poz = 3 poz = s1.find ("jklmn", 0); // poz = -1 poz = s1.find (s3); // poz = -1 poz = s2.find (s1); // poz = -1

2. példa Az rfind () függvény bemutatása.

// karakterlánc típusa, függvények find () és rfind () string s1 = "01234567890"; string s2 = "345"; string s3 = "abcd"; string s4 = "abcd --- abcd"; int pos; pos = s1.rfind (s2); // poz = 3 poz = s1.rfind (s2, 12); // poz = 3 poz = s1.rfind (s2, 3); // poz = 3 poz = s1.rfind (s2, 2); // poz = -1 poz = s2.rfind (s1); // poz = -1 poz = s1.rfind (s3, 0); // poz = -1 // különbség a find () és az rfind () függvények között pos = s4.rfind (s3); // poz = 7 poz = s4.find (s3); // poz = 0

14. Húrok részeinek összehasonlítása. Összehasonlítás () függvény. Példa

Mivel a karakterlánc típusa egy osztály, a művelet segítségével összehasonlíthat két karakterláncot egymással ‘= =’ ... Ha a két karakterlánc azonos, akkor az összehasonlítás igaz lesz. Ellenkező esetben az összehasonlítás eredménye hamis lesz.

De ha össze kell hasonlítania az egyik karakterlánc egy részét egy másikkal, akkor ehhez az összehasonlítás () függvény szolgál.

Az összehasonlítás () függvény prototípusa:

int összehasonlítás (size_type start, size_type num, const string & s) const;

s - a hívó karakterlánccal összehasonlítandó karakterlánc;
start - pozíció (index) az s karakterláncban, ahonnan a karakterlánc karaktereinek megtekintését kezdjük összehasonlítás céljából;
A szám az s karakterláncban lévő karakterek száma, amelyeket össze kell hasonlítani a hívó karakterlánccal.

A funkció a következőképpen működik. Ha a hívó karakterlánc kisebb, mint s karakterlánc, akkor a függvény -1-et (negatív értéket) ad vissza. Ha a hívó karakterlánc nagyobb, mint s karakterlánc, a függvény 1-et (pozitív értéket) ad vissza. Ha a két karakterlánc egyenlő, a függvény 0-t ad vissza.

Példa... Az összehasonlító () függvény bemutatása:

// karakterlánc típusa, összehasonlítás () függvény string s1 = "012345"; string s2 = "0123456789"; int res; res = s1.hasonlítsd össze (s2); // res = -1 res = s1.hasonlítsa össze ("33333"); // res = -1 res = s1.compare ("012345"); // res = 0 res = s1.összehasonlítás ("345"); // res = -1 res = s1.hasonlítsd össze (0, 5, s2); // res = -1 res = s2.hasonlítsd össze (0, 5, s1); // res = -1 res = s1.hasonlítsa össze (0, 5, "012345"); // res = -1 res = s2.hasonlítsd össze (s1); // res = 1 res = s2.összehasonlítás ("456"); // res = -1 res = s2.compare ("000000"); // res = 1

15. '\ 0' (char *) sorvégi karaktert tartalmazó karakterlánc lekérése. C_str () függvény. Példa

Egy karakterrel végződő karakterláncot kapni ‘\0’ a c_str () függvényt használjuk.

Funkció prototípus:

const char * c_str () const;

A függvényt a const módosítóval deklaráljuk. Ez azt jelenti, hogy a függvény nem tudja módosítani a hívót (karakterláncot).

1. példa... Karakterlánc átalakítása const char *-ra.

// karakterlánc típusa, függvény c_str () string s = "abcdef"; const char * ps; ps = s.c_str (); // ps = "abcdef"

2. példa

Az alábbiakban bemutatjuk egy karakterlánc karakterláncból a System :: karakterláncba történő fordítását a címke típusú vezérlőben való megjelenítéséhez.

A modern C ++ szabvány függvényekkel és tulajdonságokkal (változókkal) rendelkező osztályt határoz meg a karakterláncokkal végzett munka szervezéséhez (a klasszikus C nyelvben nincsenek karakterláncok, csak char tömbök):

#beleértve

#beleértve
#beleértve

A karakterláncok kezeléséhez a szabványos névteret is csatlakoztatnia kell:

A névtér használata std;

Ellenkező esetben mindenhol meg kell adnia az std :: string osztályleírót a string helyett.

Az alábbiakban egy példa látható egy programra, amely sztringgel működik (régi C-kompatibilis fordítóprogramokban nem működik!):

#beleértve #beleértve #beleértve névtér használata std; int main () (string s = "Teszt"; s.insert (1, "!"); cout<< s.c_str() << endl; string *s2 = new string("Hello"); s2->törlés (s2-> vége ()); cout<< s2->c_str (); cin.get (); visszatérés 0; )

A húrosztály főbb jellemzői:

inicializálás karaktertömbbel (egy beépített karakterlánc) vagy egy másik, string típusú objektummal. A beépített típus nem rendelkezik a második lehetőséggel;
az egyik sor átmásolása a másikba. Beépített típushoz az strcpy () függvényt kell használni;
hozzáférés a karakterlánc egyes karaktereihez olvasáshoz és íráshoz. A beépített tömbben ez az index felvételének vagy indirekt címzésnek a műveletével történik mutató segítségével;
két karakterlánc összehasonlítása az egyenlőség érdekében. A beépített típusoknál az strcmp () család függvényei használatosak;
két karakterlánc összefűzése (összefűzése), amely vagy a harmadik karakterláncként adja meg az eredményt, vagy az eredeti karakterláncok egyike helyett. Beépített típus esetén azonban az strcat () függvényt használjuk az eredmény beolvasására új sor, szükség van az strcpy () és strcat () függvények egymás utáni használatára, és gondoskodni kell a memóriafoglalásról is;
beépített eszköz egy karakterlánc hosszának meghatározására (az osztályméret () és az l ength () tagfüggvényei). Egy beépített típusú karakterlánc hosszát csak az strlen () függvénnyel történő számítással tudod megtudni;
az a képesség, hogy megtudja, hogy egy karakterlánc üres-e.

Nézzük meg közelebbről ezeket az alapvető jellemzőket.

A karakterláncok inicializálása leírásánál és vonal hossza(kivéve a befejező null lezárót):

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

A karakterlánc lehet adott és üres:

String st2;

Annak ellenőrzésére, hogy vajon üres-e a sor, összehasonlíthatja a hosszát 0-val:

Ha (! St.size ()) // üres

vagy használja az üres () metódust, üres karakterlánc esetén igaz, nem üres karakterlánc esetén false értéket ad vissza:

If (st.empty ()) // üres

A karakterlánc létrehozásának harmadik formája egy string típusú objektumot inicializál egy másik, azonos típusú objektummal:

String st3 (st);

Az st3 karakterláncot az st karakterlánc inicializálja. Hogyan biztosíthatjuk, hogy ezek húrok egyeznek? Használjuk az összehasonlító operátort (==):

If (st == st3) // az inicializálás működött

Hogyan másolja át az egyik sort a másikba? A szokásos hozzárendelési művelettel:

St2 = st3; // st3 másolása st2-be

Mert karakterlánc összefűzése használja az összeadás műveletet (+) vagy az összeadás hozzárendelési műveletet (+ =). Legyen két sor megadva:

String s1 ("helló"); string s2 ("világ \ n");

A harmadik sort, amely az első kettő összefűzéséből áll, így kaphatjuk meg:

s3 karakterlánc = s1 + s2;

Ha s2-t szeretnénk hozzáadni az s1 végéhez, akkor ezt kell írnunk:

S1+=s2;

Az összeadás művelet osztályobjektumokat fűzhet össze húr nem csak egymás között, hanem beépített típusú karakterláncokkal is. A fenti példát átírhatja úgy, hogy a speciális karaktereket és írásjeleket a beépített char * típus, a jelentős szavakat pedig string objektumok jelölje:

Const char * pc = ","; string s1 ("hello"); string s2 ("világ"); string s3 = s1 + pc + s2 + "\ n"; cout<< endl << s3;

Az ilyen kifejezések azért működnek, mert a fordító "tudja", hogyan kell automatikusan átalakítani a beépített típusú objektumokat a string osztály objektumaivá. Egy soron belüli karakterlánc egyszerű hozzárendelése egy karakterlánc objektumhoz is lehetséges:

String s1; const char * pc = "karaktertömb"; s1 = pc; // jobb

Ebben az esetben az inverz transzformáció nem működik... Ha egy beépített karakterlánc következő inicializálására tesz kísérletet, az fordítási hibát okoz:

Char * str = s1; // fordítási hiba

Az átalakítás végrehajtásához kifejezetten meg kell hívnia a c_str () tagfüggvényt ("C string"):

Const char * str = s1.c_str ();

A c_str () függvény egy mutatót ad vissza egy karaktertömbre, amely a string objektum karakterláncát tartalmazza, ahogyan az egy beépített karakterlánc típusban lenne. A const kulcsszó itt megakadályozza a "veszélyes" modern vizuális környezetekben annak lehetőségét, hogy egy objektum tartalmát mutatón keresztül közvetlenül módosítsák.

NAK NEK egyéni karakterek egy string típusú objektum, mint egy beépített típus, az index felvétele művelettel érhető el. Például itt van egy kódrészlet, amely az összes pontot aláhúzásjelre cseréli:

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

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

Igaz, itt nem a string osztály csere metódusát használjuk, hanem az azonos nevű algoritmust: