"use strict"; const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0]; const {useMDXComponents: _provideComponents} = arguments[0]; function _createMdxContent(props) { const _components = { code: "code", em: "em", h3: "h3", h4: "h4", li: "li", ol: "ol", p: "p", strong: "strong", table: "table", tbody: "tbody", td: "td", th: "th", thead: "thead", tr: "tr", ul: "ul", ..._provideComponents(), ...props.components }, {CodeBlock, ComparisonTable, DefinitionEntry, DefinitionGroup, English, Explanation, Hinglish, ImportantQA, Intuition, KeyPoints, LabConnection, MCQ, Note, Remember, SubTopicHeader, Tip, TopicOverview, Warning} = _components; if (!CodeBlock) _missingMdxReference("CodeBlock", true); if (!ComparisonTable) _missingMdxReference("ComparisonTable", true); if (!DefinitionEntry) _missingMdxReference("DefinitionEntry", true); if (!DefinitionGroup) _missingMdxReference("DefinitionGroup", true); if (!English) _missingMdxReference("English", true); if (!Explanation) _missingMdxReference("Explanation", true); if (!Hinglish) _missingMdxReference("Hinglish", true); if (!ImportantQA) _missingMdxReference("ImportantQA", true); if (!Intuition) _missingMdxReference("Intuition", true); if (!KeyPoints) _missingMdxReference("KeyPoints", true); if (!LabConnection) _missingMdxReference("LabConnection", true); if (!MCQ) _missingMdxReference("MCQ", true); if (!Note) _missingMdxReference("Note", true); if (!Remember) _missingMdxReference("Remember", true); if (!SubTopicHeader) _missingMdxReference("SubTopicHeader", true); if (!Tip) _missingMdxReference("Tip", true); if (!TopicOverview) _missingMdxReference("TopicOverview", true); if (!Warning) _missingMdxReference("Warning", true); return _jsxs(_Fragment, { children: [_jsx(SubTopicHeader, { id: "5.3", title: "Opening files: Using constructors and open(), Closing files, Reading from and writing to files, Formatted Input/output functions in file" }), "\n", _jsxs(TopicOverview, { title: "File Operations: Opening, Closing, Reading, Writing & Formatted I/O", topicId: "5.3", readingTime: "8 min read", difficulty: "Medium", children: [_jsxs(English, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "File operations in C++" }), " are performed using stream classes that provide a consistent interface for reading from and writing to files. The C++ standard library offers three primary file stream classes — ", _jsx(_components.code, { children: "ifstream" }), " (input), ", _jsx(_components.code, { children: "ofstream" }), " (output), and ", _jsx(_components.code, { children: "fstream" }), " (both) — which can be associated with physical files either through their constructors or via the ", _jsx(_components.code, { children: "open()" }), " member function. 📂"] }), _jsxs(_components.p, { children: ["In this subtopic, we will systematically explore how to open files using both constructors and ", _jsx(_components.code, { children: "open()" }), ", the various file mode flags that control access behavior, proper closing of files, reading and writing data using stream operators and formatted I/O functions, and managing file position pointers for random access."] }), _jsxs(Intuition, { title: "The Office Filing Cabinet", children: [_jsxs(_components.p, { children: ["💡 ", _jsx(_components.strong, { children: "Intuition:" }), " Imagine a well-organized office filing cabinet 🗄️:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Constructor / open():" }), " Unlocking and pulling out a specific drawer (file) with a label indicating ", _jsx(_components.em, { children: "read-only" }), ", ", _jsx(_components.em, { children: "write-only" }), ", or ", _jsx(_components.em, { children: "read-write" }), " access."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "File modes:" }), " Instructions on the drawer — \"Append only\", \"Binary data\", \"Create if missing\"."] }), "\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: ["Stream operators (", "<", "<", ", >>):"] }), " Standard forms you fill out or read from."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Formatted I/O functions (get, put, read, write):" }), " Specialized tools for handling raw data, lines, or binary blocks precisely."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "close():" }), " Locking the drawer and returning it to the cabinet when done."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "seekg/seekp:" }), " Moving a bookmark to a specific page inside the file."] }), "\n"] })] }), _jsx(_components.h3, { children: "📌 Key Learning Focus" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Opening files:" }), " Using constructors vs. ", _jsx(_components.code, { children: "open()" }), " function with mode flags (", _jsx(_components.code, { children: "ios::in" }), ", ", _jsx(_components.code, { children: "ios::out" }), ", ", _jsx(_components.code, { children: "ios::app" }), ", ", _jsx(_components.code, { children: "ios::binary" }), ", ", _jsx(_components.code, { children: "ios::ate" }), ", ", _jsx(_components.code, { children: "ios::trunc" }), ")."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Closing files:" }), " Explicit ", _jsx(_components.code, { children: "close()" }), " vs. automatic destructor cleanup."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Reading & Writing:" }), " Stream insertion (", _jsx(_components.code, { children: "<<" }), ") and extraction (", _jsx(_components.code, { children: ">>" }), ") operators for formatted text."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Formatted I/O functions:" }), " ", _jsx(_components.code, { children: "get()" }), ", ", _jsx(_components.code, { children: "put()" }), ", ", _jsx(_components.code, { children: "getline()" }), ", ", _jsx(_components.code, { children: "write()" }), ", ", _jsx(_components.code, { children: "read()" }), ", ", _jsx(_components.code, { children: "ignore()" }), ", ", _jsx(_components.code, { children: "peek()" }), "."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "File position pointers:" }), " ", _jsx(_components.code, { children: "seekg()" }), ", ", _jsx(_components.code, { children: "seekp()" }), ", ", _jsx(_components.code, { children: "tellg()" }), ", ", _jsx(_components.code, { children: "tellp()" }), " for random access navigation."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "C++ mein file operations" }), " stream classes ke madhyam se perform ki jati hain jo files se read/write karne ke liye ek consistent interface provide karti hain. C++ standard library teen primary file stream classes offer karti hai — ", _jsx(_components.code, { children: "ifstream" }), " (input), ", _jsx(_components.code, { children: "ofstream" }), " (output), aur ", _jsx(_components.code, { children: "fstream" }), " (donon) — jinhe physical files ke saath ya to constructors ke through ya ", _jsx(_components.code, { children: "open()" }), " member function ke through associate kiya ja sakta hai. 📂"] }), _jsxs(_components.p, { children: ["Is subtopic mein hum systematically samjhenge ki files ko constructors aur ", _jsx(_components.code, { children: "open()" }), " dono se kaise open karte hain, various file mode flags jo access behavior control karte hain, files ko properly kaise close karte hain, stream operators aur formatted I/O functions ka upyog karke data read/write kaise karte hain, aur file position pointers ko random access ke liye kaise manage karte hain."] }), _jsxs(Intuition, { title: "The Office Filing Cabinet", children: [_jsxs(_components.p, { children: ["💡 ", _jsx(_components.strong, { children: "Intuition:" }), " Ek achhe se organized office filing cabinet 🗄️ ki kalpana kijiye:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Constructor / open():" }), " Ek specific drawer (file) ko unlock karke nikalna jisme label ho ", _jsx(_components.em, { children: "read-only" }), ", ", _jsx(_components.em, { children: "write-only" }), ", ya ", _jsx(_components.em, { children: "read-write" }), " access ka."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "File modes:" }), " Drawer par likhe instructions — \"Sirf append karo\", \"Binary data\", \"Agar missing ho to create karo\"."] }), "\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: ["Stream operators (", "<", "<", ", >>):"] }), " Standard forms jo aap bharte hain ya padhte hain."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Formatted I/O functions (get, put, read, write):" }), " Specialized tools jo raw data, lines, ya binary blocks ko precisely handle karte hain."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "close():" }), " Drawer ko lock karke cabinet mein wapas rakhna jab kaam complete ho jaye."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "seekg/seekp:" }), " File ke andar ek specific page par bookmark move karna."] }), "\n"] })] }), _jsx(_components.h3, { children: "📌 Key Learning Focus" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Files open karna:" }), " Constructors vs ", _jsx(_components.code, { children: "open()" }), " function mode flags (", _jsx(_components.code, { children: "ios::in" }), ", ", _jsx(_components.code, { children: "ios::out" }), ", ", _jsx(_components.code, { children: "ios::app" }), ", ", _jsx(_components.code, { children: "ios::binary" }), ", ", _jsx(_components.code, { children: "ios::ate" }), ", ", _jsx(_components.code, { children: "ios::trunc" }), ") ke saath."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Files close karna:" }), " Explicit ", _jsx(_components.code, { children: "close()" }), " vs automatic destructor cleanup."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Reading & Writing:" }), " Formatted text ke liye stream insertion (", _jsx(_components.code, { children: "<<" }), ") aur extraction (", _jsx(_components.code, { children: ">>" }), ") operators."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Formatted I/O functions:" }), " ", _jsx(_components.code, { children: "get()" }), ", ", _jsx(_components.code, { children: "put()" }), ", ", _jsx(_components.code, { children: "getline()" }), ", ", _jsx(_components.code, { children: "write()" }), ", ", _jsx(_components.code, { children: "read()" }), ", ", _jsx(_components.code, { children: "ignore()" }), ", ", _jsx(_components.code, { children: "peek()" }), "."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "File position pointers:" }), " ", _jsx(_components.code, { children: "seekg()" }), ", ", _jsx(_components.code, { children: "seekp()" }), ", ", _jsx(_components.code, { children: "tellg()" }), ", ", _jsx(_components.code, { children: "tellp()" }), " random access navigation ke liye."] }), "\n"] })] })] }), "\n", _jsxs(DefinitionGroup, { children: [_jsxs(DefinitionEntry, { term: "File Stream Classes", children: [_jsxs(English, { children: [_jsxs(_components.p, { children: ["📂 ", _jsx(_components.strong, { children: "File Stream Classes" }), " are C++ standard library classes (", _jsx(_components.code, { children: "ifstream" }), ", ", _jsx(_components.code, { children: "ofstream" }), ", ", _jsx(_components.code, { children: "fstream" }), ") derived from ", _jsx(_components.code, { children: "istream" }), ", ", _jsx(_components.code, { children: "ostream" }), ", and ", _jsx(_components.code, { children: "iostream" }), " respectively, designed specifically for file I/O operations."] }), _jsx(Intuition, { title: "Specialized Pipe Types", children: _jsxs(_components.p, { children: ["Think of them as ", _jsx(_components.strong, { children: "specialized pipes" }), " 🚰: ", _jsx(_components.code, { children: "ifstream" }), " is a pipe that only sucks data ", _jsx(_components.em, { children: "in" }), " from a file, ", _jsx(_components.code, { children: "ofstream" }), " only pushes data ", _jsx(_components.em, { children: "out" }), " to a file, and ", _jsx(_components.code, { children: "fstream" }), " is a two-way pipe that can do both."] }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: ["📂 ", _jsx(_components.strong, { children: "File Stream Classes" }), " C++ standard library classes (", _jsx(_components.code, { children: "ifstream" }), ", ", _jsx(_components.code, { children: "ofstream" }), ", ", _jsx(_components.code, { children: "fstream" }), ") hain jo ", _jsx(_components.code, { children: "istream" }), ", ", _jsx(_components.code, { children: "ostream" }), ", aur ", _jsx(_components.code, { children: "iostream" }), " se derive hoti hain, specifically file I/O operations ke liye design ki gayi hain."] }), _jsx(Intuition, { title: "Specialized Pipe Types", children: _jsxs(_components.p, { children: ["Inhe ", _jsx(_components.strong, { children: "specialized pipes" }), " 🚰 ki tarah samajhiye: ", _jsx(_components.code, { children: "ifstream" }), " ek aisa pipe hai jo sirf file se data ", _jsx(_components.em, { children: "andar" }), " khinchta hai, ", _jsx(_components.code, { children: "ofstream" }), " sirf file mein data ", _jsx(_components.em, { children: "bahar" }), " push karta hai, aur ", _jsx(_components.code, { children: "fstream" }), " ek two-way pipe hai jo donon kaam kar sakta hai."] }) })] })] }), _jsxs(DefinitionEntry, { term: "File Mode Flags", children: [_jsxs(English, { children: [_jsxs(_components.p, { children: ["⚙️ ", _jsx(_components.strong, { children: "File Mode Flags" }), " are bitmask constants (defined in ", _jsx(_components.code, { children: "ios" }), " namespace) that specify how a file should be opened — e.g., ", _jsx(_components.code, { children: "ios::in" }), " (read), ", _jsx(_components.code, { children: "ios::out" }), " (write), ", _jsx(_components.code, { children: "ios::app" }), " (append), ", _jsx(_components.code, { children: "ios::binary" }), " (binary mode), ", _jsx(_components.code, { children: "ios::ate" }), " (seek to end), ", _jsx(_components.code, { children: "ios::trunc" }), " (truncate existing)."] }), _jsx(Intuition, { title: "Instruction Labels on a Drawer", children: _jsxs(_components.p, { children: ["Imagine ", _jsx(_components.strong, { children: "instruction labels" }), " 🏷️ stuck on a file drawer: \"Read Only\", \"Write Only\", \"Add at End\", \"Binary Data\", \"Start at End\", \"Empty First\". You can combine multiple labels (bitwise OR) to get the exact behavior you need."] }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: ["⚙️ ", _jsx(_components.strong, { children: "File Mode Flags" }), " bitmask constants hain (jo ", _jsx(_components.code, { children: "ios" }), " namespace mein defined hain) jo specify karte hain ki file kaise open honi chahiye — jaise ", _jsx(_components.code, { children: "ios::in" }), " (read), ", _jsx(_components.code, { children: "ios::out" }), " (write), ", _jsx(_components.code, { children: "ios::app" }), " (append), ", _jsx(_components.code, { children: "ios::binary" }), " (binary mode), ", _jsx(_components.code, { children: "ios::ate" }), " (end par seek karo), ", _jsx(_components.code, { children: "ios::trunc" }), " (existing ko truncate karo)."] }), _jsx(Intuition, { title: "Instruction Labels on a Drawer", children: _jsxs(_components.p, { children: ["Ek file drawer par chipke ", _jsx(_components.strong, { children: "instruction labels" }), " 🏷️ ki kalpana kijiye: \"Sirf Padho\", \"Sirf Likho\", \"End pe Jodo\", \"Binary Data\", \"End se Shuru Karo\", \"Pehle Khaali Karo\". Aap multiple labels combine kar sakte hain (bitwise OR) taaki exact behavior mile jo aapko chahiye."] }) })] })] }), _jsxs(DefinitionEntry, { term: "Formatted I/O Functions", children: [_jsxs(English, { children: [_jsxs(_components.p, { children: ["🔧 ", _jsx(_components.strong, { children: "Formatted I/O Functions" }), " are member functions of stream classes that provide fine-grained control over reading and writing — e.g., ", _jsx(_components.code, { children: "get()" }), "/", _jsx(_components.code, { children: "put()" }), " for single characters, ", _jsx(_components.code, { children: "getline()" }), " for lines, ", _jsx(_components.code, { children: "read()" }), "/", _jsx(_components.code, { children: "write()" }), " for binary blocks, ", _jsx(_components.code, { children: "ignore()" }), " to skip characters, ", _jsx(_components.code, { children: "peek()" }), " to look ahead without extracting."] }), _jsx(Intuition, { title: "Precision Tools vs. Standard Forms", children: _jsxs(_components.p, { children: ["If ", _jsx(_components.code, { children: "<<" }), " and ", _jsx(_components.code, { children: ">>" }), " are ", _jsx(_components.strong, { children: "standard forms" }), ", these functions are ", _jsx(_components.strong, { children: "precision tools" }), " 🛠️ — like tweezers for single characters, a line-copier for whole lines, or a block-mover for raw binary chunks."] }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: ["🔧 ", _jsx(_components.strong, { children: "Formatted I/O Functions" }), " stream classes ke member functions hain jo reading aur writing par fine-grained control provide karte hain — jaise ", _jsx(_components.code, { children: "get()" }), "/", _jsx(_components.code, { children: "put()" }), " single characters ke liye, ", _jsx(_components.code, { children: "getline()" }), " lines ke liye, ", _jsx(_components.code, { children: "read()" }), "/", _jsx(_components.code, { children: "write()" }), " binary blocks ke liye, ", _jsx(_components.code, { children: "ignore()" }), " characters skip karne ke liye, ", _jsx(_components.code, { children: "peek()" }), " bina extract kiye aage dekhne ke liye."] }), _jsx(Intuition, { title: "Precision Tools vs. Standard Forms", children: _jsxs(_components.p, { children: ["Agar ", _jsx(_components.code, { children: "<<" }), " aur ", _jsx(_components.code, { children: ">>" }), " ", _jsx(_components.strong, { children: "standard forms" }), " hain, to yeh functions ", _jsx(_components.strong, { children: "precision tools" }), " 🛠️ hain — jaise single characters ke liye chimti (tweezers), poori line copy karne ke liye line-copier, ya raw binary chunks ke liye block-mover."] }) })] })] }), _jsxs(DefinitionEntry, { term: "File Position Pointers", children: [_jsxs(English, { children: [_jsxs(_components.p, { children: ["📍 ", _jsx(_components.strong, { children: "File Position Pointers" }), " are internal markers maintained by each file stream — ", _jsx(_components.strong, { children: "get pointer" }), " (for reading, manipulated by ", _jsx(_components.code, { children: "seekg" }), "/", _jsx(_components.code, { children: "tellg" }), ") and ", _jsx(_components.strong, { children: "put pointer" }), " (for writing, manipulated by ", _jsx(_components.code, { children: "seekp" }), "/", _jsx(_components.code, { children: "tellp" }), ") — that track the current byte position for the next I/O operation."] }), _jsx(Intuition, { title: "Dual Bookmarks in a Book", children: _jsxs(_components.p, { children: ["Picture a book with ", _jsx(_components.strong, { children: "two separate bookmarks" }), " 🔖: a red one (get pointer) marking where you'll read next, and a blue one (put pointer) marking where you'll write next. ", _jsx(_components.code, { children: "tellg" }), "/", _jsx(_components.code, { children: "tellp" }), " tell you the current page number; ", _jsx(_components.code, { children: "seekg" }), "/", _jsx(_components.code, { children: "seekp" }), " move the bookmarks to a specific page."] }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: ["📍 ", _jsx(_components.strong, { children: "File Position Pointers" }), " har file stream ke internal markers hain — ", _jsx(_components.strong, { children: "get pointer" }), " (reading ke liye, ", _jsx(_components.code, { children: "seekg" }), "/", _jsx(_components.code, { children: "tellg" }), " se manipulate hota hai) aur ", _jsx(_components.strong, { children: "put pointer" }), " (writing ke liye, ", _jsx(_components.code, { children: "seekp" }), "/", _jsx(_components.code, { children: "tellp" }), " se manipulate hota hai) — jo next I/O operation ke liye current byte position track karte hain."] }), _jsx(Intuition, { title: "Dual Bookmarks in a Book", children: _jsxs(_components.p, { children: ["Ek kitab mein ", _jsx(_components.strong, { children: "do alag bookmarks" }), " 🔖 ki kalpana kijiye: ek laal (get pointer) jo bataata hai agla read kahan se hoga, ek neela (put pointer) jo bataata hai agla write kahan hoga. ", _jsx(_components.code, { children: "tellg" }), "/", _jsx(_components.code, { children: "tellp" }), " current page number batate hain; ", _jsx(_components.code, { children: "seekg" }), "/", _jsx(_components.code, { children: "seekp" }), " bookmarks ko specific page par move karte hain."] }) })] })] })] }), "\n", _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsxs(_components.h3, { children: ["Opening Files: Constructors vs. ", _jsx(_components.code, { children: "open()" })] }), _jsx(_components.p, { children: "C++ provides two equivalent ways to associate a file stream object with a physical file on disk. Both approaches accept the same filename and mode flags." }), _jsx(Intuition, { title: "Two Ways to Unlock a Drawer", children: _jsxs(_components.p, { children: ["💡 ", _jsx(_components.strong, { children: "Intuition:" }), " Whether you ", _jsx(_components.strong, { children: "bring the key when the drawer is made" }), " (constructor) or ", _jsx(_components.strong, { children: "fetch the key later and insert it" }), " (", _jsx(_components.code, { children: "open()" }), "), the result is the same — the drawer is unlocked and ready for use."] }) }), _jsx(_components.h4, { children: "1. Using Constructors" }), _jsx(_components.p, { children: "The file is opened at the moment the stream object is created. This is concise and ensures the stream is ready immediately." }), _jsx(CodeBlock, { language: "cpp", children: `#include #include using namespace std; int main() { // Open for writing (truncates existing, creates new) ofstream outfile("data.txt", ios::out | ios::trunc); if (!outfile) { cerr << "Error opening file for writing!" << endl; return 1; } outfile << "Hello, File!" << endl; outfile.close(); // Open for reading ifstream infile("data.txt", ios::in); if (!infile) { cerr << "Error opening file for reading!" << endl; return 1; } string line; while (getline(infile, line)) { cout << line << endl; } infile.close(); return 0; }` }), _jsxs(_components.h4, { children: ["2. Using ", _jsx(_components.code, { children: "open()" }), " Member Function"] }), _jsxs(_components.p, { children: ["The stream object is created first (unassociated), and ", _jsx(_components.code, { children: "open()" }), " is called later. This is useful when the filename is determined at runtime or when reusing the same stream object for multiple files sequentially."] }), _jsx(CodeBlock, { language: "cpp", children: `#include #include #include using namespace std; int main() { ofstream outfile; string filename = "runtime_data.txt"; // Open later when filename is known outfile.open(filename, ios::out | ios::app); // Append mode if (outfile.is_open()) { outfile << "Appended line." << endl; outfile.close(); } // Reuse same object for another file outfile.open("another.txt", ios::out); if (outfile) { outfile << "Fresh file." << endl; outfile.close(); } return 0; }` }), _jsx(KeyPoints, { children: _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Both methods accept identical mode flags (bitwise OR combinable)." }), "\n", _jsx(_components.li, { children: "Constructor approach: RAII-friendly, file opens immediately." }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "open()" }), " approach: Flexible for runtime filenames, reusable stream objects."] }), "\n", _jsxs(_components.li, { children: ["Always check stream state (", _jsx(_components.code, { children: "if (!stream)" }), " or ", _jsx(_components.code, { children: "stream.is_open()" }), ") after opening."] }), "\n"] }) }), _jsx(_components.h3, { children: "File Mode Flags — Detailed Reference" }), _jsx(ComparisonTable, { title: "Common File Mode Flags (ios namespace)", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "left" }, children: "Flag" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Purpose" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Typical Use Case" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::in" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Open for reading" }), _jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "ifstream" }), ", ", _jsx(_components.code, { children: "fstream" })] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::out" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Open for writing" }), _jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "ofstream" }), ", ", _jsx(_components.code, { children: "fstream" })] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::app" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Append — all writes go to end" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Log files, preserving existing content" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::ate" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Open and seek to end initially" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Read-modify-write at end" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::trunc" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Truncate existing file to zero length" }), _jsxs(_components.td, { style: { textAlign: "left" }, children: ["Fresh write (default for ", _jsx(_components.code, { children: "ofstream" }), ")"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::binary" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Binary mode (no newline translation)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Images, executables, structs" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::nocreate" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Fail if file doesn't exist (legacy)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Strict read-only existing files" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::noreplace" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Fail if file already exists (legacy)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Prevent accidental overwrite" })] })] })] }) }), _jsx(Remember, { children: _jsxs(_components.p, { children: ["💡 ", _jsx(_components.strong, { children: "Important:" }), " ", _jsx(_components.code, { children: "ios::app" }), " implies ", _jsx(_components.code, { children: "ios::out" }), ". ", _jsx(_components.code, { children: "ios::trunc" }), " is default for ", _jsx(_components.code, { children: "ofstream" }), ". For ", _jsx(_components.code, { children: "fstream" }), ", you ", _jsx(_components.strong, { children: "must" }), " specify at least one of ", _jsx(_components.code, { children: "ios::in" }), " or ", _jsx(_components.code, { children: "ios::out" }), ". Binary mode (", _jsx(_components.code, { children: "ios::binary" }), ") is critical for non-text data to prevent ", _jsx(_components.code, { children: "\\n" }), " ↔ ", _jsx(_components.code, { children: "\\r\\n" }), " translation on Windows."] }) }), _jsx(_components.h3, { children: "Closing Files" }), _jsxs(_components.p, { children: ["The ", _jsx(_components.code, { children: "close()" }), " member function severs the association between the stream object and the physical file, flushing any buffered data to disk. It is good practice to call ", _jsx(_components.code, { children: "close()" }), " explicitly, though the destructor automatically calls it when the stream object goes out of scope."] }), _jsx(CodeBlock, { language: "cpp", children: `ofstream log("app.log", ios::app); log << "Event occurred" << endl; log.close(); // Explicit close — ensures data flushed immediately // Destructor will also call close() automatically here // but explicit close gives you control over timing. ` }), _jsx(Tip, { children: _jsxs(_components.p, { children: ["✅ ", _jsx(_components.strong, { children: "Best Practice:" }), " Call ", _jsx(_components.code, { children: "close()" }), " explicitly when you are done writing to a file, especially if you intend to open the same file again immediately afterward (e.g., write then read). This guarantees buffers are flushed and the file handle is released."] }) }), _jsx(_components.h3, { children: "Reading from and Writing to Files — Stream Operators" }), _jsxs(_components.p, { children: ["The insertion (", _jsx(_components.code, { children: "<<" }), ") and extraction (", _jsx(_components.code, { children: ">>" }), ") operators work with file streams exactly as they do with ", _jsx(_components.code, { children: "cout" }), " and ", _jsx(_components.code, { children: "cin" }), ", providing ", _jsx(_components.strong, { children: "formatted text I/O" }), ". They skip whitespace (by default) for extraction and format according to stream manipulators."] }), _jsx(CodeBlock, { language: "cpp", children: `#include #include #include using namespace std; int main() { // Writing formatted data ofstream out("records.txt"); out << left << setw(15) << "Name" << setw(10) << "Age" << "City" << endl; out << left << setw(15) << "Alice" << setw(10) << 30 << "New York" << endl; out << left << setw(15) << "Bob" << setw(10) << 25 << "London" << endl; out.close(); // Reading formatted data ifstream in("records.txt"); string name, city; int age; // Skip header in >> name >> age >> city; while (in >> name >> age >> city) { cout << name << ", " << age << ", " << city << endl; } in.close(); return 0; }` }), _jsx(Note, { children: _jsxs(_components.p, { children: ["📝 ", _jsx(_components.strong, { children: "Note:" }), " ", _jsx(_components.code, { children: "operator>>" }), " skips leading whitespace (spaces, newlines, tabs) by default. Use ", _jsx(_components.code, { children: "noskipws" }), " manipulator or ", _jsx(_components.code, { children: "get()" }), "/", _jsx(_components.code, { children: "getline()" }), " if you need to read whitespace characters."] }) }), _jsx(_components.h3, { children: "Formatted Input/Output Functions" }), _jsxs(_components.p, { children: ["Beyond ", _jsx(_components.code, { children: "<<" }), " and ", _jsx(_components.code, { children: ">>" }), ", file streams provide member functions for ", _jsx(_components.strong, { children: "character-level" }), ", ", _jsx(_components.strong, { children: "line-level" }), ", and ", _jsx(_components.strong, { children: "block-level" }), " I/O with precise control."] }), _jsxs(_components.h4, { children: ["Character I/O: ", _jsx(_components.code, { children: "get()" }), " and ", _jsx(_components.code, { children: "put()" })] }), _jsx(CodeBlock, { language: "cpp", children: `// Reading character by character ifstream in("text.txt"); char ch; while (in.get(ch)) { // Returns stream, converts to false on EOF/error cout << ch; } // Writing character by character ofstream out("copy.txt"); out.put('H'); out.put('i'); out.put('!'); ` }), _jsxs(_components.h4, { children: ["Line I/O: ", _jsx(_components.code, { children: "getline()" })] }), _jsx(_components.p, { children: "Reads an entire line (up to newline) into a string buffer. The newline is extracted and discarded." }), _jsx(CodeBlock, { language: "cpp", children: `ifstream in("notes.txt"); string line; while (getline(in, line)) { // Global getline for std::string cout << "Line: " << line << endl; } // Member version with custom delimiter char buffer[256]; in.getline(buffer, 256, ';'); // Read up to ';' ` }), _jsxs(_components.h4, { children: ["Block I/O: ", _jsx(_components.code, { children: "write()" }), " and ", _jsx(_components.code, { children: "read()" }), " — Binary Data"] }), _jsxs(_components.p, { children: ["These functions perform ", _jsx(_components.strong, { children: "unformatted binary I/O" }), ", writing/reading raw bytes. Essential for saving/restoring structs, arrays, or binary files."] }), _jsx(CodeBlock, { language: "cpp", children: `struct Student { int roll; char name[20]; float marks; }; Student s = {101, "Alice", 92.5f}; // Write binary ofstream out("student.dat", ios::binary); out.write(reinterpret_cast(&s), sizeof(s)); out.close(); // Read binary ifstream in("student.dat", ios::binary); Student s2; in.read(reinterpret_cast(&s2), sizeof(s2)); in.close(); cout << s2.roll << " " << s2.name << " " << s2.marks << endl; ` }), _jsxs(Warning, { children: [_jsxs(_components.p, { children: ["⚠️ ", _jsx(_components.strong, { children: "Critical:" }), " When using ", _jsx(_components.code, { children: "write()" }), "/", _jsx(_components.code, { children: "read()" }), " for binary I/O:"] }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: ["Open file with ", _jsx(_components.code, { children: "ios::binary" }), " flag."] }), "\n", _jsxs(_components.li, { children: ["Use ", _jsx(_components.code, { children: "reinterpret_cast" }), " to treat object as byte array."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Only safe for POD (Plain Old Data) types" }), " — no ", _jsx(_components.code, { children: "std::string" }), ", ", _jsx(_components.code, { children: "std::vector" }), ", virtual functions, or pointers inside the struct."] }), "\n", _jsx(_components.li, { children: "Platform-dependent: binary layout may differ across architectures (endianness, padding)." }), "\n"] })] }), _jsxs(_components.h4, { children: ["Utility Functions: ", _jsx(_components.code, { children: "ignore()" }), ", ", _jsx(_components.code, { children: "peek()" }), ", ", _jsx(_components.code, { children: "putback()" })] }), _jsx(ComparisonTable, { title: "Stream Utility Functions", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "left" }, children: "Function" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Purpose" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Example" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ignore(n, delim)" }) }), _jsxs(_components.td, { style: { textAlign: "left" }, children: ["Skip up to ", _jsx(_components.code, { children: "n" }), " chars or until ", _jsx(_components.code, { children: "delim" }), " found"] }), _jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "in.ignore(100, '\\n');" }), " skip rest of line"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "peek()" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "View next char without extracting" }), _jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "char c = in.peek();" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "putback(c)" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Put char back into stream" }), _jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "in.putback(c);" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "unget()" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Move get pointer back by one" }), _jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "in.unget();" }) })] })] })] }) }), _jsx(Intuition, { title: "Peek vs. Get", children: _jsxs(_components.p, { children: ["💡 ", _jsx(_components.strong, { children: "Intuition:" }), " ", _jsx(_components.code, { children: "peek()" }), " is like ", _jsx(_components.strong, { children: "looking at the next card" }), " in a deck without drawing it 🃏. ", _jsx(_components.code, { children: "get()" }), " ", _jsx(_components.strong, { children: "draws the card" }), ". ", _jsx(_components.code, { children: "putback()" }), " ", _jsx(_components.strong, { children: "returns the card to the top" }), " of the deck."] }) }), _jsx(_components.h3, { children: "File Position Pointers — Random Access Navigation" }), _jsx(_components.p, { children: "Every file stream maintains two independent position pointers:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Get pointer" }), " (input position) — controlled by ", _jsx(_components.code, { children: "seekg()" }), " / ", _jsx(_components.code, { children: "tellg()" })] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Put pointer" }), " (output position) — controlled by ", _jsx(_components.code, { children: "seekp()" }), " / ", _jsx(_components.code, { children: "tellp()" })] }), "\n"] }), _jsx(CodeBlock, { language: "cpp", children: `#include #include using namespace std; int main() { fstream file("random.dat", ios::in | ios::out | ios::binary | ios::trunc); // Write 10 integers for (int i = 0; i < 10; ++i) { file.write(reinterpret_cast(&i), sizeof(int)); } // Seek to 5th integer (0-indexed: position 4 * sizeof(int)) file.seekg(4 * sizeof(int), ios::beg); int val; file.read(reinterpret_cast(&val), sizeof(int)); cout << "5th integer (read): " << val << endl; // Should be 4 // Seek put pointer to 2nd integer and overwrite file.seekp(1 * sizeof(int), ios::beg); int newVal = 999; file.write(reinterpret_cast(&newVal), sizeof(int)); // Verify by reading back file.seekg(1 * sizeof(int), ios::beg); file.read(reinterpret_cast(&val), sizeof(int)); cout << "2nd integer (after overwrite): " << val << endl; // Should be 999 // tellg/tellp return current position cout << "Current get position: " << file.tellg() << " bytes" << endl; cout << "Current put position: " << file.tellp() << " bytes" << endl; file.close(); return 0; }` }), _jsx(ComparisonTable, { title: "seekg / seekp Origin Constants", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "left" }, children: "Origin Constant" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Meaning" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::beg" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Beginning of file (default)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::cur" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Current position" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::end" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "End of file" })] })] })] }) }), _jsxs(Remember, { children: [_jsxs(_components.p, { children: ["💡 ", _jsx(_components.strong, { children: "Key Points on Random Access:" })] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "seekg" }), "/", _jsx(_components.code, { children: "seekp" }), " take ", _jsx(_components.strong, { children: "offset" }), " (long) and ", _jsx(_components.strong, { children: "origin" }), " (", _jsx(_components.code, { children: "ios::beg" }), ", ", _jsx(_components.code, { children: "ios::cur" }), ", ", _jsx(_components.code, { children: "ios::end" }), ")."] }), "\n", _jsxs(_components.li, { children: ["Offsets are in ", _jsx(_components.strong, { children: "bytes" }), ". For structs/arrays, multiply index by ", _jsx(_components.code, { children: "sizeof(Type)" }), "."] }), "\n", _jsxs(_components.li, { children: ["Works reliably only in ", _jsx(_components.strong, { children: "binary mode" }), " (", _jsx(_components.code, { children: "ios::binary" }), "). In text mode, newline translation makes byte positions unpredictable."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "tellg()" }), "/", _jsx(_components.code, { children: "tellp()" }), " return ", _jsx(_components.code, { children: "streampos" }), " (convertible to ", _jsx(_components.code, { children: "streamoff" }), " / ", _jsx(_components.code, { children: "long" }), ")."] }), "\n"] })] }), _jsx(_components.h3, { children: "Complete Example: Mini Record Manager" }), _jsx(CodeBlock, { language: "cpp", children: `#include #include #include #include using namespace std; struct Employee { int id; char name[30]; float salary; }; void addRecord(fstream& file) { Employee e; cout << "Enter ID: "; cin >> e.id; cout << "Enter Name: "; cin.ignore(); cin.getline(e.name, 30); cout << "Enter Salary: "; cin >> e.salary; file.seekp(0, ios::end); // Append at end file.write(reinterpret_cast(&e), sizeof(e)); cout << "Record added.\n"; } void displayAll(fstream& file) { Employee e; file.seekg(0, ios::beg); cout << left << setw(10) << "ID" << setw(30) << "Name" << "Salary\n"; cout << string(50, '-') << endl; while (file.read(reinterpret_cast(&e), sizeof(e))) { cout << left << setw(10) << e.id << setw(30) << e.name << e.salary << endl; } file.clear(); // Clear EOF flag for further operations } void searchById(fstream& file, int targetId) { Employee e; file.seekg(0, ios::beg); bool found = false; while (file.read(reinterpret_cast(&e), sizeof(e))) { if (e.id == targetId) { cout << "Found: " << e.id << ", " << e.name << ", " << e.salary << endl; found = true; break; } } if (!found) cout << "Record not found.\n"; file.clear(); } int main() { fstream file("employees.dat", ios::in | ios::out | ios::binary | ios::app); // ios::app ensures file created if not exists; but for read/write we need in|out // Note: ios::app forces all writes to end. For random write, omit ios::app. // Better: open with ios::in | ios::out | ios::binary; if fails, create with trunc. if (!file) { file.open("employees.dat", ios::in | ios::out | ios::binary | ios::trunc); } int choice, id; do { cout << "\n1. Add Record\n2. Display All\n3. Search by ID\n4. Exit\nChoice: "; cin >> choice; switch (choice) { case 1: addRecord(file); break; case 2: displayAll(file); break; case 3: cout << "Enter ID: "; cin >> id; searchById(file, id); break; case 4: cout << "Exiting...\n"; break; default: cout << "Invalid choice.\n"; } } while (choice != 4); file.close(); return 0; }` }), _jsx(LabConnection, { children: _jsxs(_components.p, { children: ["🧪 ", _jsx(_components.strong, { children: "Lab Connection:" }), " Implement a student database program that stores records in a binary file. Use ", _jsx(_components.code, { children: "write()" }), "/", _jsx(_components.code, { children: "read()" }), " for struct I/O, ", _jsx(_components.code, { children: "seekg()" }), "/", _jsx(_components.code, { children: "seekp()" }), " for record-level navigation (edit/delete specific roll number), and ", _jsx(_components.code, { children: "getline()" }), " for name input with spaces. Test with 10+ records and verify persistence across program runs."] }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.h3, { children: ["Files Open Karna: Constructors vs ", _jsx(_components.code, { children: "open()" })] }), _jsx(_components.p, { children: "C++ do equivalent tarike provide karta hai file stream object ko physical file ke saath associate karne ke liye. Dono approaches same filename aur mode flags accept karte hain." }), _jsx(Intuition, { title: "Two Ways to Unlock a Drawer", children: _jsxs(_components.p, { children: ["💡 ", _jsx(_components.strong, { children: "Intuition:" }), " Chahe aap ", _jsx(_components.strong, { children: "drawer banate waqt hi chabi le aayein" }), " (constructor) ya ", _jsx(_components.strong, { children: "baad mein chabi laakar lagayein" }), " (", _jsx(_components.code, { children: "open()" }), "), result same hai — drawer unlock ho gaya aur use ke liye ready hai."] }) }), _jsx(_components.h4, { children: "1. Constructors Ka Upyog" }), _jsx(_components.p, { children: "File usi moment open hoti hai jab stream object create hota hai. Yeh concise hai aur ensure karta hai ki stream turant ready hai." }), _jsx(CodeBlock, { language: "cpp", children: `#include #include using namespace std; int main() { // Writing ke liye open (existing truncate, naya create) ofstream outfile("data.txt", ios::out | ios::trunc); if (!outfile) { cerr << "Error opening file for writing!" << endl; return 1; } outfile << "Hello, File!" << endl; outfile.close(); // Reading ke liye open ifstream infile("data.txt", ios::in); if (!infile) { cerr << "Error opening file for reading!" << endl; return 1; } string line; while (getline(infile, line)) { cout << line << endl; } infile.close(); return 0; }` }), _jsxs(_components.h4, { children: ["2. ", _jsx(_components.code, { children: "open()" }), " Member Function Ka Upyog"] }), _jsxs(_components.p, { children: ["Stream object pehle banta hai (unassociated), aur ", _jsx(_components.code, { children: "open()" }), " baad mein call kiya jata hai. Yeh useful hai jab filename runtime pe decide hota hai ya jab same stream object ko multiple files ke liye sequentially reuse karna ho."] }), _jsx(CodeBlock, { language: "cpp", children: `#include #include #include using namespace std; int main() { ofstream outfile; string filename = "runtime_data.txt"; // Baad mein open jab filename pata ho outfile.open(filename, ios::out | ios::app); // Append mode if (outfile.is_open()) { outfile << "Appended line." << endl; outfile.close(); } // Same object ko dusre file ke liye reuse outfile.open("another.txt", ios::out); if (outfile) { outfile << "Fresh file." << endl; outfile.close(); } return 0; }` }), _jsx(KeyPoints, { children: _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Dono methods identical mode flags accept karte hain (bitwise OR combinable)." }), "\n", _jsx(_components.li, { children: "Constructor approach: RAII-friendly, file turant open hoti hai." }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "open()" }), " approach: Runtime filenames ke liye flexible, reusable stream objects."] }), "\n", _jsxs(_components.li, { children: ["Hamesha stream state check karein (", _jsx(_components.code, { children: "if (!stream)" }), " ya ", _jsx(_components.code, { children: "stream.is_open()" }), ") open ke baad."] }), "\n"] }) }), _jsx(_components.h3, { children: "File Mode Flags — Detailed Reference" }), _jsx(ComparisonTable, { title: "Common File Mode Flags (ios namespace)", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "left" }, children: "Flag" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Purpose" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Typical Use Case" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::in" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Reading ke liye open" }), _jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "ifstream" }), ", ", _jsx(_components.code, { children: "fstream" })] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::out" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Writing ke liye open" }), _jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "ofstream" }), ", ", _jsx(_components.code, { children: "fstream" })] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::app" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Append — saare writes end pe jayein" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Log files, existing content preserve karna" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::ate" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Open karke initially end pe seek" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "End pe read-modify-write" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::trunc" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Existing file ko zero length kar do" }), _jsxs(_components.td, { style: { textAlign: "left" }, children: ["Fresh write (default for ", _jsx(_components.code, { children: "ofstream" }), ")"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::binary" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Binary mode (newline translation nahi)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Images, executables, structs" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::nocreate" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Fail agar file exist na kare (legacy)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Strict read-only existing files" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::noreplace" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Fail agar file already exist kare (legacy)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Accidental overwrite prevent karna" })] })] })] }) }), _jsx(Remember, { children: _jsxs(_components.p, { children: ["💡 ", _jsx(_components.strong, { children: "Important:" }), " ", _jsx(_components.code, { children: "ios::app" }), " implies ", _jsx(_components.code, { children: "ios::out" }), ". ", _jsx(_components.code, { children: "ios::trunc" }), " default hai ", _jsx(_components.code, { children: "ofstream" }), " ke liye. ", _jsx(_components.code, { children: "fstream" }), " ke liye, aapko ", _jsx(_components.strong, { children: "kam se kam ek" }), " ", _jsx(_components.code, { children: "ios::in" }), " ya ", _jsx(_components.code, { children: "ios::out" }), " specify karna ", _jsx(_components.strong, { children: "zaruri" }), " hai. Binary mode (", _jsx(_components.code, { children: "ios::binary" }), ") critical hai non-text data ke liye taaki ", _jsx(_components.code, { children: "\\n" }), " ↔ ", _jsx(_components.code, { children: "\\r\\n" }), " translation Windows pe na ho."] }) }), _jsx(_components.h3, { children: "Files Close Karna" }), _jsxs(_components.p, { children: [_jsx(_components.code, { children: "close()" }), " member function stream object aur physical file ke beech association tod deta hai, buffered data ko disk pe flush karke. Explicit ", _jsx(_components.code, { children: "close()" }), " call karna good practice hai, haan destructors automatically call karte hain jab stream object scope se bahar jata hai."] }), _jsx(CodeBlock, { language: "cpp", children: `ofstream log("app.log", ios::app); log << "Event occurred" << endl; log.close(); // Explicit close — ensures data flushed immediately // Destructor bhi automatically close() call karega yahan // lekin explicit close aapko timing par control deta hai. ` }), _jsx(Tip, { children: _jsxs(_components.p, { children: ["✅ ", _jsx(_components.strong, { children: "Best Practice:" }), " Jab aap file mein writing complete kar lein to ", _jsx(_components.code, { children: "close()" }), " explicitly call karein, khas kar agar aap same file ko turant baad mein phir se open karna chahte hain (jaise write then read). Yeh guarantee karta hai ki buffers flushed hain aur file handle release ho gaya."] }) }), _jsx(_components.h3, { children: "Files Se Reading aur Writing — Stream Operators" }), _jsxs(_components.p, { children: ["Insertion (", _jsx(_components.code, { children: "<<" }), ") aur extraction (", _jsx(_components.code, { children: ">>" }), ") operators file streams ke saath bilkul waise hi kaam karte hain jaise ", _jsx(_components.code, { children: "cout" }), " aur ", _jsx(_components.code, { children: "cin" }), " ke saath, ", _jsx(_components.strong, { children: "formatted text I/O" }), " provide karte hain. Wo extraction ke liye whitespace skip karte hain (by default) aur stream manipulators ke hisaab se format karte hain."] }), _jsx(CodeBlock, { language: "cpp", children: `#include #include #include using namespace std; int main() { // Formatted data likhna ofstream out("records.txt"); out << left << setw(15) << "Name" << setw(10) << "Age" << "City" << endl; out << left << setw(15) << "Alice" << setw(10) << 30 << "New York" << endl; out << left << setw(15) << "Bob" << setw(10) << 25 << "London" << endl; out.close(); // Formatted data padhna ifstream in("records.txt"); string name, city; int age; // Header skip in >> name >> age >> city; while (in >> name >> age >> city) { cout << name << ", " << age << ", " << city << endl; } in.close(); return 0; }` }), _jsx(Note, { children: _jsxs(_components.p, { children: ["📝 ", _jsx(_components.strong, { children: "Note:" }), " ", _jsx(_components.code, { children: "operator>>" }), " by default leading whitespace (spaces, newlines, tabs) skip karta hai. Agar aapko whitespace characters padhne hain to ", _jsx(_components.code, { children: "noskipws" }), " manipulator ya ", _jsx(_components.code, { children: "get()" }), "/", _jsx(_components.code, { children: "getline()" }), " use karein."] }) }), _jsx(_components.h3, { children: "Formatted Input/Output Functions" }), _jsxs(_components.p, { children: [_jsx(_components.code, { children: "<<" }), " aur ", _jsx(_components.code, { children: ">>" }), " ke alawa, file streams member functions provide karte hain ", _jsx(_components.strong, { children: "character-level" }), ", ", _jsx(_components.strong, { children: "line-level" }), ", aur ", _jsx(_components.strong, { children: "block-level" }), " I/O ke liye precise control ke saath."] }), _jsxs(_components.h4, { children: ["Character I/O: ", _jsx(_components.code, { children: "get()" }), " aur ", _jsx(_components.code, { children: "put()" })] }), _jsx(CodeBlock, { language: "cpp", children: `// Character by character padhna ifstream in("text.txt"); char ch; while (in.get(ch)) { // Stream return karta, EOF/error pe false cout << ch; } // Character by character likhna ofstream out("copy.txt"); out.put('H'); out.put('i'); out.put('!'); ` }), _jsxs(_components.h4, { children: ["Line I/O: ", _jsx(_components.code, { children: "getline()" })] }), _jsx(_components.p, { children: "Poori line (newline tak) string buffer mein padhta hai. Newline extract hokar discard ho jati hai." }), _jsx(CodeBlock, { language: "cpp", children: `ifstream in("notes.txt"); string line; while (getline(in, line)) { // Global getline for std::string cout << "Line: " << line << endl; } // Member version with custom delimiter char buffer[256]; in.getline(buffer, 256, ';'); // ';' tak padho ` }), _jsxs(_components.h4, { children: ["Block I/O: ", _jsx(_components.code, { children: "write()" }), " aur ", _jsx(_components.code, { children: "read()" }), " — Binary Data"] }), _jsxs(_components.p, { children: ["Yeh functions ", _jsx(_components.strong, { children: "unformatted binary I/O" }), " perform karte hain, raw bytes likhte/padhte hain. Structs, arrays, ya binary files save/restore karne ke liye essential hain."] }), _jsx(CodeBlock, { language: "cpp", children: `struct Student { int roll; char name[20]; float marks; }; Student s = {101, "Alice", 92.5f}; // Binary likhna ofstream out("student.dat", ios::binary); out.write(reinterpret_cast(&s), sizeof(s)); out.close(); // Binary padhna ifstream in("student.dat", ios::binary); Student s2; in.read(reinterpret_cast(&s2), sizeof(s2)); in.close(); cout << s2.roll << " " << s2.name << " " << s2.marks << endl; ` }), _jsxs(Warning, { children: [_jsxs(_components.p, { children: ["⚠️ ", _jsx(_components.strong, { children: "Critical:" }), " ", _jsx(_components.code, { children: "write()" }), "/", _jsx(_components.code, { children: "read()" }), " binary I/O ke liye use karte waqt:"] }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: ["File ko ", _jsx(_components.code, { children: "ios::binary" }), " flag ke saath open karein."] }), "\n", _jsxs(_components.li, { children: ["Object ko byte array ki tarah treat karne ke liye ", _jsx(_components.code, { children: "reinterpret_cast" }), " use karein."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Sirf POD (Plain Old Data) types ke liye safe" }), " — ", _jsx(_components.code, { children: "std::string" }), ", ", _jsx(_components.code, { children: "std::vector" }), ", virtual functions, ya pointers struct ke andar na hon."] }), "\n", _jsx(_components.li, { children: "Platform-dependent: binary layout architectures ke across alag ho sakta hai (endianness, padding)." }), "\n"] })] }), _jsxs(_components.h4, { children: ["Utility Functions: ", _jsx(_components.code, { children: "ignore()" }), ", ", _jsx(_components.code, { children: "peek()" }), ", ", _jsx(_components.code, { children: "putback()" })] }), _jsx(ComparisonTable, { title: "Stream Utility Functions", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "left" }, children: "Function" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Purpose" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Example" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ignore(n, delim)" }) }), _jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "n" }), " chars skip ya ", _jsx(_components.code, { children: "delim" }), " tak"] }), _jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "in.ignore(100, '\\n');" }), " line ka baaki skip"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "peek()" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Next char dekhna bina extract kiye" }), _jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "char c = in.peek();" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "putback(c)" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Char wapas stream mein daalna" }), _jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "in.putback(c);" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "unget()" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Get pointer ek peeche move" }), _jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "in.unget();" }) })] })] })] }) }), _jsx(Intuition, { title: "Peek vs. Get", children: _jsxs(_components.p, { children: ["💡 ", _jsx(_components.strong, { children: "Intuition:" }), " ", _jsx(_components.code, { children: "peek()" }), " waise hai jaise ", _jsx(_components.strong, { children: "deck ka next card dekhna" }), " bina nikale 🃏. ", _jsx(_components.code, { children: "get()" }), " ", _jsx(_components.strong, { children: "card nikalta hai" }), ". ", _jsx(_components.code, { children: "putback()" }), " ", _jsx(_components.strong, { children: "card wapas deck ke top pe rakhta hai" }), "."] }) }), _jsx(_components.h3, { children: "File Position Pointers — Random Access Navigation" }), _jsx(_components.p, { children: "Har file stream do independent position pointers maintain karta hai:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Get pointer" }), " (input position) — ", _jsx(_components.code, { children: "seekg()" }), " / ", _jsx(_components.code, { children: "tellg()" }), " se control hota hai"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Put pointer" }), " (output position) — ", _jsx(_components.code, { children: "seekp()" }), " / ", _jsx(_components.code, { children: "tellp()" }), " se control hota hai"] }), "\n"] }), _jsx(CodeBlock, { language: "cpp", children: `#include #include using namespace std; int main() { fstream file("random.dat", ios::in | ios::out | ios::binary | ios::trunc); // 10 integers likhna for (int i = 0; i < 10; ++i) { file.write(reinterpret_cast(&i), sizeof(int)); } // 5th integer pe seek (0-indexed: position 4 * sizeof(int)) file.seekg(4 * sizeof(int), ios::beg); int val; file.read(reinterpret_cast(&val), sizeof(int)); cout << "5th integer (read): " << val << endl; // 4 hona chahiye // Put pointer 2nd integer pe seek karke overwrite file.seekp(1 * sizeof(int), ios::beg); int newVal = 999; file.write(reinterpret_cast(&newVal), sizeof(int)); // Verify karne ke liye wapas padho file.seekg(1 * sizeof(int), ios::beg); file.read(reinterpret_cast(&val), sizeof(int)); cout << "2nd integer (after overwrite): " << val << endl; // 999 hona chahiye // tellg/tellp current position return karte hain cout << "Current get position: " << file.tellg() << " bytes" << endl; cout << "Current put position: " << file.tellp() << " bytes" << endl; file.close(); return 0; }` }), _jsx(ComparisonTable, { title: "seekg / seekp Origin Constants", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "left" }, children: "Origin Constant" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Meaning" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::beg" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "File ka beginning (default)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::cur" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Current position" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "ios::end" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "File ka end" })] })] })] }) }), _jsxs(Remember, { children: [_jsxs(_components.p, { children: ["💡 ", _jsx(_components.strong, { children: "Random Access Ke Key Points:" })] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "seekg" }), "/", _jsx(_components.code, { children: "seekp" }), " ", _jsx(_components.strong, { children: "offset" }), " (long) aur ", _jsx(_components.strong, { children: "origin" }), " (", _jsx(_components.code, { children: "ios::beg" }), ", ", _jsx(_components.code, { children: "ios::cur" }), ", ", _jsx(_components.code, { children: "ios::end" }), ") lete hain."] }), "\n", _jsxs(_components.li, { children: ["Offsets ", _jsx(_components.strong, { children: "bytes" }), " mein hote hain. Structs/arrays ke liye index ko ", _jsx(_components.code, { children: "sizeof(Type)" }), " se multiply karein."] }), "\n", _jsxs(_components.li, { children: ["Reliably sirf ", _jsx(_components.strong, { children: "binary mode" }), " (", _jsx(_components.code, { children: "ios::binary" }), ") mein kaam karta hai. Text mode mein newline translation byte positions ko unpredictable bana deta hai."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "tellg()" }), "/", _jsx(_components.code, { children: "tellp()" }), " ", _jsx(_components.code, { children: "streampos" }), " return karte hain (convertible to ", _jsx(_components.code, { children: "streamoff" }), " / ", _jsx(_components.code, { children: "long" }), ")."] }), "\n"] })] }), _jsx(_components.h3, { children: "Complete Example: Mini Record Manager" }), _jsx(CodeBlock, { language: "cpp", children: `#include #include #include #include using namespace std; struct Employee { int id; char name[30]; float salary; }; void addRecord(fstream& file) { Employee e; cout << "Enter ID: "; cin >> e.id; cout << "Enter Name: "; cin.ignore(); cin.getline(e.name, 30); cout << "Enter Salary: "; cin >> e.salary; file.seekp(0, ios::end); // End pe append file.write(reinterpret_cast(&e), sizeof(e)); cout << "Record added.\n"; } void displayAll(fstream& file) { Employee e; file.seekg(0, ios::beg); cout << left << setw(10) << "ID" << setw(30) << "Name" << "Salary\n"; cout << string(50, '-') << endl; while (file.read(reinterpret_cast(&e), sizeof(e))) { cout << left << setw(10) << e.id << setw(30) << e.name << e.salary << endl; } file.clear(); // EOF flag clear for further operations } void searchById(fstream& file, int targetId) { Employee e; file.seekg(0, ios::beg); bool found = false; while (file.read(reinterpret_cast(&e), sizeof(e))) { if (e.id == targetId) { cout << "Found: " << e.id << ", " << e.name << ", " << e.salary << endl; found = true; break; } } if (!found) cout << "Record not found.\n"; file.clear(); } int main() { fstream file("employees.dat", ios::in | ios::out | ios::binary | ios::app); // ios::app ensures file created if not exists; but read/write ke liye in|out chahiye // Note: ios::app forces all writes to end. Random write ke liye, ios::app omit karein. // Better: ios::in | ios::out | ios::binary se open; agar fail to trunc se create. if (!file) { file.open("employees.dat", ios::in | ios::out | ios::binary | ios::trunc); } int choice, id; do { cout << "\n1. Add Record\n2. Display All\n3. Search by ID\n4. Exit\nChoice: "; cin >> choice; switch (choice) { case 1: addRecord(file); break; case 2: displayAll(file); break; case 3: cout << "Enter ID: "; cin >> id; searchById(file, id); break; case 4: cout << "Exiting...\n"; break; default: cout << "Invalid choice.\n"; } } while (choice != 4); file.close(); return 0; }` }), _jsx(LabConnection, { children: _jsxs(_components.p, { children: ["🧪 ", _jsx(_components.strong, { children: "Lab Connection:" }), " Ek student database program implement karein jo records binary file mein store kare. Struct I/O ke liye ", _jsx(_components.code, { children: "write()" }), "/", _jsx(_components.code, { children: "read()" }), " use karein, record-level navigation (specific roll number edit/delete) ke liye ", _jsx(_components.code, { children: "seekg()" }), "/", _jsx(_components.code, { children: "seekp()" }), ", aur spaces wale name input ke liye ", _jsx(_components.code, { children: "getline()" }), ". 10+ records ke saath test karein aur program runs ke across persistence verify karein."] }) })] })] }), "\n", _jsx(ImportantQA, { questions: [{ "q": "Explain the two methods to open a file in C++ and state the key difference between them.", "marks": 2, "a": { "components": [{ "type": "Explanation", "content": "In C++, a file can be opened using two methods:\n\n **1. Using Constructor:** The file is opened at the time of object creation.\n ```cpp\n ofstream fout(\"data.txt\"); // Opens for writing\n ifstream fin(\"data.txt\"); // Opens for reading\n ```\n\n **2. Using `open()` Member Function:** The stream object is created first, then `open()` is called explicitly.\n ```cpp\n ofstream fout;\n fout.open(\"data.txt\");\n ```\n\n \n | Aspect | Constructor | open() Function |\n |---|---|---|\n | **Initialization** | File opens during object creation | File opens after object creation |\n | **Reusability** | Cannot reopen requires new object | Same object can open multiple files sequentially |\n | **Error Handling** | Harder to check immediately | Can check state before/after open call |\n \n\n \n Always check if the file opened successfully using `if (!fout)` or `if (fout.fail())` before performing I/O operations!" }] } }, { "q": "Describe the file mode flags available in C++ and explain the formatted I/O functions used for file operations.", "marks": 4, "a": { "components": [{ "type": "Explanation", "content": "### 📋 File Mode Flags (ios Namespace)\n\n File modes are specified as the second argument to constructor or `open()`. They can be combined using bitwise OR (`|`).\n\n \n | Flag | Description |\n |---|---|\n | `ios::in` | Open for reading (default for `ifstream`) |\n | `ios::out` | Open for writing (default for `ofstream`) |\n | `ios::app` | Append mode - write at end of file |\n | `ios::ate` | Open and seek to end immediately |\n | `ios::trunc` | Truncate file to zero length if exists (default for `ofstream`) |\n | `ios::binary` | Open in binary mode (no newline translation) |\n | `ios::nocreate` | Fail if file does not exist |\n | `ios::noreplace` | Fail if file already exists |\n \n\n **Example:**\n ```cpp\n fstream file;\n file.open(\"record.dat\", ios::in | ios::out | ios::binary);\n ```\n\n ### 📝 Formatted Input/Output Functions\n\n C++ streams support formatted I/O using extraction (`>>`) and insertion (`<<`) operators, along with manipulators.\n\n **Output Functions:**\n - `<<` operator: Writes formatted data to file (e.g., `fout << name << \" \" << age;`)\n - `put()`: Writes a single character\n - `write()`: Writes block of binary data (unformatted)\n\n **Input Functions:**\n - `>>` operator: Reads formatted data (skips whitespace)\n - `get()`: Reads single character (includes whitespace/newline)\n - `getline()`: Reads entire line into string buffer\n - `read()`: Reads block of binary data (unformatted)\n\n \n Formatted I/O (`>>`/`<<`) converts data to/from text representation. For binary files storing structures/classes, use `read()`/`write()` with `reinterpret_cast` to avoid formatting overhead and precision loss." }] } }, { "q": "Write a complete C++ program that creates a student record file, writes multiple records using formatted output, then reads and displays them using formatted input.", "marks": 6, "a": { "components": [{ "type": "Explanation", "content": "Here is a complete C++ program demonstrating file operations with formatted I/O:\n\n \n {`#include \n #include \n #include \n using namespace std;\n\n class Student {\n int rollNo;\n string name;\n float marks;\n\n public:\n void input() {\n cout << \"Enter Roll No: \"; cin >> rollNo;\n cout << \"Enter Name: \"; cin >> name;\n cout << \"Enter Marks: \"; cin >> marks;\n }\n\n void display() const {\n cout << \"Roll No: \" << rollNo \n << \", Name: \" << name \n << \", Marks: \" << marks << endl;\n }\n\n // Friend functions for formatted file I/O\n friend ofstream& operator<<(ofstream& fout, const Student& s);\n friend ifstream& operator>>(ifstream& fin, Student& s);\n };\n\n // Formatted write to file\n ofstream& operator<<(ofstream& fout, const Student& s) {\n fout << s.rollNo << \" \" << s.name << \" \" << s.marks << endl;\n return fout;\n }\n\n // Formatted read from file\n ifstream& operator>>(ifstream& fin, Student& s) {\n fin >> s.rollNo >> s.name >> s.marks;\n return fin;\n }\n\n int main() {\n Student s;\n int n;\n\n // --- WRITING RECORDS ---\n ofstream fout(\"students.txt\");\n if (!fout) {\n cerr << \"Error creating file!\" << endl;\n return 1;\n }\n\n cout << \"How many students? \";\n cin >> n;\n\n for (int i = 0; i < n; i++) {\n cout << \"\\nStudent \" << (i+1) << \":\\n\";\n s.input();\n fout << s; // Uses overloaded << for formatted write\n }\n fout.close();\n cout << \"\\nRecords written successfully.\\n\";\n\n // --- READING RECORDS ---\n ifstream fin(\"students.txt\");\n if (!fin) {\n cerr << \"Error opening file for reading!\" << endl;\n return 1;\n }\n\n cout << \"\\n--- Student Records from File ---\\n\";\n while (fin >> s) { // Uses overloaded >> for formatted read\n s.display();\n }\n\n fin.close();\n return 0;\n }`}\n \n\n ### 🔍 Program Explanation\n\n **1. Class Design:** `Student` class encapsulates data with `input()`/`display()` methods.\n\n **2. Operator Overloading for File I/O:**\n - `operator<<` for `ofstream`: Writes space-separated fields + newline (formatted text)\n - `operator>>` for `ifstream`: Reads space-separated fields (skips whitespace)\n\n **3. File Operations Flow:**\n - **Opening:** `ofstream fout(\"students.txt\")` — constructor opens in `ios::out | ios::trunc` mode\n - **Writing:** Loop calls `fout << s` for each record\n - **Closing:** `fout.close()` flushes buffer and releases handle\n - **Reopening:** `ifstream fin(\"students.txt\")` — opens in `ios::in` mode\n - **Reading:** `while (fin >> s)` reads until EOF/failure\n - **Closing:** `fin.close()`\n\n **4. Error Handling:** Checks `!fout` and `!fin` immediately after opening.\n\n \n Always close files explicitly using `close()` to ensure buffers are flushed. The destructor also closes automatically, but explicit closing is a good practice for clarity and immediate resource release.\n \n\n \n - **Formatted I/O** (`<<`/`>>`) converts data to human-readable text\n - **Space/newline** acts as delimiter between fields\n - **`while (fin >> s)`** loop terminates automatically on EOF or read error\n - **`close()`** is essential before reopening same file in different mode" }] } }] }), "\n", _jsx(MCQ, { questions: [{ "id": "844e8e04-2bc8-48ff-93cf-153e9c007a85", "q": "Which class constructor can open a file directly during object creation in C++?", "options": ["ifstream only", "ofstream, ifstream, and fstream", "fstream only", "ofstream only"], "answer": 1, "hint": "The fstream constructor can open a file directly during object creation.", "explanation": "The constructor of file stream classes accepts filename and mode parameters to open the file immediately." }, { "id": "decf7f66-503e-4a87-b813-57c2c348f69a", "q": "What is the purpose of the open() member function in file stream classes?", "options": ["To associate a file with an existing stream object", "To close a file and free resources", "To create a new file stream object", "To read data from a file"], "answer": 0, "hint": "open() is a member function of file stream classes used to associate a file with the stream.", "explanation": "The open() function is used to open a file after the stream object has been created." }, { "id": "4adf2c76-5737-467f-929e-8a2bc5c18469", "q": "How are multiple file modes combined when opening a file in C++?", "options": ["Using the plus (+) operator", "Using the logical AND (&&) operator", "Using the bitwise OR (|) operator", "Using the comma (,) operator"], "answer": 2, "hint": "File modes like ios::in, ios::out, ios::app can be combined using bitwise OR operator.", "explanation": "Multiple file modes are combined using the bitwise OR operator (|) to specify combined behavior." }, { "id": "2d9a1ef8-46c8-4e96-9826-c898ea715262", "q": "Which function is used to explicitly close a file in C++ file handling?", "options": ["terminate()", "end()", "shutdown()", "close()"], "answer": 3, "hint": "close() is a member function that disconnects the file from the stream and flushes buffers.", "explanation": "The close() function explicitly closes the file and releases the associated resources." }, { "id": "8aca1676-0c5c-4939-b5fe-05f96a6f81d9", "q": "Which operator is used for formatted input reading from a file stream?", "options": ["get()", ">>", "read()", "getline()"], "answer": 1, "hint": "The extraction operator (>\n\n>) reads formatted data skipping whitespace by default.", "explanation": "The >> operator performs formatted input, reading data according to the variable type and skipping whitespace." }, { "id": "79ffea58-a3ac-4e96-a31d-c1b2cf060d3d", "q": "Which operator is used for formatted output writing to a file stream?", "options": ["{\"<\"}{\"<\"}", "put()", "write()", "print()"], "answer": 0, "hint": "The insertion operator (<<) writes formatted data to the output stream.", "explanation": "The << operator performs formatted output, writing data to the file according to the variable type." }, { "id": "f1745fa1-0007-43a4-b081-728cd39e6616", "q": "Which function reads a single character from a file stream including whitespace characters?", "options": ["read()", ">>", "get()", "getline()"], "answer": 2, "hint": "get() reads a single character including whitespace, while getline() reads a line up to a delimiter.", "explanation": "The get() function reads a single character from the file stream without skipping whitespace." }, { "id": "71c2abf6-9793-4117-8e19-f8ddb0a013a3", "q": "Which function is used to read a complete line of text from a file into a string?", "options": ["get()", "read()", ">>", "getline()"], "answer": 3, "hint": "getline() reads characters until a delimiter (default newline) is found, storing them in a string.", "explanation": "The getline() function reads an entire line from the file into a string variable." }, { "id": "776e9e9e-5af7-4c7b-946c-31ce49a81226", "q": "Which function writes a block of binary data to a file stream?", "options": ["put()", "write()", "{\"<\"}{\"<\"}", "print()"], "answer": 1, "hint": "write() writes a block of binary data, while put() writes a single character.", "explanation": "The write() function performs unformatted binary output of a specified number of bytes." }, { "id": "ecf44743-d3ef-4312-8812-1d5394774491", "q": "Which file mode opens a file for writing at the end without truncating existing content?", "options": ["ios::app", "ios::out", "ios::trunc", "ios::ate"], "answer": 0, "hint": "The ios::app mode opens the file for output and positions the pointer at the end for appending.", "explanation": "ios::app mode ensures all writes append to the end of the file without truncating existing content." }], topicId: "5.3" })] }); } function MDXContent(props = {}) { const {wrapper: MDXLayout} = { ..._provideComponents(), ...props.components }; return MDXLayout ? _jsx(MDXLayout, { ...props, children: _jsx(_createMdxContent, { ...props }) }) : _createMdxContent(props); } return { default: MDXContent }; function _missingMdxReference(id, component) { throw new Error("Expected " + (component ? "component" : "object") + " `" + id + "` to be defined: you likely forgot to import, pass, or provide it."); }