C++లో బైనరీ ఫైల్‌ను వ్రాయండి

బైనరీ డేటాను వ్రాయడానికి బైనరీ ఫైల్‌లతో, ముఖ్యంగా “ఆఫ్‌స్ట్రీమ్” క్లాస్‌తో పరస్పర చర్య చేయడానికి C++ లైబ్రరీని అందిస్తుంది. ఈ సామర్ధ్యం డెవలపర్‌లను బైనరీ ఫైల్‌లను సజావుగా సృష్టించడానికి, సవరించడానికి మరియు నిర్వహించడానికి అనుమతిస్తుంది. ఈ కథనం C++లో బైనరీ ఫైళ్లను వ్రాయడానికి వివిధ పద్ధతులు మరియు సాంకేతికతలను అన్వేషిస్తుంది, వాటి అప్లికేషన్లు మరియు వినియోగ కేసులపై వెలుగునిస్తుంది.

C++ ఉపయోగించి బైనరీ ఫైల్‌ను వ్రాయండి

C++ ఉపయోగించి డేటాను బైనరీ ఫైల్‌లో సేవ్ చేయడానికి, రైట్() పద్ధతి ఉపయోగించబడుతుంది. ఈ ఫంక్షన్ 'పుట్' పాయింటర్ యొక్క స్థానం నుండి ప్రారంభించి, నిర్దేశించిన స్ట్రీమ్‌కు పేర్కొన్న సంఖ్యలో బైట్‌లను వ్రాస్తుంది. 'పుట్' పాయింటర్ చివరిలో ఉంటే, ఫైల్ పొడిగించబడుతుంది. అయితే, పాయింటర్ ఫైల్‌లో ఉంటే కొత్త డేటా ఇప్పటికే ఉన్న అక్షరాలను ఓవర్‌రైట్ చేస్తుంది. వ్రాత ప్రక్రియలో లోపం సంభవించినప్పుడు, స్ట్రీమ్ లోపం స్థితిలో ఉన్నట్లు గుర్తించబడుతుంది. ఇప్పుడు, కొన్ని సాధారణ మరియు అంతర్నిర్మిత C++ ఫంక్షన్‌లను ఉపయోగించి బైనరీ ఫైల్‌లో ఎలా వ్రాయాలో తెలుసుకోవడానికి ఉదాహరణలకు వెళ్దాం.

విధానం 1: స్ట్రక్చర్డ్ డేటాతో బైనరీ ఫైల్స్ రాయడం

మీరు అనేక సందర్భాల్లో బైనరీ ఫైల్‌కి అనుకూల నిర్మాణాల వంటి నిర్మాణాత్మక డేటాను వ్రాయవలసి రావచ్చు. ఒక వ్యక్తి పేరు, ఎత్తు మరియు వయస్సుతో కూడిన వ్యక్తి యొక్క రికార్డును కలిగి ఉన్న ఉదాహరణను పరిశీలిద్దాం. క్రింద ఇవ్వబడిన కోడ్‌ని చూడండి మరియు వివరణను చూడండి:

నిర్దిష్ట వివరాలతో కోడ్ యొక్క విచ్ఛిన్నం ఇక్కడ ఉంది. ప్రోగ్రామ్ 'వ్యక్తి' అనే కస్టమ్ నిర్మాణాన్ని నిర్వచించడంతో ప్రారంభమవుతుంది. దీనికి మూడు ఫీల్డ్‌లు ఉన్నాయి: పేరు, వయస్సు మరియు ఎత్తు. ఈ ఫీల్డ్‌ల వివరాలు క్రింది విధంగా ఉన్నాయి:

• పేరు: వ్యక్తి పేరు (50 అక్షరాల వరకు) నిల్వ చేయడానికి ఒక స్ట్రింగ్
• వయస్సు: వ్యక్తి వయస్సును నిల్వ చేయడానికి ఒక పూర్ణాంకం
• ఎత్తు: వ్యక్తి యొక్క ఎత్తును నిల్వ చేయడానికి డబుల్

