Literal na Katangian
Ang isang literal na character ay isang character sa iisang mga quote. Kaya,
charident1= 'TO'; charident2= 'b'; charident3= '4'; charident4= '6';
ang lahat ay magkakaibang kahulugan ng mga character. Tandaan na ang isang digit sa iisang mga quote ay isang character at hindi isang integer.
Ang isang pagkakasunud-sunod ng pagtakas tulad ng (tingnan sa ibaba) sa iisang mga quote, ay isang character. Kaya,
charident1= '' ';
ay isang tauhan.
Ang isang solong simbolo sa dobleng-quote ay hindi isang character; ito ay isang string ng isang character. Kaya ang A o c o 2 ay hindi isang character ngunit isang string ng bawat character bawat isa.
Ang variable ng isang char ay maaaring maitalaga muli, pagkatapos ay pababa sa programa, tulad ng sumusunod:
charident= 'x';
ident= 'AT';
Upang ihinto ang isang character na nakatalaga sa isang identifier mula sa pagbabago, sa paglaon pababa sa programa, paunahin ang kahulugan sa nakalaan na salita, const, tulad ng sumusunod:
Const charident= 'd';Ang variable, ident ay sinasabing read-only.
String Literal
Ang isang literal na string ay isang pagkakasunud-sunod ng mga character sa dobleng quote. Kaya,
charident1[] = 'Mahal kita'; charident2[] = 'Ayokong 3 kayo'; charident3[]= 'tayo ang mundo'; charident4[] = 'Hello World!';
ang lahat ay magkakaibang kahulugan ng mga string literal. Tandaan ang paggamit ng mga dobleng quote. Walang katulad ng isang ordinaryong variable para sa isang string. Ang isang literal na string ay isang hanay ng mga chars, kung saan sa halip na maglilimita sa {}, ang pagkakasunud-sunod ay na-delimitado. Ang mga char ay hindi pinaghihiwalay ng mga kuwit. Ang anumang bilang na mas malaki kaysa sa bilang ng mga chars sa string na literal ay maaaring mailagay sa mga square bracket. Gayunpaman, mas mahusay na iwanan na walang laman ang mga square bracket.
Ang isang solong character sa dobleng-quote ay hindi isang character; ito ay isang string ng isang character. Kaya ang A o c o 2 ay hindi isang character, ngunit isang string ng bawat character bawat isa.
Hindi pinapayagan ng isang variable ng string ang muling pagtatalaga ng kumpletong literal, sa bandang huli sa programa - tingnan sa ibaba. Gayunpaman, ang mga indibidwal na character ay maaaring maitalaga muli - tingnan sa ibaba.
Single at Double Quote sa Character o Literal
Upang magkaroon ng isang solong quote bilang isang character, gumawa ng isang bagay tulad ng,
charident= ' '';Upang magkaroon ng isang dobleng quote bilang isang character sa isang string literal, gumawa ng isang bagay tulad ng,
charident[] = 'malayo'CD';Ginagamit ang backslash sa isang pagkakasunud-sunod ng pagtakas, upang maiwasan ang salungatan sa mga delimiters. Upang magkaroon ng isang dobleng quote bilang isang character, hindi na kailangan ang backslash: ‘‘ ayos lang. Upang magkaroon ng isang solong quote sa isang literal na string, hindi na kailangan para sa backslash: ayos lang ang ab’cd.
Dahil ang backslash ay ginagamit upang makatakas sa isang character, kailangan itong makatakas gamit ang isa pang backslash kapag ginamit bilang isang character o sa isang literal na string.
Escape Sequence
Ang isang pagkakasunud-sunod ng pagtakas ay isa sa:
' \ sa b f n r> t vAng bawat pagkakasunud-sunod ng pagtakas ay karaniwang nai-type alinman sa isang character sa loob ng solong mga quote o bilang isang pagkakasunud-sunod ng pagtakas sa loob ng mga dobleng quote.
- Ginagamit ang ’: bilang isang solong tauhang quote, sa loob ng solong mga quote.
- : ay ginagamit bilang isang dobleng character na quote, sa loob ng isang literal.
- : simula nun ay isang nakalaan na character, dapat itong makatakas sa isang literal.
- \: ang backslash ay dapat na makatakas bilang isang character o sa isang string na literal, upang hindi magresulta sa ilang ibang kahulugan.
- a: tunog ng alarm bell minsan, kapag ginamit bilang isang character o sa loob ng isang literal na string.
- b: mga resulta bilang isang backspace sa display sa loob ng isang string na literal, inaalis ang nakaraang character.
- f: sanhi ng susunod na pahina upang mapakain sa printer kapag ginamit bilang isang character o sa loob ng isang literal.
- ibabalik ang cursor, kung saan ang susunod na character ay mai-print, ngunit sa loob ng kasalukuyang linya.
- n: ibabalik ang cursor sa simula ng susunod na linya o sa susunod na linya lamang, depende sa operating system.
- t: lumilikha ng isang pahalang na tab.
- v: lumilikha ng isang patayong tab.
Mga pagpapatakbo na may Mga Character
Pagtatapos
Sa kahulugan, ang dalawang string literals ay maaaring sumali sa puwang tulad ng sumusunod:
charident[] = 'abc' 'def';gastos<<ident<< ' n';
Ang output ay: abcdef. Ang kahulugan na ito ay maaaring mapalawak sa higit sa dalawang lital. Tandaan: ang pahayag ay isang kahulugan, hindi lamang isang takdang-aralin. Ang kahulugan ay maaaring magpatuloy sa susunod na linya na may espasyo na pinaghihiwalay ang mga linya tulad ng sumusunod:
charident[] = 'abc' 'def''Tandaan';
gastos<<ident<< ' n';
Ang output ay, abcdefghi.
Tandaan: Ang mga character ay hindi maaaring pagsamahin sa ganitong paraan, dahil ang solong mga quote para sa character ay hindi maaaring magkaroon ng higit sa isang simbolo.
Mga Operator ng Equality
Parehong mga character sa parehong kaso ay pantay. Hindi sila pantay kung hindi sila pareho ng kaso. Isaalang-alang,
resulta ng bool= 'B' == 'B';gastos<<resulta<< ' n';
== nangangahulugang katumbas, habang = nangangahulugang naatasan-sa at hindi katumbas. Ang output ay 1 para sa totoo. Isaalang-alang,
resulta ng bool= 'B' == 'b';gastos<<resulta<< ' n';
Ang output ay 0 para sa hindi totoo. Isaalang-alang,
resulta ng bool= 'b' == 'c';gastos<<resulta<< ' n';
Ang output ay 0 para sa hindi totoo. Isaalang-alang,
resulta ng bool= 'B' ! = 'B';gastos<<resulta<< ' n';
! = nangangahulugang hindi pantay, habang = nangangahulugang naatasan-sa at hindi hindi pantay. Ang output ay 0 para sa hindi totoo. Isaalang-alang,
resulta ng bool= 'B' ! = 'b';gastos<<resulta<< ' n';
Ang output ay 1 para sa totoo. Isaalang-alang,
resulta ng bool= 'b' ! = 'c';gastos<<resulta<< ' n';
Ang output ay 1 para sa totoo.
Kaya, == at! = Ang mga operator ng pagkakapantay-pantay.
Mga kaugnay na Operator
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.
Kaya
Ang String Literal bilang isang Bagay
Ang array ay isang pare-pareho na pointer sa simula ng isang partikular na pagkakasunud-sunod ng uri ng data. Katulad nito, ang string ay isang pare-pareho na pointer sa simula ng isang pagkakasunud-sunod ng character. Ihambing ang mga sumusunod na kahulugan:
intarr[] = {3, 4, 5, 6, 7};charp[] = {'sa', 'o', 'm', 'to', 'n'};
charstri[] = 'babae';
Ang unang array ay isang array ng ints at may limang elemento. Ang pangalawa at pangatlong arrays ay mga arrays ng chars na may iba't ibang mga pangalan, ngunit ang parehong bilang ng mga elemento. Ang pangalawa at pangatlong arrays ay pareho, ngunit para sa kanilang mga pangalan. Ang nilalaman ng teksto ng pangalawang array ay nililimitahan ng mga brace; ang mga character ay pinaghihiwalay ng mga kuwit at ang bawat character ay nasa solong mga quote. Ang nilalaman ng teksto ng pangatlong array ay nililimitahan ng mga dobleng quote; ang mga character ay hindi pinaghihiwalay ng mga kuwit at ang bawat character ay wala sa iisang quote. Ang pangalawa at pangatlong arrays ay dalawang paraan ng paggawa ng isang string, kasama ang pangatlong paraan na mas mahusay na paraan.
Ang arr ay isang pare-pareho na pointer sa unang elemento ng kanyang array, ibig sabihin arr ay palaging tumuturo sa lokasyon na mayroong integer, 3 kahit na ang halaga ng 3 ay binago. Ang laki ng array, limang elemento, ay hindi mananatiling pare-pareho. Gayunpaman, ang bawat isa sa mga halaga ng array ay maaaring mabago.
Ang str ay isang pare-pareho na pointer sa unang elemento ng kanyang array, nangangahulugang str ay palaging tumuturo sa lokasyon na mayroong character, 'w' kahit na ang halaga ng 'w' ay binago. Ang laki ng array ng character, limang elemento, ay hindi mananatiling pare-pareho. Gayunpaman, ang bawat isa sa mga halaga ng literal ay maaaring mabago.
Ang stri ay isang pare-pareho na pointer sa unang elemento ng kanyang literal (array), ibig sabihin ang stri ay palaging tumuturo sa lokasyon na mayroong character, w kahit na ang halaga ng w ay binago. Ang laki ng string literal (array), limang elemento, ay hindi mananatiling pare-pareho. Gayunpaman, ang bawat isa sa mga halagang literal ay maaaring mabago.
Ano ang pare-pareho sa isang array o literal na string? Ang memorya ng address ng unang elemento ng array o literal na nananatili bilang halaga ng pangalan (identifier) ng array o literal, at hindi mababago. Sa gayon, ang laki ng array o literal ay hindi mananatiling pare-pareho. Ang bawat halaga sa array o literal ay maaaring mabago. Ipinapakita ng sumusunod na code kung paano nabago ang ika-apat na elemento ng bawat isa sa mga array:
intarr[] = {3, 4, 5, 6, 7};charp[] = {'sa', 'o', 'm', 'to', 'n'};
charstri[] = 'babae';
arr[3] = 9;
p[3] = 'At';
stri[3] = 'At';
gastos<<arr[3] << ' n';
gastos<<p<< ' n';
gastos<<stri<< ' n';
Ang output ay:
9mga kababaihan
mga babae
Tandaan na ang mga elemento ng isang tinukoy na string na literal, tulad ng para sa pangatlong kahulugan sa itaas, ay maaaring ma-access gamit ang array index (subscript). Ang dahilan para sa pangalawang linya ng output ay ibinibigay sa ibaba.
Kahulugan Subscript
Tandaan na sa mga kahulugan sa itaas, walang integer para sa subscript. Kapag ang bilang ng mga elemento ay hindi madaling matukoy, ng programmer, dapat na alisin ang integer para sa subscript. Anuman ang kaso, ang integer ay hindi dapat mas mababa sa bilang ng mga elemento sa array.
Para sa literal na string, ang integer ay dapat na hindi bababa sa 1 mas mataas kaysa sa bilang ng mga character sa string. Ito ay sapagkat ang null character ( 0) ay palaging idinagdag ng tagatala, sa dulo ng isang array na isang string, na nililimitahan ng mga dobleng quote. Ang null character ay hindi naidagdag sa dulo ng pangalawang array sa itaas, dahil hindi ito isang opisyal na string. Ang pangatlong array ay isang opisyal na string. Ipinapakita ng sumusunod na code ang mga minimum na halaga ng subscript.
intarr[5] = {3, 4, 5, 6, 7};charp[5] = {'sa', 'o', 'm', 'to', 'n'};
charstri[6] = 'babae';
Upang gawing opisyal na string ang pangalawang kahulugan, kailangang idagdag ang null character tulad ng sumusunod:
intarr[5] = {3, 4, 5, 6, 7};charp[6] = {'sa', 'o', 'm', 'to', 'n', ' 0'};
charstri[6] = 'babae';
Ang output ay dapat na,
9mga babae
mga babae
nang walang pangalawang babae. Tandaan na ang kaukulang subscription para sa pangalawang array ay 6, at hindi 5 tulad nito.
Patuloy na Halaga ng Literal
Upang ihinto ang anumang character sa mga dobleng quote na nakatalaga sa isang identifier mula sa pagbabago, sa paglaon pababa sa programa, paunahin ang kahulugan sa nakalaan na salita, ayon sa mga sumusunod:
Const charident[] = 'Mahal kita';Mga Operasyon na may String Literals
Pagpapatakbo ng Pagkakapantay-pantay
Ang mga operator ng pagkakapantay-pantay ay == at! =. Kapag inihambing ang mga variable (identifier) ng dalawang mga string, ang mga pahiwatig (address) ng mga literal na nauuwi sa paghahambing; Iyan ay mali. Upang ihambing ang mga string, kailangang ihambing ang mga literal, tulad ng sa sumusunod na code:
resulta ng bool= 'babae' == 'babae';gastos<<resulta<< ' n';
Ang output ay 1 para sa totoo. Ang paghahambing ay ginagawa sa fashion ng diksyonaryo, ngunit sa mga numero na nauuna sa pataas na pagkakasunud-sunod, bago ang malalaking titik, na darating bago ang mga maliit na titik. Ang output ng sumusunod na code ay 0, para sa mali.
resulta ng bool= 'babae' ! = 'babae';gastos<<resulta<< ' n';
Mga Kaugnay na Operator na may String Literals
Ang mga kamag-anak na operator ay hindi gumagana sa mga string literal.
Raw String Literal
Ang isang literal na hilaw na string, pinapayagan ang isang string na maipakita bilang nai-type, hindi pinapansin ang mga pagkakasunud-sunod ng pagtakas at paggalang sa mga newline. Isaalang-alang ang sumusunod na code:
charp[] =R'(abc\d efg siyaklmn n' 'opq
rst) ';
gastos<< str << ' n';
Ang output ay:
abc \ d efg siyaklmn n'opq
rst
Sa code, ang hilaw na string na literal ay nagsisimula sa R, na sinusundan ng at (. Nagtatapos sa) at.
C ++ Pangunahing Mga Uri ng String na Literal
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.
Konklusyon
Ang isang literal na character ay isang solong character sa solong mga quote. Ang isang pagkakasunud-sunod ng pagtakas ay isang character na maaari ding maging sa solong mga quote. Ang isang literal na string ay isang pagkakasunud-sunod ng mga character sa dobleng-quote. Ang isang literal na string ay isang hanay ng mga character na nagtatapos sa 0. Ang pagkakapantay-pantay at mga ugnayan ng operator ay gumagana sa mga character na literal. Ang mga operator ng pagkakapantay-pantay ay gumagana sa mga string literal, ngunit ang mga operator na pamanggit ay hindi gumagana sa mga string literals. Ang mga tagapagpakilala ng character ay maaaring gamitin sa mga paghahambing, ngunit ang mga identifier ng string ay hindi dapat gamitin sa mga paghahambing. Pinapayagan ng isang hilaw na string na literal ang isang string na maipakita bilang na-type, hindi pinapansin ang mga pagkakasunud-sunod ng pagtakas at paggalang sa mga newline.
Chrys