Hem / Råd/ Terminsuppsatser, laborationer och examensbevis i datavetenskap.

Terminsuppsatser, laborationer och examensbevis i datavetenskap.

Arbeta med strängar. Strängklass. Klasskonstruktörer. Funktionerna tilldela (), lägga till (), infoga (), ersätta (), radera (), hitta (), rfind (), jämföra (), c_str (). Exempel på

1. Vad är syftet med strängklassen i C++-program?

Strängklassen är designad för att fungera med strängar av typen char *, som är nollterminerade strängar. Strängklassen introducerades som Alternativt alternativ för att arbeta med strängar av typen char *. Rader som slutar med ett tecken ‘\0’ även kallade C-strängar. Eftersom sträng är en klass kan du deklarera objekt av denna klass.

2. Vilka moduler (bibliotek) måste anslutas för att kunna använda strängklassens funktioner i MS Visual Studio C++?

För att använda funktionerna för strängklassen i MS Visual Studio (C ++) måste du inkludera biblioteket och standardnamnområdet.

#omfatta använder namnutrymme std;

3. Hur deklareras en variabel av typen sträng? Exempel på

Att deklarera en variabel av typen sträng görs på samma sätt som en vanlig variabel. Möjlig variant samtidiga initieringsdeklarationer.

// strängtyp sträng s1; // variabel med namnet s1 av typen sträng string s2 = "Detta är en strängvariabel"; // deklaration med initialisering // använder en variabel av typen sträng med en tilldelningsoperator sl = s2; // s1 = "Detta är en strängvariabel" s2 = "Ny text";

4. Vilka är fördelarna och nackdelarna med att använda strängklassen kontra char *?

Skapandet av den nya strängtypen berodde på bristerna med att arbeta med teckensträngar, vilket char *-typen visade. I jämförelse med char *-typen har strängtypen följande huvudsakliga fördelar:

förmågan att bearbeta strängar med standard C++ operatorer ( = , + , = = , <> etc.). Som du vet, när du använder char *-typen, såg även de enklaste operationerna med strängar komplicerade ut och krävde att skriva överdrivet programkod;
säkerställa den bästa tillförlitligheten (säkerheten) för programkoden. Till exempel, när du kopierar strängar, tillhandahåller strängtypen lämpliga åtgärder som kan inträffa om källsträngen är större än målsträngen;
tillhandahålla en sträng som en oberoende datatyp. Deklarationen av strängtypen som en sträng är densamma för alla variabler i programmet, vilket säkerställer datakonsistens.

Den största nackdelen med strängtypen i jämförelse med char *-typen är den långsammare databehandlingshastigheten. Detta beror på att strängtypen faktiskt är en containerklass. Och att arbeta med en klass kräver ytterligare implementering av programkoden, vilket i sin tur tar extra tid.

5. Vilka operatorer kan användas med objekt i strängklassen?

Strängklassen är bekväm genom att den låter dig enkelt manipulera strängar med standardoperatorer (överbelastade).

Följande operatorer kan användas med objekt av strängklassen

= - uppdrag
+ - sammanlänkning (strängsammansättning)
+= - uppdrag med sammanlänkning
== - jämlikhet
!= - ojämlikhet
< - mindre
<= - mindre än eller lika med
> - Mer
>= - mer eller lika
- indexering

Exempel, som visar användningen av ovanstående operatörer

// strängtyp, operationer på strängar sträng s1 = "s-1"; sträng s2 = "s-2"; sträng s3; bool b; // operation "=" (tilldelning av strängar) s3 = sl; // s3 = "s-1" // operation "+" - strängsammansättning s3 = s3 + s2; // s3 = "s-1s-2" // operation "+ =" - tilldelning med sammanlänkning s3 = "s-3"; s3 + = "abc"; // s3 = "s-3abc" // operation "==" - strängjämförelse b = s2 == sl; // b = falskt b = s2 == "s-2"; // b = sant // operation "! =" - strängjämförelse (inte lika) s1 = "s1"; s2 = "s2"; b = sl! = s2; // b = sant // operationer "<" и ">"- strängjämförelse s1 = "abcd"; s2 = "de"; b = s1 > s2; // b = falskt b = s1< s2; // b = true // operationer "<=" и ">= "- strängjämförelse (mindre än eller lika, större än eller lika) s1 = "abcd"; s2 = "ab"; b = sl> = s2; // b = sant b = s1<= s2; // b = false b = s2 >= "ab"; // b = sant // operation - indexering char c; s1 = "abcd"; c = si; // c = "c" c = s1; // c = "a"

