ఈ ఆర్టికల్లో, అనేక ఉదాహరణలను ఉపయోగించి C ++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లోని ఫైల్‌ని ఎలా చదవాలి మరియు వ్రాయాలో మేము మీకు చూపించబోతున్నాము. చదవడం మరియు వ్రాయడం వంటి C ++ ఫైల్ కార్యకలాపాలను అర్థం చేసుకోవడానికి, మేము మొదట C ++ లో స్ట్రీమ్ భావనను అర్థం చేసుకోవాలి.
స్ట్రీమ్ అంటే ఏమిటి?
స్ట్రీమ్ అంటే కేవలం డేటా లేదా అక్షరాల ప్రవాహం. రెండు రకాల స్ట్రీమ్‌లు ఉన్నాయి: ఇన్‌పుట్ స్ట్రీమ్‌లు మరియు అవుట్‌పుట్ స్ట్రీమ్‌లు. కీబోర్డ్ వంటి బాహ్య ఇన్‌పుట్ పరికరం నుండి డేటాను చదవడానికి ఇన్‌పుట్ స్ట్రీమ్ ఉపయోగించబడుతుంది, అయితే మానిటర్ వంటి బాహ్య అవుట్‌పుట్ పరికరానికి డేటాను వ్రాయడానికి అవుట్‌పుట్ స్ట్రీమ్ ఉపయోగించబడుతుంది. ఒక ఫైల్‌ను ఇన్‌పుట్ మరియు అవుట్‌పుట్ మూలంగా పరిగణించవచ్చు.
C ++ లో, మేము డేటాను పంపడానికి లేదా స్వీకరించడానికి ఒక స్ట్రీమ్‌ని ఉపయోగిస్తాము లేదా బాహ్య మూలం నుండి.
ఇన్‌పుట్/అవుట్‌పుట్ స్ట్రీమ్‌ను యాక్సెస్ చేయడానికి మేము అంతర్నిర్మిత తరగతులను ఉపయోగించవచ్చు, అనగా ios.
C ++ ప్రోగ్రామింగ్ లాంగ్వేజ్ యొక్క స్ట్రీమ్ క్లాస్ సోపానక్రమం ఇక్కడ ఉంది:
సిన్ మరియు కౌట్ వస్తువులు కీబోర్డ్ నుండి డేటాను చదవడానికి మరియు మానిటర్‌లో అవుట్‌పుట్‌ను ప్రదర్శించడానికి ఉపయోగిస్తారు. అదనంగా, ఇన్‌పుట్ ఫైల్ స్ట్రీమ్‌ని సూచించే ifstream, ఫైల్ నుండి డేటా స్ట్రీమ్‌ను చదవడానికి ఉపయోగించబడుతుంది మరియు అవుట్‌పుట్ ఫైల్ స్ట్రీమ్‌ని సూచిస్తుంది, ఇది ఫైల్‌కు డేటా స్ట్రీమ్‌ను వ్రాయడానికి ఉపయోగించబడుతుంది.
Iostram.h ఫైల్‌లో C ++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో అవసరమైన అన్ని ప్రామాణిక ఇన్‌పుట్/అవుట్‌పుట్ స్ట్రీమ్ క్లాసులు ఉన్నాయి.
ఉదాహరణలు
ఇప్పుడు మీరు స్ట్రీమ్‌ల ప్రాథమికాలను అర్థం చేసుకున్నారు, C ++ లో ఫైల్ కార్యకలాపాలను బాగా అర్థం చేసుకోవడానికి మీకు సహాయపడటానికి మేము ఈ క్రింది ఉదాహరణలను చర్చిస్తాము:
- ఉదాహరణ 1: ఫైల్‌ని తెరిచి మూసివేయండి
- ఉదాహరణ 2: ఒక ఫైల్‌కు వ్రాయండి
- ఉదాహరణ 3: ఫైల్ నుండి చదవండి
- ఉదాహరణ 4: ఒక ఫైల్‌కి చదవండి మరియు వ్రాయండి
- ఉదాహరణ 5: బైనరీ ఫైల్‌ని చదవండి మరియు వ్రాయండి
ఉదాహరణ 1: ఫైల్‌ని తెరిచి మూసివేయండి
ఈ ఉదాహరణ ప్రోగ్రామ్‌లో, C ++ లో ఫైల్‌ను ఎలా తెరవాలి/క్రియేట్ చేయాలి మరియు ఫైల్‌ను ఎలా క్లోజ్ చేయాలి అని మేము ప్రదర్శిస్తాము. దిగువ ప్రోగ్రామ్‌లో మీరు చూడగలిగినట్లుగా, ఫైల్ కార్యకలాపాలకు అవసరమైన లైబ్రరీని మేము చేర్చాము.
ఫైల్‌ను తెరవడానికి మరియు మూసివేయడానికి, మాకు స్ట్రీమ్ యొక్క వస్తువు అవసరం. అప్పుడు, ఒక ఫైల్‌ని చదవడానికి లేదా వ్రాయడానికి, మేము ఫైల్‌ను తెరవాలి. మేము స్ట్రీమ్ క్లాస్ యొక్క యాక్సెస్ కోసం లైన్ నంబర్ -1 వద్ద fstream హెడర్ ఫైల్‌ను చేర్చాము.
మేము ప్రధాన ఫంక్షన్ లోపల myFile_Handler ని స్ట్రీమ్ యొక్క వస్తువుగా ప్రకటించాము. ఖాళీ ఫైల్‌ను సృష్టించడానికి ఓపెన్ () ఫంక్షన్‌ని మరియు ఫైల్‌ను క్లోజ్ చేయడానికి క్లోజ్ () ఫంక్షన్‌ను ఉపయోగించవచ్చు.
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన()
{
ఆఫ్‌స్ట్రీమ్ myFile_Handler;
// ఫైల్ ఓపెన్
myFile_Handler.తెరవండి('File_1.txt');
// ఫైల్ క్లోజ్
myFile_Handler.దగ్గరగా();
తిరిగి 0;
}
ఇప్పుడు, మేము ప్రోగ్రామ్‌ను కంపైల్ చేస్తాము మరియు అవుట్‌పుట్‌ను పరిశీలిస్తాము. దిగువ అవుట్‌పుట్ విండోలో మీరు చూడగలిగినట్లుగా, ప్రోగ్రామ్‌ను అమలు చేసిన తర్వాత File_1.txt ఫైల్ సృష్టించబడింది. మేము ఫైల్‌లో ఏ కంటెంట్ రాయలేదు కాబట్టి ఫైల్ పరిమాణం సున్నా.
ఉదాహరణ 2: ఒక ఫైల్‌కు వ్రాయండి
మునుపటి ఉదాహరణ ప్రోగ్రామ్‌లో, ఫైల్‌ను ఎలా తెరవాలో మరియు ఫైల్‌ను ఎలా క్లోజ్ చేయాలో మేము మీకు చూపించాము. ఇప్పుడు, ఫైల్‌లో ఏదైనా ఎలా రాయాలో మేము మీకు చూపుతాము.
స్ట్రీమ్ ఇన్సర్షన్ ఆపరేటర్‌ను ఉపయోగించి మేము ఫైల్‌కు వ్రాయవచ్చు, అనగా,<<. In this program, we have used the file handler and insertion operator to write two lines in the file. The insertion operator (<<) indicates that we are inserting the string into the output file stream object.
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన()
{
ఆఫ్‌స్ట్రీమ్ myFile_Handler;
// ఫైల్ ఓపెన్
myFile_Handler.తెరవండి('File_1.txt');
// ఫైల్‌కు వ్రాయండి
myFile_Handler<< 'ఇది నమూనా పరీక్ష ఫైల్. ' <<endl;
myFile_Handler<< 'ఇది ఫైల్ యొక్క రెండవ లైన్. ' <<endl;
// ఫైల్ క్లోజ్
myFile_Handler.దగ్గరగా();
తిరిగి 0;
}
ఇప్పుడు, మేము పై ప్రోగ్రామ్‌ను కంపైల్ చేసి దానిని అమలు చేస్తాము. మీరు క్రింద చూడగలిగినట్లుగా, మేము File_1.txt ఫైల్‌కు విజయవంతంగా వ్రాసాము.
ఉదాహరణ 3: ఫైల్ నుండి చదవండి
మునుపటి ఉదాహరణలలో, ఫైల్‌కు కంటెంట్‌ను ఎలా వ్రాయాలో మేము మీకు చూపించాము. ఇప్పుడు, ఉదాహరణ -2 లో మనం సృష్టించిన ఫైల్ నుండి కంటెంట్‌ను చదివి, ప్రామాణిక అవుట్‌పుట్ పరికరంలో కంటెంట్‌ను ప్రదర్శిద్దాం, అనగా మానిటర్.
ఫైల్ నుండి పూర్తి పంక్తిని చదవడానికి మేము getline () ఫంక్షన్‌ను ఉపయోగిస్తాము మరియు తరువాత మానిటర్‌పై లైన్ ప్రింట్ చేయడానికి కౌట్ చేస్తాము.
#చేర్చండి#చేర్చండి
#చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన()
{
ifstream myFile_Handler;
స్ట్రింగ్ మైలైన్;
// ఫైల్ రీడ్ మోడ్‌లో తెరవండి
myFile_Handler.తెరవండి('File_1.txt');
ఉంటే(myFile_Handler.తెరవబడింది())
{
// ఫైల్ చదువుతూ ఉండండి
అయితే(గెట్‌లైన్(myFile_Handler, myLine))
{
// ప్రామాణిక అవుట్‌పుట్‌పై లైన్ ప్రింట్ చేయండి
ఖరీదు <<మైలైన్<<endl;
}
// ఫైల్ క్లోజ్
myFile_Handler.దగ్గరగా();
}
లేకపోతే
{
ఖరీదు << 'ఫైల్‌ని తెరవడం సాధ్యపడలేదు!';
}
తిరిగి 0;
}
ఇప్పుడు, మేము కింది ఆదేశాన్ని ఉపయోగించి File_1.txt యొక్క కంటెంట్‌ను ప్రింట్ చేస్తాము: cat File_1.txt. మేము ప్రోగ్రామ్‌ను కంపైల్ చేసి, ఎగ్జిక్యూట్ చేసిన తర్వాత, అవుట్‌పుట్ ఫైల్ కంటెంట్‌తో సరిపోలుతుందని స్పష్టమవుతుంది. అందువల్ల, మేము ఫైల్‌ను విజయవంతంగా చదివాము మరియు ఫైల్ యొక్క కంటెంట్‌ను మానిటర్‌కు ముద్రించాము.
ఉదాహరణ 4: ఒక ఫైల్‌కి చదవండి మరియు వ్రాయండి
ఇప్పటివరకు, ఫైల్‌ను ఎలా తెరవాలి, చదవాలి, వ్రాయాలి మరియు మూసివేయాలి అని మేము మీకు చూపించాము. C ++ లో, మేము ఒకే సమయంలో ఒక ఫైల్‌ని చదవవచ్చు మరియు వ్రాయవచ్చు. ఒక ఫైల్‌ని చదవడానికి మరియు వ్రాయడానికి, మేము ఒక fstream వస్తువును పొందాలి మరియు ios :: in మరియు ios :: అవుట్ మోడ్‌లో ఫైల్‌ని తెరవాలి.
ఈ ఉదాహరణలో, మేము మొదట కొంత కంటెంట్‌ను ఫైల్‌కు వ్రాస్తాము. అప్పుడు, మేము ఫైల్ నుండి డేటాను చదివి మానిటర్‌కు ప్రింట్ చేస్తాము.
#చేర్చండి#చేర్చండి
#చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన()
{
fstream myFile_Handler;
స్ట్రింగ్ మైలైన్;
// ఫైల్ ఓపెన్
myFile_Handler.తెరవండి('File_1.txt', ios::లో |ios::బయటకు);
// ఫైల్ తెరిచిందో లేదో తనిఖీ చేయండి
ఉంటే(!myFile_Handler)
{
ఖరీదు << 'ఫైల్ తెరవలేదు!';
బయటకి దారి(1);
}
// ఫైల్‌కు వ్రాయండి
myFile_Handler<< '1 ఇది మరొక నమూనా పరీక్ష ఫైల్. ' <<endl;
myFile_Handler<< '2 ఇది ఫైల్ యొక్క రెండవ లైన్. ' <<endl;
myFile_Handler.కోరుకుంటారు(ios::వేడుకో);
// ఫైల్ చదవండి
ఉంటే(myFile_Handler.తెరవబడింది())
{
// ఫైల్ చదువుతూ ఉండండి
అయితే(గెట్‌లైన్(myFile_Handler, myLine))
{
// ప్రామాణిక అవుట్‌పుట్‌పై లైన్ ప్రింట్ చేయండి
ఖరీదు <<మైలైన్<<endl;
}
// ఫైల్ క్లోజ్
myFile_Handler.దగ్గరగా();
}
లేకపోతే
{
ఖరీదు << 'ఫైల్‌ని తెరవడం సాధ్యపడలేదు!';
}
myFile_Handler.దగ్గరగా();
తిరిగి 0;
}
ఇప్పుడు, మేము ప్రోగ్రామ్‌ను కంపైల్ చేసి అమలు చేస్తాము.
ఉదాహరణ 5: బైనరీ ఫైల్‌ని చదవండి మరియు వ్రాయండి
ఈ ఉదాహరణలో, మేము ఒక తరగతిని ప్రకటించబోతున్నాము మరియు ఆబ్జెక్ట్‌ను బైనరీ ఫైల్‌కు వ్రాస్తాము. ఈ ఉదాహరణను సరళీకృతం చేయడానికి, మేము పబ్లిక్ వేరియబుల్ emp_id తో ఉద్యోగుల తరగతిని ప్రకటించాము. అప్పుడు, మేము బైనరీ ఫైల్‌ని చదివి అవుట్‌పుట్‌ను మానిటర్‌కు ప్రింట్ చేస్తాము.
#చేర్చండి#చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్గంటలు;
తరగతిఉద్యోగి
{
ప్రజా:
intemp_id;
};
intప్రధాన()
{
ఆఫ్‌స్ట్రీమ్ binOutFile_Handler;
ifstream binInFile_Handler;
ఉద్యోగి empObj_W, empObj_R;
// ఫైల్ ఓపెన్
binOutFile_Handler.తెరవండి('ఉద్యోగి. డేట్', ios::బయటకు |ios::బైనరీ);
// ఫైల్ తెరిచిందో లేదో తనిఖీ చేయండి
ఉంటే(!binOutFile_Handler)
{
ఖరీదు << 'ఫైల్ తెరవలేదు!';
బయటకి దారి(1);
}
// empObj_W ని ప్రారంభించండి
empObj_W.emp_id = 1512;
// ఫైల్‌కు వ్రాయండి
binOutFile_Handler.వ్రాయడానికి((చార్ *) &empObj_W,పరిమాణం(ఉద్యోగి));
binOutFile_Handler.దగ్గరగా();
ఉంటే(!binOutFile_Handler.మంచిది())
{
ఖరీదు << 'బైనరీ ఫైల్ రాసేటప్పుడు లోపం సంభవించింది!' <<endl;
బయటకి దారి(2);
}
// ఇప్పుడు, ఉద్యోగి. డాట్ ఫైల్ చదువుదాం
binInFile_Handler.తెరవండి('ఉద్యోగి. డేట్', ios::లో |ios::బైనరీ);
// ఫైల్ తెరిచిందో లేదో తనిఖీ చేయండి
ఉంటే(!binInFile_Handler)
{
ఖరీదు << 'ఫైల్ తెరవలేదు!';
బయటకి దారి(3);
}
// బైనరీ ఫైల్ కంటెంట్‌ని చదవండి
binInFile_Handler.చదవండి((చార్ *) &empObj_R,పరిమాణం(ఉద్యోగి));
binInFile_Handler.దగ్గరగా();
ఉంటే(!binInFile_Handler.మంచిది())
{
ఖరీదు << 'బైనరీ ఫైల్ చదువుతున్నప్పుడు లోపం సంభవించింది!' <<endl;
బయటకి దారి(4);
}
// empObj_R అవుట్‌పుట్‌ను ప్రింట్ చేయండి
ఖరీదు << 'ఉద్యోగి వివరాలు:' <<endl;
ఖరీదు << 'ఉద్యోగ గుర్తింపు : ' <<empObj_R.emp_id <<endl;
తిరిగి 0;
}
ముగింపు
ఫైల్‌లు ప్రధానంగా డేటాను నిల్వ చేయడానికి ఉపయోగించబడతాయి మరియు వాస్తవ ప్రపంచ ప్రోగ్రామింగ్‌లో అవి ముఖ్యమైన పాత్ర పోషిస్తాయి. ఈ ఆర్టికల్లో, అనేక ఉదాహరణల ద్వారా పని చేయడం ద్వారా C ++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌తో వివిధ ఫైల్ ఆపరేషన్‌లను ఎలా ఉపయోగించాలో మేము మీకు చూపించాము. ఇంకా, టెక్స్ట్ ఫైల్స్ మరియు బైనరీ ఫైల్స్ రెండింటిలో డేటాను ఎలా చదవాలో మరియు వ్రాయాలో మేము మీకు చూపించాము.