Ch13-FileIO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 13 File Input/Output (IO)\n",
    "\n",
    "## Topics\n",
    "- input/output streams\n",
    "- file input stream\n",
    "- file output stream\n",
    "- reading unstructured and structured text files\n",
    "- formatting file output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 13.1 Streams\n",
    "- a **stream** is an abstract object that represents the flow of data from a source like keyboard or a file to a destination like the screen or a file\n",
    "- we've learned earlier about standard io streams\n",
    "- iostream is used to read the data from standard input (keyboard)\n",
    "    - data is then stored in computer memory to be manipulated to solve problems\n",
    "    - data result is written to the standard output (monitor) from computer memory\n",
    "- C++ uses various streams to reading data from and write data to\n",
    "    - stringstream is another stream that creates stream of strings\n",
    "- often programs need to read data, process it and write the result back to secondary devices for permanent storage\n",
    "- file stream is used to read data from secondary storage like disk and write result and data back to it for permenant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 13.2 File stream\n",
    "- we use &lt;fstream&gt; header to create input and output file streams\n",
    "\n",
    "## 13.3 File input\n",
    "- **ifstream** object is created to read data from file\n",
    "- it creates a stream that flows from the file into the program (memory)\n",
    "\n",
    "### steps for file input\n",
    "1. open file to read data from\n",
    "    - file must exist; run-time error otherwise\n",
    "2. read file contents\n",
    "3. close the file\n",
    "\n",
    "### open file\n",
    "- to open the file you need to create ifstream object\n",
    "- syntax to create ifstream object:\n",
    "```cpp\n",
    "// create stream without opening the file\n",
    "ifstream objectName;\n",
    "// create object and open the given file\n",
    "ifstream objectName(\"file_name\");\n",
    "```\n",
    "- objectName is any identifier you want to use it for this particular ifstream\n",
    "- file name is passed as an argument; we'll learn how to read text files\n",
    "- file name must be present to read data from\n",
    "\n",
    "\n",
    "\n",
    "- let's open and read this sample text file called [inputfile.txt](inputfile.txt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <fstream> // ifstream\n",
    "#include <iostream>\n",
    "#include <string>\n",
    "\n",
    "using namespace std;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "// declare ifstream object\n",
    "ifstream fin;\n",
    "// i prefer fin as stream object name; rhymes with cin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "// open the file using open method\n",
    "fin.open(\"inputfile.txt\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "// declare stream object and open the given file\n",
    "ifstream fin1(\"inputfile.txt\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### read data\n",
    "- once the ifstream object is created, reading data is similar to reading from iostream\n",
    "- we use >> (input extraction) and getline functions to read the data\n",
    "- syntax:\n",
    "```cpp\n",
    "ifstreamObject >> variable1 >> variable2 >> ...;\n",
    "```\n",
    "- \\>> - extracts one value of variable type and stops at a whitespace or mismatch type\n",
    "```cpp\n",
    "getline(ifstreamObject, strVariable);\n",
    "```\n",
    "- getline( ) - reads the whole line as string into strVariable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "// let's read couple of words from inputfile.txt\n",
    "string word1, word2;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "fin >> word1 >> word2;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is"
     ]
    }
   ],
   "source": [
    "cout << word1 << \" \" << word2;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "// let's read the rest of the line\n",
    "string line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "getline(fin, line);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " first sentence."
     ]
    }
   ],
   "source": [
    "cout << line;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is 2nd sentence"
     ]
    }
   ],
   "source": [
    "// let's read the next line\n",
    "getline(fin, line);\n",
    "cout << line;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "some numbers are below"
     ]
    }
   ],
   "source": [
    "// let's read the next line\n",
    "getline(fin, line);\n",
    "cout << line;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "// let's read the 3 numbers\n",
    "int nums[3];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "fin >> nums[0] >> nums[1] >> nums[2];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20 30"
     ]
    },
    {
     "data": {
      "text/plain": [
       "@0x10d2b5ec0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cout << nums[0] << \" \" << nums[1] << \" \" << nums[2];\n",
    "// done reading all the contents of the file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### close file\n",
    "- use close() method on ifstream objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "fin.close();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// can check if file is open\n",
    "fin.is_open()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "fin1.close();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ifstream member functions\n",
    "- there are a whole bunch of methods avaiable in ifstream objects\n",
    "- all the methods can be found here with examples: https://en.cppreference.com/w/cpp/io/basic_ifstream\n",
    "\n",
    "## 13.4 Reading structured data\n",
    "- one must know the contents of the data inorder to properly read them into program\n",
    "- reading unstructured data is difficult\n",
    "    - best way is to read line by line and process each line\n",
    "- reading structured data is a bit easier\n",
    "- let's read the structured data provided in [studentgrades.txt](studentgrades.txt) file\n",
    "    - there are 3 rows or records and 5 columns (values) for each record\n",
    "    - first 2 columns are string (names) and the rest 3 columns are integers (grades)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "#include <fstream>\n",
    "#include <string>\n",
    "#include <functional>\n",
    "#include <algorithm>\n",
    "\n",
    "using namespace std;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "// struct type is a perfect way to read these student's grades\n",
    "struct Student {\n",
    "    string firstName;\n",
    "    string lastName;\n",
    "    int grades[3];\n",
    "    float averageGrade;\n",
    "    char letterGrade;\n",
    "};"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "// let's create a vector of Student type to store all the records\n",
    "#include <vector>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "vector<Student> gradebook;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "//ifstream fin; // declare it if not declared before"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "// let's read the data\n",
    "// fin is ifstream object declared above\n",
    "fin.open(\"studentgrades.txt\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "// let's compute average grade\n",
    "float average(const Student & s) {\n",
    "    float sum = s.grades[0] + s.grades[1] + s.grades[2];\n",
    "    return sum/3.0;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "while(!fin.eof()) { // eof() checks if end-of-file has been reached\n",
    "    // create Student object to hold the data temporarily\n",
    "    Student temp;\n",
    "    fin >> temp.firstName >> temp.lastName >> temp.grades[0] >> temp.grades[1] >> temp.grades[2];\n",
    "    if (!fin.good()) break;\n",
    "    temp.averageGrade = average(temp);\n",
    "    // add the temp to gradebook\n",
    "    gradebook.push_back(temp);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "// close file\n",
    "fin.close();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "// let's write a function to print Student's info\n",
    "void printStudent(const Student & s) {\n",
    "    cout << s.firstName << \" \" << s.lastName << \" \" << s.grades[0] << \" \" \n",
    "        << s.grades[1] << \" \" << s.grades[2] << \" avg: \" << s.averageGrade;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John Smith 100 95 85 avg: 93.3333"
     ]
    }
   ],
   "source": [
    "// let's print the first student's info\n",
    "printStudent(gradebook[0]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John Smith 100 95 85 avg: 93.3333"
     ]
    }
   ],
   "source": [
    "printStudent(gradebook[0]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John Smith 100 95 85 avg: 93.3333\n",
      "Jane Doe 85 89 99 avg: 91\n",
      "Jill Jones 56 89 99 avg: 81.3333\n"
     ]
    }
   ],
   "source": [
    "// print all the students' info\n",
    "for(Student s: gradebook) {\n",
    "    printStudent(s);\n",
    "    cout << endl;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "// sort the student records based on average score?\n",
    "// need to define a comparision function and pass it to sort\n",
    "// compares two students' average grades in ascending order\n",
    "bool compareSmaller(const Student & s1, const Student & s2) {\n",
    "    return (s1.averageGrade < s2.averageGrade);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "// now we can sort the gradebook\n",
    "sort(gradebook.begin(), gradebook.end(), compareSmaller);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jill Jones 56 89 99 avg: 81.3333\n",
      "Jane Doe 85 89 99 avg: 91\n",
      "John Smith 100 95 85 avg: 93.3333\n"
     ]
    }
   ],
   "source": [
    "// print all the students' info\n",
    "for(Student s: gradebook) {\n",
    "    printStudent(s);\n",
    "    cout << endl;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "// let's write a compare function for descending order\n",
    "bool compareGreater(const Student & s1, const Student & s2) {\n",
    "    return (s1.averageGrade > s2.averageGrade);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "// now we can sort the gradebook in descending order using our own compare function\n",
    "sort(gradebook.begin(), gradebook.end(), compareGreater);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John Smith 100 95 85 avg: 93.3333\n",
      "Jane Doe 85 89 99 avg: 91\n",
      "Jill Jones 56 89 99 avg: 81.3333\n"
     ]
    }
   ],
   "source": [
    "// print all the students' info\n",
    "// looks like this could go into a function...\n",
    "for(Student s: gradebook) {\n",
    "    printStudent(s);\n",
    "    cout << endl;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 13.5 File output\n",
    "- sending output data to a file is similar to reading data\n",
    "- 3 steps:\n",
    "    1. Create a new file\n",
    "    2. Write data to the file\n",
    "    3. Close the file\n",
    "    \n",
    "### create file\n",
    "- to write data to a file, first create ofstrem object\n",
    "- syntax:\n",
    "```cpp\n",
    "// create ofstream object without creating a file\n",
    "ofstream fout;\n",
    "// create ofstream object with a given file\n",
    "ofstream fout(\"output-filename\");\n",
    "```\n",
    "- if the file exists, the file will be truncated\n",
    "    - existing data will be lost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <fstream> // ifstream and ofstream\n",
    "#include <iostream>\n",
    "#include <string>\n",
    "#include <iomanip>\n",
    "#include <vector>\n",
    "#include <algorithm>\n",
    "\n",
    "using namespace std;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "// create output file stream object\n",
    "ofstream fout;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "// create file\n",
    "fout.open(\"outputfile.txt\");\n",
    "// you should see a new text file created in the same folder as this notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "ofstream fout1(\"outputfile1.txt\");\n",
    "// you should see a new text file created in the same folder as this notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### write data\n",
    "- writing data to file is similar to writing data to std output stream\n",
    "- use << (output insertion operator) with the stream object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "// write data to output file stream\n",
    "fout << \"Hello World!\" << endl;\n",
    "fout1 << 2 << \" + \" << 2 << \" = \" << (2+2) << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### close file\n",
    "- closing file is important specially that was opened to write\n",
    "- file will be locked if it's not explictly closed until the program ends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "fout.close();\n",
    "fout1.close();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 13.6 Formatting output\n",
    "- iomanip manipulators work excatly the same way for file output\n",
    "- fixed, setw(), setprecision(), left, right, ws, setfill(), etc. all can be used to format the file output\n",
    "\n",
    "### print students' grades report in a tabular format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iomanip>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "fout.open(\"studentgradereport.txt\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "int colWidth;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "colWidth = 20;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "// print all the students' info to the fout stream\n",
    "\n",
    "// write column headers\n",
    "fout << setw(90) << setfill('=') << \" \" << setfill(' ') << endl;\n",
    "fout << setw(colWidth) << left << \"First Name\" \n",
    "    << setw(colWidth) << left << \"Last Name\";\n",
    "// students grades\n",
    "for(int i=0; i<3; i++) {\n",
    "    string testHeader = \"test\" + to_string(i+1);\n",
    "    fout << setw(10) << right << testHeader;\n",
    "}\n",
    "    \n",
    "fout << setw(15) << right << \"Avgerage\" << endl;\n",
    "fout << setw(90) << right << setfill('=') << \" \" << endl;\n",
    "\n",
    "// write records\n",
    "fout << setfill(' ') << fixed << setprecision(1);\n",
    "for(Student s: gradebook) {\n",
    "    fout << setw(colWidth) << left << s.firstName\n",
    "        << setw(colWidth) << left << s.lastName;\n",
    "    for(int i=0; i<3; i++)\n",
    "        fout << setw(10) << right << s.grades[i];\n",
    "    fout << setw(15) << right << s.averageGrade << endl;\n",
    "}\n",
    "fout << setw(90) << setfill('*') << \" \" << endl;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "// convert the above code to a function!\n",
    "// all the stream objects must be passed-by reference!\n",
    "// out is a generic ostream parameter (can be cout or fout)\n",
    "void writeResults(ostream & out) {\n",
    "    // print all the students' info to the fout stream\n",
    "\n",
    "    // write column headers\n",
    "    out << setw(90) << setfill('=') << \" \" << setfill(' ') << endl;\n",
    "    out << setw(colWidth) << left << \"First Name\" \n",
    "        << setw(colWidth) << left << \"Last Name\";\n",
    "    // students grades\n",
    "    for(int i=0; i<3; i++) {\n",
    "        string testHeader = \"test\" + to_string(i+1);\n",
    "        out << setw(10) << right << testHeader;\n",
    "    }\n",
    "    out << setw(15) << right << \"Avgerage\" << endl;\n",
    "    out << setw(90) << setfill('=') << \" \" << endl;\n",
    "\n",
    "    // write records\n",
    "    out << setfill(' ') << fixed << setprecision(1);\n",
    "    for(Student s: gradebook) {\n",
    "        out << setw(colWidth) << left << s.firstName\n",
    "            << setw(colWidth) << left << s.lastName;\n",
    "        for(int i=0; i<3; i++)\n",
    "            out << setw(10) << right << s.grades[i];\n",
    "        out << setw(15) << right << s.averageGrade << endl;\n",
    "    }\n",
    "    out << setw(90) << setfill('*') << \" \" << endl;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "========================================================================================= \n",
      "First Name          Last Name                test1     test2     test3       Avgerage\n",
      "========================================================================================= \n",
      "John                Smith                      100        95        85           93.3\n",
      "Jane                Doe                         85        89        99           91.0\n",
      "Jill                Jones                       56        89        99           81.3\n",
      "***************************************************************************************** \n"
     ]
    }
   ],
   "source": [
    "// write to standard output/console\n",
    "writeResults(cout);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "// write to file output\n",
    "writeResults(fout);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "// close the file\n",
    "fout.close();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 13.7 Exercises\n",
    "\n",
    "1. Write a program that computes distance between two points in Cartesian coordinates.\n",
    "    - use struct to represent Point\n",
    "    - prompt user to enter name of the input file that contains a bunch of points\n",
    "        - using a text editor manually create a file with two coordinate points (x, y) per line\n",
    "    - use as many function(s) as possible\n",
    "    - write at least 3 test cases for each computing functions\n",
    "    - program continues to run until user wants to quit\n",
    "    - most of the part is done in Jupyter Notebook demo\n",
    "    \n",
    "    \n",
    "2. Write a program to compute area and circumference of a circle using struct.\n",
    "    - use struct to represent Circle\n",
    "    - prompt user to enter name of the input text file that contains a bunch of radii of several circles\n",
    "        - using a text editor manually create a file that contains an arbitrary number of radii\n",
    "    - use as many function(s) as possible\n",
    "    - write at least 3 test cases for each computing functions\n",
    "    - program continues to run until user wants to quit\n",
    "    \n",
    "\n",
    "3. Write a program to compute area and perimeter of a rectangle using struct.\n",
    "    - use struct to represent Rectangle\n",
    "    - prompt user to enter name of the input text file that contains lengths and widths of several rectangles\n",
    "        - using a text editor manually create a file with length and width of a rectangle per line\n",
    "    - use as many function(s) as possible\n",
    "    - write at least 3 test cases for each computing functions\n",
    "    - program continues to run until user wants to quit\n",
    "    \n",
    "    \n",
    "4. Write a program to compute area and perimeter of a triangle given 3 sides.\n",
    "    - use struct to represent Triangle\n",
    "    - prompt user to enter name of the file that contains 3 sides of several triangles\n",
    "        - using a text editor manually create a file that contains 3 sides of a triangle per line\n",
    "    - use as many function(s) as possible\n",
    "    - write at least 3 test cases for each computing functions\n",
    "    - program continues to run until user wants to quit\n",
    "    \n",
    "    \n",
    "#### see a sample solution for exercise 4 at [demo_programs/Ch13/triangle.cpp](demo_programs/Ch13/triangle.cpp)\n",
    "\n",
    "\n",
    "5. A Grade Book:\n",
    "    - Write a C++ menu-driven program that let's professors keep track of students grades with the following requirements:\n",
    "    - program must use struct to keep track of students grades\n",
    "    - program prompts user to enter name of the input text file that contains students information in the following format\n",
    "        - first name, last name, test1, test2, test3, test4, test5\n",
    "    - program calculates avearge grade and the letter grade (A-F) based on the average grade\n",
    "    - program sorts the student records based on grade in non-increasing order (highest to lowest)\n",
    "    - program lets user add a new student\n",
    "    - program lets user update existing student's information\n",
    "    - program lets user delete existing student\n",
    "    - program saves the data back into the same input file as a database\n",
    "    - program creates a cleanly formatted report of students' grades\n",
    "    \n",
    "    \n",
    "6. Airline Reservation System:\n",
    "    - Write a C++ menu-driven CLI-based program that let's an airline company manage airline reservation on a single aircraft they own with the following requirements:\n",
    "    - aircraft has 10 rows with 2 seat on each row\n",
    "    - program provieds menu option to display all the avaialable seats\n",
    "    - program provides menu option to let user pick any available seat\n",
    "    - program provides menu option to creates total sales report\n",
    "    - program provides menu option to update price of any seat\n",
    "    - program saves the data into a file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 13.8 Kattis problems\n",
    "- typically Kattis problems don't require File IO"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 13.9 Summary\n",
    "- the notebook covered file streams (input and output)\n",
    "- learned how to read structured and unstructured data\n",
    "- write and format output to a output file\n",
    "- exercises and sample solution(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "C++17",
   "language": "C++17",
   "name": "xcpp17"
  },
  "language_info": {
   "codemirror_mode": "text/x-c++src",
   "file_extension": ".cpp",
   "mimetype": "text/x-c++src",
   "name": "c++",
   "version": "17"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}