'వ్యక్తి' నిర్మాణాన్ని నిర్వచించిన తర్వాత, ప్రోగ్రామ్ యొక్క ఎంట్రీ పాయింట్ అయిన ప్రధాన ఫంక్షన్ ప్రారంభమవుతుంది. ప్రధాన ప్రోగ్రామ్‌లోని మొదటి పంక్తి 'people.bin' అనే ఫైల్‌ను తెరుస్తుంది. బైనరీ ఫార్మాట్‌లో డేటాను వ్రాయడం కోసం “people.bin” పేరుతో ఫైల్‌ని సృష్టించడానికి మేము “std::ofstream”ని ఉపయోగిస్తాము. ఫైల్ విజయవంతంగా తెరవబడిందో లేదో తనిఖీ చేయడం చాలా ముఖ్యం. లేకపోతే, ఒక దోష సందేశం చూపబడుతుంది మరియు ప్రోగ్రామ్ ఆగిపోతుంది. అందువల్ల, “if” కండిషన్ మరియు is_open() ఫంక్షన్ సహాయంతో, ఫైల్ విజయవంతంగా తెరవబడిందో లేదో తనిఖీ చేస్తాము.

ఇక్కడ, రెండు 'వ్యక్తి' వస్తువులు సృష్టించబడతాయి. మేము 'వ్యక్తి' రకానికి చెందిన 'person1' మరియు 'person2' అనే రెండు వేరియబుల్స్‌ని నిర్వచించాము. మేము 'కల్సూమ్ ఇలియాస్' మరియు 'కల్సూమ్ బజ్వా' కోసం వేరియబుల్ పేరు, వయస్సు మరియు ఎత్తు విలువలను కేటాయిస్తాము.

ఇప్పుడు బైనరీ ఫైల్‌లో వ్రాయడానికి మనకు డేటా ఉంది, రైట్() ఫంక్షన్‌తో అసలు ఫంక్షన్‌ని చేద్దాం. ప్రతి 'వ్యక్తి' వస్తువు యొక్క కంటెంట్‌లను ఫైల్‌కి వ్రాయడానికి మేము 'outFile.write'ని ఉపయోగిస్తాము. “reinterpret_cast(&person1)” మరియు “reinterpret_cast(&person2)” మొత్తం “వ్యక్తి” నిర్మాణాన్ని (అన్ని ఫీల్డ్‌లతో సహా) బైనరీ ఫైల్‌కు వ్రాయడానికి అనువైన బైట్‌ల నిరంతర స్ట్రీమ్‌గా మారుస్తుంది. . మేము ప్రతి 'వ్యక్తి' ఆబ్జెక్ట్ యొక్క పరిమాణాన్ని 'sizeof(person1)' మరియు 'sizeof(person2)' ఉపయోగించి మొత్తం డేటా సరిగ్గా వ్రాయబడిందని నిర్ధారించుకుంటాము.

ఫైల్‌పై డేటాను వ్రాసిన తర్వాత, దాన్ని సరిగ్గా మూసివేయడం చాలా ముఖ్యం, తద్వారా ఏదైనా ఇతర ఫంక్షన్ కారణంగా డేటా కోల్పోదు. ఫైల్‌తో అనుబంధించబడిన వనరులను విడుదల చేయడానికి మరియు డేటా ఖచ్చితంగా వ్రాయబడిందని నిర్ధారించుకోవడానికి మేము outFile.close()ని ఉపయోగిస్తాము. చివరగా, బైనరీ ఫైల్‌కు డేటా విజయవంతంగా రాయడాన్ని నిర్ధారించే సందేశాన్ని మేము ప్రింట్ చేస్తాము.

మేము ఈ ఉదాహరణను సరళమైన పరంగా వివరిస్తే, రహస్య భాషలో వ్యక్తుల గురించి సమాచారాన్ని మాత్రమే నిల్వ చేయగల ప్రత్యేక నోట్‌బుక్‌ను ఊహించుకోండి. ఈ కోడ్ సమాచారాన్ని (పేరు, వయస్సు, ఎత్తు) నిర్వహించడానికి బ్లూప్రింట్‌ను సృష్టిస్తుంది. ఇది నోట్‌బుక్‌ను తెరుస్తుంది, ఇద్దరు వ్యక్తుల ప్రొఫైల్‌లను నింపుతుంది, సమాచారాన్ని రహస్య భాషలోకి అనువదిస్తుంది మరియు లోపల చక్కగా రాస్తుంది. ఇది భవిష్యత్తులో ఉపయోగం కోసం ప్రొఫైల్‌లను భద్రపరిచి, నోట్‌బుక్‌ను సురక్షితంగా మూసివేస్తుంది. కింది స్నాప్‌షాట్‌లో ఇవ్వబడిన ప్రోగ్రామ్ అవుట్‌పుట్‌ను చూడండి:

విధానం 2: బైనరీ ఫైల్‌కు పూర్ణాంకాలను వ్రాయడం

ఈ పద్ధతిలో, పూర్ణాంకాల శ్రేణి “integers.bin” అనే బైనరీ ఫైల్‌కు వ్రాయబడుతుంది. “reinterpret_cast” ఫైల్‌లో వ్రాయడానికి పూర్ణాంక శ్రేణిని అక్షరాల (బైట్‌లు) క్రమం వలె పరిగణిస్తుంది. బైనరీ ఫైల్‌లు ముడి బైట్ డేటాతో వ్యవహరిస్తాయి కాబట్టి ఇది చాలా ముఖ్యమైనది. కింది సాధారణ ఉదాహరణను చూద్దాం:

నిర్దిష్ట వివరాలతో కోడ్ యొక్క విచ్ఛిన్నం ఇక్కడ ఉంది:

“#include ” మరియు “#include ” ఫైల్‌లతో పని చేయడానికి మరియు సిన్ మరియు రైట్() వంటి సందేశాలను ప్రింట్ చేయడానికి అవసరమైన సాధనాలను తీసుకువస్తాయి. “std::ofstream outFile(“integers.bin”, std::ios::binary);” 'integers.bin' పేరుతో ఒక బైనరీ ఫైల్‌ను తెరుస్తుంది, అది ఒక రహస్య కోడ్ (బైనరీ ఫార్మాట్)లో మాత్రమే సంఖ్యలను నిల్వ చేయగలదు. ఫైల్ తెరిచి ఉందో లేదో తనిఖీ చేస్తుంది. లేదంటే ఎర్రర్ మెసేజ్ వస్తుంది.

తదుపరి పంక్తి “పూర్ణాంక సంఖ్యలు[] = {42, 99, -1, 0};” పూర్ణాంకాల 42, 99, -1 మరియు 0తో “సంఖ్యలు” అనే పేరుగల శ్రేణిని నిర్వచిస్తుంది. “outFile.write(reinterpret_cast(సంఖ్యలు), sizeof(సంఖ్యలు));” పూర్ణాంకాలను బైనరీ ఫార్మాట్‌లోకి జాగ్రత్తగా అనువదిస్తుంది మరియు వాటిని “integer.bin” ఫైల్‌లో వ్రాస్తుంది. “outFile.close();” పూర్ణాంకాలను సురక్షితంగా మరియు క్రమబద్ధంగా ఉంచడానికి ఫైల్‌ను సరిగ్గా మూసివేస్తుంది. చివరగా, బైనరీ ఫైల్‌లో పూర్ణాంకాలు విజయవంతంగా నిల్వ చేయబడిందని నిర్ధారించడానికి ఒక సందేశం ముద్రించబడుతుంది. ఫలితాన్ని చూడటానికి ఈ ప్రోగ్రామ్ యొక్క క్రింది అవుట్‌పుట్‌ని చూడండి:

ముగింపు

వివిధ రకాల డేటాను సమర్ధవంతంగా నిర్వహించడానికి C++లో బైనరీ ఫైళ్లను రాయడం అనేది ఒక కీలకమైన నైపుణ్యం. C++లో బైనరీ ఫైల్‌లను వ్రాయడం యొక్క ఈ అన్వేషణలో, బైనరీ డేటాను సమర్ధవంతంగా నిర్వహించడానికి 'ఆఫ్‌స్ట్రీమ్' తరగతిని ఎలా ఉపయోగించవచ్చో మేము తెలుసుకున్నాము. కస్టమ్ స్ట్రక్చర్‌లను ఉపయోగించి సాధారణ పూర్ణాంకాలతో లేదా నిర్మాణాత్మక డేటాతో వ్యవహరించినా, ప్రక్రియలో ఫైల్ స్ట్రీమ్‌ను తెరవడం, బైనరీ ఫార్మాట్‌లో డేటాను రాయడం, ఆపై ఫైల్‌ను మూసివేయడం వంటివి ఉంటాయి. ఈ సామర్ధ్యం C++ డెవలపర్‌లకు విభిన్న శ్రేణి బైనరీ డేటా రకాలతో పని చేసే సౌలభ్యాన్ని అందిస్తుంది, సిస్టమ్-స్థాయి ప్రోగ్రామింగ్ నుండి మల్టీమీడియా ప్రాసెసింగ్ వరకు ఉండే అప్లికేషన్‌లలో భాష యొక్క బహుముఖ ప్రజ్ఞకు దోహదం చేస్తుంది.