6. Innehåller strängklassen konstruktorer?

Som alla klasser har strängklassen ett antal konstruktörer. De viktigaste är följande:

String (); sträng (konst char * str); sträng (const sträng & str);

7. Exempel på initiering med konstruktorer

Nedan finns exempel på initialisering av variabler av typen sträng

String s1 ("Hej!"); string s2 = "Hej!" ; // initiering - konstruktorsträng (const char * str) char * ps = "Hej"; sträng s3 (ps); // initialiseringssträng s4 (s3); // initiering - konstruktorsträng (const sträng & str) sträng s5; // initiering - konstruktorsträng ()

8. Tilldelning av strängar. Tilldela () funktion. Exempel på

För att tilldela en sträng till en annan kan du använda en av två metoder:

använd uppdragsoperatör ‘=’ ;
använd funktionen tilldela () från strängklassen.

Funktionen tilldela () har flera överbelastade implementeringar.

Det första alternativet är att anropa en funktion utan parametrar.

Sträng & tilldela (void);

I det här fallet finns det en enkel tilldelning av en sträng till en annan.

Det andra alternativet låter dig kopiera ett givet antal tecken från en sträng:

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

s - objektet från vilket källsträngen är hämtad;
st - index (position) i strängen för att börja kopiera antal tecken;
num - antalet tecken som ska kopieras från position st;
size_type är en ordningsdatatyp.

Den tredje varianten av funktionen tilldela () kopierar de första numeriska tecknen i strängen s till den som ringer:

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

s - en sträng som avslutas med ett tecken ‘\0’ ;
num är antalet tecken som kopieras till den som ringer. De första numeriska tecknen från strängen s kopieras.

Nedan är ett exempel med olika implementeringar av funktionen tilldela ().

Exempel.

// tilldelning av strängar, funktionstilldelning () sträng s1 = "webbplats"; sträng s2; sträng s3; char * ps = "webbplats"; s3 = sl; // s3 = "site" s2.assign (s1); // s2 = "site" s2.assign (s1, 0, 4); // s2 = "bästa" s2.assign (ps, 8); // s2 = "bästa program"

9. Sammanfogning av strängar. Lägg till () funktion. Exempel

Funktionen append () används för att sammanfoga strängar. Du kan också använda operationen för att lägga till rader ‘+’ , till exempel:

Sträng s1; sträng s2; s1 = "abc"; s2 = "def"; sl = sl + s2; // s1 = "abcdef"

Funktionen append () är dock bra när du behöver lägga till en del av en sträng.

Funktionen har följande implementeringsalternativ:

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

I den första implementeringen får funktionen en länk till ett strängobjekt s som läggs till den som ringer. I den andra implementeringen får funktionen en pekare till en const char *-sträng, som slutar med tecknet '\ 0'.

Exempel. Demonstration av append ()-funktionen.

String s1 = "abcdef"; s2 = "1234567890"; lägg till (s2, 3, 4); // s1 = "abcdef4567" char * ps = "1234567890"; s1 = "abcdef"; s1.append (ps, 3); // s1 = "abcdef123"

10. Infoga tecken på en rad. Infoga () funktion. Exempel

För att infoga en rad på en given position på en annan rad måste du använda funktionen infoga () som har flera alternativ för implementering.

Den första versionen av funktionen låter dig infoga hela strängen s vid den angivna startpositionen för den anropande raden (anropsobjektet):

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

Den andra versionen av funktionen låter dig infoga en del (insStart, num parametrar) av sträng s vid den angivna startpositionen för den anropande strängen:

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

I ovanstående funktioner:

s - strängen som ska infogas i den anropande strängen;
start - positionen i den anropande raden från vilken strängen s ska infogas;
insStart - positionen i strängen s som ska infogas från;
num är antalet tecken i strängen s som ska infogas från position insStart.

