Třída a objekty
Třída je sada proměnných a funkcí, které spolupracují; kde proměnné nemají přiřazené hodnoty. Když jsou proměnným přiřazeny hodnoty, třída se stane objektem. Různé hodnoty dané stejné třídě vedou k různým objektům; to znamená, že různé objekty jsou stejnou třídou s různými hodnotami. Vytváření objektu ze třídy se říká o instanci objektu.
Název, řetězec, je třída. Objekt vytvořený ze třídy řetězců má název zvolený programátorem.
Funkce, která patří do třídy, je potřebná k vytvoření instance objektu ze třídy. V C ++ má tato funkce stejný název jako název třídy. Objekty vytvořené (vytvořené instancí) ze třídy mají různá jména, která jim dal programátor.
Vytvoření objektu ze třídy znamená konstrukci objektu; to také znamená instanci.
Program C ++, který používá třídu řetězců, začíná v horní části souboru následujícími řádky:
#zahrnout#zahrnout
pomocí oboru názvů std;
První řádek je pro vstup/výstup. Druhý řádek je umožnit programu využívat všechny funkce třídy řetězců. Třetí řádek umožňuje programu používat jména ve standardním oboru názvů.
Přetížení funkce
Pokud mají dva nebo více různých podpisů funkcí stejný název, je tento název údajně přetížen. Při volání jedné funkce určuje počet a typ argumentů, která funkce se provede.
Konstrukce
tětiva()
Následující příkaz vytvoří řetězec nulové délky bez znaku.
Začíná názvem třídy (typ objektu), řetězec. Následuje název řetězce objektu zadaný programátorem. Následuje operátor přiřazení; potom název konstruktoru s prázdnými závorkami. Zde je strCol instancovaným objektem se všemi datovými členy (vlastnostmi) a členskými funkcemi (metodami).
řetězec (str)
To je podobné výše uvedenému, ale jako argument v konstruktoru bere řetězcový literál nebo identifikátor. Následující prohlášení to ilustruje:
Konstrukce pomocí seznamu inicializátorů
Následující kód to ilustruje:
řetězec strCol=tětiva({'Já','','the','nebo','proti','A','','a','nebo','u',' 0'});Řetězcový doslov je Miluji tě. Všimněte si nulového znaku na konci seznamu inicializátorů.
řetězec (str, n)
Tím se vytvoří kolekce řetězců prvních n znaků jiného řetězce. Následující kód to ilustruje:
charp[] = 'Miluji tě';řetězec strCol=tětiva(p, 6);
náklady<<strCol<< ' n';
Výstupem je I love with the first 6 characters from I love you. Pamatujte: jedno místo je znak.
řetězec (str, pos, n)
Tím se vytvoří kolekce řetězců n znaků, počínaje od nulové indexované pozice, pos, jiného řetězce. Následující kód to ilustruje:
charp[] = 'Miluji tě';řetězec strCol=tětiva(p, 2, 4);
náklady<<strCol<< ' n';
Výstupem je láska.
Ve výše uvedených dvou případech platí, že pokud n je větší než velikost řetězce, je vyvolána výjimka out_of_range - viz později.
řetězec (n, ‘c’)
Vytváří kolekci n znaků, kde jsou všechny znaky stejné. Zvážit,
řetězec strCol=tětiva(5,'A');náklady<<strCol<< ' n';
Výstup je, eeeee, 5 e.
Přiřazení řetězce
Řetězec lze přiřadit následujícím způsobem poté, co deklarujete oba řetězce:
řetězec strCol1=tětiva('Miluji tě');řetězec strCol2;
strCol2=strCol1;
náklady<<strCol2<< ' n';
Výstupem je, miluji tě.
Konstrukce s iterátorem
Iterátor poskytuje obecnou reprezentaci skenování prostřednictvím hodnot kolekce. Syntaxe pro vytvoření řetězce s iterátorem je:
šablona<třída InputIterator>basic_string(InputIterator begin,Konec InputIterator, konstPřidělovač&
na=Přidělovač());
Tím se vytvoří řetězec pro rozsah [začátek, konec] - podrobnosti viz později.
Zničení řetězce
Chcete -li řetězec zničit, nechte jej mimo dosah.
Přístup k elementu String Class
Instalovaný objekt řetězce může být subskriptován (indexován) jako pole. Počítání indexů začíná od nuly.
stringName [i]
Operace stringName [i] vrací odkaz na znak (prvek) na ithrejstřík kolekce znaků. Následující výstup kódu v:
řetězec strCol=tětiva('Miluji tě');charch=strCol[4];
náklady<<ch<< ' n';
stringName [i] konst
Operace stringName [i] const je provedena namísto stringName [i], pokud je objekt string konstantním objektem. Používá se například v následujícím kódu:
konstřetězec strCol=tětiva('Miluji tě');charch=strCol[4];
náklady<<ch<< ' n';
Výraz vrací konstantní odkaz na ithprvek objektu řetězce. Žádný z prvků řetězce nelze změnit.
Přiřazení postavy pomocí indexu
Znak lze přiřadit nekonzistentnímu řetězcovému objektu následujícím způsobem:
řetězec strCol=tětiva('Volám');strCol[2] = 'F';
náklady<<strCol<< ' n';
Výstupem je pád. „C“ bylo změněno na „f“.
stringName.at (i)
stringName.at (i) je podobný stringName [i], ale stringName.at (i) je spolehlivější. Následující kód ukazuje, jak by měl být použit:
řetězec strCol=tětiva('Miluji tě');charch=strCol.na(4);
náklady<<ch<< ' n';
at () je vlastně členská funkce třídy řetězců.
stringName.at (i) konst
stringName.at (i) const je podobný stringName [i] const, ale stringName.at (i) const je spolehlivější. stringName.at (i) const je proveden namísto stringName.at (i), pokud je objekt string konstantním řetězcovým objektem. Používá se například v následujícím kódu:
konstřetězec strCol=tětiva('Miluji tě');charch=strCol.na(4);
náklady<<ch<< ' n';
at () const je ve skutečnosti členskou funkcí třídy řetězců.
Přiřazení hodnoty pomocí funkce at ()
K nekonstantnímu řetězcovému objektu s funkcí at () lze přiřadit hodnotu následujícím způsobem:
řetězec strCol=tětiva('Volám');strCol.na(2) = 'F';
náklady<<strCol<< ' n';
Výstupem je pád.
Problém se subskriptováním
Problém subskriptování (indexování) spočívá v tom, že pokud je index mimo rozsah, může dojít k nesprávnému výsledku nebo může být za běhu vydána chyba.
přední()
Tím se vrátí odkaz na první prvek objektu řetězce bez odebrání prvku. Výstupem následujícího kódu je „I“.
řetězec strCol=tětiva('Miluji tě');charch=strCol.přední();
náklady<<ch<< ' n';
Znak není odstraněn z objektu řetězce.
přední () konst
Když konstrukci řetězcového objektu předchází const, provede se výraz front () const místo front (). Používá se například v následujícím kódu.
konstřetězec strCol=tětiva('Miluji tě');charch=strCol.přední();
náklady<<ch<< ' n';
Je vrácena konstantní reference. Prvek není odstraněn z objektu řetězce. U objektu s konstantním řetězcem nelze změnit žádný znak.
zadní()
Tím se vrátí odkaz na poslední prvek objektu řetězce bez odebrání prvku. Výstupem následujícího kódu je „u“.
řetězec strCol=tětiva('Miluji tě');charch=strCol.zadní();
náklady<<ch<< ' n';
zpět () konst
Když konstrukci řetězcového objektu předchází const, provede se místo back () výraz back () const. Používá se například v následujícím kódu.
konstřetězec strCol=tětiva('Miluji tě');charch=strCol.zadní();
náklady<<ch<< ' n';
Je vrácena konstantní reference. Prvek není odstraněn z objektu řetězce.
Kapacita řetězce
size_type kapacita () konst noexcept
Tato funkce členů kapacity vrací celkový počet znaků, které řetězec může obsahovat, aniž by bylo nutné přerozdělení. Segment kódu pro toto je:
řetězec strCol=tětiva();intna jednom=strCol.kapacita();
náklady<<na jednom<< ' n';
Výstup je 15 na mém počítači.
rezerva (n)
Prostor paměti není ve volném obchodě vždy k dispozici. Prostor navíc lze rezervovat předem. Zvažte následující segment kódu:
řetězec strCol=tětiva('milovat');strCol.rezervovat(6);
náklady<<strCol.kapacita() << ' n';
Výstup je 15 na mém počítači.
size () const noexcept
Tím se vrátí počet znaků v řetězci. Následující kód ukazuje:
řetězec strCol=tětiva('Miluji tě');intna jednom=strCol.velikost();
náklady<<na jednom<< ' n';
Výstup je 10, což nezahrnuje znak nula 0.
length () const noexcept
-stejné jako velikost().Poznámka:velikost() <=kapacita().
shrink_to_fit ()
Může snížit kapacitu () na velikost () způsobením přerozdělení; není to povinné. Následující kód to ukazuje:
řetězec strCol=tětiva('Miluji tě');strCol.rezervovat(12);
strCol.shrink_to_fit();
ints=strCol.velikost();
náklady<<s<< ' n';
Výstup je 10 a ne 12 nebo 16. Funkce vrací neplatné.
resize (sz), resize (sz, ‘c’)
Tím se změní velikost řetězce. Pokud je nová velikost menší než stará velikost, prvky na konci budou vymazány. Pokud je nová velikost delší, přidá se ke konci nějaký výchozí znak. Chcete -li přidat konkrétní znak, použijte funkci resize () se dvěma argumenty. Následující segment kódu ukazuje použití těchto dvou funkcí:
řetězec strCol=tětiva('Miluji tě');strCol.změnit velikost(6);
náklady<< 'Nová velikost strCol:' <<strCol.velikost() << ' n';
řetězec strCol1=tětiva('Miluji', 'A');
strCol1.změnit velikost(12);
náklady<< 'Nová velikost strCol1:' <<strCol1.velikost() << ' n';
Výstupem je:
Nová velikost strCol: 6Nová velikost strCol1: 12
Funkce vrací neplatné.
clear () noexcept
Odebere všechny prvky z řetězce, jak ukazuje následující segment kódu:
řetězec strCol=tětiva('Miluji tě');strCol.Průhledná();
náklady<<strCol.velikost() << ' n';
Výstup je 0. Funkce vrací neplatné.
empty () const noexcept
To vrátí 1 pro true, pokud v řetězcovém objektu není žádný znak, nebo 0 pro false, pokud objekt řetězce není prázdný. Následující kód to ilustruje:
řetězec strCol1=tětiva('Miluji tě');náklady<<strCol1.prázdný() << ' n';
řetězec strCol2=tětiva();
náklady<<strCol2.prázdný() << ' n';
Výstupem je:
01
Vracející se iterátory a třída řetězců
Iterátor je jako ukazatel, ale má více funkcí než ukazatel.
begin () noexcept
Vrátí iterátor, který ukazuje na první znak (prvek) objektu řetězce, jako v následujícím segmentu kódu:
řetězec strCol=tětiva('Miluji tě');basic_string<char> ::iterátoriter=strCol.začít();
náklady<< *iter<< ' n';
Výstupem je „I“. Všimněte si způsobu deklarace deklarace, která obdrží iterátor. Iterátor je dereferencován v návratovém výrazu, aby se získala hodnota stejným způsobem, jako je dereferencován ukazatel.
begin () const noexcept;
Vrátí iterátor, který ukazuje na první prvek kolekce řetězcových objektů. Když konstrukci objektu předchází const, místo begin () se provede výraz begin () const. Za této podmínky nelze odpovídající prvek v objektu upravit. Používá se například v následujícím kódu.
konstřetězec strCol=tětiva('Miluji tě');basic_string<char> ::const_iteratoriter=strCol.začít();
náklady<< *iter<< ' n';
Výstupem je „I“. Všimněte si toho, že tentokrát byl k přijetí vráceného iterátoru použit const_iterator, nikoli pouze iterátor.
end () noexcept
Vrátí iterátor, který ukazuje bezprostředně za poslední prvek objektu řetězce. Zvažte následující segment kódu:
řetězec strCol=tětiva('Miluji tě');basic_string<char> ::iterátoriter=strCol.konec();
náklady<< *iter<< ' n';
Výstup je null, což není nic, protože za posledním prvkem není žádný konkrétní prvek.
end () const noexcept
Vrátí iterátor, který ukazuje bezprostředně za poslední prvek objektu řetězce. Když konstrukci řetězcového objektu předchází const, místo end () se provede výraz end () const. Zvažte následující segment kódu:
konstřetězec strCol=tětiva('Miluji tě');basic_string<char> ::const_iteratoriter=strCol.konec();
náklady<< *iter<< ' n';
Výstup je null. Všimněte si toho, že tentokrát byl k přijetí vráceného iterátoru použit const_iterator, nikoli pouze iterátor.
Reverzní iterace
Je možné mít iterátor, který iteruje od skutečného konce těsně před první prvek:
rbegin () noexcept
Vrátí iterátor, který ukazuje na poslední prvek objektu instance řetězce, jako v následujícím segmentu kódu:
řetězec strCol=tětiva('Miluji tě');basic_string<char> ::reverzní_iterátoriter=strCol.rbegin();
náklady<< *iter<< ' n';
Výstupem je „u“. Všimněte si způsobu, jakým byla deklarována deklarace, která přijímá reverzní iterátor. Iterátor je dereferencován v návratovém výrazu, aby se získala hodnota stejným způsobem, jako je dereferencován ukazatel.
rbegin () const noexcept;
Vrátí iterátor, který ukazuje na poslední prvek objektu řetězce. Když konstrukci objektu předchází const, místo rbegin () se provede výraz rbegin () const. Za této podmínky nelze odpovídající prvek v objektu upravit. Tato funkce se používá například v následujícím kódu.
konstřetězec strCol=tětiva('Miluji tě');basic_string<char> ::const_reverse_iteratoriter=strCol.rbegin();
náklady<< *iter<< ' n';
Výstupem je „u“. Všimněte si toho, že tentokrát byl pro příjem vráceného iterátoru použit const_reverse_iterator, namísto pouze reverse_iterator.
render () noexcept
Vrátí iterátor, který ukazuje těsně před první prvek objektu řetězce. Zvažte následující segment kódu:
řetězec strCol=tětiva('Miluji tě');basic_string<char> ::reverzní_iterátoriter=strCol.dělá();
náklady<< *iter<< ' n';
Výstup je null, což není nic, protože těsně před prvním prvkem neexistuje žádný konkrétní prvek.
render () const noexcept
Vrátí iterátor, který ukazuje těsně před první prvek objektu řetězce. Když konstrukci objektu předchází const, místo rend () se provede výraz rend () const. Zvažte následující segment kódu:
konstřetězec strCol=tětiva('Miluji tě');basic_string<char> ::const_reverse_iteratoriter=strCol.dělá();
náklady<< *iter<< ' n';
Výstup je null. Všimněte si toho, že tentokrát byl pro příjem vráceného iterátoru použit const_reverse_iterator, namísto pouze reverse_iterator.
Modifikátory řetězce
Modifikátor, který upravuje objekt řetězce, může také převzít nebo vrátit iterátor.
Připojování
basic_string&operátor+ =(konstbasic_string&p)Připojí objekt pravého řetězce k objektu levého řetězce. Příklad:
řetězec strCol1=tětiva('Miluji');řetězec strCol2=tětiva(' vy');
strCol1+ =strCol2;
náklady<<strCol1<< ' n';
Výstupem je Miluji tě. Nezapomeňte, že strCol1 += strCol2 je stejné jako strCol1 = strCol1 +strCol2.
basic_string & operator+= (const charT* s)
Připojí doslovný řetězec ke kolekci řetězcových objektů. Příklad:
řetězec strCol=tětiva('Miluji');strCol+ = ' vy';
náklady<<strCol<< ' n';
Výstup: Miluji tě.
basic_string & operator+= (charT c)
Připojí jeden znak k řetězci objektu. Příklad:
řetězec strCol=tětiva('Miluji tě');strCol+ = 'u';
náklady<<strCol<< ' n';
Výstup: Miluji tě.
basic_string & operator+= (seznam inicializátorů)
Připojí seznam inicializátorů. Příklad:
řetězec strCol=tětiva('Miluji');strCol+ = {'','a','nebo','u',' 0'};
náklady<<strCol<< ' n';
Výstup: Miluji tě. Vždy je dobré přidat nul, 0 na konec seznamu inicializátorů znaků.
basic_string & append (const basic_string & str)
Připojí objekt řetězce argumentu k objektu hlavního řetězce. Příklad:
řetězec strCol1=tětiva('Miluji');řetězec strCol2=tětiva(' vy');
strCol1.připojit(strCol2);
náklady<<strCol1<< ' n';
Výstup: Miluji tě.
basic_string & append (const charT* s)
Připojí k hlavnímu řetězci argument doslovného řetězce. Příklad
řetězec strCol=tětiva('Miluji');strCol=strCol.připojit(' vy');
náklady<<strCol<< ' n';
Výstup: Miluji tě.
basic_string & append (seznam inicializátorů)
Připojí seznam inicializátorů, což je argument, k hlavnímu řetězci. Příklad:
řetězec strCol=tětiva('Miluji');strCol=strCol.připojit({'','a','nebo','u',' 0'});
náklady<<strCol<< ' n';
Výstup: Miluji tě. Vždy je dobré přidat na konec seznamu inicializátorů znak nula 0.
basic_string & append (size_type n, charT c)
Připojí n stejného znaku. Příklad:
řetězec strCol=tětiva('karta');strCol=strCol.připojit(2, 'nebo');
náklady<<strCol<< ' n';
Výstup: tabu.
basic_string & append (const charT* s, size_type n)
Připojí prvních n prvků řetězcového literálu k hlavnímu řetězcovému objektu. Příklad:
řetězec strCol=tětiva('Miluji');strCol=strCol.připojit(' ty také', 4);
náklady<<strCol<< ' n';
Výstup zní: Miluji tě. Pokud je n větší než délka literálu, je vyvolána výjimka length_error.
basic_string & append (const basic_string & str, size_type pos, size_type n = npos)
Připojí n znaků z indexu, pos do hlavního řetězce. Příklad:
řetězec strCol=tětiva('Miluji');strCol=strCol.připojit('jsi tak', 2, 4);
náklady<<strCol<< ' n';
Výstup: Miluji tě. Tady by se také hodila výjimka, viz později.
Přiřazení
basic_string&přiřadit(konstbasic_string&p)Přiřadí objekt řetězce argumentu hlavnímu řetězci a nahradí veškerý obsah, který tam byl.
řetězec strCol1=tětiva('Miluji tě');řetězec strCol2=tětiva('Potřebuje mě');
strCol1=strCol1.přiřadit(strCol2);
náklady<<strCol1<< ' n';
Výstup: Potřebuje mě.
basic_string&přiřadit(konstschéma*s)Přiřadí řetězcový doslovný argument hlavnímu řetězci a nahradí veškerý obsah, který tam byl.
řetězec strCol=tětiva('Miluji tě');strCol=strCol.přiřadit('Potřebuje mě');
náklady<<strCol<< ' n';
Výstup: Potřebuje mě.
basic_string&přiřadit(seznam inicializátorů<schéma>)Přiřadí argumentu seznamu inicializátorů k hlavnímu řetězci,nahrazující veškerý obsah, který tam byl.
[cc lang='C'utekl='skutečný'šířka='780']
řetězec strCol=tětiva('Miluji tě');
strCol=strCol.přiřadit({'S','h','A','','n','A','A','d','s','','m','A',' 0'});
náklady<<strCol<< ' n';
Výstup: Potřebuje mě. Je dobré vždy přidat nul, 0 na konec seznamu znaků, abyste vytvořili řetězcový literál.
basic_string&přiřadit(konstschéma*s,size_type n)Přiřadí prvním n znakům řetězcového doslovného argumentu hlavní řetězec a nahradí veškerý obsah, který tam byl.
řetězec strCol=tětiva('Miluji tě');strCol=strCol.přiřadit('Potřebuje mě', 9);
náklady<<strCol<< ' n';
Výstup: Potřebuje.
basic_string&přiřadit(size_type n,charC c)Přiřadí argument n stejných znaků hlavnímu řetězci a nahradí veškerý obsah, který tam byl.
řetězec strCol=tětiva('Miluji tě');strCol=strCol.přiřadit(4, 'A');
náklady<<strCol<< ' n';
Výstup: eeee
basic_string&přiřadit(konstbasic_string&p,size_type poz,size_type n=npos)
Přiřadí n znakům argumentu řetězcového objektu počínaje od pos k hlavnímu řetězci a nahradí veškerý obsah, který tam byl.
řetězec strCol=tětiva('Miluji tě');strCol=strCol.přiřadit('Potřebuje mě', 4, 5);
náklady<<strCol<< ' n';
Výstup: potřeby. Vyhodí výjimku - viz později.
Vkládání
basic_string&vložit(size_type poz, konstbasic_string&p)Vloží argument objektu řetězce do hlavního řetězce, v indexu, pos.
řetězec strCol1=tětiva('Miluji tě');řetězec strCol2=tětiva('nenávist a');
strCol1=strCol1.vložit(2,strCol2);
náklady<<strCol1<< ' n';
Výstup: Nenávidím a miluji tě. Vyhodí výjimku - viz později.
basic_string&vložit(size_type pos1, konstbasic_string&p,size_type pos2,size_type n=npos)
Vloží délku n znaků z pos2 argumentu string objektu, do hlavního řetězce, v indexu, pos1.
řetězec strCol1=tětiva('Miluji tě');řetězec strCol2=tětiva(„nenávidět, chtít a potřebovat“);
strCol1=strCol1.vložit(2,strCol2, 6, 9);
náklady<<strCol1<< ' n';
Výstup: Chci a miluji tě.
vložka iterátoru (const_iterator p, charT c)
Vloží konkrétní znak, což je argument, do polohy, na kterou iterátor ukazuje. Vrátí iterátor pro pozici nově vloženého znaku.
řetězec strCol=tětiva('Miluji tě');basic_string<char> ::iterátoriter=strCol.začít();
++iter; ++iter; ++iter; ++iter; ++iter; ++iter;
basic_string<char> ::iterátorsíť=strCol.vložit(iter, 'd');
náklady<< *síť<< ' n';
náklady<<strCol<< ' n';
Výstupem je:
'D'
miloval jsem tě
vložka iterátoru (const_iterator p, size_type n, charT c)
Vloží n stejného charakteru argumentu do pozice, na kterou ukazuje iterátor. Vrátí iterátor pro pozici začátku nově vložených stejných znaků.
řetězec strCol=tětiva('Záložka v zemi.');basic_string<char> ::iterátoriter=strCol.začít();
++iter; ++iter; ++iter;
basic_string<char> ::iterátorsíť=strCol.vložit(iter, 2, 'nebo');
náklady<< *síť<< ' n';
náklady<<strCol<< ' n';
Výstupem je:
'nebo'
Tabu v zemi.
basic_string&vložit(size_type poz, konstschéma*s)Vloží řetězec argumentu doslovný do indexu, pos do hlavního řetězce.
řetězec strCol=tětiva('Záložka v zemi.');strCol=strCol.vložit(3, 'oo');
náklady<<strCol<< ' n';
Výstup: Tabu v zemi.
basic_string&vložit(size_type poz, konstschéma*s,size_type n)Vloží prvních n znaků doslovného argumentu řetězce do indexu pos v hlavním řetězci.
řetězec strCol=tětiva('Záložka v zemi.');strCol=strCol.vložit(3, 'oooo', 2);
náklady<<strCol<< ' n';
Výstup: Tabu v zemi.
Výměna
basic_string&nahradit(size_type pos1,size_type n1, konstbasic_string&p))Nahradí n1 znaků v hlavním řetězcovém objektu z indexu, pos1, řetězcovým objektem argumentu.
řetězec strCol1=tětiva('Miluji tě');řetězec strCol2=tětiva('Nenávidím tě a');
strCol1=strCol1.nahradit(2, 4,strCol2);
náklady<<strCol1<< ' n';
Výstup: Nenávidím vás a vás. Vyhodí výjimku - viz později.
basic_string&nahradit(size_type pos1,size_type n1, konstbasic_string&p,size_type pos2,size_type n2=npos)
Nahradí n1 znaků v hlavním řetězcovém objektu z indexu, pos1, s n2 znaky objektu argumentového řetězce z indexu, pos2.
řetězec strCol1=tětiva('Miluji tě');řetězec strCol2=tětiva('nenávidíme jeho i ji');
strCol1=strCol1.nahradit(2, 4,strCol2, 3, 12);
náklady<<strCol1<< ' n';
Výstup: Nenávidím jeho i tebe.
basic_string&nahradit(size_type pos1,size_type n1, konstschéma*s,size_type n2)
Nahradí n1 znaků v hlavním řetězcovém objektu z indexu, pos1, prvními n2 znaky argumentu doslovného řetězce.
řetězec strCol1=tětiva('Miluji tě');strCol1=strCol1.nahradit(2, 4, 'nenávidět ho a ji', 12);
náklady<<strCol1<< ' n';
Výstup: Nenávidím jeho i tebe.
basic_string & replace (size_type pos, size_type n, const charT* s)
Nahradí n znaků v hlavním řetězcovém objektu z indexu, pos, argumentem doslovného řetězce.
řetězec strCol1=tětiva('Miluji tě');strCol1=strCol1.nahradit(2, 4, „nenávidím ho a“);
náklady<<strCol1<< ' n';
Výstup: Nenávidím jeho i tebe.
basic_string&nahradit(size_type pos1,size_type n1,size_type n2,charC c)Nahradí n1 znaků v hlavním řetězcovém objektu z indexu, pos1, n2 stejného znaku argumentu.
řetězec strCol1=tětiva('Je tam špatný tablet.');strCol1=strCol1.nahradit(9, 3, 2, 'nebo');
náklady<<strCol1<< ' n';
Výstup: Je tam špatné tabu.
vymazání iterátoru (const_iterator p)
Odebere znak na pozici, na kterou ukazuje iterátor; poté vrátí pozici iterátoru, která je nyní obsazena znakem, který byl vedle tohoto znaku (nebo end ()). Následující kód to ilustruje:
řetězec strCol=tětiva('abeceda');basic_string<char> ::iterátoriter=strCol.začít();
++iter; ++iter;
strCol.vymazat(iter);
náklady<<strCol[0] << '' <<strCol[1] << '
' <<strCol[2]<< ' n';
Výstup: a b d
basic_string&vymazat(size_type poz= 0,size_type n=npos)Odebere n znaků z indexu, poz.
řetězec strCol=tětiva('abeceda');strCol.vymazat(1, 2);
náklady<<strCol[0] << '' <<strCol[1] << ' n';
Výstup: a d
neplatné push_back (charT c)
Chcete -li přidat jeden znak na konec řetězce:
řetězec strCol=tětiva('abeceda');strCol.zatlačit zpátky('5');
náklady<<strCol<< ' n';
Výstup: abcd5
neplatné pop_back ()
Odebere poslední znak, aniž by jej vrátil. Velikost řetězce se zmenší o 1.
řetězec strCol=tětiva('abcde');strCol.pop_back();
náklady<<strCol<< ' n';
Výstup: abcd
void swap (basic_string & s)
Literály dvou řetězcových objektů lze zaměnit.
řetězec strCol1=tětiva(<id='post-69618 -__ DdeLink__781_3724385525'>na>'abcde');řetězec strCol2=tětiva('1234567');
strCol1.vyměnit(strCol2);
náklady<<strCol1<< ' n';
náklady<<strCol2<< ' n';
Výstupem je:
'1234567''abcde'
Řetězcové operace
const charT* c_str () konst noexcept
Vrátí ukazatel na první prvek řetězce. Ukazatel lze zvýšit.
konstřetězec strCol=tětiva('abcde');konst char*p=strCol.c_str();
náklady<< *p<< ' n';
++p;
náklady<< *p<< ' n';
Výstup je:
nab
Kvůli druhé konstantě v nadpisu nemůže program změnit žádný znak v řetězci. Stavbě předchází konst.
const charT* data () konst noexcept
Vrátí ukazatel na první prvek řetězce. Ukazatel lze zvýšit.
konstřetězec strCol=tětiva('abcde');konst char*p=strCol.data();
náklady<< *p<< ' n';
++p;
náklady<< *p<< ' n';
Výstup je:
nab
Kvůli druhé konstantě v nadpisu nemůže program změnit žádný znak v řetězci. Stavbě předchází konst.
basic_string substr (size_type pos = 0, size_type n = npos) const
Vrátí objekt řetězce n znaků pro dílčí řetězec začínající od indexu, pos.
konstřetězec strCol=tětiva('abcdefghij');konstřetězec retStr=strCol.substr(2, 4);
náklady<<retStr<< ' n';
Výstup: cdef
find () členské funkce
size_type find (const basic_string & str, size_type pos = 0) const noexcept
Hledá objekt podřetězce začínající od indexu, poz. Pokud je nalezen, vrátí začátek podřetězce v hlavním řetězci.
řetězec strCol=tětiva('My jsme svět!');řetězec strCol1=tětiva('the');
intna jednom=strCol.nalézt(strCol1, 2);
náklady<<na jednom<< ' n';
Výstup:
index: 7Vrací -1, pokud nebyl nalezen.
size_type find (const charT* s, size_type pos = 0) konst
Hledá podřetězcový doslovný začátek od indexu, poz. Pokud je nalezen, vrátí začátek podřetězce v hlavním řetězci.
řetězec strCol=tětiva('My jsme svět!');intna jednom=strCol.nalézt('jsou', 0);
náklady<<na jednom<< ' n';
Protože pos = 0 je výchozí, 0 v argumentu mohlo být vynecháno.
Výstup: 3
Vrací -1, pokud nebyl nalezen.
size_type find (const charT* s, size_type pos, size_type n) const
Hledá prvních n znaků podřetězcového literálu začínajícího z indexu, poz. Pokud je nalezen, vrátí začátek podřetězce v hlavním řetězci.
řetězec strCol=tětiva(„Největší chlapec“);intna jednom=strCol.nalézt('větší', 1, 3);
náklady<<na jednom<< ' n';
Výstup: 4
Vrací -1, pokud nebyl nalezen.
size_type find (charT c, size_type pos = 0) konst
Hledá znak, c počínaje indexem, poz. Pokud je nalezen, vrátí začátek podřetězce v hlavním řetězci. Pokud není nalezen, vrátí -1.
řetězec strCol=tětiva('My jsme svět!');intna jednom=strCol.nalézt('S');
náklady<<na jednom<< ' n';
Výstup: -1
Existují následující členské funkce reverse find ():
size_type rfind(konstbasic_string&p,size_type poz=npos) konstnoexcept;size_type rfind(konstschéma*s,size_type poz=npos) konst;
size_type rfind(konstschéma*s,size_type poz,size_type n) konst;
size_type rfind(charC c,size_type poz=npos) konst;
Porovnání funkcí členů
int porovnat (const basic_string & str) const noexcept
Porovná objekt řetězce argumentu s objektem hlavního řetězce. Pokud se hlavní řetězec objeví před argumentem (ve slovníku), vrátí kladné číslo. Pokud k němu dojde po hlavním řetězci, vrátí záporné číslo. Pokud jsou dva řetězce stejné, vrátí nulu.
řetězec strCol1=tětiva('dav');řetězec strCol2=tětiva('lidé');
intna jednom=strCol1.porovnat(strCol2);
náklady<<na jednom<< ' n';
Výstup: -13
int porovnat (const charT* s) konst
Stejné jako výše, ale argument je řetězcový doslovný.
řetězec strCol1=tětiva('lidé');intna jednom=strCol1.porovnat('lidé');
náklady<<na jednom<< ' n';
Výstup: 0
Operátory řetězců
Tyto operátory jsou použitelné pro řetězcové objekty a ne nutně pro řetězcové literály.
+
Zřetězí dva řetězcové objekty a vrátí zřetězení.
řetězec strCol1=tětiva('tančí na');řetězec strCol2=tětiva(' měsíc');
řetězec strCol=strCol1+strCol2;
náklady<<strCol<< ' n';
Výstup: tanec na Měsíci.
==
Vrací 1 pro true, pokud jsou objekty řetězce stejné; a nula pro false, pokud nejsou.
řetězec strCol1=tětiva('tančí na');řetězec strCol2=tětiva(' na Měsíci');
bool bl=strCol1==strCol2;
náklady<<bl<< ' n';
Výstup: 0
! =
Vrací 1, pokud nejsou řetězcové objekty stejné, a nula, pokud jsou.
řetězec strCol1=tětiva('tančí na');řetězec strCol2=tětiva(' na Měsíci');
bool bl=strCol1! =strCol2;
náklady<<bl<< ' n';
Výstup: 1
<
Vrátí 1, pokud je levý operand menší než pravý operand podle slovníku, nebo nula, pokud není.
řetězec strCol1=tětiva('tančí na');řetězec strCol2=tětiva(' na Měsíci');
bool bl=strCol1<strCol2;
náklady<<bl<< ' n';
Výstup: 0
U běžných znaků v C ++ jsou čísla ve vzestupném pořadí před velkými písmeny a před malými písmeny. Vesmírná postava přichází před nulou a všechny.
Typy znaků hlavního řetězce C ++
char
Typ char je původní typ C ++ a obvykle ukládá znak do 8 bitů.
char16_t
Tím se uloží postava na 16 bitů.
char32_t
Tím se uloží postava do 32 bitů.
wchar_t
char16_t a char32_t jsou široké znaky. wchar_t je široký charakter, který je proprietární a je definován implementací.
Tyto typy se nazývají vlastnosti. C ++ je však technicky označuje jako specializace vlastností. Tento článek se zaměřil na typ char. Přístup k ostatním typům je mírně odlišný - viz později.
Další funkce členů pro operaci řetězce
Podpisy dalších funkcí operací řetězců jsou:
size_type find_first_of(konstbasic_string&p,size_type poz= 0) konstnoexcept;size_type find_first_of(konstschéma*s,size_type poz,size_type n) konst;
size_type find_first_of(konstschéma*s,size_type poz= 0) konst;
size_type find_first_of(charC c,size_type poz= 0) konst;
size_type find_last_of(konstbasic_string&p,size_type poz=npos) konstnoexcept;
size_type find_last_of(konstschéma*s,size_type poz,size_type n) konst;
size_type find_last_of(konstschéma*s,size_type poz=npos) konst;
size_type find_last_of(charC c,size_type poz=npos) konst;
size_type find_first_not_of(konstbasic_string&p,size_type poz= 0) konstnoexcept;
size_type find_first_not_of(konstschéma*s,size_type poz,size_type n) konst;
size_type find_first_not_of(konstschéma*s,size_type poz= 0) konst;
size_type find_first_not_of(charC c,size_type poz= 0) konst;
size_type find_last_not_of(konstbasic_string&p,size_type poz=npos) konstnoexcept;
size_type find_last_not_of(konstschéma*s,size_type poz,size_type n) konst;
size_type find_last_not_of(konstschéma*s,size_type poz=npos) konst;
size_type find_last_not_of(charC c,size_type poz=npos) konst;
Závěr
C ++ má řetězcové literály a řetězcové objekty. Řetězcový objekt má sbírku znaků v pořadí, podobně jako pole znaků v pořadí. Rozdíl mezi kolekcí řetězců a polem je v tom, že kolekce řetězců se může zvětšovat nebo zmenšovat. Objekt řetězce je vytvořen (vytvořen) ze třídy řetězců. Řetězcový objekt je datová struktura s členskými funkcemi. Členské funkce lze zařadit pod nadpisy konstrukce objektů, přístup k prvkům, kapacita řetězce, členské funkce řetězce s argumenty iterátoru a návratovými typy a modifikátory řetězců. Rovněž existují řetězcové rovnosti a relační operátory.