అక్షర అక్షరం
అక్షర సాహిత్యం అనేది ఒకే కోట్స్‌లో ఉండే పాత్ర. కాబట్టి,
చార్గుర్తింపు 1= 'TO'; చార్గుర్తింపు 2= 'b'; చార్గుర్తింపు 3= '4'; చార్గుర్తింపు 4= '6';
అన్నీ అక్షరాలకు భిన్నమైన నిర్వచనాలు. సింగిల్ కోట్స్‌లో ఒక అంకె ఒక అక్షరం మరియు పూర్ణాంకం కాదని గమనించండి.
సింగిల్ కోట్స్‌లో (క్రింద చూడండి) వంటి ఎస్కేప్ సీక్వెన్స్ ఒక అక్షరం. కాబట్టి,
చార్గుర్తింపు 1= '' ';
ఒక పాత్ర.
డబుల్-కోట్స్‌లో ఒకే చిహ్నం అక్షరం కాదు; ఇది ఒక అక్షరం యొక్క స్ట్రింగ్. కాబట్టి A లేదా c లేదా 2 అనేది ఒక పాత్ర కాదు కానీ ఒక్కొక్క అక్షరం యొక్క స్ట్రింగ్.
చార్ యొక్క వేరియబుల్‌ను తిరిగి కేటాయించవచ్చు, తరువాత ప్రోగ్రామ్‌లో, కింది విధంగా:
చార్గుర్తింపు= 'x';
గుర్తింపు= 'మరియు';
ఐడెంటిఫైయర్‌కు కేటాయించిన అక్షరం మార్చకుండా ఆపడానికి, తర్వాత ప్రోగ్రామ్‌లో, రిజర్వ్డ్ వర్డ్, కాన్స్ట్రెంట్‌తో నిర్వచనాన్ని ఈ క్రింది విధంగా చేయండి:
కానిస్టేట్ చార్గుర్తింపు= 'd';వేరియబుల్, ఐడెం రీడ్-మాత్రమే అని చెప్పబడింది.
స్ట్రింగ్ లిటరల్
స్ట్రింగ్ లిటరల్ అనేది డబుల్ కోట్స్‌లో అక్షరాల క్రమం. కాబట్టి,
చార్గుర్తింపు 1[] = 'నేను నిన్ను ప్రేమిస్తున్నాను'; చార్గుర్తింపు 2[] = 'నేను మీలో 3 మందిని ద్వేషిస్తున్నాను'; చార్గుర్తింపు 3[]= 'మనం ప్రపంచం'; చార్గుర్తింపు 4[] = 'హలో వరల్డ్!';
స్ట్రింగ్ లిటరల్స్ యొక్క అన్ని విభిన్న నిర్వచనాలు. డబుల్ కోట్స్ వాడకాన్ని గమనించండి. స్ట్రింగ్ కోసం సాధారణ వేరియబుల్ లాంటిది ఏదీ లేదు. స్ట్రింగ్ లిటరల్ అనేది అక్షరాల శ్రేణి, ఇక్కడ {} తో డీలిమిట్ చేయడానికి బదులుగా, సీక్వెన్స్ డీలిమిట్ చేయబడింది. అక్షరాలు కామాలతో వేరు చేయబడవు. స్ట్రింగ్ సాహిత్యంలోని అక్షరాల సంఖ్య కంటే ఎక్కువ సంఖ్యను చదరపు బ్రాకెట్లలో ఉంచవచ్చు. అయితే, చదరపు బ్రాకెట్లను ఖాళీగా ఉంచడం మంచిది.
డబుల్-కోట్స్‌లో ఒకే అక్షరం ఒక పాత్ర కాదు; ఇది ఒక అక్షరం యొక్క స్ట్రింగ్. కాబట్టి A లేదా c లేదా 2 అనేది ఒక అక్షరం కాదు, ఒక్కొక్క అక్షరం యొక్క స్ట్రింగ్.
స్ట్రింగ్ వేరియబుల్ పూర్తి సాహిత్యానికి తిరిగి అప్పగించడానికి అనుమతించదు, తరువాత ప్రోగ్రామ్‌లో-క్రింద చూడండి. అయితే, వ్యక్తిగత అక్షరాలను తిరిగి కేటాయించవచ్చు-క్రింద చూడండి.
అక్షరం లేదా సాహిత్యంలో సింగిల్ మరియు డబుల్ కోట్
ఒకే కోట్‌ని క్యారెక్టర్‌గా పొందడానికి, ఇలా చేయండి,
చార్గుర్తింపు= ' '';స్ట్రింగ్ లిటరల్‌లో క్యారెక్టర్‌గా డబుల్ కోట్ పొందడానికి, ఇలా చేయండి,
చార్గుర్తింపు[] = 'దూరంగా'CD';డిలిమిటర్‌లతో సంఘర్షణను నివారించడానికి, ఎస్కేప్ సీక్వెన్స్‌లో బ్యాక్‌స్లాష్ ఉపయోగించబడుతుంది. క్యారెక్టర్‌గా డబుల్ కోట్ కలిగి ఉండటానికి, బ్యాక్‌స్లాష్ అవసరం లేదు: ‘‘ బాగానే ఉంది. స్ట్రింగ్ లిటరల్‌లో ఒకే కోట్‌ని కలిగి ఉండటానికి, బ్యాక్‌స్లాష్ అవసరం లేదు: ab'cd బాగానే ఉంది.
ఒక పాత్ర నుండి తప్పించుకోవడానికి బ్యాక్‌స్లాష్ ఉపయోగించబడుతుంది కాబట్టి, ఒక పాత్రగా లేదా స్ట్రింగ్ అక్షరాలా ఉపయోగించినప్పుడు అది మరొక బ్యాక్‌స్లాష్‌తో తప్పించుకోవాలి.
ఎస్కేప్ సీక్వెన్స్
తప్పించుకునే క్రమం వీటిలో ఒకటి:
''? \ కు బి f n r> t vప్రతి ఎస్కేప్ సీక్వెన్స్ సాధారణంగా సింగిల్ కోట్స్‌లోని క్యారెక్టర్‌గా లేదా డబుల్-కోట్స్‌లో ఎస్కేప్ సీక్వెన్స్‌గా టైప్ చేయబడుతుంది.
- ': సింగిల్ కోట్స్‌లో ఒకే కోట్ క్యారెక్టర్‌గా ఉపయోగించబడుతుంది.
- : అక్షరార్థంలో డబుల్ కోట్ అక్షరంగా ఉపయోగించబడుతుంది.
- ? : అప్పటి నుండి? రిజర్వ్ చేయబడిన పాత్ర, అది అక్షరాలా తప్పించుకోవాలి.
- \: బ్యాక్ స్లాష్ ఒక అక్షరం లేదా స్ట్రింగ్ సాహిత్యంలో తప్పించుకోవాలి, తద్వారా ఇతర అర్థాలు ఏర్పడవు.
- a: అక్షరంగా లేదా స్ట్రింగ్‌లో ఉపయోగించినప్పుడు ఒకసారి అలారం బెల్ ధ్వనిస్తుంది.
- b: స్ట్రింగ్ అక్షరంలోని డిస్‌ప్లేలో బ్యాక్‌స్పేస్‌గా ఫలితాలు, మునుపటి అక్షరాన్ని తీసివేస్తాయి.
- f: అక్షరంగా లేదా అక్షరార్థంలో ఉపయోగించినప్పుడు తదుపరి పేజీని ప్రింటర్‌కు అందించడానికి కారణమవుతుంది.
- r: కర్సర్‌ను అందిస్తుంది, ఇక్కడ తదుపరి అక్షరం ముద్రించబడాలి, కానీ ప్రస్తుత లైన్‌లో ఉంటుంది.
- n: ఆపరేటింగ్ సిస్టమ్‌ని బట్టి కర్సర్‌ని తదుపరి లైన్ ప్రారంభానికి లేదా తదుపరి లైన్‌కు తిరిగి ఇస్తుంది.
- t: క్షితిజ సమాంతర ట్యాబ్‌ను సృష్టిస్తుంది.
- v: నిలువు ట్యాబ్‌ను సృష్టిస్తుంది.
పాత్రలతో కార్యకలాపాలు
సమ్మేళనం
నిర్వచనం ప్రకారం, రెండు స్ట్రింగ్ లిటరల్స్ స్పేస్‌తో కింది విధంగా చేరవచ్చు:
చార్గుర్తింపు[] = 'abc' 'డెఫ్';ఖరీదు<<గుర్తింపు<< ' n';
అవుట్పుట్: abcdef. ఈ నిర్వచనాన్ని రెండు కంటే ఎక్కువ అక్షరాలకు విస్తరించవచ్చు. గమనిక: స్టేట్‌మెంట్ అనేది కేవలం ఒక అసైన్‌మెంట్ మాత్రమే కాదు. కింది విధంగా పంక్తులను వేరుచేసే స్థలంతో నిర్వచనం తదుపరి పంక్తికి కూడా కొనసాగవచ్చు:
చార్గుర్తింపు[] = 'abc' 'డెఫ్''గమనించండి';
ఖరీదు<<గుర్తింపు<< ' n';
అవుట్పుట్, abcdefghi.
గమనిక: పాత్రల కోసం ఒకే కోట్‌లు ఒకటి కంటే ఎక్కువ చిహ్నాలను కలిగి ఉండవు కాబట్టి, అక్షరాలను ఈ విధంగా కలపలేము.
సమానత్వ నిర్వాహకులు
ఒకే సందర్భంలో ఒకే అక్షరాలు సమానంగా ఉంటాయి. వారు ఒకే సందర్భంలో లేనట్లయితే వారు సమానం కాదు. పరిగణించండి,
బూల్ ఫలితం= 'B' == 'B';ఖరీదు<<ఫలితం<< ' n';
== అంటే సమానం, = = అంటే కేటాయించినది మరియు సమానం కాదు. అవుట్పుట్ 1 నిజం. పరిగణించండి,
బూల్ ఫలితం= 'B' == 'b';ఖరీదు<<ఫలితం<< ' n';
అవుట్పుట్ తప్పు కోసం 0. పరిగణించండి,
బూల్ ఫలితం= 'b' == 'సి';ఖరీదు<<ఫలితం<< ' n';
అవుట్పుట్ తప్పు కోసం 0. పరిగణించండి,
బూల్ ఫలితం= 'B' ! = 'B';ఖరీదు<<ఫలితం<< ' n';
! = అంటే సమానం కాదు, = అంటే అసైన్డ్-టు మరియు సమానం కాదు. అవుట్పుట్ తప్పు కోసం 0. పరిగణించండి,
బూల్ ఫలితం= 'B' ! = 'b';ఖరీదు<<ఫలితం<< ' n';
అవుట్పుట్ 1 నిజం. పరిగణించండి,
బూల్ ఫలితం= 'b' ! = 'సి';ఖరీదు<<ఫలితం<< ' n';
అవుట్పుట్ 1 నిజం.
కాబట్టి, == మరియు! = సమానత్వ నిర్వాహకులు.
రిలేషనల్ ఆపరేటర్లు
C ++ లో సాధారణ అక్షరాల కోసం, ఆరోహణ క్రమంలో, చిన్న అక్షరాలకు ముందు వచ్చే పెద్ద అక్షరాలకు ముందు సంఖ్యలు వస్తాయి.
కాబట్టి
స్ట్రింగ్ లిటరల్ ఒక వస్తువుగా
ఒక నిర్దిష్ట డేటా రకం క్రమం ప్రారంభానికి శ్రేణి స్థిరమైన పాయింటర్. అదేవిధంగా, స్ట్రింగ్ అనేది అక్షర క్రమం ప్రారంభానికి స్థిరమైన పాయింటర్. కింది నిర్వచనాలను సరిపోల్చండి:
intఅరె[] = {3, 4, 5, 6, 7};చార్p[] = {'లో', 'లేదా', 'm', 'కు', 'n'};
చార్స్ట్రి[] = 'మహిళ';
మొదటి శ్రేణి ఇన్ట్‌ల శ్రేణి మరియు ఐదు మూలకాలను కలిగి ఉంటుంది. రెండవ మరియు మూడవ శ్రేణులు వేర్వేరు పేర్లతో అక్షరాల శ్రేణులు, కానీ అదే సంఖ్యలో మూలకాలు. రెండవ మరియు మూడవ శ్రేణులు ఒకే విధంగా ఉంటాయి, కానీ వాటి పేర్ల కోసం. రెండవ శ్రేణి యొక్క టెక్స్ట్ కంటెంట్ బ్రేస్‌ల ద్వారా వేరు చేయబడింది; అక్షరాలు కామాలతో వేరు చేయబడతాయి మరియు ప్రతి అక్షరం ఒకే కోట్స్‌లో ఉంటుంది. మూడవ శ్రేణి యొక్క టెక్స్ట్ కంటెంట్ డబుల్ కోట్స్ ద్వారా వేరు చేయబడింది; అక్షరాలు కామాలతో వేరు చేయబడవు మరియు ప్రతి అక్షరం ఒకే కోట్స్‌లో ఉండదు. రెండవ మరియు మూడవ శ్రేణులు స్ట్రింగ్‌ను ఉత్పత్తి చేయడానికి రెండు మార్గాలు, మూడవ మార్గం మంచి మార్గం.
arr అనేది దాని శ్రేణి యొక్క మొదటి మూలకానికి ఒక స్థిరమైన పాయింటర్, అంటే arr ఎల్లప్పుడూ పూర్ణాంకం ఉన్న స్థానాన్ని సూచిస్తుంది, 3 విలువ మారినప్పటికీ. శ్రేణి పరిమాణం, ఐదు అంశాలు, నిజంగా స్థిరంగా ఉండవు. అయితే, శ్రేణి యొక్క ప్రతి విలువను మార్చవచ్చు.
str అనేది దాని శ్రేణి యొక్క మొదటి మూలకానికి స్థిరమైన పాయింటర్, అంటే 'w' విలువ మారినప్పటికీ, 'w' అక్షరాన్ని కలిగి ఉన్న స్థానాన్ని str ఎల్లప్పుడూ సూచిస్తుంది. అక్షర శ్రేణి పరిమాణం, ఐదు అంశాలు, నిజంగా స్థిరంగా ఉండవు. అయితే, అక్షరార్థం యొక్క ప్రతి విలువను మార్చవచ్చు.
స్ట్రై అనేది దాని అక్షర (అర్రే) యొక్క మొదటి మూలకానికి ఒక స్థిరమైన పాయింటర్, అంటే w విలువ మారినప్పటికీ స్ట్రి ఎల్లప్పుడూ పాత్ర ఉన్న స్థానాన్ని సూచిస్తుంది. స్ట్రింగ్ లిటరల్ (అర్రే) పరిమాణం, ఐదు అంశాలు, నిజంగా స్థిరంగా ఉండవు. ఏదేమైనా, అక్షరార్థంలోని ప్రతి విలువలను సవరించవచ్చు.
శ్రేణి లేదా స్ట్రింగ్ సాహిత్యంలో స్థిరంగా ఉన్నది ఏమిటి? శ్రేణి లేదా సాహిత్యంలోని మొదటి మూలకం యొక్క మెమరీ చిరునామా శ్రేణి లేదా అక్షరార్థం యొక్క పేరు (ఐడెంటిఫైయర్) విలువగా ఉంటుంది మరియు మార్చలేము. బాగా, శ్రేణి లేదా సాహిత్య పరిమాణం నిజంగా స్థిరంగా ఉండదు. శ్రేణి లేదా సాహిత్యంలోని ప్రతి విలువను మార్చవచ్చు. కింది కోడ్ ప్రతి శ్రేణి యొక్క నాల్గవ మూలకం ఎలా మార్చబడిందో చూపుతుంది:
intఅరె[] = {3, 4, 5, 6, 7};చార్p[] = {'లో', 'లేదా', 'm', 'కు', 'n'};
చార్స్ట్రి[] = 'మహిళ';
అరె[3] = 9;
p[3] = 'మరియు';
స్ట్రి[3] = 'మరియు';
ఖరీదు<<అరె[3] << ' n';
ఖరీదు<<p<< ' n';
ఖరీదు<<స్ట్రి<< ' n';
అవుట్పుట్:
9మహిళా మహిళలు
మహిళలు
పైన పేర్కొన్న మూడవ నిర్వచనం వలె నిర్వచించబడిన స్ట్రింగ్ సాహిత్యంలోని అంశాలను శ్రేణి సూచిక (సబ్‌స్క్రిప్ట్) తో యాక్సెస్ చేయవచ్చని గమనించండి. అవుట్పుట్ యొక్క రెండవ పంక్తికి కారణం క్రింద ఇవ్వబడింది.
నిర్వచనం సబ్‌స్క్రిప్ట్
పై నిర్వచనాలలో, సబ్‌స్క్రిప్ట్ కోసం పూర్ణాంకం లేదని గమనించండి. మూలకాల సంఖ్యను సులభంగా గుర్తించలేనప్పుడు, ప్రోగ్రామర్ ద్వారా, సబ్‌స్క్రిప్ట్ కోసం పూర్ణాంకం వదిలివేయబడాలి. ఏది ఏమైనా, పూర్ణాంకం శ్రేణిలోని మూలకాల సంఖ్య కంటే తక్కువగా ఉండకూడదు.
స్ట్రింగ్ అక్షరార్థం కోసం, స్ట్రింగ్‌లోని అక్షరాల సంఖ్య కంటే పూర్ణాంకం కనీసం 1 ఎక్కువగా ఉండాలి. ఎందుకంటే శూన్య అక్షరం ( 0) ఎల్లప్పుడూ కంపైలర్ ద్వారా జోడించబడుతుంది, శ్రేణి చివరలో స్ట్రింగ్, డబుల్-కోట్స్ ద్వారా డీలిమిట్ చేయబడింది. పైన ఉన్న రెండవ శ్రేణి చివరలో శూన్య అక్షరం జోడించబడలేదు, ఎందుకంటే ఇది అధికారిక స్ట్రింగ్ కాదు. మూడవ శ్రేణి ఒక అధికారిక స్ట్రింగ్. కింది కోడ్ కనీస సబ్‌స్క్రిప్ట్ విలువలను చూపుతుంది.
intఅరె[5] = {3, 4, 5, 6, 7};చార్p[5] = {'లో', 'లేదా', 'm', 'కు', 'n'};
చార్స్ట్రి[6] = 'మహిళ';
రెండవ నిర్వచనాన్ని అధికారిక స్ట్రింగ్‌గా చేయడానికి, శూన్య అక్షరాన్ని ఈ క్రింది విధంగా జోడించాలి:
intఅరె[5] = {3, 4, 5, 6, 7};చార్p[6] = {'లో', 'లేదా', 'm', 'కు', 'n', ' 0'};
చార్స్ట్రి[6] = 'మహిళ';
అవుట్పుట్ ఇప్పుడు ఉండాలి,
9మహిళలు
మహిళలు
రెండవ మహిళలు లేకుండా. రెండవ శ్రేణికి సంబంధించిన సబ్‌స్క్రిప్ట్ 6 అని గమనించండి మరియు 5 ఉన్నట్లుగా కాదు.
స్థిరమైన సాహిత్య విలువలు
ఐడెంటిఫైయర్‌కి కేటాయించిన డబుల్ కోట్‌లలోని ఏదైనా క్యారెక్టర్‌ను సవరించకుండా ఆపడానికి, తర్వాత ప్రోగ్రామ్‌లో, రిజర్వ్డ్ వర్డ్, కాన్స్ట్‌తో నిర్వచనానికి ముందు కింది విధంగా ఇవ్వండి:
కానిస్టేట్ చార్గుర్తింపు[] = 'నేను నిన్ను ప్రేమిస్తున్నాను';స్ట్రింగ్ లిటరల్స్‌తో కార్యకలాపాలు
సమానత్వ కార్యకలాపాలు
సమానత్వ నిర్వాహకులు == మరియు! =. రెండు స్ట్రింగ్‌ల వేరియబుల్స్ (ఐడెంటిఫైయర్‌లు) పోల్చినప్పుడు, లిటరల్స్ యొక్క పాయింటర్‌లు (చిరునామాలు) సరిపోల్చబడతాయి; అది తప్పు. తీగలను సరిపోల్చడానికి, ఈ క్రింది కోడ్‌లో ఉన్నట్లుగా అక్షరాలను పోల్చాలి:
బూల్ ఫలితం= 'మహిళ' == 'మహిళ';ఖరీదు<<ఫలితం<< ' n';
అవుట్పుట్ 1 నిజం. పోలిక డిక్షనరీ పద్ధతిలో జరుగుతుంది, అయితే చిన్న అక్షరాలకు ముందు వచ్చే పెద్ద అక్షరాలకు ముందు, ఆరోహణ క్రమంలో మొదటి సంఖ్యలు వస్తాయి. కింది కోడ్ యొక్క అవుట్పుట్ 0, తప్పు కోసం.
బూల్ ఫలితం= 'మహిళ' ! = 'మహిళ';ఖరీదు<<ఫలితం<< ' n';
స్ట్రింగ్ లిటరల్స్‌తో రిలేషనల్ ఆపరేటర్లు
సంబంధిత ఆపరేటర్లు స్ట్రింగ్ అక్షరాలతో పని చేయరు.
రా స్ట్రింగ్ సాహిత్య
ముడి స్ట్రింగ్ అక్షరాలా, స్ట్రింగ్ టైప్ చేయబడినట్లుగా ప్రదర్శించడానికి అనుమతిస్తుంది, ఎస్కేప్ సీక్వెన్స్‌లను విస్మరించి కొత్త లైన్‌లను గౌరవిస్తుంది. కింది కోడ్‌ని పరిగణించండి:
చార్p[] =ఆర్(abc\d efg అతనుklmn n' 'opq
rst) ';
ఖరీదు<< str << ' n';
అవుట్పుట్:
abc \ d efg అతనుklmn n'' opq
మొదటి
కోడ్‌లో, ముడి స్ట్రింగ్ అక్షరార్థం R తో ప్రారంభమవుతుంది, తరువాత మరియు (. ఇది ముగుస్తుంది) మరియు.
C ++ ప్రధాన స్ట్రింగ్ సాహిత్య రకాలు
చార్
చార్ రకం అసలు సి ++ రకం మరియు సాధారణంగా 8 బిట్స్‌లో ఒక అక్షరాన్ని నిల్వ చేస్తుంది.
char16_t
ఇది 16 బిట్స్‌లో ఒక అక్షరాన్ని నిల్వ చేస్తుంది.
char32_t
ఇది 32 బిట్స్‌లో అక్షరాన్ని నిల్వ చేస్తుంది.
wchar_t
char16_t మరియు char32_t విస్తృత అక్షరాలు. wchar_t అనేది యాజమాన్య మరియు అమలు-నిర్వచించిన విస్తృత అక్షరం.
ముగింపు
అక్షర సాహిత్యం అనేది ఒకే కోట్స్‌లో ఒకే అక్షరం. ఎస్కేప్ సీక్వెన్స్ అనేది సింగిల్ కోట్స్‌లో కూడా ఉండే క్యారెక్టర్. స్ట్రింగ్ లిటరల్ అంటే డబుల్ కోట్స్‌లో అక్షరాల క్రమం. స్ట్రింగ్ సాహిత్యం అంటే 0 తో ముగిసే అక్షరాల శ్రేణి. సమానత్వం మరియు సంబంధిత ఆపరేటర్లు అక్షర అక్షరాలతో పని చేస్తారు. ఈక్వాలిటీ ఆపరేటర్లు స్ట్రింగ్ లిటరల్స్‌తో పని చేస్తారు, కానీ రిలేషనల్ ఆపరేటర్లు స్ట్రింగ్ లిటరల్స్‌తో పని చేయరు. పోలికలలో అక్షర గుర్తింపులను ఉపయోగించవచ్చు, కానీ పోలికలలో స్ట్రింగ్ ఐడెంటిఫైయర్‌లను ఉపయోగించకూడదు. ముడి స్ట్రింగ్ అక్షరక్రమం స్ట్రింగ్‌ను టైప్ చేసినట్లుగా ప్రదర్శించడానికి అనుమతిస్తుంది, తప్పించుకునే సన్నివేశాలను విస్మరించి కొత్త లైన్‌లను గౌరవిస్తుంది.
క్రిస్