sträng s1 = "abcdef"; sträng s2 = "1234567890"; sl.insert (3, s2); // s1 = "abc" + "1234567890" + "def" = "abc1234567890def" s2.insert (2, sl, 1, 3); // s2 = "12bcd34567890"

11. Ersätta tecken i en sträng. Ersätt () funktion. Exempel

Funktionen replace () ersätter tecken i den anropande strängen. Funktionen har följande implementeringsalternativ:

String & replace (size_type start, size_type num, const string & s); sträng & ersätt (storlekstyp start, storlekstyp num, const sträng & s, storlekstyp replStart, storlekstyp replNum);

I den första implementeringen ersätts den anropande strängen med strängen s. Det är möjligt att ställa in positionen (start) och antalet tecken (num) i den anropande raden, som måste ersättas med strängen s.

Den andra versionen av funktionen ersätt () skiljer sig från den första genom att den låter dig ersätta den anropande strängen med endast en del av strängen s. I det här fallet två ytterligare parametrar: positionen för replStart och antalet tecken i strängen s som bildar delsträngen som ersätter den anropande strängen.

Exempel. Demonstration av funktionen ersätt () .

String s1 = "abcdef"; sträng s2 = "1234567890"; s2.ersätt (2, 4, s1); // s2 = "12abcdef7890" s2 = "1234567890"; s2.ersätt (3, 2, s1); // s2 = "123abcdef67890" s2 = "1234567890"; s2.ersätt (5, 1, s1); // s2 = "12345abcdef7890" // ersätt tecken, ersätt () funktion sträng s1 = "abcdef"; sträng s2 = "1234567890"; s2.ersätt (2, 4, s1); // s2 = "12abcdef7890" s2 = "1234567890"; s2.ersätt (3, 2, s1); // s2 = "123abcdef67890" s2 = "1234567890"; s2.ersätt (5, 1, s1); // s2 = "12345abcdef7890" s2 = "1234567890"; s2.ersätt (5, 1, s1, 2, 3); // s2 = "12345cde7890" s2 = "1234567890"; s2.ersätt (4, 2, s1, 0, 4); // s2 = "1234abcd7890"

12. Borttagning ett givet belopp tecken från strängen. Radera () funktion. Exempel

För att ta bort tecken från anropssträngen, använd radera ()-funktionen:

Sträng & radera (storlekstypindex = 0, storlekstyp num = npos);

index - index (position), från vilket du vill ta bort tecken i den anropande raden;
num är antalet tecken som ska tas bort.

Exempel.

String s = "01234567890"; s. radera (3, 5); // s = "012890" s = "01234567890"; s.radera (); // s = ""

13. Sök efter ett tecken i en sträng. Hitta () och rfind () funktioner. Exempel på

I strängklassen kan sökning efter en sträng i en delsträng göras på två sätt, som skiljer sig åt i sökningens riktning:

genom att titta på strängen från början till slut med funktionen find ();
genom att skanna strängen från slutet till början med rfind ().

Hitta ()-funktionsprototypen ser ut så här:

Size_type find (const string & s, size_type start = 0) const;

s - delsträngen som söks efter i strängen, vilket orsakar denna funktion... Funktionen söker efter den första förekomsten av strängen s. Om delsträngen s hittas i strängen som anropade den givna funktionen, returneras positionen för den första förekomsten. Annars returneras -1;

Prototypen för funktionen rfind () är:

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

s är delsträngen att leta efter i den anropande strängen. Sökning efter en delsträng i en sträng utförs från slutet till början. Om delsträngen s hittas i den anropande strängen, returnerar funktionen positionen för den första förekomsten. Annars returnerar funktionen -1;
npos - positionen för det sista tecknet i den anropande linjen;
start - positionen från vilken sökningen utförs.

Exempel 1. Ett kodavsnitt som visar resultatet av hitta ()-funktionen

// strängtyp, hitta () funktion sträng s1 = "01234567890"; sträng s2 = "345"; sträng s3 = "abcd"; int pos; pos = s1.find (s2); // pos = 3 pos = s1.find (s2, 1); // pos = 3 pos = s1.find ("jklmn", 0); // pos = -1 pos = s1.find (s3); // pos = -1 pos = s2.find (s1); // pos = -1

