Klase at Mga Bagay
Ang isang klase ay isang hanay ng mga variable at pag-andar na nagtutulungan; kung saan ang mga variable ay walang mga halagang nakatalaga. Kapag ang mga halaga ay itinalaga sa mga variable, ang klase ay magiging isang object. Ang iba't ibang mga halagang binigyan ng parehong klase ay nagreresulta sa iba't ibang mga bagay; iyon ay, iba't ibang mga bagay ay ang parehong klase na may iba't ibang mga halaga. Ang paglikha ng isang bagay mula sa isang klase ay sinasabing nagpapatibay ng bagay.
Ang pangalan, string, ay isang klase. Ang isang bagay na nilikha mula sa string class ay may isang napiling programmer na pangalan.
Ang isang pagpapaandar na kabilang sa klase ay kinakailangan upang masimulan ang isang bagay mula sa klase. Sa C ++, ang pagpapaandar na iyon ay may parehong pangalan sa pangalan ng klase. Ang mga bagay na nilikha (instantiated) mula sa klase ay may iba't ibang mga pangalan na ibinigay sa kanila, ng programmer.
Ang paglikha ng isang bagay mula sa isang klase ay nangangahulugang pagbuo ng object; nangangahulugan din ito ng pag-uudyok.
Ang isang C ++ na programa na gumagamit ng string class, nagsisimula sa mga sumusunod na linya sa tuktok ng file:
# isama# isama
gamit ang namespace std;
Ang unang linya ay para sa input / output. Ang pangalawang linya ay upang payagan ang programa na gamitin ang lahat ng mga tampok ng klase ng string. Pinapayagan ng pangatlong linya ang programa na gamitin ang mga pangalan sa karaniwang namespace.
Pag-overload ng isang Pag-andar
Kapag ang dalawa o higit pang magkakaibang mga lagda ng pag-andar ay may parehong pangalan, ang pangalan na iyon ay sinasabing sobra ang karga. Kapag tinawag ang isang pagpapaandar, ang bilang at uri ng mga argumento, alamin kung aling pagpapaandar ang naisakatuparan.
Konstruksyon
string ()
Ang sumusunod na pahayag ay bumubuo ng isang string ng zero haba na walang character.
Nagsisimula ito sa pangalan ng klase (uri ng bagay), string. Sinusundan ito ng pangalan para sa object string, na ibinigay ng programmer. Sumusunod ang operator ng pagtatalaga; pagkatapos ang pangalan ng tagagawa ay may walang laman na panaklong. Dito, ang strCol ay ang instantiated na bagay sa lahat ng mga kasapi ng data (mga katangian) at mga pagpapaandar ng miyembro (pamamaraan).
string (str)
Ito ay katulad ng nasa itaas, ngunit tumatagal ng alinman sa isang literal na string o isang identifier bilang isang argument, sa tagapagbuo. Ang sumusunod na pahayag ay naglalarawan nito:
Konstruksyon na may Listahan ng Initializer
Ang sumusunod na code ay naglalarawan nito:
string strCol=lubid({'Ako',','ang','o','v','At',','at','o','ikaw',' 0'});Ang literal na string ay mahal kita. Tandaan ang nul character sa dulo ng listahan ng initializer.
string (str, n)
Bumubuo ito ng isang koleksyon ng string, ng mga unang n character ng ibang string. Ang sumusunod na code ay naglalarawan nito:
charp[] = 'Mahal kita';string strCol=lubid(p, 6);
gastos<<strCol<< ' n';
Ang output ay mahal ko sa unang 6 na mga character mula sa Mahal kita. Tandaan: ang solong puwang ay isang character.
string (str, pos, n)
Bumubuo ito ng isang koleksyon ng string ng mga n character, simula sa zero-based na naka-index na posisyon, pos, ng isa pang string. Ang sumusunod na code ay naglalarawan nito:
charp[] = 'Mahal kita';string strCol=lubid(p, 2, 4);
gastos<<strCol<< ' n';
Ang output ay, pag-ibig.
Para sa dalawang kaso sa itaas, kung ang n ay mas malaki kaysa sa laki ng string, ang out_of_range na pagbubukod ay itinapon - tingnan sa paglaon.
string (n, 'c')
Bumubuo ng isang koleksyon ng mga n character, kung saan ang lahat ng mga character ay pareho. Isaalang-alang,
string strCol=lubid(5,'At');gastos<<strCol<< ' n';
Ang output ay, eeeee, 5 e.
Pagtatalaga ng isang String
Maaaring italaga ang isang string tulad ng sumusunod, pagkatapos na ideklara ang parehong mga string:
string strCol1=lubid('Mahal kita');string strCol2;
strCol2=strCol1;
gastos<<strCol2<< ' n';
Ang output ay, mahal kita.
Bumubuo sa Iterator
Ang isang iterator ay nagbibigay ng isang pangkaraniwang representasyon ng pag-scan, sa pamamagitan ng mga halaga ng isang koleksyon. Ang isang syntax upang lumikha ng isang string na may iterator, ay:
template<klase InputIterator>basic_string(Magsimula ang InputIterator,Pagtatapos ng InputIterator, ConstAllocator&
sa=Allocator());
Bumubuo ito ng isang string para sa saklaw [simulan, tapusin) - tingnan ang mga detalye sa paglaon.
Pagwawasak ng isang String
Upang sirain ang isang string, hayaan mo lang itong lumabas sa saklaw.
Pag-access sa Elementong String Class
Ang isang instantiated string object ay maaaring maging sub-scripted (index) tulad ng isang array. Nagsisimula ang pagbibilang ng index mula sa zero.
stringName [i]
Ang operasyon stringName [i] ay nagbabalik ng isang sanggunian sa character (elemento) sa iikaindex ng koleksyon ng character. Ang mga sumusunod na output ng code v:
string strCol=lubid('Mahal kita');charch=strCol[4];
gastos<<ch<< ' n';
stringName [i] const
Ang pagpapatakbo ng stringName [i] const ay naisakatuparan sa halip na stringName [i] kapag ang string object ay isang pare-pareho na object. Ginagamit ito sa sumusunod na code halimbawa:
Conststring strCol=lubid('Mahal kita');charch=strCol[4];
gastos<<ch<< ' n';
Ang expression ay nagbabalik ng isang pare-pareho na sanggunian sa iikaelemento ng string object. Wala sa mga elemento ng string ang maaaring mabago.
Pagtatalaga ng isang Character na may Subscript
Ang isang character ay maaaring italaga sa isang hindi pare-pareho na object ng string, tulad ng sumusunod:
string strCol=lubid('Tawag ko');strCol[2] = 'f';
gastos<<strCol<< ' n';
Ang output ay mahulog ako. Ang 'c' ay binago sa 'f'.
stringName.at (i)
Ang stringName.at (i) ay katulad ng stringName [i], ngunit ang stringName.at (i) ay mas maaasahan. Ipinapakita ng sumusunod na code kung paano ito dapat gamitin:
string strCol=lubid('Mahal kita');charch=strColsa(4);
gastos<<ch<< ' n';
Ang () ay talagang isang function ng miyembro ng klase ng string.
stringName.at (i) const
Ang stringName.at (i) const ay katulad ng stringName [i] const, ngunit ang stringName.at (i) const ay mas maaasahan. Ang stringName.at (i) const ay naisakatuparan sa halip na stringName.at (i) kapag ang string object ay isang pare-pareho na object ng string. Ginagamit ito sa sumusunod na code, halimbawa:
Conststring strCol=lubid('Mahal kita');charch=strColsa(4);
gastos<<ch<< ' n';
sa () const ay talagang isang function ng miyembro ng klase ng string.
Pagtatalaga ng isang Halaga gamit ang () Pag-andar
Ang isang halaga ay maaaring italaga sa isang hindi pare-pareho na object ng string, na may function na (), tulad ng sumusunod:
string strCol=lubid('Tawag ko');strColsa(2) = 'f';
gastos<<strCol<< ' n';
Ang output ay mahulog ako.
May problema sa Sub-scripting
Ang problema sa sub-scripting (pag-index) ay, na kung ang index ay wala sa saklaw, maaaring makuha ang maling resulta, o maaaring maglabas ng isang error sa run-time.
harap ()
Nagbabalik ito ng isang sanggunian sa unang elemento ng string object, nang hindi inaalis ang elemento. Ang output ng sumusunod na code ay 'I'.
string strCol=lubid('Mahal kita');charch=strColsa harap();
gastos<<ch<< ' n';
Ang character ay hindi inalis mula sa string object.
harap () const
Kapag ang konstruksyon ng object ng string ay naunahan ng const, ang expression na front () const ay naisagawa sa halip na harap (). Ginagamit ito sa sumusunod na code, halimbawa.
Conststring strCol=lubid('Mahal kita');charch=strColsa harap();
gastos<<ch<< ' n';
Ang isang pare-pareho na sanggunian ay naibalik. Ang elemento ay hindi inalis mula sa string object. Walang character na mababago para sa isang pare-pareho na object ng string.
likod ()
Nagbabalik ito ng isang sanggunian sa huling elemento ng string object, nang hindi inaalis ang elemento. Ang output ng sumusunod na code ay 'u'.
string strCol=lubid('Mahal kita');charch=strColbumalik();
gastos<<ch<< ' n';
likod () const
Kapag ang pagbuo ng string object ay naunahan ng const, ang expression back () const ay naisakatuparan sa halip na pabalik (). Ginagamit ito sa sumusunod na code, halimbawa.
Conststring strCol=lubid('Mahal kita');charch=strColbumalik();
gastos<<ch<< ' n';
Ang isang pare-pareho na sanggunian ay naibalik. Ang elemento ay hindi inalis mula sa string object.
Kapasidad sa String
size_type kapasidad () const noexcept
Ang kabuuang bilang ng mga character na maaaring hawakan ng string nang hindi nangangailangan ng reallocation, naibalik ng pagpapaandar ng miyembro ng kapasidad na ito. Ang isang segment ng code para dito ay:
string strCol=lubid();intsa isa=strColkapasidad();
gastos<<sa isa<< ' n';
Ang output ay 15 sa aking computer.
reserba (n)
Ang memorya ng puwang ay hindi palaging magagamit sa libreng tindahan. Ang ekstrang puwang ay maaaring maipareserba nang maaga. Isaalang-alang ang sumusunod na segment ng code:
string strCol=lubid('mahal');strColnakareserba(6);
gastos<<strColkapasidad() << ' n';
Ang output ay 15 sa aking computer.
laki () const noexcept
Ibinabalik nito ang bilang ng mga character sa string. Ang sumusunod na code ay naglalarawan:
string strCol=lubid('Mahal kita');intsa isa=strCollaki();
gastos<<sa isa<< ' n';
Ang output ay 10, na hindi kasama ang nul, 0 character.
haba () const noexcept
-pareho sa laki().Tandaan:laki() <=kapasidad().
Lumiit para magkasya()
Maaaring mabawasan ang kapasidad () sa laki () sa pamamagitan ng pagdudulot ng reallocation; hindi ito sapilitan. Ipinapakita ito ng sumusunod na code:
string strCol=lubid('Mahal kita');strColnakareserba(12);
strColLumiit para magkasya();
ints=strCollaki();
gastos<<s<< ' n';
Ang output ay 10 at hindi 12 o 16. Ang function ay nagbabalik walang bisa.
baguhin ang laki (sz), baguhin ang laki (sz, 'c')
Binabago nito ang laki ng string. Kung ang bagong sukat ay mas maliit kaysa sa dating laki, kung gayon ang mga elemento patungo sa dulo ay nabura. Kung ang bagong laki ay mas mahaba, pagkatapos ang ilang mga default na character ay idinagdag sa pagtatapos. Upang maidagdag ang isang partikular na character, gamitin ang function na baguhin ang laki () na may dalawang mga argument. Ang sumusunod na segment ng code ay naglalarawan ng paggamit ng dalawang pag-andar:
string strCol=lubid('Mahal kita');strColbaguhin ang laki(6);
gastos<< 'Bagong laki ng strCol:' <<strCollaki() << ' n';
string strCol1=lubid('Mahal ko', 'At');
strCol1.baguhin ang laki(12);
gastos<< 'Bagong laki ng strCol1:' <<strCol1.laki() << ' n';
Ang output ay:
Bagong laki ng strCol: 6Bagong laki ng strCol1: 12
Ang function ay nagbabalik walang bisa.
malinaw () walang eksep
Inaalis ang lahat ng mga elemento mula sa string, tulad ng inilalarawan ng sumusunod na code segment:
string strCol=lubid('Mahal kita');strColmalinaw();
gastos<<strCollaki() << ' n';
Ang output ay 0. Ang function ay nagbabalik walang bisa.
walang laman () const noexcept
Ibinabalik nito ang 1 para sa totoo kung walang character sa string object, o 0 para sa false kung ang string object ay hindi walang laman. Ang sumusunod na code ay naglalarawan nito:
string strCol1=lubid('Mahal kita');gastos<<strCol1.walang laman() << ' n';
string strCol2=lubid();
gastos<<strCol2.walang laman() << ' n';
Ang output ay:
01
Mga Bumabalik na Iterator at ang String Class
Ang isang iterator ay tulad ng isang pointer ngunit may higit na pag-andar kaysa sa pointer.
magsimula () walang eksep
Nagbabalik ng isang iterator na tumuturo sa unang character (elemento) ng string object, tulad ng sa sumusunod na segment ng code:
string strCol=lubid('Mahal kita');basic_string<char> ::paulit-ulititer=strColmagsimula();
gastos<< *iter<< ' n';
Ang output ay 'I'. Tandaan ang paraan ng pagdeklara na tumatanggap ng iterator, ay idineklara. Ang iterator ay dinepresenta sa isang expression ng pagbabalik upang makuha ang halaga, sa parehong paraan, na ang isang pointer ay na-disferferensya.
simulan () const noexcept;
Nagbabalik ng isang umuulit na tumuturo sa unang elemento ng koleksyon ng object ng string. Kapag ang pagbuo ng bagay ay naunahan ng const, ang expression na magsisimula () ay naisakatuparan sa halip na magsimula (). Sa ilalim ng kondisyong ito, ang katumbas na elemento sa bagay ay hindi maaaring mabago. Ginagamit ito sa sumusunod na code, halimbawa.
Conststring strCol=lubid('Mahal kita');basic_string<char> ::Const_iteratoriter=strColmagsimula();
gastos<< *iter<< ' n';
Ang output ay 'I'. Tandaan na ang Const_iterator ay ginamit sa oras na ito, sa halip na iterator lamang, upang matanggap ang naibalik na iterator.
magtapos () walang eksep
Nagbabalik ng isang umuulit na tumuturo kaagad na lampas sa huling elemento ng bagay na string. Isaalang-alang ang sumusunod na segment ng code:
string strCol=lubid('Mahal kita');basic_string<char> ::paulit-ulititer=strColmagtapos();
gastos<< *iter<< ' n';
Ang output ay null, na kung saan ay wala, dahil walang kongkretong elemento na lampas sa huling elemento.
pagtatapos () const noexcept
Nagbabalik ng isang umuulit na tumuturo kaagad na lampas sa huling elemento ng bagay na string. Kapag ang pagbuo ng string object ay naunahan ng const, ang expression end () const ay naisakatuparan sa halip na end (). Isaalang-alang ang sumusunod na segment ng code:
Conststring strCol=lubid('Mahal kita');basic_string<char> ::Const_iteratoriter=strColmagtapos();
gastos<< *iter<< ' n';
Null ang output. Tandaan na ang Const_iterator ay ginamit sa oras na ito, sa halip na iterator lamang, upang matanggap ang naibalik na iterator.
Baliktarin ang Iteration
Posibleng magkaroon ng isang umuulit na umuulit mula sa aktwal na dulo hanggang sa bago ang unang elemento:
rbegin () walang eksep
Nagbabalik ng isang iterator na tumuturo sa huling elemento ng string instantiated object, tulad ng sa sumusunod na segment ng code:
string strCol=lubid('Mahal kita');basic_string<char> ::reverse_iteratoriter=strColrbegin();
gastos<< *iter<< ' n';
Ang output ay 'u'. Tandaan kung paano idineklara ang deklarasyong tumatanggap ng reverse iterator. Ang iterator ay dinepresenta sa isang expression ng pagbabalik upang makuha ang halaga, sa parehong paraan, na ang isang pointer ay na-disferferensya.
rbegin () const noexcept;
Nagbabalik ng isang iterator na tumuturo sa huling elemento ng string object. Kapag ang pagbuo ng bagay ay naunahan ng const, ang expression na rbegin () const ay naisagawa sa halip na rbegin (). Sa ilalim ng kondisyong ito, ang katumbas na elemento sa bagay ay hindi maaaring mabago. Ang tampok ay ginagamit sa sumusunod na code, halimbawa.
Conststring strCol=lubid('Mahal kita');basic_string<char> ::Const_reverse_iteratoriter=strColrbegin();
gastos<< *iter<< ' n';
Ang output ay 'u'. Tandaan na ang const_reverse_iterator ay ginamit sa oras na ito, sa halip na reverse_iterator lamang, upang matanggap ang naibalik na iterator.
mag-render () nang walang eksepto
Nagbabalik ng isang umuulit na tumuturo bago ang unang elemento ng bagay na string. Isaalang-alang ang sumusunod na segment ng code:
string strCol=lubid('Mahal kita');basic_string<char> ::reverse_iteratoriter=strColgumagawa();
gastos<< *iter<< ' n';
Ang output ay null, na kung saan ay wala, dahil walang kongkretong elemento bago ang unang elemento.
render () const noexcept
Nagbabalik ng isang umuulit na tumuturo bago ang unang elemento ng bagay na string. Kapag ang pagbuo ng bagay ay naunahan ng const, ang expression rend () const ay naisakatuparan sa halip na rend (). Isaalang-alang ang sumusunod na segment ng code:
Conststring strCol=lubid('Mahal kita');basic_string<char> ::Const_reverse_iteratoriter=strColgumagawa();
gastos<< *iter<< ' n';
Null ang output. Tandaan na ang const_reverse_iterator ay ginamit sa oras na ito, sa halip na reverse_iterator lamang, upang matanggap ang naibalik na iterator.
Mga Modifier ng String
Ang isang modifier na binabago ang string object, maaari ring kumuha o bumalik ng isang iterator.
Nagdadagdag
basic_string&operator+ =(Constbasic_string&p)Nagdaragdag ng tamang object ng string sa kaliwang string object. Halimbawa:
string strCol1=lubid('Mahal ko');string strCol2=lubid(' ikaw');
strCol1+ =strCol2;
gastos<<strCol1<< ' n';
Ang output mahal kita. Huwag kalimutan na ang strCol1 + = strCol2 ay kapareho ng strCol1 = strCol1 + strCol2.
basic_string at operator + = (const charT * s)
Nagdaragdag ng isang literal na string sa isang koleksyon ng object ng string. Halimbawa:
string strCol=lubid('Mahal ko');strCol+ = ' ikaw';
gastos<<strCol<< ' n';
Output: Mahal kita.
basic_string at operator + = (charT c)
Nagdaragdag ng isang solong character sa isang string ng object. Halimbawa:
string strCol=lubid('Mahal kita');strCol+ = 'ikaw';
gastos<<strCol<< ' n';
Output: Mahal kita.
basic_string at operator + = (initializer_list)
Nagdadagdag ng isang listahan ng initializer. Halimbawa:
string strCol=lubid('Mahal ko');strCol+ = {','at','o','ikaw',' 0'};
gastos<<strCol<< ' n';
Output: Mahal kita. Palaging mabuti na idagdag ang nul, 0 sa dulo ng isang listahan ng inisyal na character.
basic_string at idagdag (const basic_string & str)
Nagdadagdag ng object ng argument string sa pangunahing object ng string. Halimbawa:
string strCol1=lubid('Mahal ko');string strCol2=lubid(' ikaw');
strCol1.idugtong(strCol2);
gastos<<strCol1<< ' n';
Output: Mahal kita.
basic_string at idagdag (const charT * s)
Nagdaragdag ng isang literal na argumento ng string sa pangunahing string. Halimbawa
string strCol=lubid('Mahal ko');strCol=strColidugtong(' ikaw');
gastos<<strCol<< ' n';
Output: Mahal kita.
basic_string at idagdag (initializer_list)
Ikinalalagay ang listahan ng initializer, na kung saan ay isang argument, sa pangunahing string. Halimbawa:
string strCol=lubid('Mahal ko');strCol=strColidugtong({','at','o','ikaw',' 0'});
gastos<<strCol<< ' n';
Output: Mahal kita. Palaging mabuti na idagdag ang nul, 0 character sa dulo ng isang listahan ng initializer.
basic_string at idagdag (size_type n, charT c)
Lumalabas n ng parehong karakter. Halimbawa:
string strCol=lubid('tab');strCol=strColidugtong(2, 'o');
gastos<<strCol<< ' n';
Output: bawal.
basic_string at idagdag (const charT * s, size_type n)
Nagdaragdag ng mga unang n elemento ng isang string na literal sa pangunahing string object. Halimbawa:
string strCol=lubid('Mahal ko');strCol=strColidugtong('ikaw kaya', 4);
gastos<<strCol<< ' n';
Ang kinalabasan ay: Mahal kita. Kung ang n ay mas malaki kaysa sa haba ng literal, isang pagbubukod ng haba ng_rorror ang itinapon.
basic_string & idagdag (const basic_string & str, size_type pos, size_type n = npos)
Nagdaragdag ng mga n character mula sa index, pos sa pangunahing string. Halimbawa:
string strCol=lubid('Mahal ko');strCol=strColidugtong(ikaw ba ', 2, 4);
gastos<<strCol<< ' n';
Output: Mahal kita. Ang isang pagbubukod ay itatapon din dito, tingnan sa paglaon.
Pagtatalaga
basic_string&magtalaga(Constbasic_string&p)Itinatalaga ang object ng argument string sa pangunahing string, na pinapalitan ang anumang nilalaman na naroon.
string strCol1=lubid('Mahal kita');string strCol2=lubid('Kailangan niya ako');
strCol1=strCol1.magtalaga(strCol2);
gastos<<strCol1<< ' n';
Output: Kailangan niya ako.
basic_string&magtalaga(ConstcharT*s)Nagtatalaga ng isang string literal na argument sa pangunahing string, na pinapalitan ang anumang nilalaman na naroon.
string strCol=lubid('Mahal kita');strCol=strColmagtalaga('Kailangan niya ako');
gastos<<strCol<< ' n';
Output: Kailangan niya ako.
basic_string&magtalaga(initializer_list<charT>)Nagtatalaga ng isang argumento ng listahan ng tagapagpasimula sa pangunahing string,pinapalitan ang anumang nilalaman na naroon.
[cc lang='c'nakatakas='totoo'lapad='780']
string strCol=lubid('Mahal kita');
strCol=strColmagtalaga({'S','h','At',','n','At','At','d','s',','m','At',' 0'});
gastos<<strCol<< ' n';
Output: Kailangan niya ako. Mabuti na palaging idagdag ang nul, 0 sa dulo ng listahan ng character, upang makabuo ng isang string na literal.
basic_string&magtalaga(ConstcharT*s,size_type n)Nagtatalaga ng mga unang n character ng isang string literal na argument sa pangunahing string, na pinapalitan ang anumang nilalaman na naroon.
string strCol=lubid('Mahal kita');strCol=strColmagtalaga('Kailangan niya ako', 9);
gastos<<strCol<< ' n';
Output: Kailangan niya.
basic_string&magtalaga(size_type n,charT c)Nagtatalaga ng isang argument ng n ng parehong mga character sa pangunahing string, na pinapalitan ang anumang nilalaman na naroon.
string strCol=lubid('Mahal kita');strCol=strColmagtalaga(4, 'At');
gastos<<strCol<< ' n';
Output: eeee
basic_string&magtalaga(Constbasic_string&p,size_type pos,size_type n=npos)
Nagtatalaga ng mga n character ng isang argument ng string object, simula sa pos, hanggang sa pangunahing string, na pinapalitan ang anumang nilalaman na naroon.
string strCol=lubid('Mahal kita');strCol=strColmagtalaga('Kailangan niya ako', 4, 5);
gastos<<strCol<< ' n';
Output: pangangailangan. Magtapon ng isang pagbubukod - tingnan sa paglaon.
Pagsingit
basic_string&ipasok(size_type pos, Constbasic_string&p)Ipasok ang argument ng string object sa pangunahing string, sa index, pos.
string strCol1=lubid('Mahal kita');string strCol2=lubid('hate at');
strCol1=strCol1.ipasok(2,strCol2);
gastos<<strCol1<< ' n';
Output: Ayaw ko at mahal kita. Magtapon ng isang pagbubukod - tingnan sa paglaon.
basic_string&ipasok(size_type pos1, Constbasic_string&p,size_type pos2,size_type n=npos)
Nagpapasok ng haba ng n character mula sa pos2 ng string object argument, sa pangunahing string, sa index, pos1.
string strCol1=lubid('Mahal kita');string strCol2=lubid('hate, gusto at kailangan');
strCol1=strCol1.ipasok(2,strCol2, 6, 9);
gastos<<strCol1<< ' n';
Output: Gusto ko at mahal kita.
iterator insert (const_iterator p, charT c)
Nagpapasok ng isang partikular na character, na kung saan ay isang argument, sa posisyong itinuro ng umuulit. Nagbabalik ng isang umuulit para sa posisyon ng bagong pinasok na character.
string strCol=lubid('Mahal kita');basic_string<char> ::paulit-ulititer=strColmagsimula();
++iter; ++iter; ++iter; ++iter; ++iter; ++iter;
basic_string<char> ::paulit-ulitnetwork=strColipasok(iter, 'd');
gastos<< *network<< ' n';
gastos<<strCol<< ' n';
Ang output ay:
‘D’
minahal kita
iterator insert (const_iterator p, size_type n, charT c)
Ipasok ang n ng parehong karakter ng argument, sa posisyon, na itinuro ng umuulit. Nagbabalik ng isang umuulit para sa posisyon ng simula ng bagong ipinasok na parehong mga character.
string strCol=lubid('Tab sa lupa.');basic_string<char> ::paulit-ulititer=strColmagsimula();
++iter; ++iter; ++iter;
basic_string<char> ::paulit-ulitnetwork=strColipasok(iter, 2, 'o');
gastos<< *network<< ' n';
gastos<<strCol<< ' n';
Ang output ay:
'o'
Bawal sa lupa.
basic_string&ipasok(size_type pos, ConstcharT*s)Nagpapasok ng isang literal na argument ng string sa index, pos sa pangunahing string.
string strCol=lubid('Tab sa lupa.');strCol=strColipasok(3, 'oo');
gastos<<strCol<< ' n';
Output: Bawal sa lupa.
basic_string&ipasok(size_type pos, ConstcharT*s,size_type n)Isingit ang mga unang n character ng argument ng string literal, sa index, pos sa pangunahing string.
string strCol=lubid('Tab sa lupa.');strCol=strColipasok(3, 'oooo', 2);
gastos<<strCol<< ' n';
Output: Bawal sa lupa.
Pinapalitan
basic_string&palitan(size_type pos1,size_type n1, Constbasic_string&p))Pinapalitan ang mga n1 character sa pangunahing object ng string mula sa index, pos1, ng object ng string string.
string strCol1=lubid('Mahal kita');string strCol2=lubid('hate you and');
strCol1=strCol1.palitan(2, 4,strCol2);
gastos<<strCol1<< ' n';
Output: Ayaw kita at ikaw. Magtapon ng isang pagbubukod - tingnan sa paglaon.
basic_string&palitan(size_type pos1,size_type n1, Constbasic_string&p,size_type pos2,size_type n2=npos)
Pinapalitan ang mga n1 character sa pangunahing object ng string mula sa index, pos1, na may n2 na mga character ng argument string object mula sa index, pos2.
string strCol1=lubid('Mahal kita');string strCol2=lubid('galit kami sa kanya at sa kanya');
strCol1=strCol1.palitan(2, 4,strCol2, 3, 12);
gastos<<strCol1<< ' n';
Output: Kinamumuhian ko siya at ikaw.
basic_string&palitan(size_type pos1,size_type n1, ConstcharT*s,size_type n2)
Pinapalitan ang mga n1 character sa pangunahing object ng string mula sa index, pos1, sa mga unang n2 character ng literal na argument ng string.
string strCol1=lubid('Mahal kita');strCol1=strCol1.palitan(2, 4, 'hate him and her', 12);
gastos<<strCol1<< ' n';
Output: Kinamumuhian ko siya at ikaw.
basic_string & palitan (size_type pos, size_type n, const charT * s)
Pinapalitan ang mga n character sa pangunahing object ng string mula sa index, pos, na may literal na argumento ng string.
string strCol1=lubid('Mahal kita');strCol1=strCol1.palitan(2, 4, 'hate him and');
gastos<<strCol1<< ' n';
Output: Kinamumuhian ko siya at ikaw.
basic_string&palitan(size_type pos1,size_type n1,size_type n2,charT c)Pinapalitan ang mga n1 character sa pangunahing object ng string mula sa index, pos1, na may n2 ng parehong character ng argument.
string strCol1=lubid('Isang masamang tablet doon.');strCol1=strCol1.palitan(9, 3, 2, 'o');
gastos<<strCol1<< ' n';
Output: Isang masamang bawal doon ..
iterator burahin (Const_iterator p)
Tinatanggal ang isang character sa posisyon na itinuro ng iterator; pagkatapos ay ibabalik ang posisyon ng iterator, na ngayon ay sinasakop ng character na katabi ng character na ito (o end ()). Ang sumusunod na code ay naglalarawan nito:
string strCol=lubid('a B C D');basic_string<char> ::paulit-ulititer=strColmagsimula();
++iter; ++iter;
strColburahin(iter);
gastos<<strCol[0] << ' <<strCol[1] << '
' <<strCol[2]<< ' n';
Ang output: a b d
basic_string&burahin(size_type pos= 0,size_type n=npos)Inaalis ang mga n character mula sa index, pos.
string strCol=lubid('a B C D');strColburahin(1, 2);
gastos<<strCol[0] << ' <<strCol[1] << ' n';
Output: a d
walang bisa ang push_back (charT c)
Upang magdagdag ng isang solong character sa dulo ng string:
string strCol=lubid('a B C D');strColpush_back('5');
gastos<<strCol<< ' n';
Output: abcd5
walang bisa pop_back ()
Tinatanggal ang huling character nang hindi naibabalik ito. Ang laki ng string ay nabawasan ng 1.
string strCol=lubid('abcde');strColpop_back();
gastos<<strCol<< ' n';
Output: abcd
void swap (basic_string & s)
Ang mga literal ng dalawang mga bagay na string ay maaaring mapalitan.
string strCol1=lubid(<isang id='post-69618 -__ DdeLink__781_3724385525'>sa>'abcde');string strCol2=lubid('1234567');
strCol1.magpalit(strCol2);
gastos<<strCol1<< ' n';
gastos<<strCol2<< ' n';
Ang output ay:
'1234567''abcde'
Mga Pagpapatakbo ng String
const charT * c_str () const noexcept
Ibinabalik ang isang pointer sa unang elemento ng string. Ang pointer ay maaaring madagdagan.
Conststring strCol=lubid('abcde');Const char*p=strColc_str();
gastos<< *p<< ' n';
++p;
gastos<< *p<< ' n';
Ang output ay:
sab
Dahil sa pangalawang const sa heading, ang programa ay hindi maaaring baguhin ang anumang character sa string. Ang konstruksyon ay naunahan ng const.
Const charT * data () const noexcept
Ibinabalik ang isang pointer sa unang elemento ng string. Ang pointer ay maaaring madagdagan.
Conststring strCol=lubid('abcde');Const char*p=strColdata();
gastos<< *p<< ' n';
++p;
gastos<< *p<< ' n';
Ang output ay:
sab
Dahil sa pangalawang const sa heading, ang programa ay hindi maaaring baguhin ang anumang character sa string. Ang konstruksyon ay naunahan ng const.
basic_string substr (size_type pos = 0, size_type n = npos) const
Nagbabalik ng isang string object ng n character para sa sub-string na nagsisimula mula sa index, pos.
Conststring strCol=lubid('abcdefghij');Conststring retStr=strColsubstr(2, 4);
gastos<<retStr<< ' n';
Output: cdef
hanapin () Mga Pag-andar ng Miyembro
size_type find (const basic_string & str, size_type pos = 0) const noexcept
Naghahanap para sa isang bagay na sub-string na nagsisimula sa index, pos. Kung nahanap, ibabalik ang simula ng sub-string sa pangunahing string.
string strCol=lubid('Tayo ang mundo!');string strCol1=lubid('ang');
intsa isa=strColhanapin(strCol1, 2);
gastos<<sa isa<< ' n';
Output:
index: 7Nagbabalik -1, kapag hindi nahanap.
size_type find (const charT * s, size_type pos = 0) const
Naghahanap ng isang literal na sub-string na nagsisimula sa index, pos. Kung nahanap, ibabalik ang simula ng sub-string sa pangunahing string.
string strCol=lubid('Tayo ang mundo!');intsa isa=strColhanapin('ay', 0);
gastos<<sa isa<< ' n';
Dahil ang pos = 0 ay ang default, 0 sa pagtatalo ay maaaring tinanggal.
Output: 3
Nagbabalik -1, kapag hindi nahanap.
size_type find (const charT * s, size_type pos, size_type n) const
Naghahanap ng mga unang n character ng isang sub-string na literal na nagsisimula sa index, pos. Kung nahanap, ibabalik ang simula ng sub-string sa pangunahing string.
string strCol=lubid('Ang pinakamalaking lalaki');intsa isa=strColhanapin('mas malaki', 1, 3);
gastos<<sa isa<< ' n';
Output: 4
Nagbabalik -1, kapag hindi nahanap.
size_type find (charT c, size_type pos = 0) const
Hinahanap ang character, c simula sa index, pos. Kung nahanap, ibabalik ang simula ng sub-string sa pangunahing string. Kung hindi nahanap, ibabalik -1.
string strCol=lubid('Tayo ang mundo!');intsa isa=strColhanapin('Sa');
gastos<<sa isa<< ' n';
Output: -1
Ang mga sumusunod na reverse find () na pagpapaandar ng miyembro ay mayroon:
size_type rfind(Constbasic_string&p,size_type pos=npos) Constnoexcept;size_type rfind(ConstcharT*s,size_type pos=npos) Const;
size_type rfind(ConstcharT*s,size_type pos,size_type n) Const;
size_type rfind(charT c,size_type pos=npos) Const;
Mga Pag-andar ng Miyembro sa Paghahambing
int ihambing (const basic_string & str) const noexcept
Kinukumpara ang object ng string string sa pangunahing object ng string. Kung ang pangunahing string ay nangyayari bago ang argumento (sa diksyonaryo) nagbabalik ito ng isang positibong numero. Kung nangyari ito pagkatapos ng pangunahing string, nagbabalik ito ng isang negatibong numero. Kung ang dalawang mga string ay pareho, ibabalik ito sa zero.
string strCol1=lubid('crowd');string strCol2=lubid('tao');
intsa isa=strCol1.ihambing(strCol2);
gastos<<sa isa<< ' n';
Output: -13
int ihambing (const charT * s) const
Parehas sa itaas, ngunit ang argumento ay isang literal na string.
string strCol1=lubid('tao');intsa isa=strCol1.ihambing('tao');
gastos<<sa isa<< ' n';
Output: 0
Mga Operator ng String
Nalalapat ang mga operator na ito sa mga bagay ng string at hindi kinakailangang mga string literal.
+
Pinagsasama ang dalawang bagay sa string, at ibinabalik ang pagsasabay.
string strCol1=lubid('sumasayaw sa');string strCol2=lubid(' ang buwan');
string strCol=strCol1+strCol2;
gastos<<strCol<< ' n';
Output: pagsasayaw sa buwan.
==
Ibinabalik ang 1 para sa totoo, kung ang mga string object ay pareho; at zero para sa hindi totoo, kung hindi.
string strCol1=lubid('sumasayaw sa');string strCol2=lubid('sa buwan');
bool bl=strCol1==strCol2;
gastos<<bl<< ' n';
Output: 0
! =
Ibinabalik ang 1 kung ang mga string object ay hindi pareho, at zero kung ang mga ito.
string strCol1=lubid('sumasayaw sa');string strCol2=lubid('sa buwan');
bool bl=strCol1! =strCol2;
gastos<<bl<< ' n';
Output: 1
<
Ibinabalik ang 1, kung ang kaliwang operand ay mas mababa kaysa sa tamang operan ayon sa diksyunaryo, o zero kung hindi.
string strCol1=lubid('sumasayaw sa');string strCol2=lubid('sa buwan');
bool bl=strCol1<strCol2;
gastos<<bl<< ' n';
Output: 0
Para sa mga ordinaryong character sa C ++, sa pataas na pagkakasunud-sunod, ang mga numero ay nauna sa mga malalaking titik, na dating bago ang mga maliliit na titik. Ang character space ay nauna bago ang zero at lahat ng mga ito.
C ++ Pangunahing Mga Uri ng Katangian ng String
char
Ang uri ng char ay ang orihinal na uri ng C ++ at karaniwang mag-iimbak ng isang character sa 8 bits.
char16_t
Nag-iimbak ito ng isang character sa 16 bits.
char32_t
Nag-iimbak ito ng character sa 32 bit.
wchar_t
ang char16_t at char32_t ay malawak na mga character. Ang wchar_t ay isang malawak na character na pagmamay-ari at tinukoy ng pagpapatupad.
Ang mga uri ay tinatawag na mga ugali. Gayunpaman, ang C ++ ay tumutukoy sa mga ito sa teknikal na bilang, pagdadalubhasa ng mga ugali. Ang artikulong ito ay nakatuon sa uri ng char. Ang diskarte sa iba pang mga uri ay bahagyang naiiba - tingnan sa paglaon.
Iba pang Mga Pag-andar ng Miyembro ng String Operation
Ang mga lagda ng iba pang mga pagpapaandar sa pagpapatakbo ng string ay:
size_type find_first_of(Constbasic_string&p,size_type pos= 0) Constnoexcept;size_type find_first_of(ConstcharT*s,size_type pos,size_type n) Const;
size_type find_first_of(ConstcharT*s,size_type pos= 0) Const;
size_type find_first_of(charT c,size_type pos= 0) Const;
size_type find_last_of(Constbasic_string&p,size_type pos=npos) Constnoexcept;
size_type find_last_of(ConstcharT*s,size_type pos,size_type n) Const;
size_type find_last_of(ConstcharT*s,size_type pos=npos) Const;
size_type find_last_of(charT c,size_type pos=npos) Const;
size_type find_first_not_of(Constbasic_string&p,size_type pos= 0) Constnoexcept;
size_type find_first_not_of(ConstcharT*s,size_type pos,size_type n) Const;
size_type find_first_not_of(ConstcharT*s,size_type pos= 0) Const;
size_type find_first_not_of(charT c,size_type pos= 0) Const;
size_type find_last_not_of(Constbasic_string&p,size_type pos=npos) Constnoexcept;
size_type find_last_not_of(ConstcharT*s,size_type pos,size_type n) Const;
size_type find_last_not_of(ConstcharT*s,size_type pos=npos) Const;
size_type find_last_not_of(charT c,size_type pos=npos) Const;
Konklusyon
Ang C ++ ay may mga string literal at string object. Ang string object ay may isang koleksyon ng mga character sa pagkakasunud-sunod, katulad ng isang hanay ng mga character sa pagkakasunud-sunod. Ang pagkakaiba sa pagitan ng koleksyon ng string at ng isang array, ay, ang koleksyon ng string ay maaaring lumago sa haba o lumiit ang haba. Ang isang string object ay instantiated (itinayo) mula sa isang string class. Ang isang string object ay isang istraktura ng data na may mga pagpapaandar ng miyembro. Ang mga pagpapaandar ng miyembro ay maaaring maiuri sa ilalim ng mga heading ng pagtatayo ng bagay, pag-access ng elemento, kapasidad ng string, pag-andar ng miyembro ng string na may mga argumento ng iterator at mga uri ng pagbabalik, at mga modifier ng string. Umiiral din ang pagkakapantay-pantay ng mga string at pagkarelasyon operator.