కంప్యూటింగ్‌లో, కన్సోల్ కంప్యూటర్ కీబోర్డ్ మరియు కంప్యూటర్ మానిటర్. గతంలో, అవుట్పుట్ నేరుగా మానిటర్ స్క్రీన్‌కు పంపబడుతుంది మరియు మానిటర్‌లో ప్రదర్శించబడే విండోకు కాదు. సాధారణ కంప్యూటర్ వినియోగదారు కోసం, ఈ రోజు అప్లికేషన్‌లు మానిటర్‌ను స్పష్టంగా ఉపయోగించవు. ఈ అప్లికేషన్‌లు మానిటర్‌లో ప్రదర్శించబడే విండోలను ఉపయోగిస్తాయి. అయితే, కంప్యూటర్ ప్రోగ్రామర్ ఇప్పటికీ మానిటర్ స్క్రీన్‌ను ఉపయోగించాల్సిన అవసరం ఉంది. ప్రోగ్రామర్ ఇప్పటికీ మానిటర్ స్క్రీన్‌ను ఉపయోగించాల్సిన అవసరం ఉన్నప్పటికీ, ఆపరేటింగ్ సిస్టమ్ అతన్ని అలా చేయడానికి అనుమతించదు. ఆపరేటింగ్ సిస్టమ్ మానిటర్ స్క్రీన్‌ను అనుకరించే విండోను అందిస్తుంది. విండోస్ ఆపరేటింగ్ సిస్టమ్‌లో, ఈ విండోను కమాండ్ ప్రాంప్ట్ అంటారు. లైనక్స్ ఆపరేటింగ్ సిస్టమ్ మరియు దాని వైవిధ్యాలలో, ఈ విండోను టెర్మినల్ అంటారు.
కమాండ్ ప్రాంప్ట్ లేదా టెర్మినల్‌ను ఎలా ఉపయోగించాలో రీడర్‌కు ఇప్పటికే తెలుసునని భావిస్తున్నారు. ఈ వ్యాసం కీబోర్డ్ నుండి అక్షరాలు మరియు తీగలను ఎలా చదవాలో మరియు అక్షరాలు మరియు తీగలను టెర్మినల్‌కు (లేదా కమాండ్ ప్రాంప్ట్) ఎలా పంపాలో వివరిస్తుంది. ఈ కథనంలో ప్రతి C ++ ప్రోగ్రామర్ తెలుసుకోవాలి.
కీబోర్డ్ నుండి ఇన్పుట్ మరియు టెర్మినల్‌కు అవుట్పుట్ పొందడానికి, ప్రోగ్రామ్ దీనితో ప్రారంభం కావాలి:
#చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్గంటలు;
వ్యాసం కంటెంట్
- ప్రామాణిక iostream యొక్క ఇరుకైన స్ట్రీమ్ వస్తువులు
- కీబోర్డ్ నుండి అక్షరాలు మరియు తీగలను పొందడం
- ఎంటర్ నొక్కడానికి ముందు అక్షరాలను ప్రదర్శించడం మరియు తొలగించడం
- మానిటర్‌కు అక్షరాలు మరియు తీగలను పంపుతోంది
- C ++ ప్రోగ్రామ్ కోసం వాదనలు
- ముగింపు
ప్రామాణిక iostream యొక్క ఇరుకైన స్ట్రీమ్ వస్తువులు
Iostream తరగతి, ప్రామాణిక వస్తువులు, cout, cin, cerr, మరియు clog, తక్షణం మరియు ఇప్పటికే ప్రామాణిక లైబ్రరీలో ఉన్నాయి. ప్రోగ్రామర్ వాటిని మళ్లీ ఇన్‌స్టాంటిట్ చేయకుండానే ఉపయోగిస్తాడు.
ఖరీదు
ప్రధాన () ఫంక్షన్‌లో కింది స్టేట్మెంట్ టెక్స్ట్‌ను పంపుతుంది, ఇది అవుట్పుట్. టెర్మినల్‌కు:
ఖరీదు << 'ఇది అవుట్పుట్.';
cout అనేది ప్రామాణిక లైబ్రరీలోని అవుట్పుట్ ఐయోస్ట్రీమ్ వస్తువు, ఇది ఇప్పటికే ఇన్‌స్టాంటియేట్ చేయబడింది.<< is the insertion operator, which sent the bytes, This is output. to the output stream object, cout. When the statement is executed, the text appears on the screen.
పై స్టేట్‌మెంట్‌తో, తిరిగి ప్రదర్శించబడే కమాండ్ ప్రాంప్ట్ అవుట్పుట్ పదబంధం యొక్క కుడి వైపున కనిపిస్తుంది. ఇది తదుపరి పంక్తికి వెళ్లదు. కింది స్టేట్మెంట్ ముగింపులో endl స్క్రీన్ ద్వారా ప్రింట్ చేయబడిన వాటిని తదుపరి పంక్తికి బలవంతం చేస్తుంది:
ఖరీదు << 'ఇది అవుట్పుట్.' <<endl;
endl అనేది ముందే నిర్వచించబడిన వేరియబుల్. స్క్రీన్ కంటెంట్‌ని దీనితో తదుపరి లైన్‌కు బలవంతం చేయవచ్చు:
ఖరీదు << 'ఇది అవుట్పుట్.' << ' n';‘ N’ వాడకంతో, టెక్స్ట్ యొక్క అన్ని పంక్తులు వెంటనే తెరపై కనిపించకపోవచ్చు. ఎండ్ఎల్ టెక్స్ట్ యొక్క పూర్తి లైన్‌ను స్క్రీన్‌కు ఫ్లష్ చేస్తుంది.
గమనిక: cout కి పంపిన స్ట్రింగ్ డబుల్ కోట్స్‌లో ఉంటుంది, అయితే పంపిన క్యారెక్టర్ సింగిల్ కోట్స్‌లో ఉంటుంది. వరుస స్ట్రింగ్‌లు మరియు అక్షరాలు ఒక స్టేట్‌మెంట్‌లో పంపబడతాయి, ఒక్కొక్కటి ముందు ఉంటుంది<< . All that will appear in one line at the output if ‘ ’ is not in the series.
జిన్
cin అనేది ప్రామాణిక iostream ఇన్పుట్ ఆబ్జెక్ట్, ఇప్పటికే ఇన్‌స్టాంటియేట్ చేయబడింది మరియు ప్రామాణిక లైబ్రరీలో అందుబాటులో ఉంది. ప్రధాన () ఫంక్షన్‌లో కింది కోడ్ విభాగాన్ని పరిగణించండి:
చార్పదము[యాభై];ఖరీదు << 'పదాన్ని నమోదు చేసి ఎంటర్ నొక్కండి:' పదము;
ఖరీదు <<పదము<<endl;
మొదటి స్టేట్మెంట్ 50 అక్షరాల ఖాళీ శ్రేణిని ప్రకటించింది. రెండవ స్టేట్మెంట్ తదుపరి స్క్రీన్ లైన్‌లో ఒక పదాన్ని టైప్ చేసి, ఎంటర్ కీని నొక్కమని వినియోగదారుని నిర్దేశిస్తుంది. స్క్రీన్ యొక్క తదుపరి లైన్‌లో టెక్స్ట్‌ని నమోదు చేయమని వినియోగదారుని బలవంతం చేసే 'endl' వినియోగాన్ని గమనించండి. యూజర్ టెక్స్ట్ టైప్ చేస్తున్నప్పుడు, ఎంటర్ చేసిన టెక్స్ట్ సిన్ ఆబ్జెక్ట్‌లోకి వెళ్తున్నప్పుడు స్క్రీన్‌కు ప్రతిధ్వనిస్తుంది. ఎంటర్ నొక్కిన తర్వాత, కోడ్ విభాగంలో మూడవ స్టేట్మెంట్ అమలు చేయబడుతుంది. ఈ మూడవ స్టేట్మెంట్ ఎంటర్ చేసిన టెక్స్ట్‌ను వేరియబుల్, txt కి పంపుతుంది. నమోదు చేసిన వచనం ఈ సందర్భంలో 50 అక్షరాల కంటే ఎక్కువ ఉండకూడదు. వెలికితీత ఆపరేటర్ యొక్క ఉపయోగాన్ని గమనించండి, >>. చివరి ప్రకటన తెరపై నమోదు చేసిన వచనాన్ని ప్రదర్శిస్తుంది.
cin కీబోర్డ్ నుండి ఒకటి కంటే ఎక్కువ పదాలను తీసుకోవచ్చు, ఖాళీలు వేరు చేయబడతాయి. ఈ పదాలను వివిధ వేరియబుల్స్‌లోకి తీయాలి. కింది కోడ్ విభాగం దీనిని వివరిస్తుంది:
చార్పదము[ఇరవై];intఅది;
తేలుతాయిఅడుగు;
ఖరీదు << '3 విలువలను నమోదు చేయండి మరియు Enter నొక్కండి:' పదము>>అది>>అడుగు;
ఖరీదు <<పదము<< '' <<అది<< '' <<అడుగు<<endl;
ప్రకటనను గమనించండి:
జిన్ >>పదము>>అది>>అడుగు;మొదటి పదం txt కి, తదుపరిది దానికి, చివరిది ft కి సంగ్రహించబడింది. ఇన్పుట్ అయితే,
ఒకటి25 3.6అప్పుడు కోడ్ సెగ్మెంట్ ద్వారా అవుట్పుట్ ఉంటుంది,
ఒకటి25 3.6సెర్
కింది ప్రోగ్రామ్‌లో లోపం ఉంది:
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన()
{
myInt లో;
తిరిగి 0;
}
మెయిన్ () లోని మొదటి స్టేట్మెంట్ సరైనది కాదు. కోడ్ ఉన్న ఫైల్ పేరు temp.cc మరియు ఫలితంగా అమలు చేయగల ఫైల్‌ను temp అని పిలవాల్సి వస్తే, కింది g ++ కమాండ్ కంపైలర్ దోష సందేశాన్ని ఫైల్, error.txt కి పంపుతుంది:
g++ -o తాత్కాలిక ఉష్ణోగ్రత.DC 2>లోపం.పదముError.txt ఫైల్ లేనట్లయితే, అది సృష్టించబడుతుంది. G ++ కమాండ్ యొక్క భాగం 2> error.txt ని గమనించండి.
స్క్రీన్ ప్రామాణిక అవుట్పుట్ గమ్యం, మరియు ఇది ప్రామాణిక లోపం గమ్యం కూడా. G ++ కమాండ్ నుండి 2> error.txt విస్మరించబడితే, కంపైలర్ దోష సందేశం ప్రామాణిక లోపం గమ్యస్థానానికి పంపబడుతుంది, ఇది ఇప్పటికీ స్క్రీన్ (మానిటర్).
ప్రామాణిక అవుట్పుట్ గమ్యాన్ని సూచించే స్ట్రీమ్ వస్తువు cout. ప్రామాణిక లోపం గమ్యాన్ని సూచించే స్ట్రీమ్ వస్తువు సెర్. ప్రోగ్రామ్ రన్‌టైమ్ లోపాన్ని స్క్రీన్‌కు ఈ క్రింది విధంగా పంపవచ్చు:
సెర్ << 'దోష సందేశం!' << ' n';అడ్డుపడే
ఒక అప్లికేషన్ వివిధ సమయాల్లో వేర్వేరు ఇన్‌పుట్‌లను తీసుకుంటుంది. అన్ని ఇన్‌పుట్‌లను మళ్లీ తెరపై ప్రదర్శించవచ్చు. అన్ని ఇన్‌పుట్‌లను ఫైల్‌లో సేవ్ చేయవచ్చు. ఇది లాగింగ్. ప్రామాణిక లాగింగ్ గమ్యం స్క్రీన్. ప్రామాణిక లాగింగ్ స్ట్రీమ్ ఆబ్జెక్ట్ ఒక క్లాగ్. కింది కోడ్ స్క్రీన్‌కు ఇన్పుట్ టెక్స్ట్‌ను తిరిగి ప్రదర్శిస్తుంది:
చార్పదము[యాభై];ఖరీదు<<'టెక్స్ట్ ఎంటర్ చేసి ఎంటర్ నొక్కండి:'పదము;
అడ్డుపడే<<పదము<<endl;
ఇన్పుట్ టెక్స్ట్ 'ఇన్పుట్_టెక్స్ట్' అయితే, క్లాగ్ స్క్రీన్‌కు 'ఇన్పుట్_టెక్స్ట్' తిరిగి ప్రదర్శిస్తుంది.
ఆచరణలో, లాగింగ్ సాధారణంగా ఫైల్‌కి మళ్ళించబడుతుంది. కింది కార్యక్రమం దీనిని వివరిస్తుంది:
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన()
{
ఫ్రీపెన్( 'log.txt','లో',stdout);
ఖరీదు << 'input_text' <<endl;
}
ఫంక్షన్, ఫ్రీపెన్ () మరియు దాని వాదనల వినియోగాన్ని గమనించండి. దీని మొదటి వాదన లాగ్ ఫైల్ పేరు. ఫైల్ లేనట్లయితే, అది సృష్టించబడుతుంది. దీని రెండవ వాదన 'వ్రాయడం' కోసం 'w'. దాని మూడవ వాదన స్టాండర్డ్-అవుట్పుట్ కోసం stdout. ప్రధాన () ఫంక్షన్‌లోని రెండవ స్టేట్మెంట్ ఫైల్‌కు లాగింగ్ టెక్స్ట్‌ను పంపడానికి cout ని ఉపయోగిస్తుంది. గమనిక: ఈ ప్రోగ్రామ్‌లో అసలు ఇన్పుట్ కోడ్ చూపబడలేదు.
కీబోర్డ్ నుండి అక్షరాలు మరియు తీగలను పొందడం
వినియోగదారు ఇన్‌పుట్‌ను టైప్ చేస్తున్నప్పుడు, అక్షరాలు ఇన్పుట్ స్ట్రీమ్ బఫర్‌కు పంపబడతాయి మరియు స్క్రీన్‌లో ప్రదర్శించబడతాయి. వినియోగదారు ఎంటర్ కీని నొక్కినప్పుడు, అన్ని అక్షరాలు బఫర్‌లో ఉంటాయి; అలాగే, కర్సర్ దిగువన తదుపరి లైన్ ప్రారంభానికి, స్క్రీన్ వద్దకు వెళుతుంది. ఇన్పుట్ రీడింగ్ స్టేట్మెంట్ తర్వాత ప్రోగ్రామ్ తదుపరి ప్రోగ్రామ్ స్టేట్‌మెంట్‌కు కొనసాగుతుంది.
సిన్ ఆబ్జెక్ట్‌కు పద్ధతులు ఉన్నాయి, ఈ విభాగం దీనికి సంబంధించినది.
మొదటి అక్షరాన్ని చదవడం
పొందండి (char_type & c):
కింది కోడ్ సెగ్మెంట్ ఇన్పుట్ స్ట్రీమ్ బఫర్ నుండి మొదటి అక్షరాన్ని ఎలా చదవాలో చూపుతుంది:
ఖరీదు << 'ఇన్పుట్ టెక్స్ట్:' <<endl;
జిన్.పొందండి(చ);
ఖరీదు <<చ<<endl;
మొదటి స్టేట్మెంట్ అసైన్‌మెంట్ లేకుండా క్యారెక్టర్‌ని ప్రకటించింది. రెండవ స్టేట్మెంట్ వినియోగదారుకు అక్షరాన్ని ఇన్పుట్ చేయమని చెబుతుంది. వినియోగదారు అక్షరాన్ని టైప్ చేసి, ఎంటర్ కీని నొక్కినప్పుడు, మూడవ స్టేట్మెంట్ ఇన్పుట్ స్ట్రీమ్ బఫర్ నుండి అక్షరాన్ని వేరియబుల్, ch లోకి కాపీ చేస్తుంది.
వినియోగదారు ఒకటి కంటే ఎక్కువ అక్షరాలను టైప్ చేసినప్పటికీ, మొదటి అక్షరాన్ని కోడ్ సెగ్మెంట్ ద్వారా తీసుకుంటారు.
పొందండి ():
వాదన లేకుండా పొందండి () దశాంశ ASCII కోడ్‌ను అందిస్తుంది. కింది కోడ్ విభాగాన్ని పరిగణించండి:
ఖరీదు << జిన్.పొందండి() <<endl;
ఇన్పుట్ 'asdfg' అయితే, 97 తిరిగి ఇవ్వబడుతుంది, ఇది 'a' కోసం దశాంశ ASCII కోడ్.
పొందండి (char_type* s, స్ట్రీమ్‌సైజ్ n)
వినియోగదారు ఒక పదబంధాన్ని నమోదు చేసి, ఎంటర్ కీని నొక్కిన తర్వాత, మొదటి నుండి ప్రారంభమయ్యే అనేక అక్షరాలను సిన్ స్ట్రీమ్ బఫర్ నుండి సేకరించవచ్చు. కింది కోడ్‌ని ఉపయోగించవచ్చు:
చార్p[10];ఖరీదు << 'ఇన్పుట్ టెక్స్ట్:' <<endl;
జిన్.పొందండి(str,10);
ఖరీదు <<p<<endl;
ఇన్పుట్ 'గొప్ప వ్యక్తులు' అయితే, అవుట్పుట్ 'గ్రేట్ ప్యూ' అవుతుంది, 9 అక్షరాలు మరియు 10 కాదు స్ట్రింగ్ NUL అక్షరం ( 0) పొందండి ఆర్గ్యుమెంట్‌లో పదవ స్థానం. కాబట్టి, str లో 9 అక్షరాలు కలిగి ఉండాలంటే, దాని స్టోరేజ్ సైజు కనీసం 10 ఉండాలి, మరియు పొందండి () ఆర్గ్యుమెంట్ 11. మొత్తం ఇన్పుట్ లైన్ కావాలంటే, స్ట్రింగ్ స్టోరేజ్ నంబర్ కనీసం సంఖ్యగా ఉండాలి టైప్ చేసిన అక్షరాలు, ప్లస్ 1. కాబట్టి, మొత్తం పంక్తికి 12 అక్షరాలు టైప్ చేయబడితే, సంఖ్య స్ట్రింగ్ (str) నిల్వ పరిమాణానికి 13 మరియు పొందడానికి () వాదనకు 13 ఉండాలి. ఒక స్పేస్ ఒక అక్షరంగా లెక్కించబడుతుందని గమనించండి.
పొందండి (char_type* s, స్ట్రీమ్‌సైజ్ n, char_type డెలిమ్)
ఒక నిర్దిష్ట అక్షరం మొదటిసారి సంభవించడం ద్వారా లేదా ఉప-స్ట్రింగ్ యొక్క స్ట్రీమ్‌సైజ్ ద్వారా, కుడివైపున డీలిమిట్ చేయబడిన ఒక ఉప-స్ట్రింగ్‌ని సంగ్రహించడం సాధ్యమవుతుంది. కింది కోడ్‌కి ఇన్పుట్ టెక్స్ట్ గొప్ప వ్యక్తులు అయితే, గొప్పది సేకరించబడుతుంది:
ఖరీదు << 'ఇన్పుట్ టెక్స్ట్:' <<endl;
జిన్.పొందండి(str,6,'లేదా');
ఖరీదు <<p<<endl;
ప్రారంభం నుండి ఆరవ స్థానం అంతరిక్ష పాత్ర, మరియు అది సేకరించిన సబ్‌స్ట్రింగ్‌ని ప్రత్యేకంగా వేరు చేస్తుంది. 'O' అనే ఏకైక పాత్రకు ముందు ఆరవ స్థానం మొదట వస్తుంది. Str కోసం నిల్వ పరిమాణం సాధ్యమైనంత ఎక్కువగా ఉంటుందని గమనించండి.
కింది కోడ్‌కి ఇన్పుట్ టెక్స్ట్ గొప్ప వ్యక్తులు అయితే, gr సంగ్రహించబడుతుంది:
చార్p[30];ఖరీదు << 'ఇన్పుట్ టెక్స్ట్:' <<endl;
జిన్.పొందండి(str,10,'మరియు');
ఖరీదు <<p<<endl;
పదవ స్థానానికి ముందు మొదట 'ఇ' సంభవించడం జరుగుతుంది.
ఒక లైన్ యొక్క అన్ని పాత్రలను పొందడం
ఎంటర్ కీని నొక్కిన తర్వాత, లైన్‌లో టైప్ చేసిన అన్ని అక్షరాలు, కింది కోడ్‌లో చూపిన విధంగా పొందవచ్చు:
ఖరీదు << 'ఇన్పుట్ టెక్స్ట్:' <<endl;అయితే (1) {
చార్చ= (చార్)జిన్.పొందండి();
ఖరీదు <<చ;
ఉంటే (చ== ' n')
విరామం;
}
(చార్) తో కాస్టింగ్, ప్రతి దశాంశ సంఖ్యను సంబంధిత ASCII అక్షరంలోకి మారుస్తుంది.
పీక్ ()
గెట్ () సభ్యుల విధులు తదుపరి అక్షరాన్ని మాత్రమే చదవవు; వారు దానిని స్ట్రీమ్ బఫర్ నుండి తీసివేస్తారు. అయితే, పీక్ () సభ్యుల ఫంక్షన్ సింపుల్ గా బఫర్ నుండి తీసివేయకుండా తదుపరి అక్షరాన్ని (మొదటి నుండి మొదలుపెట్టి) చదువుతుంది. కింది కోడ్‌లో, ప్రతి అక్షరాన్ని మొదట గెట్ () ఫంక్షన్ ద్వారా తీసివేసే ముందు పీక్ () ఫంక్షన్‌తో చదవబడుతుంది. వినియోగదారు ఎంటర్ కీని నొక్కిన తర్వాత జరిగేదంతా:
ఖరీదు << 'ఇన్పుట్ టెక్స్ట్:' <<endl;అయితే (1) {
చార్చ= (చార్)జిన్.పీక్();
ఖరీదు <<చ;
జిన్.పొందండి();
ఉంటే (చ== ' n')
విరామం;
}
గెట్ () ద్వారా తదుపరి అక్షరాలు తీసివేయబడకపోతే, పీక్ () మొదటి అక్షరాన్ని మాత్రమే చదువుతుంది, మరియు లూప్ నిరవధికంగా మారుతుంది.
ఎంటర్ నొక్కడానికి ముందు అక్షరాలను ప్రదర్శించడం మరియు తొలగించడం
సిన్ ఆబ్జెక్ట్‌తో, చర్య జరగడానికి ముందు ఎంటర్ కీని నొక్కాల్సి ఉంటుందని గమనించండి. సరే, ఎంటర్ కీని నొక్కే ముందు టైప్ చేయబడి మరియు చెరిపివేయబడినప్పుడు అక్షరాలు ప్రదర్శించబడవచ్చు. అయితే, ఆపరేటింగ్ సిస్టమ్‌తో ఇంటర్‌ఫేసింగ్ అని అర్థం. ఆపరేటింగ్ సిస్టమ్స్ భిన్నంగా ఉంటాయి. కాబట్టి దీని అర్థం వివిధ ఆపరేటింగ్ సిస్టమ్‌లకు వేర్వేరు కోడింగ్. కాబట్టి ఈ అంశం పూర్తిగా భిన్నమైన ట్యుటోరియల్‌కు అర్హమైనది - తర్వాత చూడండి.
మానిటర్‌కు అక్షరాలు మరియు తీగలను పంపుతోంది
Cout ఆబ్జెక్ట్ అనేది అవుట్పుట్ స్ట్రీమ్ ఆబ్జెక్ట్, ఇది C ++ స్టాండర్డ్ లైబ్రరీలో ఇప్పటికే ఇన్‌స్టాంటియేట్ చేయబడింది. మానిటర్‌కు అక్షరాలు మరియు తీగలను పంపడంలో ఉపయోగించే ప్రధాన వస్తువు cout. ఇది చొప్పించే ఆపరేటర్‌తో చేయబడుతుంది,<< . With the cin object, the text is obtained line-by-line. With the cout object, the text is added onto the same line until ‘ ’ or endl is encountered.
స్కేలర్లు ఏర్పడే వ్యక్తీకరణలు చొప్పించే ఆపరేటర్ కోసం వాదనలు కావచ్చు. ఆపరేటర్ స్కేలార్‌ను టెక్స్ట్‌గా మార్చి, టెక్స్ట్‌ను కౌట్ ఆబ్జెక్ట్ స్ట్రీమ్‌లో ఉంచుతాడు. కౌట్ ఆబ్జెక్ట్‌కు టెక్స్ట్ పంపినప్పుడు, అది సాధారణంగా స్క్రీన్‌పై (మానిటర్) కనిపిస్తుంది. అయితే, అప్పుడప్పుడు, అది వెంటనే కనిపించకపోవచ్చు. టెక్స్ట్‌ని స్క్రీన్‌పైకి బలవంతం చేయడానికి, టెక్స్ట్‌ని ఇన్సర్ట్ చేసిన తర్వాత ప్రత్యేక విలువ, ఎండ్‌ఎల్‌ని చొప్పించండి. ఇది టెక్స్ట్‌ను స్క్రీన్‌పైకి ఫ్లష్ చేయడానికి కారణమవుతుంది మరియు కొత్త లైన్ జోడించబడుతుంది. గమనిక: ‘ n’ కేవలం కొత్త లైన్‌ని జోడిస్తుంది కానీ స్క్రీన్‌కు టెక్స్ట్‌ను ఫ్లష్ చేయదు.
స్క్రీన్, ఫ్లోట్ మరియు సాధారణ టెక్స్ట్ యొక్క విలువలను స్క్రీన్‌పై ఎలా ముద్రించాలో కింది ప్రోగ్రామ్ చూపుతుంది:
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన()
{
intఅది= 5;
తేలుతాయిఅడుగు= 63.5;
ఖరీదు << 'ది ' <<అది<< 'వస్తువుల ధర $' <<అడుగు<< 'యుఎస్.' <<endl;
తిరిగి 0;
}
అవుట్పుట్:
ది5వస్తువుల ధర $63.5USకింది ప్రోగ్రామ్ తరగతి నుండి తక్షణం అందించబడిన వస్తువు యొక్క స్ట్రింగ్ ఎలా ముద్రించబడిందో చూపుతుంది:
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్గంటలు;
నిర్మాణాత్మకసెయింట్{
చార్p[పదకొండు] = 'కొన్ని పదాలు';
}ఆబ్జెక్ట్;
intప్రధాన()
{
ఖరీదు <<ఆబ్జెక్ట్p << ' n';
తిరిగి 0;
}
అవుట్పుట్ 'కొన్ని పదాలు'.
C ++ ప్రోగ్రామ్ కోసం వాదనలు
కార్యక్రమం అమలు ప్రధాన () ఫంక్షన్ నుండి ప్రారంభమవుతుంది. ప్రధాన () ఫంక్షన్ వాస్తవానికి రెండు ఐచ్ఛిక పారామితులను కలిగి ఉంది. ఐచ్ఛిక పారామితులతో ప్రధాన () ఫంక్షన్ యొక్క వాక్యనిర్మాణం:
intప్రధాన(intargc,చార్ *argv[argc]){
తిరిగి 0;
}
ఎక్జిక్యూటబుల్ C ++ ఫైల్ పేరు తాత్కాలికంగా ఉందనుకోండి. ప్రోగ్రామ్ దాని పర్యావరణం (ఆపరేటింగ్ సిస్టమ్) నుండి యూజర్ టైప్ చేసిన వాదనలు,
వ్యాసాలు3బుక్ పెన్'పెద్ద ఇల్లు'ఇక్కడ 5 వాదనలు ఉన్నాయి: వ్యాసాలు, 3, పుస్తకం, పెన్ మరియు పెద్ద ఇల్లు
ప్రతి వచనం. ప్రోగ్రామ్‌కి సంఖ్యా వాదన టెక్స్ట్. మరో మాటలో చెప్పాలంటే, ప్రతి వాదన స్ట్రింగ్. పెద్ద ఇల్లు కోట్స్‌లో ఉంది ఎందుకంటే ఇది ఒక పదబంధం. ఈ ప్రోగ్రామ్‌ను అమలు చేయడానికి టెర్మినల్ కమాండ్:
./తాత్కాలిక కథనాలు3బుక్ పెన్'పెద్ద ఇల్లు'ఫైల్ టెంప్ హోమ్ డైరెక్టరీలో ఉందనుకోండి. ఖాళీలు మరియు కామాలు వాదనలను వేరు చేయవని గమనించండి.
ఇప్పుడు, ప్రధాన () ఫంక్షన్ సింటాక్స్‌లో, ఆర్‌జిసి అనేది ప్రోగ్రామ్ కోసం వాదనల సంఖ్య, ప్లస్ 1. ఈ సందర్భంలో, ప్రోగ్రామ్ కోసం 5 వాదనలు ఉన్నాయి. కాబట్టి, ఆర్‌జిసి 6. సింటాక్స్‌లో, ఆర్‌జివి [ఆర్‌జిసి] అనేది స్ట్రింగ్‌లకు పాయింటర్‌ల శ్రేణి. Argv [0] వద్ద ఈ శ్రేణికి మొదటి విలువ కంపైలర్ ద్వారా ఇవ్వబడింది. ఇది ప్రోగ్రామ్ ఫైల్ పేరుకు సూచిక. మిగిలిన విలువలు వినియోగదారు ఆర్డర్‌లోని ప్రోగ్రామ్ ఆర్గ్యుమెంట్‌లకు సూచించబడినవి. ఈ శ్రేణి పరిమాణం argc. ఈ సందర్భంలో పరిమాణం 1 + 5 = 6.
సంకలనం వద్ద, కింది ప్రోగ్రామ్‌కు టెంప్ అని పేరు పెట్టారు:
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన(intargc,చార్**argv)
{
ఖరీదు <<argv[0] << ',' <<argv[1] << ',' <<argv[2] << ',' <<argv[3] << ',' <<argv[4] << ',' <<argv[5] <<endl;
తిరిగి 0;
}
ఇక్కడ గమనించండి, శ్రేణి 'char*argv [argc]', 'char ** argv' గా ప్రకటించబడింది.
ఈ కార్యక్రమం టెర్మినల్ ఆదేశంతో అమలు చేయబడితే,
./తాత్కాలిక కథనాలు3బుక్ పెన్'పెద్ద ఇల్లు'అప్పుడు అవుట్పుట్ ఇలా ఉంటుంది:
./తాత్కాలిక, వ్యాసాలు,3, పుస్తకం, పెన్, పెద్ద ఇల్లుఎక్జిక్యూటబుల్ ఫైల్ పేరుతో డైరెక్టరీ మార్గం చేర్చబడిందని గమనించండి.
అలాగే, ప్రోగ్రామ్ రన్నింగ్‌లో (ప్రోగ్రామ్ యొక్క కాలింగ్), ఆర్‌జిసికి విలువ పంపబడలేదని గమనించండి.
ముగింపు
ఐయోస్ట్రీమ్ క్లాస్‌లో నాలుగు ముఖ్యమైన వస్తువులు ఉన్నాయి, అవి కౌట్, సిన్, సెర్ మరియు క్లాగ్. cin ఒక ఇన్పుట్ వస్తువు, మిగిలినవి అవుట్పుట్ వస్తువులు. ప్రోగ్రామ్ రన్ అవుతున్నప్పుడు, ప్రోగ్రామ్ రన్ చేయడం మొదలుపెట్టినప్పుడు ప్రోగ్రామ్‌కి ఇన్పుట్ భిన్నంగా ఉంటుంది. ప్రోగ్రామ్ రన్ చేయడం ప్రారంభించినప్పుడు, ప్రోగ్రామ్‌కి ఇన్పుట్ ప్రోగ్రామ్‌ని అమలు చేయడానికి కమాండ్‌తో జతచేయబడుతుంది, ఖాళీలు వేరు చేయబడతాయి.