Exempel 2. Demonstration av funktionen rfind ().

// strängtyp, funktionerna hitta () och rfind () sträng s1 = "01234567890"; sträng s2 = "345"; sträng s3 = "abcd"; string s4 = "abcd --- abcd"; int pos; pos = s1.rfind (s2); // pos = 3 pos = s1.rfind (s2, 12); // pos = 3 pos = s1.rfind (s2, 3); // pos = 3 pos = s1.rfind (s2, 2); // pos = -1 pos = s2.rfind (s1); // pos = -1 pos = s1.rfind (s3, 0); // pos = -1 // skillnad mellan funktionerna find () och rfind (). pos = s4.rfind (s3); // pos = 7 pos = s4.find (s3); // pos = 0

14. Jämförelse av delar av strängar. Jämför () funktion. Exempel

Eftersom strängtypen är en klass kan du använda operationen för att jämföra två strängar med varandra ‘= =’ ... Om de två strängarna är samma, kommer jämförelsen att vara sann. Annars blir resultatet av jämförelsen falskt.

Men om du behöver jämföra en del av en sträng med en annan, finns funktionen compare () för detta.

Jämför () funktionsprototypen:

int compare (size_type start, size_type num, const string & s) const;

s - strängen att jämföra med den anropande strängen;
start - position (index) i sträng s, från vilken man kan börja titta på strängens tecken för jämförelse;
num är antalet tecken i strängen s att jämföra med den anropande strängen.

Funktionen fungerar enligt följande. Om den anropande strängen är mindre än strängen s, returnerar funktionen -1 (negativt värde). Om den anropande strängen är större än strängen s, returnerar funktionen 1 (positivt värde). Om de två strängarna är lika, returnerar funktionen 0.

Exempel... Demonstration av funktionen compare ():

// strängtyp, jämför () funktion sträng s1 = "012345"; sträng s2 = "0123456789"; int res; res = s1.jämför (s2); // res = -1 res = s1.compare ("33333"); // res = -1 res = s1.compare ("012345"); // res = 0 res = s1.compare ("345"); // res = -1 res = s1.compare (0, 5, s2); // res = -1 res = s2.compare (0, 5, s1); // res = -1 res = s1.compare (0, 5, "012345"); // res = -1 res = s2.compare (s1); // res = 1 res = s2.compare ("456"); // res = -1 res = s2.compare ("000000"); // res = 1

15. Få en sträng med radsluttecknet '\ 0' (char *). C_str () funktion. Exempel

För att få en sträng som slutar med ett tecken ‘\0’ funktionen c_str () används.

Funktionsprototyp:

const char * c_str () const;

Funktionen deklareras med const-modifieraren. Detta innebär att funktionen inte kan modifiera anroparen (strängen).

Exempel 1... Konvertera sträng till const char *.

// strängtyp, funktion c_str () sträng s = "abcdef"; const char * ps; ps = s.c_str (); // ps = "abcdef"

Exempel 2.

Följande visar översättningen av en sträng från sträng till System :: String-typen för att visa den i en kontroll av Label-typen.

Den moderna C++-standarden definierar en klass med funktioner och egenskaper (variabler) för att organisera arbete med strängar (i det klassiska C-språket finns inga strängar som sådana, det finns bara char-arrayer):

#omfatta

#omfatta
#omfatta

För att arbeta med strängar måste du också ansluta standardnamnområdet:

Använder namnutrymme std;

Annars måste du ange klassbeskrivningen std :: sträng istället för sträng överallt.

Nedan är ett exempel på ett program som fungerar med sträng (fungerar inte i gamla C-kompatibla kompilatorer!):

#omfatta #omfatta #omfatta använder namnutrymme std; int main () (sträng s = "Test"; s.insert (1, "!"); cout<< s.c_str() << endl; string *s2 = new string("Hello"); s2->radera (s2-> slut ()); cout<< s2->c_str (); cin.get (); returnera 0; )

Huvuddragen i strängklassen:

initiering med en uppsättning tecken (en sträng av inbyggd typ) eller ett annat objekt av typen sträng. Den inbyggda typen har inte det andra alternativet;
kopiera en rad till en annan. För en inbyggd typ måste du använda strcpy ()-funktionen;
tillgång till enskilda tecken i strängen för läsning och skrivning. I en inbyggd array görs detta med hjälp av operationen att ta indexet eller indirekt adressering med hjälp av en pekare;
jämförelse av två strängar för jämlikhet. För en inbyggd typ används funktioner i familjen strcmp ();
sammanlänkning (sammansättning) av två strängar, vilket ger resultatet antingen som den tredje strängen eller istället för en av de ursprungliga. För en inbyggd typ används funktionen strcat () dock för att få in resultatet ny linje, är det nödvändigt att sekventiellt använda funktionerna strcpy () och strcat () och även ta hand om minnesallokering;
inbyggda medel för att bestämma längden på en sträng (medlemsfunktioner av klassstorleken () och l ength ()). Du kan ta reda på längden på en sträng av en inbyggd typ endast genom beräkning med funktionen strlen ();
möjligheten att ta reda på om en sträng är tom.

Låt oss ta en närmare titt på dessa grundläggande funktioner.

Initialiserande strängar när man beskriver och linjelängd(exklusive den avslutande nullterminatorn):

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

Strängen kan ges och tömmas:

Sträng st2;

För att kontrollera om är raden tom, du kan jämföra dess längd med 0:

Om (! St.size ()) // tom

eller använd metoden empty () och returnerar true för en tom sträng och false för en icke-tom sträng:

If (st.empty ()) // tom

Den tredje formen av strängskapande initierar ett objekt av typen sträng med ett annat objekt av samma typ:

Sträng st3 (st);

String st3 initieras med sträng st. Hur kan vi säkerställa att dessa strängar matchar? Låt oss använda jämförelseoperatorn (==):

Om (st == st3) // initiering fungerade

Hur kopiera en rad till en annan? Med den vanliga tilldelningsoperationen:

St2 = st3; // kopiera st3 till st2

För strängsammansättning använd additionsoperationen (+) eller (+ =). Låt två rader ges:

String s1 ("hej,"); sträng s2 ("världen \ n");

Vi kan få den tredje raden, som består av sammanlänkningen av de två första, så här:

Sträng s3 = s1 + s2;

Om vi vill lägga till s2 till slutet av s1 måste vi skriva:

S1+ = s2;

Adderingsoperationen kan sammanfoga klassobjekt sträng inte bara sinsemellan, utan också med inline typ strängar. Du kan skriva om exemplet ovan så att specialtecken och skiljetecken representeras av den inbyggda char *-typen, och betydelsefulla ord representeras av strängobjekt:

Const char * pc = ","; sträng s1 ("hej"); sträng s2 ("världen"); sträng s3 = s1 + pc + s2 + "\ n"; cout<< endl << s3;

Uttryck som dessa fungerar eftersom kompilatorn "vet" hur man automatiskt konverterar objekt av den inbyggda typen till objekt av strängklassen. En enkel tilldelning av en inline-sträng till ett strängobjekt är också möjlig:

Sträng s1; const char * pc = "en teckenuppsättning"; s1 = pc; // höger

I det här fallet den omvända transformationen fungerar inte... Ett försök att göra följande initiering av en inbyggd typsträng kommer att ge ett kompileringsfel:

Char * str = s1; // kompileringsfel

För att utföra denna konvertering måste du uttryckligen anropa medlemsfunktionen c_str () ("C-sträng"):

Const char * str = s1.c_str ();

Funktionen c_str () returnerar en pekare till en teckenarray som innehåller strängen för strängobjektet som den skulle vara i en inbyggd strängtyp. Nyckelordet const förhindrar här det "farliga" i moderna visuella miljöer möjligheten att direkt modifiera innehållet i ett objekt genom en pekare.

TILL enskilda karaktärer ett objekt av typen sträng, som en inbyggd typ, kan nås med hjälp av operationen att ta indexet. Till exempel, här är ett kodavsnitt som ersätter alla punkter med understreck:

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

Ersätt (str.begin (), str.end (), ".", "_");

Det är sant att inte ersättningsmetoden för strängklassen används här, utan algoritmen med samma namn: