ఇన్పుట్ & అవుట్పుట్ (cin, cout)
కంప్యూటర్ ప్రోగ్రామ్లు నిజ జీవితంలో ఉపయోగపడాలంటే అవి వినియోగదారుల (Users) నుండి సమాచారాన్ని స్వీకరించగలగాలి (Input), అలాగే లెక్కించిన ఫలితాలను అందమైన రూపంలో స్క్రీన్ పైన ప్రదర్శించగలగాలి (Output). C లాంగ్వేజ్లోని printf, scanf ల స్థానంలో C++ సరికొత్త ఆబ్జెక్ట్ ఓరియెంటెడ్ I/O స్ట్రీమ్స్ (Streams) ఆర్కిటెక్చర్ను ప్రవేశపెట్టింది.
ఈ మూడవ అధ్యాయంలో, కీబోర్డ్ బఫర్ మెకానిక్స్, std::cin తో స్పేసెస్తో కూడిన వాక్యాలను చదివేటప్పుడు వచ్చే ప్రసిద్ధ "Trailing Newline Trap", ఇన్పుట్ ఎర్రర్లను హ్యాండిల్ చేసే పద్ధతులు, <iomanip> తో సూపర్ మార్కెట్ రసీదు లాంటి అందమైన అవుట్పుట్ను డిజైన్ చేయడం మరియు కాంపిటీటివ్ ప్రోగ్రామింగ్ కోసం Fast I/O ట్రిక్స్ గురించి సంపూర్ణంగా నేర్చుకుందాం!
1 C++ I/O స్ట్రీమ్స్ ఆర్కిటెక్చర్: cin, cout, cerr & clog
C++ లో ఇన్పుట్ మరియు అవుట్పుట్ ఆపరేషన్లు స్ట్రీమ్స్ (Streams) ద్వారా నడుస్తాయి. స్ట్రీమ్ అంటే ఏమిటి? సులభంగా చెప్పాలంటే "బైట్ల యొక్క నిరంతర ప్రవాహం (Sequence / Flow of Bytes)".
మీరు కీబోర్డ్ పై టైప్ చేసిన అక్షరాలు నీటి ప్రవాహంలా కీబోర్డ్ నుండి మీ ప్రోగ్రామ్లోకి వస్తాయి (Input Stream). అలాగే మీరు ప్రింట్ చేసే డేటా స్క్రీన్ లేదా ఫైల్ వైపు ప్రవహిస్తుంది (Output Stream). C++ స్టాండర్డ్ లైబ్రరీ (<iostream>) నాలుగు ప్రాథమిక గ్లోబల్ స్ట్రీమ్ ఆబ్జెక్ట్లను అందిస్తుంది:
1. std::cin (Standard Input)
ఇది కీబోర్డ్కు కనెక్ట్ అయి ఉన్న istream క్లాస్ ఆబ్జెక్ట్. కీబోర్డ్ నుండి డేటాను చదవడానికి Extraction Operator (>>) తో కలిసి పనిచేస్తుంది.
2. std::cout (Standard Output)
కన్సోల్ స్క్రీన్కు కనెక్ట్ అయి ఉన్న బఫర్డ్ (Buffered) ostream ఆబ్జెక్ట్. డేటాను స్క్రీన్పై ప్రింట్ చేయడానికి Insertion Operator (<<) ను ఉపయోగిస్తుంది.
3. std::cerr (Standard Error)
ఎర్రర్ మెసేజ్ల కోసం ప్రత్యేకించబడిన Unbuffered స్ట్రీమ్. ఎటువంటి ఆలస్యం లేకుండా తక్షణమే ఎర్రర్ను స్క్రీన్పై లేదా ఎర్రర్ లాగ్లో డిస్ప్లే చేస్తుంది (ప్రోగ్రామ్ క్రాష్ అయినా కూడా).
4. std::clog (Standard Log)
సిస్టమ్ ఈవెంట్స్ మరియు ఆడిట్ లాగ్స్ రాయడానికి వాడే Buffered ఎర్రర్ స్ట్రీమ్. బఫర్ నిండినప్పుడు మాత్రమే ఫ్లష్ అవుతుంది.
2 std::cin మరియు Stream Extraction Operator (>>) మెకానిక్స్
కీబోర్డ్ నుండి డేటాను చదవడానికి మనం std::cin >> variable; అని రాస్తాము. ఇక్కడ >> గుర్తును Stream Extraction Operator అంటారు.
బాణం గుర్తులు కుడివైపు వేరియబుల్ వైపు చూపిస్తున్నాయి అంటే: "cin స్ట్రీమ్ నుండి డేటాను తీసి (Extract), కుడివైపు ఉన్న వేరియబుల్ మెమరీ బాక్స్లోకి నెట్టు" అని అర్థం.
🔍 cin >> ఎలా పనిచేస్తుంది? (White-space Skipping Rule)
1. cin >> ఆపరేటర్ కీబోర్డ్ బఫర్లో ప్రారంభంలో ఉండే స్పేస్లు (Spaces), ట్యాబ్లు (\t), మరియు కొత్త లైన్లను (\n) ఆటోమేటిక్గా వదిలేస్తుంది (Skips Leading Whitespace).
2. వాస్తవమైన డేటా క్యారెక్టర్ కనిపించగానే దానిని చదవడం మొదలుపెడుతుంది.
3. తదుపరి స్పేస్ గానీ, ఎంటర్కీ గానీ తగలగానే చదవడం తక్షణమే ఆపేస్తుంది!
#include <iostream>
int main() {
int age{0};
double cgpa{0.0};
std::cout << "మీ వయస్సును ఎంటర్ చేయండి: ";
std::cin >> age;
std::cout << "మీ ఇంజనీరింగ్ CGPA ఎంటర్ చేయండి: ";
std::cin >> cgpa;
std::cout << "\nనమోదైన వివరాలు -> వయస్సు: " << age
<< " సంవత్సరాలు | CGPA: " << cgpa << '\n';
return 0;
}
3 మల్టిపుల్ ఇన్పుట్ చదవడం (Chaining cin >> a >> b >> c;)
యూజర్ నుండి ఒకేసారి అనేక విలువలను ఒకే వరుసలో తీసుకోవడానికి మనం cin ని చైనింగ్ (Chaining) చేయవచ్చు. ఇది C లాంగ్వేజ్లోని సంక్లిష్టమైన ఫార్మాట్ స్పెసిఫైయర్ల కంటే ఎంతో సులభం:
#include <iostream>
int main() {
int day{0}, month{0}, year{0};
std::cout << "పుట్టిన తేదీని స్పేస్ ఇచ్చి ఎంటర్ చేయండి (DD MM YYYY): ";
// ఒకే లైన్లో 3 వేరియబుల్స్ చదవడం
std::cin >> day >> month >> year;
std::cout << "తేదీ ఫార్మాట్: " << day << "/" << month << "/" << year << '\n';
return 0;
}
వినియోగదారుడు 15 08 1947 అని స్పేస్లతో ఇచ్చినా, లేదా ప్రతి సంఖ్య తర్వాత ఎంటర్ ప్రెస్ చేసినా కంపైలర్ ఒకేలా సమర్థవంతంగా చదువుతుంది.
4 స్పేసెస్తో కూడిన పూర్తి వాక్యాలు చదవడం: std::getline()
మీరు ఒక విద్యార్థి పూర్తి పేరు (ఉదాహరణకు: "Nara Lokesh") లేదా చిరునామాను std::cin >> name; తో చదివితే ఏమి జరుగుతుంది?
cin >> అనేది స్పేస్ కనిపించగానే చదవడం ఆపేస్తుంది! కాబట్టి name లోకి కేవలం "Nara" మాత్రమే వస్తుంది; మిగిలిన "Lokesh" బఫర్లోనే ఉండిపోయి తదుపరి ఇన్పుట్లను నాశనం చేస్తుంది!
ఈ సమస్యను పరిష్కరించడానికి C++ లో std::getline(std::cin, stringVariable) ఫంక్షన్ ఉంది. ఇది యూజర్ ఎంటర్కీ ('\n') నొక్కేంతవరకు మధ్యలో ఎన్ని స్పేస్లు ఉన్నా వాక్య మొత్తాన్ని సింగిల్ షాట్లో చదువుతుంది.
#include <iostream>
#include <string>
int main() {
std::string fullName;
std::string collegeName;
std::cout << "మీ పూర్తి పేరు నమోదు చేయండి: ";
std::getline(std::cin, fullName);
std::cout << "మీ కళాశాల పేరు నమోదు చేయండి: ";
std::getline(std::cin, collegeName);
std::cout << "\nవిద్యార్థి: " << fullName << "\nకళాశాల: " << collegeName << '\n';
return 0;
}
5 ది డేంజరస్ "cin >> తర్వాత getline()" న్యూలైన్ ట్రాప్ & cin.ignore()
ప్రతి C++ బిగినర్ తన జీవితంలో కచ్చితంగా ఎదుర్కొనే అత్యంత విచిత్రమైన బగ్ ఏమిటంటే: ఒక నంబర్ చదివిన తర్వాత వెంటనే getline() రాస్తే, యూజర్ టైప్ చేయకుండానే ఆ లైన్ ఆటోమేటిక్గా స్కిప్ అయిపోతుంది!
⚠️ The Mystery Behind the Skip (బగ్ రహస్యం)
మీరు రోల్ నంబర్ కోసం 101 అని టైప్ చేసి కీబోర్డ్పై Enter నొక్కుతారు. అప్పుడు కీబోర్డ్ బఫర్లో "101\n" నిల్వ ఉంటుంది.
cin >> rollNo; కేవలం 101 ని మాత్రమే చదివి, ఆ '\n' (న్యూలైన్ క్యారెక్టర్) ను బఫర్లోనే అలాగే వదిలేస్తుంది!
తర్వాతి లైన్లో ఉన్న getline(cin, name); బఫర్ను చూడగానే అక్కడ సిద్ధంగా ఉన్న ఆ పాత '\n' క్యారెక్టర్ను చూసి "ఓహో యూజర్ ఎంటర్ నొక్కేసాడు" అనుకుని ఏమీ టైప్ చేయకుండానే ఖాళీ స్ట్రింగ్తో ముగిసిపోతుంది!
✅ The Universal Solution: std::cin.ignore()
cin >> తర్వాత getline() వాడే ముందు బఫర్లో ఉన్న ఆ మిగిలిపోయిన న్యూలైన్ను తీసివేయడానికి cin.ignore() వాడాలి:
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
#include <iostream>
#include <string>
#include <limits>
int main() {
int studentId{0};
std::string projectTitle;
std::cout << "స్టూడెంట్ ID ఎంటర్ చేయండి: ";
std::cin >> studentId;
// 🛡️ బఫర్లో ఉన్న Trailing Newline ను క్లీన్ చేయడం
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
std::cout << "ప్రాజెక్ట్ టైటిల్ నమోదు చేయండి (స్పేస్లతో సహా): ";
std::getline(std::cin, projectTitle); // ఇప్పుడు స్కిప్ అవ్వకుండా పర్ఫెక్ట్గా పనిచేస్తుంది!
std::cout << "\nనమోదైన డేటా -> ID: " << studentId << " | టైటిల్: " << projectTitle << '\n';
return 0;
}
6 ఇన్పుట్ వాలిడేషన్ & ఫెయిల్యూర్ స్టేట్స్ (cin.fail, cin.clear)
ఒక ప్రోగ్రామ్ వయస్సు (ఇంటిజర్) అడిగినప్పుడు యూజర్ పొరపాటున "twenty" అని ఇంగ్లీష్ అక్షరాలు టైప్ చేస్తే ఏమి జరుగుతుంది?
C++ లో cin వెంటనే Fail State లోకి వెళ్లిపోతుంది (cin.fail() == true). ఆ తర్వాత ప్రోగ్రామ్లోని మిగిలిన అన్ని ఇన్పుట్ స్టేట్మెంట్లు మూగబోయి పనిచేయడం ఆగిపోతాయి!
ప్రొఫెషనల్ కోడ్లో ఇన్పుట్ విఫలమైతే సిస్టమ్ను రక్షించడానికి రెండు ఫంక్షన్లు వాడాలి:
std::cin.clear();— ఫెయిల్ అయిన ఎర్రర్ ఫ్లాగ్ను రీసెట్ చేసిcinను మళ్లీ జీవం పోస్తుంది.std::cin.ignore(...);— బఫర్లో ఉన్న ఆ చెత్త డేటాను బయటకు పారేస్తుంది.
#include <iostream>
#include <limits>
int main() {
int validAge{0};
while (true) {
std::cout << "దయచేసి మీ వయస్సును (నంబర్ మాత్రమే) ఎంటర్ చేయండి: ";
if (std::cin >> validAge) {
// సరైన ఇంటిజర్ ఇన్పుట్ వచ్చింది!
break;
} else {
// యూజర్ అక్షరాలు లేదా తప్పుడు ఇన్పుట్ ఇచ్చాడు!
std::cout << "❌ తప్పుడు ఇన్పుట్! కేవలం సంఖ్యలను మాత్రమే నమోదు చేయండి.\n";
std::cin.clear(); // 1. ఎర్రర్ స్టేట్ను రీసెట్ చేయడం
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 2. చెత్త డేటాను క్లియర్ చేయడం
}
}
std::cout << "✅ ధృవీకరించబడిన వయస్సు: " << validAge << '\n';
return 0;
}
7 ఎర్రర్ లాగింగ్: std::cout vs std::cerr vs std::clog
ఎంటర్ప్రైజ్ సాఫ్ట్వేర్ సిస్టమ్స్ (సర్వర్లు, గేమింగ్ ఇంజిన్లు) లో సాధారణ సమాచారం మరియు ఎర్రర్లను ఒకేలా ట్రీట్ చేయకూడదు:
| స్ట్రీమ్ ఆబ్జెక్ట్ | బఫరింగ్ రకం | ఉపయోగం (Purpose) | రీడైరెక్షన్ (Redirection) |
|---|---|---|---|
std::cout |
Buffered | సాధారణ ప్రోగ్రామ్ ఫలితాలు & యూజర్ ఇంటర్ఫేస్ | ఫైల్ లోకి మళ్లించవచ్చు (./app > out.txt) |
std::cerr |
Unbuffered | క్రిటికల్ ఎర్రర్స్, క్రాష్ రిపోర్ట్స్ (తక్షణమే ఫ్లష్ అవుతుంది) | ప్రత్యేక ఎర్రర్ లాగ్ లోకి (2> error.log) |
std::clog |
Buffered | సాధారణ ఈవెంట్ లాగ్స్, ఆడిట్ ట్రాకింగ్ | లాగ్ ఫైల్స్ లోకి పంపబడుతుంది |
8 అడ్వాన్స్డ్ అవుట్పుట్ ఫార్మాటింగ్: <iomanip> లైబ్రరీ
కన్సోల్పై సంఖ్యలను మరియు టెక్స్ట్ను పట్టికల రూపంలో అందంగా అమర్చడానికి C++ <iomanip> (Input Output Manipulators) హెడర్ ఫైల్ను అందిస్తుంది. దీనిలోని అత్యంత ముఖ్యమైన మానిప్యులేటర్లు:
std::setw(n)— ఒక కాలమ్ యొక్క వెడల్పును (Width) 'n' క్యారెక్టర్లుగా నిర్దేశిస్తుంది.std::setfill(ch)— ఖాళీ స్థలంలో స్పేస్కు బదులుగా చుక్కలు (.) లేదా డ్యాష్లు (-) నింపుతుంది.std::fixed— సంఖ్యలను సైంటిఫిక్ ఎక్స్పోనెన్షియల్ (1e+05) లో కాకుండా సాధారణ దశాంశ రూపంలో చూపిస్తుంది.std::setprecision(n)— దశాంశ బిందువు తర్వాత ఖచ్చితంగా ఎన్ని స్థానాలు ఉండాలో లాక్ చేస్తుంది.
#include <iostream>
#include <iomanip>
int main() {
std::cout << std::left << std::setw(15) << "వస్తువు"
<< std::right << std::setw(8) << "పరిమాణం"
<< std::setw(12) << "ధర (₹)" << '\n';
std::cout << std::string(35, '-') << '\n';
std::cout << std::fixed << std::setprecision(2);
std::cout << std::left << std::setw(15) << "Apple"
<< std::right << std::setw(8) << 5
<< std::setw(12) << 150.00 << '\n';
std::cout << std::left << std::setw(15) << "Basmati Rice"
<< std::right << std::setw(8) << 2
<< std::setw(12) << 280.50 << '\n';
return 0;
}
9 సంఖ్యా ఆధారిత బేసెస్ ఫార్మాటింగ్: dec, hex, oct & showbase
మెమరీ అడ్రస్లు మరియు నెట్వర్క్ ప్యాకెట్లు ప్రాసెస్ చేసేటప్పుడు సంఖ్యలను హెక్సాడెసిమల్ (Hex) లేదా ఆక్టల్ (Octal) లో చూపించడం అవసరం:
#include <iostream>
int main() {
int num = 255;
std::cout << std::showbase; // ప్రిఫిక్స్లు (0x, 0) చూపిస్తుంది
std::cout << "Decimal (సాధారణం) : " << std::dec << num << '\n';
std::cout << "Hexadecimal (హెక్స్) : " << std::hex << num << '\n';
std::cout << "Octal (ఆక్టల్) : " << std::oct << num << '\n';
return 0;
}
10 బూలియన్ & అలైన్మెంట్ ఫార్మాటింగ్: boolalpha, left, right
డిఫాల్ట్గా C++ లో బూలియన్ వేరియబుల్స్ 1 మరియు 0 గా ప్రింట్ అవుతాయి. కానీ యూజర్ చదవడానికి వీలుగా "true" మరియు "false" గా ప్రింట్ చేయడానికి std::boolalpha ఉపయోగిస్తాము. తిరిగి సంఖ్యలుగా మార్చడానికి std::noboolalpha వాడతాము:
bool isServerRunning = true;
std::cout << isServerRunning << '\n'; // ప్రింట్ అయ్యేది: 1
std::cout << std::boolalpha << isServerRunning << '\n'; // ప్రింట్ అయ్యేది: true
11 ఫాస్ట్ I/O ట్రిక్స్: కాంపిటీటివ్ ప్రోగ్రామింగ్ కోసం (Fast I/O)
LeetCode, Codeforces, CodeChef లాంటి ప్లాట్ఫారమ్లలో లక్షలాది ఇన్పుట్లను మిల్లీసెకన్లలో ప్రాసెస్ చేయాల్సి ఉంటుంది. C++ లో cin డిఫాల్ట్గా C లాంగ్వేజ్ యొక్క stdio తో సింక్రనైజ్ అయి ఉండటం వల్ల కొంత స్లోగా ఉంటుంది.
మీ main() ఫంక్షన్ ప్రారంభంలో కేవలం ఈ రెండు లైన్లు రాస్తే cin వేగం 10 రెట్లు మెరుపువేగంగా మారుతుంది!
⚡ The Competitive Programming Secret:
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
sync_with_stdio(false) అనేది పాత C స్ట్రీమ్స్ తో సింక్రనైజేషన్ను ఆపేస్తుంది. cin.tie(NULL) అనేది ప్రతి ఇన్పుట్ కి ముందు అనవసరంగా cout ను ఫ్లష్ చేసే పనిని ఆపుతుంది!
12 సాధారణ బిగినర్ తప్పులు, బఫర్ హ్యాంగ్స్ & బెస్ట్ ప్రాక్టీసెస్
ఇంటిజర్ చదివిన వెంటనే getline() రాస్తే 100% ఆ లైన్ స్కిప్ అవుతుంది. ఎల్లప్పుడూ మధ్యలో cin.ignore() పెట్టడం ఒక బంగారు అలవాటుగా మార్చుకోండి.
ఫాస్ట్ I/O ఆన్ చేసిన తర్వాత పొరపాటున కూడా అదే ప్రోగ్రామ్లో printf లేదా scanf వాడకూడదు. అలా చేస్తే అవుట్పుట్ తారుమారైపోతుంది. కేవలం cin, cout మాత్రమే వాడాలి.
13 రియల్-వరల్డ్ ప్రాక్టీస్ ప్రాజెక్ట్: "Smart POS Billing & Invoice Engine"
ఈ అధ్యాయంలో నేర్చుకున్న cin, getline, cin.ignore, iomanip, fixed, setprecision, మరియు setw అన్నింటినీ ఉపయోగించి డిమార్ట్ లేదా రిలయన్స్ స్మార్ట్ సూపర్ మార్కెట్ లో ఉపయోగించే నిజమైన "Automated POS Billing & Tax Invoice Engine" ప్రాజెక్ట్ను రన్ చేద్దాం:
#include <iostream>
#include <string>
#include <iomanip>
#include <limits>
int main() {
std::string storeName = "OUR COMPILER SUPERMARKET";
std::string cashierName = "రమేష్ బాబు (Ramesh Babu)";
std::string customerName = "సురేష్ వర్మ (Suresh Varma)";
std::string item1Name = "Organic Basmati Rice (5kg)";
std::string item2Name = "Cold Pressed Groundnut Oil (1L)";
int qty1 = 2;
double price1 = 450.00;
int qty2 = 3;
double price2 = 210.50;
// కాలిక్యులేషన్స్
double subTotal1 = qty1 * price1;
double subTotal2 = qty2 * price2;
double totalTaxableAmount = subTotal1 + subTotal2;
double gstRatePercent = 18.0;
double gstAmount = totalTaxableAmount * (gstRatePercent / 100.0);
double discountPercent = 5.0;
double discountAmount = totalTaxableAmount * (discountPercent / 100.0);
double grandTotal = (totalTaxableAmount - discountAmount) + gstAmount;
// అధికారిక టాక్స్ ఇన్వాయిస్ ప్రింటింగ్
std::cout << std::fixed << std::setprecision(2);
std::cout << "================================================================\n";
std::cout << " " << storeName << "\n";
std::cout << " హైటెక్ సిటీ, మాదాపూర్, హైదరాబాద్ \n";
std::cout << "================================================================\n";
std::cout << "క్యాషియర్ పేరు : " << std::left << std::setw(25) << cashierName
<< "బిల్ నంబర్ : #POS-98421\n";
std::cout << "కస్టమర్ పేరు : " << std::left << std::setw(25) << customerName
<< "చెల్లింపు : UPI / Card\n";
std::cout << "----------------------------------------------------------------\n";
std::cout << std::left << std::setw(34) << "వస్తువు వివరణ (Item Description)"
<< std::right << std::setw(8) << "పరిమాణం"
<< std::setw(11) << "రేటు (₹)"
<< std::setw(11) << "మొత్తం (₹)" << '\n';
std::cout << "----------------------------------------------------------------\n";
std::cout << std::left << std::setw(34) << item1Name
<< std::right << std::setw(8) << qty1
<< std::setw(11) << price1
<< std::setw(11) << subTotal1 << '\n';
std::cout << std::left << std::setw(34) << item2Name
<< std::right << std::setw(8) << qty2
<< std::setw(11) << price2
<< std::setw(11) << subTotal2 << '\n';
std::cout << "----------------------------------------------------------------\n";
std::cout << std::left << std::setw(45) << "సబ్-టోటల్ (Sub-Total):"
<< std::right << std::setw(19) << totalTaxableAmount << '\n';
std::cout << std::left << std::setw(45) << "లాయల్టీ డిస్కౌంట్ (-5%):"
<< std::right << std::setw(19) << -discountAmount << '\n';
std::cout << std::left << std::setw(45) << "జీఎస్టీ పన్ను (+18% GST):"
<< std::right << std::setw(19) << gstAmount << '\n';
std::cout << "================================================================\n";
std::cout << std::left << std::setw(45) << "మొత్తం చెల్లించాల్సిన సొమ్ము (Grand Total):"
<< std::right << std::setw(19) << grandTotal << " /-\n";
std::cout << "================================================================\n";
std::cout << " ధన్యవాదములు! మళ్లీ విచ్చేయండి (Thank You, Visit Again!) \n";
std::cout << "================================================================\n";
return 0;
}
❓ ఇంటర్వ్యూ & పరీక్షల క్విజ్ (Knowledge Check)
ప్రశ్న 1: std::cin >> మరియు std::getline() మధ్య ప్రధాన తేడా ఏమిటి?
cin >> మొదటి స్పేస్, ట్యాబ్ లేదా న్యూలైన్ కనిపించగానే చదవడం ఆపేస్తుంది (కేవలం సింగిల్ వర్డ్ మాత్రమే చదువుతుంది). కాగా getline(cin, str) మధ్యలో ఎన్ని స్పేస్లు ఉన్నా యూజర్ ఎంటర్కీ ('\n') నొక్కేంతవరకు పూర్తి వాక్యాన్ని చదువుతుంది.
ప్రశ్న 2: cin >> తర్వాత వెంటనే getline() వాడితే ఎందుకు స్కిప్ అవుతుంది? ఎలా పరిష్కరించాలి?
cin >> సంఖ్యను చదివిన తర్వాత ఎంటర్కీ వల్ల వచ్చే న్యూలైన్ క్యారెక్టర్ ('\n') ను బఫర్లోనే వదిలేస్తుంది. ఆ తర్వాతి getline() ఆ న్యూలైన్ను చూసి ఖాళీగా ముగిసిపోతుంది. దీనిని పరిష్కరించడానికి మధ్యలో std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); వాడి బఫర్ను క్లియర్ చేయాలి.
ప్రశ్న 3: std::cout మరియు std::cerr మధ్య సాంకేతిక వ్యత్యాసం ఏమిటి?
std::cout అనేది బఫర్డ్ (Buffered) స్ట్రీమ్; వేగం కోసం బఫర్ నిండేంతవరకు వేచి ఉంటుంది. std::cerr అనేది అన్బఫర్డ్ (Unbuffered); సిస్టమ్ క్రాష్ అయినా కూడా ఎర్రర్ లాగ్ తక్షణమే స్క్రీన్పై రికార్డ్ అయ్యేలా వెంటనే ఫ్లష్ చేస్తుంది.
ప్రశ్న 4: <iomanip> లోని std::fixed మరియు std::setprecision(2) కలిసి ఎలా పనిచేస్తాయి?
setprecision(n) వాడితే అది మొత్తం అంకెల సంఖ్యను పరిమితం చేస్తుంది. కానీ std::fixed తో కలిపి వాడినప్పుడు, దశాంశ బిందువు (Decimal point) తర్వాత ఖచ్చితంగా n స్థానాలు (ఉదాహరణకు కరెన్సీ పైసల కోసం 2 స్థానాలు: 150.00) మాత్రమే స్థిరంగా ఉండేలా చేస్తుంది.
ప్రశ్న 5: std::ios_base::sync_with_stdio(false) C++ I/O వేగాన్ని ఎందుకు భారీగా పెంచుతుంది?
sync_with_stdio(false) ఆ సమకాలీకరణను నిలిపివేయడం ద్వారా C++ తన సొంత హై-స్పీడ్ బఫర్లను స్వతంత్రంగా ఉపయోగించుకునేలా చేస్తుంది, దీనివల్ల వేగం 5 నుండి 10 రెట్లు పెరుగుతుంది.
ఈ ప్రాజెక్ట్ను లైవ్గా మన కంపైలర్లో రన్ చేయండి!
ఎటువంటి లోకల్ సెటప్ లేకుండా, బ్రౌజర్లోనే నేరుగా Modern C++ (GCC 13 / C++20) కంపైలర్లో ఈ కోడ్ను ఎగ్జిక్యూట్ చేసి రన్టైమ్ అవుట్పుట్ను తనిఖీ చేయండి.