Klass och objekt
En klass är en uppsättning variabler och funktioner som fungerar tillsammans; där variablerna inte har värden tilldelade. När värden tilldelas variablerna blir klassen ett objekt. Olika värden som ges till samma klass resulterar i olika objekt; det vill säga olika objekt är samma klass med olika värden. Att skapa ett objekt från en klass sägs vara att instantiera objektet.
Namnet, sträng, är en klass. Ett objekt skapat från strängklassen har ett programmerat valt namn.
En funktion som tillhör klassen behövs för att instantiera ett objekt från klassen. I C ++ har den funktionen samma namn som klassens namn. Objekt som skapats (instanserats) från klassen har olika namn som programmeraren har gett dem.
Att skapa ett objekt från en klass innebär att konstruera objektet; det betyder också att instiniera.
Ett C ++ - program som använder strängklassen, börjar med följande rader högst upp i filen:
#omfatta#omfatta
med namnutrymme std;
Den första raden är för input/output. Den andra raden är att låta programmet använda alla funktioner i strängklassen. Den tredje raden gör att programmet kan använda namnen i standardnamnutrymmet.
Överbelastning av en funktion
När två eller flera olika funktionssignaturer har samma namn sägs det namnet vara överbelastat. När en funktion anropas bestämmer antalet och typen av argument vilken funktion som körs.
Konstruktion
sträng()
Följande sats konstruerar en sträng med noll längd utan tecken.
Det börjar med namnet på klassen (objekttyp), string. Detta följs av namnet på objektsträngen, givet av programmeraren. Uppdragsoperatören följer; sedan namnet på konstruktören med tomma parenteser. Här är strCol det instanserade objektet med alla datamedlemmar (egenskaper) och medlemsfunktioner (metoder).
sträng (str)
Detta liknar ovanstående, men tar antingen en strängbokstav eller en identifierare som ett argument i konstruktorn. Följande uttalande illustrerar detta:
Konstruktion med initieringslista
Följande kod illustrerar detta:
sträng strCol=sträng({'Jag','','de','eller','v','Och','','och','eller','du',' 0'});Strängen bokstavligt talat är jag älskar dig. Notera nul -tecknet i slutet av initialiseringslistan.
sträng (str, n)
Detta bildar en strängsamling av de första n -tecknen i en annan sträng. Följande kod illustrerar detta:
rödingsid[] = 'Jag älskar dig';sträng strCol=sträng(sid, 6);
kosta<<strCol<< ' n';
Utgången är I love med de första 6 karaktärerna från I love you. Kom ihåg: det enda utrymmet är en karaktär.
sträng (str, pos, n)
Detta bildar en strängsamling med n tecken, med början från den nollbaserade indexerade positionen pos i en annan sträng. Följande kod illustrerar detta:
rödingsid[] = 'Jag älskar dig';sträng strCol=sträng(sid, 2, 4);
kosta<<strCol<< ' n';
Utgången är, kärlek.
För de två ovanstående fallen, om n är större än strängens storlek, kastas undantaget out_of_range - se senare.
sträng (n, ‘c’)
Bildar en samling av n tecken, där alla tecken är samma. Överväga,
sträng strCol=sträng(5,'Och');kosta<<strCol<< ' n';
Utgången är, eeeee, 5 e’s.
Tilldela en sträng
En sträng kan tilldelas enligt följande efter att ha deklarerat båda strängarna:
sträng strCol1=sträng('Jag älskar dig');sträng strCol2;
strCol2=strCol1;
kosta<<strCol2<< ' n';
Utgången är, jag älskar dig.
Konstruerar med Iterator
En iterator ger en generisk representation av skanning genom värdena för en samling. En syntax för att skapa en sträng med iterator är:
mall<klass InputIterator>basic_string(InputIterator börjar,InputIterator -slut, konstTilldelare&
till=Tilldelare());
Detta konstruerar en sträng för intervallet [börja, slut) - se detaljer senare.
Förstör en sträng
För att förstöra en sträng, låt den gå utanför tillämpningsområdet.
Strängklasselementåtkomst
Ett instansierat strängobjekt kan vara subskriptat (indexerat) som en array. Indexräkning börjar från noll.
stringName [i]
Operations stringName [i] returnerar en referens till tecknet (elementet) på ithindex över teckensamlingen. Följande kodutgångar v:
sträng strCol=sträng('Jag älskar dig');rödingkap=strCol[4];
kosta<<kap<< ' n';
stringName [i] konst
Operationen stringName [i] const körs istället för stringName [i] när strängobjektet är ett konstant objekt. Det används till exempel i följande kod:
konststräng strCol=sträng('Jag älskar dig');rödingkap=strCol[4];
kosta<<kap<< ' n';
Uttrycket returnerar en konstant referens till ithelement i strängobjektet. Inget av strängens element kan ändras.
Tilldela ett tecken med prenumeration
Ett tecken kan tilldelas ett icke-konstant strängobjekt enligt följande:
sträng strCol=sträng('Jag ringer');strCol[2] = 'f';
kosta<<strCol<< ' n';
Utgången är jag faller. 'C' ändrades till 'f'.
stringName.at (i)
stringName.at (i) liknar stringName [i], men stringName.at (i) är mer tillförlitlig. Följande kod visar hur den ska användas:
sträng strCol=sträng('Jag älskar dig');rödingkap=strCol.på(4);
kosta<<kap<< ' n';
at () är faktiskt en strängklass medlemsfunktion.
stringName.at (i) konst
stringName.at (i) const liknar stringName [i] const, men stringName.at (i) const är mer pålitlig. stringName.at (i) const körs istället för stringName.at (i) när strängobjektet är ett konstant strängobjekt. Den används i följande kod, till exempel:
konststräng strCol=sträng('Jag älskar dig');rödingkap=strCol.på(4);
kosta<<kap<< ' n';
at () const är faktiskt en strängklass medlemsfunktion.
Tilldela ett värde med funktionen at ()
Ett värde kan tilldelas ett icke-konstant strängobjekt med funktionen at () enligt följande:
sträng strCol=sträng('Jag ringer');strCol.på(2) = 'f';
kosta<<strCol<< ' n';
Utgången är jag faller.
Problem med sub-scripting
Problemet med sub-scripting (indexering) är att om indexet ligger utanför intervallet kan fel resultat erhållas eller ett fel kan utfärdas vid körning.
främre()
Detta returnerar en referens till det första elementet i strängobjektet, utan att ta bort elementet. Utmatningen av följande kod är 'I'.
sträng strCol=sträng('Jag älskar dig');rödingkap=strCol.främre();
kosta<<kap<< ' n';
Tecknet tas inte bort från strängobjektet.
fram () konst
När strängobjektkonstruktionen föregås av const, körs uttrycket front () const istället för front (). Det används till exempel i följande kod.
konststräng strCol=sträng('Jag älskar dig');rödingkap=strCol.främre();
kosta<<kap<< ' n';
En konstant referens returneras. Elementet tas inte bort från strängobjektet. Inget tecken kan ändras för ett konstant strängobjekt.
tillbaka()
Detta returnerar en referens till det sista elementet i strängobjektet, utan att ta bort elementet. Utmatningen av följande kod är 'u'.
sträng strCol=sträng('Jag älskar dig');rödingkap=strCol.tillbaka();
kosta<<kap<< ' n';
tillbaka () konst
När strängobjektkonstruktionen föregås av const, körs uttrycket back () const istället för back (). Det används till exempel i följande kod.
konststräng strCol=sträng('Jag älskar dig');rödingkap=strCol.tillbaka();
kosta<<kap<< ' n';
En konstant referens returneras. Elementet tas inte bort från strängobjektet.
Strängkapacitet
size_type kapacitet () const noexcept
Det totala antalet tecken som strängen kan hålla utan att behöva omfördelas, returneras av denna kapacitetsmedelfunktion. Ett kodsegment för detta är:
sträng strCol=sträng();intpå ett=strCol.kapacitet();
kosta<<på ett<< ' n';
Utgången är 15 på min dator.
reserv (n)
Minnesutrymme är inte alltid tillgängligt i gratisbutiken. Extra plats kan bokas i förväg. Tänk på följande kodsegment:
sträng strCol=sträng('kärlek');strCol.boka(6);
kosta<<strCol.kapacitet() << ' n';
Utgången är 15 på min dator.
storlek () const noexcept
Detta returnerar antalet tecken i strängen. Följande kod illustrerar:
sträng strCol=sträng('Jag älskar dig');intpå ett=strCol.storlek();
kosta<<på ett<< ' n';
Utdata är 10, vilket inte inkluderar nul, 0 -tecknet.
length () const noexcept
-samma som storlek().Notera:storlek() <=kapacitet().
krymp för att passa()
Kan minska kapaciteten () till storlek () genom att orsaka omfördelning; det är inte obligatoriskt. Följande kod visar detta:
sträng strCol=sträng('Jag älskar dig');strCol.boka(12);
strCol.krymp för att passa();
ints=strCol.storlek();
kosta<<s<< ' n';
Utgången är 10 och inte 12 eller 16. Funktionen returnerar ogiltigt.
ändra storlek (sz), resize (sz, ’c’)
Detta ändrar storlek på strängen. Om den nya storleken är mindre än den gamla, raderas elementen mot slutet. Om den nya storleken är längre, läggs något standardtecken till mot slutet. Om du vill lägga till ett visst tecken använder du funktionen resize () med två argument. Följande kodsegment illustrerar användningen av de två funktionerna:
sträng strCol=sträng('Jag älskar dig');strCol.ändra storlek(6);
kosta<< 'Ny storlek på strCol:' <<strCol.storlek() << ' n';
sträng strCol1=sträng('Jag älskar', 'Och');
strCol1.ändra storlek(12);
kosta<< 'Ny storlek på strCol1:' <<strCol1.storlek() << ' n';
Utgången är:
Ny storlek på strCol: 6Ny storlek på strCol1: 12
Funktionen returnerar ogiltig.
klart () något utom
Tar bort alla element från strängen, som följande kodsegment illustrerar:
sträng strCol=sträng('Jag älskar dig');strCol.klar();
kosta<<strCol.storlek() << ' n';
Utgången är 0. Funktionen returnerar ogiltig.
tom () const noexcept
Detta returnerar 1 för true om det inte finns något tecken i strängobjektet, eller 0 för falskt om strängobjektet inte är tomt. Följande kod illustrerar detta:
sträng strCol1=sträng('Jag älskar dig');kosta<<strCol1.tömma() << ' n';
sträng strCol2=sträng();
kosta<<strCol2.tömma() << ' n';
Utgången är:
01
Återkommande Iteratorer och strängklassen
En iterator är som en pekare men har mer funktionalitet än pekaren.
begin () noexcept
Returnerar en iterator som pekar på det första tecknet (elementet) i strängobjektet, som i följande kodsegment:
sträng strCol=sträng('Jag älskar dig');basic_string<röding> ::iteratoriter=strCol.Börja();
kosta<< *iter<< ' n';
Utgången är 'jag'. Notera hur deklarationen som tar emot iteratorn har deklarerats. Iteratorn refereras till i ett returuttryck för att erhålla värdet på samma sätt som en pekare är refererad.
begin () const noexcept;
Returnerar en iterator som pekar på det första elementet i strängobjektsamlingen. När objektkonstruktionen föregås av const, körs uttrycket begin () const istället för begin (). Under detta villkor kan motsvarande element i objektet inte ändras. Det används till exempel i följande kod.
konststräng strCol=sträng('Jag älskar dig');basic_string<röding> ::const_iteratoriter=strCol.Börja();
kosta<< *iter<< ' n';
Utgången är 'jag'. Observera att const_iterator har använts denna gång, istället för bara iterator, för att ta emot den returnerade iteratorn.
slutet () någotxcept
Returnerar en iterator som pekar omedelbart bortom det sista elementet i strängobjektet. Tänk på följande kodsegment:
sträng strCol=sträng('Jag älskar dig');basic_string<röding> ::iteratoriter=strCol.slutet();
kosta<< *iter<< ' n';
Utmatningen är noll, vilket är ingenting, eftersom det inte finns något konkret element utöver det sista elementet.
slut () const noexcept
Returnerar en iterator som pekar omedelbart bortom det sista elementet i strängobjektet. När strängobjektkonstruktionen föregås av const, körs uttrycket end () const istället för end (). Tänk på följande kodsegment:
konststräng strCol=sträng('Jag älskar dig');basic_string<röding> ::const_iteratoriter=strCol.slutet();
kosta<< *iter<< ' n';
Utdata är noll. Observera att const_iterator har använts denna gång, istället för bara iterator, för att ta emot den returnerade iteratorn.
Omvänd Iteration
Det är möjligt att ha en iterator som itererar från själva slutet till strax före det första elementet:
rbegin () noexcept
Returnerar en iterator som pekar på det sista elementet i stränginstansierat objekt, som i följande kodsegment:
sträng strCol=sträng('Jag älskar dig');basic_string<röding> ::reverse_iteratoriter=strCol.börjar igen();
kosta<< *iter<< ' n';
Utgången är 'u'. Notera hur deklarationen som mottar den omvända iteratorn har deklarerats. Iteratorn refereras till i ett returuttryck för att erhålla värdet på samma sätt som en pekare är refererad.
rbegin () const noexcept;
Returnerar en iterator som pekar på det sista elementet i strängobjektet. När objektkonstruktionen föregås av const körs uttrycket rbegin () const istället för rbegin (). Under detta villkor kan motsvarande element i objektet inte ändras. Funktionen används till exempel i följande kod.
konststräng strCol=sträng('Jag älskar dig');basic_string<röding> ::const_reverse_iteratoriter=strCol.börjar igen();
kosta<< *iter<< ' n';
Utgången är 'u'. Observera att const_reverse_iterator har använts denna gång, istället för bara reverse_iterator, för att ta emot den returnerade iteratorn.
render () noexcept
Returnerar en iterator som pekar precis före det första elementet i strängobjektet. Tänk på följande kodsegment:
sträng strCol=sträng('Jag älskar dig');basic_string<röding> ::reverse_iteratoriter=strCol.gör();
kosta<< *iter<< ' n';
Utgången är noll, vilket är ingenting, eftersom det inte finns något konkret element strax före det första elementet.
render () const noexcept
Returnerar en iterator som pekar precis före det första elementet i strängobjektet. När objektkonstruktionen föregås av const körs uttrycket rend () const istället för rend (). Tänk på följande kodsegment:
konststräng strCol=sträng('Jag älskar dig');basic_string<röding> ::const_reverse_iteratoriter=strCol.gör();
kosta<< *iter<< ' n';
Utdata är noll. Observera att const_reverse_iterator har använts denna gång, istället för bara reverse_iterator, för att ta emot den returnerade iteratorn.
Strängmodifierare
En modifierare som modifierar strängobjektet kan också ta eller returnera en iterator.
Tillkommer
basic_string&operatör+ =(konstbasic_string&sid)Lägger till det högra strängobjektet till det vänstra strängobjektet. Exempel:
sträng strCol1=sträng('Jag älskar');sträng strCol2=sträng(' du');
strCol1+ =strCol2;
kosta<<strCol1<< ' n';
Utgången är Jag älskar dig. Glöm inte att strCol1 += strCol2 är samma som strCol1 = strCol1 +strCol2.
basic_string & operator+= (const charT* s)
Lägger till en sträng bokstavligt till en samling strängobjekt. Exempel:
sträng strCol=sträng('Jag älskar');strCol+ = ' du';
kosta<<strCol<< ' n';
Utgång: Jag älskar dig.
basic_string & operator+= (tecken c)
Lägger till ett enda tecken i en objektsträng. Exempel:
sträng strCol=sträng('Jag älskar dig');strCol+ = 'du';
kosta<<strCol<< ' n';
Utgång: Jag älskar dig.
basic_string & operator+= (initializer_list)
Lägger till en initieringslista. Exempel:
sträng strCol=sträng('Jag älskar');strCol+ = {'','och','eller','du',' 0'};
kosta<<strCol<< ' n';
Utgång: Jag älskar dig. Det är alltid bra att lägga till nul, 0 i slutet av en teckeninitialiserarlista.
basic_string & append (const basic_string & str)
Lägger till argumentsträngobjektet till huvudsträngobjektet. Exempel:
sträng strCol1=sträng('Jag älskar');sträng strCol2=sträng(' du');
strCol1.bifoga(strCol2);
kosta<<strCol1<< ' n';
Utgång: Jag älskar dig.
basic_string & append (const charT* s)
Lägger till ett strängbokstavligt argument i huvudsträngen. Exempel
sträng strCol=sträng('Jag älskar');strCol=strCol.bifoga(' du');
kosta<<strCol<< ' n';
Utgång: Jag älskar dig.
basic_string & append (initializer_list)
Lägger till initialiseringslistan, vilket är ett argument, till huvudsträngen. Exempel:
sträng strCol=sträng('Jag älskar');strCol=strCol.bifoga({'','och','eller','du',' 0'});
kosta<<strCol<< ' n';
Utgång: Jag älskar dig. Det är alltid bra att lägga till nul, 0 -tecknet i slutet av en initialiseringslista.
basic_string & append (size_type n, charT c)
Fogar n av samma karaktär. Exempel:
sträng strCol=sträng('flik');strCol=strCol.bifoga(2, 'eller');
kosta<<strCol<< ' n';
Utgång: tabu.
basic_string & append (const charT* s, size_type n)
Lägger till de första n -elementen i en sträng bokstavligt till huvudsträngobjektet. Exempel:
sträng strCol=sträng('Jag älskar');strCol=strCol.bifoga('du så', 4);
kosta<<strCol<< ' n';
Utgången är: Jag älskar dig. Om n är större än bokstavets längd kastas ett length_error -undantag.
basic_string & append (const basic_string & str, size_type pos, size_type n = npos)
Lägger till n tecken från indexet, pos till huvudsträngen. Exempel:
sträng strCol=sträng('Jag älskar');strCol=strCol.bifoga(har du så, 2, 4);
kosta<<strCol<< ' n';
Utgång: Jag älskar dig. Ett undantag skulle också kastas här, se senare.
Tilldela
basic_string&tilldela(konstbasic_string&sid)Tilldelar argumentsträngobjektet till huvudsträngen och ersätter allt innehåll som fanns där.
sträng strCol1=sträng('Jag älskar dig');sträng strCol2=sträng('Hon behöver mig');
strCol1=strCol1.tilldela(strCol2);
kosta<<strCol1<< ' n';
Utgång: Hon behöver mig.
basic_string&tilldela(konstDiagram*s)Tilldelar ett strängbokstavligt argument till huvudsträngen och ersätter allt innehåll som fanns där.
sträng strCol=sträng('Jag älskar dig');strCol=strCol.tilldela('Hon behöver mig');
kosta<<strCol<< ' n';
Utgång: Hon behöver mig.
basic_string&tilldela(initializer_list<Diagram>)Tilldelar ett initieringslistargument till huvudsträngen,ersätta allt innehåll som fanns där.
[cc lang='c'rymde='Sann'bredd='780']
sträng strCol=sträng('Jag älskar dig');
strCol=strCol.tilldela({'S','h','Och','','n','Och','Och','d','s','','m','Och',' 0'});
kosta<<strCol<< ' n';
Utgång: Hon behöver mig. Det är bra att alltid lägga till nul, 0 i slutet av teckenlistan, för att bilda en sträng bokstavlig.
basic_string&tilldela(konstDiagram*s,storlek_typ n)Tilldelar huvudsträngen de första n tecknen i ett strängbokstavsargument till att ersätta allt innehåll som fanns där.
sträng strCol=sträng('Jag älskar dig');strCol=strCol.tilldela('Hon behöver mig', 9);
kosta<<strCol<< ' n';
Utgång: Hon behöver.
basic_string&tilldela(storlek_typ n,charT c)Tilldelar ett argument av n av samma tecken till huvudsträngen och ersätter allt innehåll som fanns där.
sträng strCol=sträng('Jag älskar dig');strCol=strCol.tilldela(4, 'Och');
kosta<<strCol<< ' n';
Utgång: eeee
basic_string&tilldela(konstbasic_string&sid,storlek_typ pos,storlek_typ n=npos)
Tilldelar n tecken i ett strängobjektargument, som börjar från pos, till huvudsträngen och ersätter allt innehåll som fanns där.
sträng strCol=sträng('Jag älskar dig');strCol=strCol.tilldela('Hon behöver mig', 4, 5);
kosta<<strCol<< ' n';
Utgång: behov. Skulle göra ett undantag - se senare.
Infoga
basic_string&Föra in(storlek_typ pos, konstbasic_string&sid)Infogar strängobjektargumentet till huvudsträngen, vid index, pos.
sträng strCol1=sträng('Jag älskar dig');sträng strCol2=sträng('hat och');
strCol1=strCol1.Föra in(2,strCol2);
kosta<<strCol1<< ' n';
Utgång: Jag hatar och älskar dig. Skulle göra ett undantag - se senare.
basic_string&Föra in(storlek_typ pos1, konstbasic_string&sid,storlek_typ pos2,storlek_typ n=npos)
Infogar en längd på n tecken från pos2 i strängobjektargumentet, till huvudsträngen, vid index, pos1.
sträng strCol1=sträng('Jag älskar dig');sträng strCol2=sträng('hatar, vill och behöver');
strCol1=strCol1.Föra in(2,strCol2, 6, 9);
kosta<<strCol1<< ' n';
Utgång: Jag vill och älskar dig.
iteratorinsats (const_iterator p, charT c)
Infogar en särskild karaktär, vilket är ett argument, i den position som iteratorn pekar på. Returnerar en iterator för positionen för det nyligen infogade tecknet.
sträng strCol=sträng('Jag älskar dig');basic_string<röding> ::iteratoriter=strCol.Börja();
++iter; ++iter; ++iter; ++iter; ++iter; ++iter;
basic_string<röding> ::iteratornätverk=strCol.Föra in(iter, 'd');
kosta<< *nätverk<< ' n';
kosta<<strCol<< ' n';
Utgången är:
'D'
jag älskade dig
iteratorinsats (const_iterator p, size_type n, charT c)
Infogar n av samma karaktär av argumentet, i positionen som iteratorn pekar på. Returnerar en iterator för positionen för början av de nyligen infogade samma tecknen.
sträng strCol=sträng('Tab i landet.');basic_string<röding> ::iteratoriter=strCol.Börja();
++iter; ++iter; ++iter;
basic_string<röding> ::iteratornätverk=strCol.Föra in(iter, 2, 'eller');
kosta<< *nätverk<< ' n';
kosta<<strCol<< ' n';
Utgången är:
'eller'
Tabu i landet.
basic_string&Föra in(storlek_typ pos, konstDiagram*s)Infogar en argumentsträng bokstavligt vid indexet, pos i huvudsträngen.
sträng strCol=sträng('Tab i landet.');strCol=strCol.Föra in(3, 'oo');
kosta<<strCol<< ' n';
Utgång: Tabu i landet.
basic_string&Föra in(storlek_typ pos, konstDiagram*s,storlek_typ n)Infogar de första n tecknen i argumentsträngen bokstavligt, vid index, pos i huvudsträngen.
sträng strCol=sträng('Tab i landet.');strCol=strCol.Föra in(3, 'oooo', 2);
kosta<<strCol<< ' n';
Utgång: Tabu i landet.
Byter ut
basic_string&byta ut(storlek_typ pos1,storlek_typ n1, konstbasic_string&sid))Ersätter n1 -tecken i huvudsträngobjektet från index, pos1, med argumentsträngobjektet.
sträng strCol1=sträng('Jag älskar dig');sträng strCol2=sträng('hatar dig och');
strCol1=strCol1.byta ut(2, 4,strCol2);
kosta<<strCol1<< ' n';
Utgång: Jag hatar dig och dig. Skulle göra ett undantag - se senare.
basic_string&byta ut(storlek_typ pos1,storlek_typ n1, konstbasic_string&sid,storlek_typ pos2,storlek_typ n2=npos)
Ersätter n1 -tecken i huvudsträngobjektet från indexet, pos1, med n2 -tecken i argumentsträngobjektet från indexet, pos2.
sträng strCol1=sträng('Jag älskar dig');sträng strCol2=sträng('vi hatar honom och henne');
strCol1=strCol1.byta ut(2, 4,strCol2, 3, 12);
kosta<<strCol1<< ' n';
Utgång: Jag hatar honom och dig.
basic_string&byta ut(storlek_typ pos1,storlek_typ n1, konstDiagram*s,storlek_typ n2)
Ersätter n1 -tecken i huvudsträngobjektet från indexet, pos1, med de första n2 -tecknen i bokstavsträngargumentet.
sträng strCol1=sträng('Jag älskar dig');strCol1=strCol1.byta ut(2, 4, 'hatar honom och henne', 12);
kosta<<strCol1<< ' n';
Utgång: Jag hatar honom och dig.
basic_string & Ersätt (size_type pos, size_type n, const charT* s)
Ersätter n tecken i huvudsträngobjektet från index, pos, med bokstavssträngargumentet.
sträng strCol1=sträng('Jag älskar dig');strCol1=strCol1.byta ut(2, 4, 'hatar honom och');
kosta<<strCol1<< ' n';
Utgång: Jag hatar honom och dig.
basic_string&byta ut(storlek_typ pos1,storlek_typ n1,storlek_typ n2,charT c)Ersätter n1 -tecken i huvudsträngobjektet från indexet, pos1, med n2 med samma tecken i argumentet.
sträng strCol1=sträng('En dålig tablett där.');strCol1=strCol1.byta ut(9, 3, 2, 'eller');
kosta<<strCol1<< ' n';
Utgång: Ett dåligt tabu där ..
iterator radera (const_iterator p)
Tar bort ett tecken på den position som iteratorn pekar på; returnerar sedan iteratorpositionen, som nu är upptagen av tecknet som fanns bredvid detta tecken (eller slutet ()). Följande kod illustrerar detta:
sträng strCol=sträng('abcd');basic_string<röding> ::iteratoriter=strCol.Börja();
++iter; ++iter;
strCol.radera(iter);
kosta<<strCol[0] << '' <<strCol[1] << '
' <<strCol[2]<< ' n';
Utgången: a b d
basic_string&radera(storlek_typ pos= 0,storlek_typ n=npos)Tar bort n tecken från index, pos.
sträng strCol=sträng('abcd');strCol.radera(1, 2);
kosta<<strCol[0] << '' <<strCol[1] << ' n';
Utgång: a d
void push_back (tecken c)
Så här lägger du till ett enda tecken i slutet av strängen:
sträng strCol=sträng('abcd');strCol.trycka tillbaka('5');
kosta<<strCol<< ' n';
Utgång: abcd5
ogiltig pop_back ()
Tar bort det sista tecknet utan att returnera det. Strängens storlek reduceras med 1.
sträng strCol=sträng('abcde');strCol.pop_back();
kosta<<strCol<< ' n';
Utgång: abcd
void swap (basic_string & s)
Bokstavarna i två strängobjekt kan bytas ut.
sträng strCol1=sträng(<ett id='post-69618 -__ DdeLink__781_3724385525'>till>'abcde');sträng strCol2=sträng('1234567');
strCol1.byta(strCol2);
kosta<<strCol1<< ' n';
kosta<<strCol2<< ' n';
Utgången är:
'1234567''abcde'
Strängoperationer
const charT* c_str () const noexcept
Återställer en pekare till det första elementet i strängen. Pekaren kan ökas.
konststräng strCol=sträng('abcde');konst röding*sid=strCol.c_str();
kosta<< *sid<< ' n';
++sid;
kosta<< *sid<< ' n';
Utdata är:
tillb
På grund av den andra konstanten i rubriken kan programmet inte ändra något tecken i strängen. Konstruktionen föregås av konst.
const charT* data () const noexcept
Återställer en pekare till det första elementet i strängen. Pekaren kan ökas.
konststräng strCol=sträng('abcde');konst röding*sid=strCol.data();
kosta<< *sid<< ' n';
++sid;
kosta<< *sid<< ' n';
Utdata är:
tillb
På grund av den andra konstanten i rubriken kan programmet inte ändra något tecken i strängen. Konstruktionen föregås av konst.
basic_string substr (size_type pos = 0, size_type n = npos) const
Returnerar ett strängobjekt med n tecken för delsträngen som börjar från index, pos.
konststräng strCol=sträng('abcdefghij');konststring retStr=strCol.substr(2, 4);
kosta<<retStr<< ' n';
Utmatning: cdef
hitta () medlemsfunktioner
size_type find (const basic_string & str, size_type pos = 0) const noexcept
Letar efter ett understrängsobjekt som börjar från index, pos. Om den hittas, returnerar början av delsträngen i huvudsträngen.
sträng strCol=sträng('Vi är världen!');sträng strCol1=sträng('de');
intpå ett=strCol.hitta(strCol1, 2);
kosta<<på ett<< ' n';
Produktion:
index: 7Returnerar -1, när den inte hittas.
size_type find (const charT* s, size_type pos = 0) const
Letar efter en understräng bokstavligen från index, pos. Om den hittas, returnerar början av delsträngen i huvudsträngen.
sträng strCol=sträng('Vi är världen!');intpå ett=strCol.hitta('är', 0);
kosta<<på ett<< ' n';
Eftersom pos = 0 är standard kan 0 i argumentet ha utelämnats.
Utgång: 3
Returnerar -1, när den inte hittas.
size_type find (const charT* s, size_type pos, size_type n) const
Letar efter de första n tecknen i en understräng bokstavligen från indexet, pos. Om den hittas, returnerar början av delsträngen i huvudsträngen.
sträng strCol=sträng('Den största pojken');intpå ett=strCol.hitta('större', 1, 3);
kosta<<på ett<< ' n';
Utgång: 4
Returnerar -1, när den inte hittas.
size_type find (charT c, size_type pos = 0) const
Letar efter tecknet, c med början från index, pos. Om den hittas, returnerar början av delsträngen i huvudsträngen. Om den inte hittas returnerar -1.
sträng strCol=sträng('Vi är världen!');intpå ett=strCol.hitta('Med');
kosta<<på ett<< ' n';
Utgång: -1
Följande funktionalitet för omvänd sökning () finns:
size_type rfind(konstbasic_string&sid,storlek_typ pos=npos) konstnågot utom;size_type rfind(konstDiagram*s,storlek_typ pos=npos) konst;
size_type rfind(konstDiagram*s,storlek_typ pos,storlek_typ n) konst;
size_type rfind(charT c,storlek_typ pos=npos) konst;
Jämförelse av medlemsfunktioner
int jämför (const basic_string & str) const noexcept
Jämför argumentsträngobjektet med huvudsträngobjektet. Om huvudsträngen inträffar före argumentet (i ordlistan) returnerar den ett positivt tal. Om det inträffar efter huvudsträngen returnerar det ett negativt tal. Om de två strängarna är desamma returnerar den noll.
sträng strCol1=sträng('folkmassan');sträng strCol2=sträng('människor');
intpå ett=strCol1.jämföra(strCol2);
kosta<<på ett<< ' n';
Utgång: -13
int jämför (const charT* s) const
Samma som ovan, men argumentet är en sträng bokstavligt.
sträng strCol1=sträng('människor');intpå ett=strCol1.jämföra('människor');
kosta<<på ett<< ' n';
Utgång: 0
Strängoperatörer
Dessa operatorer är tillämpliga på strängobjekt och inte nödvändigtvis stränglitteraler.
+
Sammanfogar två strängobjekt och returnerar sammankopplingen.
sträng strCol1=sträng('dansar på');sträng strCol2=sträng(' månen');
sträng strCol=strCol1+strCol2;
kosta<<strCol<< ' n';
Utgång: dans på månen.
==
Returnerar 1 för true, om strängobjekten är desamma; och noll för falska, om de inte är det.
sträng strCol1=sträng('dansar på');sträng strCol2=sträng(' på månen');
bool bl=strCol1==strCol2;
kosta<<bl<< ' n';
Utgång: 0
! =
Returnerar 1 om strängobjekten inte är desamma och noll om de är det.
sträng strCol1=sträng('dansar på');sträng strCol2=sträng(' på månen');
bool bl=strCol1! =strCol2;
kosta<<bl<< ' n';
Utgång: 1
<
Returnerar 1, om den vänstra operanden är mindre än den högra operanden enligt ordlistan, eller noll om den inte är det.
sträng strCol1=sträng('dansar på');sträng strCol2=sträng(' på månen');
bool bl=strCol1<strCol2;
kosta<<bl<< ' n';
Utgång: 0
För vanliga tecken i C ++, i stigande ordning, kommer siffror före stora bokstäver, som kommer före gemener. Rymdkaraktären kommer före noll och alla.
C ++ Typer av huvudsträngar
röding
Char -typen är den ursprungliga C ++ - typen och lagrar vanligtvis ett tecken i 8 bitar.
char16_t
Detta lagrar ett tecken i 16 bitar.
char32_t
Detta lagrar ett tecken i 32 bitar.
wchar_t
char16_t och char32_t är breda tecken. wchar_t är en bred karaktär som är proprietär och implementeringsdefinierad.
Dessa typer kallas egenskaper. Men C ++ hänvisar till dem tekniskt som specialiseringar av egenskaper. Denna artikel har fokuserat på rödingstypen. Tillvägagångssättet för de andra typerna är något annorlunda - se senare.
Andra funktioner för strängoperationer
Signaturerna för andra strängoperationsfunktioner är:
size_type hitta_first_of(konstbasic_string&sid,storlek_typ pos= 0) konstnågot utom;size_type hitta_first_of(konstDiagram*s,storlek_typ pos,storlek_typ n) konst;
size_type hitta_first_of(konstDiagram*s,storlek_typ pos= 0) konst;
size_type hitta_first_of(charT c,storlek_typ pos= 0) konst;
size_type find_last_of(konstbasic_string&sid,storlek_typ pos=npos) konstnågot utom;
size_type find_last_of(konstDiagram*s,storlek_typ pos,storlek_typ n) konst;
size_type find_last_of(konstDiagram*s,storlek_typ pos=npos) konst;
size_type find_last_of(charT c,storlek_typ pos=npos) konst;
size_type find_first_not_of(konstbasic_string&sid,storlek_typ pos= 0) konstnågot utom;
size_type find_first_not_of(konstDiagram*s,storlek_typ pos,storlek_typ n) konst;
size_type find_first_not_of(konstDiagram*s,storlek_typ pos= 0) konst;
size_type find_first_not_of(charT c,storlek_typ pos= 0) konst;
size_type find_last_not_of(konstbasic_string&sid,storlek_typ pos=npos) konstnågot utom;
size_type find_last_not_of(konstDiagram*s,storlek_typ pos,storlek_typ n) konst;
size_type find_last_not_of(konstDiagram*s,storlek_typ pos=npos) konst;
size_type find_last_not_of(charT c,storlek_typ pos=npos) konst;
Slutsats
C ++ har strängbokstavar och strängobjekt. Strängobjektet har en samling tecken i sekvens, liknande en rad tecken i sekvens. Skillnaden mellan strängsamlingen och en matris är att strängsamlingen kan växa i längd eller krympa i längd. Ett strängobjekt instansieras (konstrueras) från en strängklass. Ett strängobjekt är en datastruktur med medlemsfunktioner. Medlemsfunktionerna kan klassificeras under rubrikerna objektkonstruktion, elementåtkomst, strängkapacitet, strängmedlemsfunktioner med iteratorargument och returtyper och strängmodifierare. Strängjämlikhet och relationsoperatörer finns också.