IOStream

IOstream

iostream.gif

What is std::cout?

std::cout and std::cin are global objects of classes std::ostream and std::istream respectively, which they've overloaded operator << and >>

  cout     <<      expr  ;
  -----   ---     -------
  object   op.   argument

is basically this

cout.operator<<(expr);

The same is true for cin

Output stream manipulators

#include <iostream>
#include <iomanip>
#include <math.h>
using namespace std;

int main(){
    cout << setprecision(4)
         << 1234.5 << endl
         << 12345678. << endl;

    cout << "========\n";
    cout << M_PI << endl; //still setprecision(4)

    cout << setprecision(15)
         << M_PI << endl;

    return 0;
}

1234
1.235e+07
========
3.142
3.14159265358979

 cout << M_PI << endl; //still setprecision(4)

Here the precision is still 4

boolalpha

#include <iostream>   

int main () {
  bool b = true;
  std::cout << std::boolalpha << b << '\n';
  std::cout << std::noboolalpha << b << '\n';
  return 0;
}

true
1

How does this work?

The ostream object overloads the << operator for each basic type.

00001 // Standard stream manipulators -*- C++ -*-
00035 // iomanip
00049 namespace std
00050 {
00199   struct _Setprecision { int _M_n; };
...
...
00223 
00224   template<typename _CharT, typename _Traits>
00225     inline basic_ostream<_CharT,_Traits>& 
00226     operator<<(basic_ostream<_CharT,_Traits>& __os, _Setprecision __f)
00227     { 
00228       __os.precision(__f._M_n); 
00229       return __os; 
00230     }

The operator returns a reference as seen here basic_ostream<_CharT,_Traits>& which allows combined output

Examples

#include <iostream>
#include <fstream>
using namespace std;

int main () {
    ofstream myfile ("example.txt");

    if (myfile.is_open()){
        myfile << "This is a line.\n";
        myfile << "This is another line.\n";
        myfile.close();
    }
    else cout << "Unable to open file";
    return 0;
}

==example.txt==
This is a line.
This is another line.

or

ofstream myfile ("example.bin", ios::out | ios::app | ios::binary);

These are some flags

ios::in	Open for input operations.
ios::out	Open for output operations.
ios::binary	Open in binary mode.
ios::ate	Set the initial position at the end of the file.
ios::app	All output operations are performed at the end of the file, appending the content to the current content of the file.
ios::trunc	If the file is opened for output operations and it already existed, its previous content is deleted and replaced by the new one.

Closing the file

When we are finished with our input and output operations on a file we shall close it so that the os is notified and its resources become available again. For that, we call the stream's member function close. This member function takes flushes the associated buffers and closes the file:

myfile.close();

Once this member function is called, the stream object can be re-used to open another file, and the file is available again to be opened by other processes.

Lengthy Example (can skip)

#include <iostream>
#include <fstream>
using namespace std;

int main(){
    string filename = "file.txt";
    ofstream outputfile;
    // creating, opening and writing/appending data to file

    outputfile.open(filename, ios::out|ios::app);

    // simple error handling for file creating/opening for writing, test if fail to open the file, do…
    if(outputfile.fail()){
        cout<<"Creating and opening file "<<filename<<" for writing\n";
        cout<<"------------------------------------------\n";
        cout<<"The "<<filename<<" file could not be created/opened!\n";
        cout<<"Possible errors:\n";
        cout<<"1.  The file does not exist.\n";
        cout<<"2.  The path was not found.\n";
        exit(1);   // just exit, 0-normal, non zero - some error
    }else{ // else, if the file can be opened, do…
        cout<<"The "<<filename<<" file was created and opened successfully!\n";
        cout<<"\nDo some file writing....\n\n";
        outputfile<<"Writing some data in this file\n";
        outputfile<<"------------------------------\n";
        cout<<"Check the "<<filename<<" file contents :-)"<<endl;
        cout<<"If the file already have had data, the new data will be appended\n";

        int sampledata; // write some integers to the file...

        for(sampledata=0; sampledata<=10; sampledata++)
            outputfile<<sampledata<<"  ";
        outputfile<<endl;

        outputfile.close();  // close the output file

        // test if fail to close the file, do the following..., simple error handling for output files closing

        if(outputfile.fail()){
            cout<<"The "<<filename<<" file could not be closed!\n";
            exit(1);
        } else  // test if successful to close the file, do the following...
            cout<<"\nThe "<<filename<<" file was closed successfully!\n";
    }

    return 0;
}

file.txt before running

some data

file.txt after running

some data

Writing some data in this file
------------------------------
0  1  2  3  4  5  6  7  8  9  10

Here we use ios::app to append the data

Reading

ostream - C++ Reference

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

void read_file(ifstream& myfile,string fileName){
    myfile.open(fileName);
    string line;

    if (myfile.is_open()){
        while ( getline (myfile,line) ){
            cout << line << '\n';
        }
        myfile.close();
    }else
        cout << "Unable to open file";
}

int main () {
    ifstream myfile;

    read_file(myfile,"example.txt");
    read_file(myfile,"example2.txt");

    return 0;
}

This is a line.
This is another line.
This is a line from example 2
This is another line from example 2.

We can get add file name to the the ctor like we did while reading

Sum up numbers

==nums.txt==
1
10
100

#include <iostream>
#include <fstream>
using namespace std;

int main() {
    int sum = 0;
    int x;
    ifstream myFile("nums.txt");

    while (myFile >> x) {
        sum = sum + x;
    }

    myFile.close();
    cout << "Sum = " << sum << endl;
    return 0;
}

Sum = 111

or this

==nums2.txt==
1    5
10    50
100    500

#include <iostream>
#include <fstream>
using namespace std;

int main() {
    int sum1 = 0;
    int sum2 = 0;
    int x1, x2;
    ifstream myFile("nums2.txt");

    while (myFile >> x1 >> x2) {
        sum1 = sum1 + x1;
        sum2 = sum2 + x2;
    }

    myFile.close();
    cout << "Sum1 = " << sum1 << endl;
    cout << "Sum2 = " << sum2 << endl;
    return 0;
}

Sum1 = 111
Sum2 = 555

or even a csv file

1,5
10,50
100,500

int sum1 = 0;
int sum2 = 0;
char comma;
int x1, x2;
ifstream myFile("numcsv.csv");

while (myFile >> x1 >> comma >> x2) {
    sum1 = sum1 + x1;
    sum2 = sum2 + x2;
}

My exercise - Building an HTML generator

The program will receive a text file using the following syntax:

html.txt

h1 : Nissans Website
p : Whats up guys?
img : https://static.wixstatic.com/media/934aa2_5a1889466db146c8833c5d0f01eba2da~mv2.png/v1/fill/w_590,h_570,al_c,q_85,usm_0.66_1.00_0.01/cartoon%20arms%20crossed.webp

• h1 - is and header

• p - is a paragraph

• img - is an image address

The program will also prompt you for the Websites title

#include <iostream>
#include <fstream>
using namespace std;

//for string switch - https://stackoverflow.com/questions/16388510/evaluate-a-string-with-a-switch-in-c/16388594
enum HTML_Options {
    TITLE,
    H1,
    PARAGRAPH,
    IMAGE,
    NOT_VALID
};

HTML_Options resolveOption(std::string input) {
    if( input == "title" ) return TITLE;
    else if( input == "p" ) return PARAGRAPH;
    else if( input == "img" ) return IMAGE;
    else if( input == "h1" ) return H1;
    return NOT_VALID;
}

int main() {
    string key, value;
    char colon; // colon is :
    ifstream inFile("html.txt");
    ofstream newHTMLfile ("website.html");
    string title;

    cout << "Enter Website title\n";
    getline(cin, title);

    //add while myfile.open()
    newHTMLfile << "<!DOCTYPE html>\n"
                << "<html lang=\"en\">\n"
                << "<head>\n"
                << "    <meta charset=\"UTF-8\">\n"
                << "    <title>"<< title <<"</title>\n"
                << "</head>\n"
                << "<body>";


    while (inFile >> key >> colon ) {
        getline(inFile, value);
        cout << value << "\n";

        switch( resolveOption(key) ){
            case PARAGRAPH: {
                newHTMLfile << "\n<p>" << value << "</p>\n";
                break;
            }case IMAGE: {
                newHTMLfile << "\n<img src=\"" << value << "\"/>\n";
                break;
            }case H1: {
                newHTMLfile << "\n<h1>" << value << "</h1>\n";
                break;
            }default: {
                //...
                break;
            }
        }
    }

    newHTMLfile << "\n</body>\n</html>";

    inFile.close();
    newHTMLfile.close();

    return 0;
}

Yeah it took me a while to think about this exercise 😂

TODO add image

Same exercise but now with redirection

Lets remeber some standard redirection first

> redirects standard output of a command to a file, overwriting previous content.

$ command > file

>> redirects standard output of a command to a file, appending new content to old content.

$ command >> file

< redirects standard input to a command.

$ command < file

html.txt

Nissans Website 2
h1 : Nissans Website
p : Whats up guys?
img : https://static.wixstatic.com/media/934aa2_5a1889466db146c8833c5d0f01eba2da~mv2.png/v1/fill/w_590,h_570,al_c,q_85,usm_0.66_1.00_0.01/cartoon%20arms%20crossed.webp
p : It me from line 2

Notice here the title (the first line) doesn't have a key

$ ./a.out < html.txt

Here we will use the < redirection operator

#include <iostream>
#include <fstream>
using namespace std;

//for string switch - https://stackoverflow.com/questions/16388510/evaluate-a-string-with-a-switch-in-c/16388594
enum HTML_Options {
    TITLE,
    H1,
    PARAGRAPH,
    IMAGE,
    NOT_VALID
};

HTML_Options resolveOption(std::string input) {
    if( input == "title" ) return TITLE;
    else if( input == "p" ) return PARAGRAPH;
    else if( input == "img" ) return IMAGE;
    else if( input == "h1" ) return H1;
    return NOT_VALID;
}

int main() {
    string key, value;
    char colon; // colon is :
    ofstream newHTMLfile ("website.html");
    string title;

    getline(cin, title);

    //add while myfile.open()
    newHTMLfile << "<!DOCTYPE html>\n"
                << "<html lang=\"en\">\n"
                << "<head>\n"
                << "    <meta charset=\"UTF-8\">\n"
                << "    <title>"<< title <<"</title>\n"
                << "</head>\n"
                << "<body>";


    while (cin >> key >> colon ) {
        getline(cin, value);
        cout << value << "\n";

        switch( resolveOption(key) ){
            case PARAGRAPH: {
                newHTMLfile << "\n<p>" << value << "</p>\n";
                break;
            }case IMAGE: {
                newHTMLfile << "\n<img src=\"" << value << "\"/>\n";
                break;
            }case H1: {
                newHTMLfile << "\n<h1>" << value << "</h1>\n";
                break;
            }default: {
                //...
                break;
            }
        }
    }

    newHTMLfile << "\n</body>\n</html>";

    newHTMLfile.close();

    return 0;
}

The main differences are the following rows:

getline(cin, title);
...
while (cin >> key >> colon ) {
        getline(cin, value);
`

Now we are using cin

Some more redirection

Lets change our interface to something like this

$ ./a.out < html.txt > website.html

Our programs

• input is now html.txt

• and it outputs to website.html

#include <iostream>
using namespace std;

//for string switch - https://stackoverflow.com/questions/16388510/evaluate-a-string-with-a-switch-in-c/16388594
enum HTML_Options {
    TITLE,
    H1,
    PARAGRAPH,
    IMAGE,
    NOT_VALID
};

HTML_Options resolveOption(std::string input) {
    if( input == "title" ) return TITLE;
    else if( input == "p" ) return PARAGRAPH;
    else if( input == "img" ) return IMAGE;
    else if( input == "h1" ) return H1;
    return NOT_VALID;
}

int main() {
    string key, value;
    char colon; // colon is :
    string title;

    getline(cin, title);

    cout << "<!DOCTYPE html>\n"
                << "<html lang=\"en\">\n"
                << "<head>\n"
                << "    <meta charset=\"UTF-8\">\n"
                << "    <title>"<< title <<"</title>\n"
                << "</head>\n"
                << "<body>";

    while (cin >> key >> colon ) {
        getline(cin, value);

        switch( resolveOption(key) ){
            case PARAGRAPH: {
                cout << "\n<p>" << value << "</p>\n";
                break;
            }case IMAGE: {
                cout << "\n<img src=\"" << value << "\"/>\n";
                break;
            }case H1: {
                cout << "\n<h1>" << value << "</h1>\n";
                break;
            }default: {
                //...
                break;
            }
        }
    }
    cout << "\n</body>\n</html>";
    return 0;
}

Now we have

cout << "<!DOCTYPE html>\n"
 ...
cout << "\n<p>" << value << "</p>\n";

Some other things we could do is add ios::app to our output stream or some other flag

Serializing Objects

Lets try to serialize a student object

//@author https://thispointer.com/c-how-to-read-or-write-objects-in-file-serializing-deserializing-objects/
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <cassert>

class Student{
public:
    std::string mName;
    std::string mId;
    std::string mPhoneNumber;

    Student(std::string id = "", std::string name = "", std::string phone = "") : mId(id), mName(name), mPhoneNumber(phone)
    {}

    bool operator==(const Student & obj){
        return (mId == obj.mId) && (mName == obj.mName) && (mPhoneNumber == obj.mPhoneNumber);
    }

    //Write the member variables to stream objects
    friend std::ostream & operator << (std::ostream &out, const Student & obj){
        out << obj.mId << "\n" <<obj.mName<<"\n"<<obj.mPhoneNumber<<std::endl;
        return out;
    }

    // Read data from stream object and fill it in member variables
    friend std::istream & operator >> (std::istream &in,  Student &obj){
        in >> obj.mId;
        in >> obj.mName;
        in >> obj.mPhoneNumber;
        return in;
    }


};

int main(){
    Student stud1("1","Jack", "4445554455");
    Student stud2("4","Riti", "4445511111");
    Student stud3("6","Aadi", "4040404011");

    // Open the File
    std::ofstream out("students.txt");

    // Write objects to file
    out<<stud1;
    out<<stud2;
    out<<stud3;

    out.close();

    // Open the File
    std::ifstream in("students.txt");

    Student student1;
    Student student2;
    Student student3;

    // Read objects from file and fill in data
    in>>student1;
    in>>student2;
    in>>student3;

    in.close();

    // Compare the Objects
    assert(stud1==student1);
    assert(stud2==student2);
    assert(stud3==student3);

    return 0;
}

Read here if we would like to serialize this in binary format

Binary files

Input/output with files - C++ Tutorials

get and put stream positioning

All i/o streams objects keep internally -at least- one internal position:

• ifstream, like istream, keeps an internal get position with the location of the element to be read in the next input operation.

• ofstream, like ostream, keeps an internal put position with the location where the next element has to be written.

Finally, fstream, keeps both, the get and the put position, like iostream

seekg() and seekp()

These functions allow to change the location of the get and put positions

• seekg ( position );

• seekp ( position );

or

• seekg ( offset, direction );

• seekp ( offset, direction );

tellg() and tellp()

These two member functions with no parameters return a value of the member type streampos, which is a type representing the:

• current get position (in the case of tellg)

• the put position (in the case of tellp).

#include <iostream>
#include <fstream>
using namespace std;

int main () {
  streampos begin,end;
  ifstream myfile ("example.bin", ios::binary);
  begin = myfile.tellg();
  myfile.seekg (0, ios::end);
  end = myfile.tellg();
  myfile.close();
  cout << "size is: " << (end-begin) << " bytes.\n";
  return 0;
}

size is: 40 bytes.

Another example:

#include <iostream>
#include <fstream>
using namespace std;

int main () {
  streampos size;
  char * memblock;

  ifstream file ("example.bin", ios::in|ios::binary|ios::ate);
  if (file.is_open()){
    size = file.tellg();
    memblock = new char [size];
    file.seekg (0, ios::beg);
    file.read (memblock, size);
    file.close();

    cout << "the entire file content is in memory\n";

    delete[] memblock;
  }
  else cout << "Unable to open file";
  return 0;
}

Lets say we would like to Serializing & Deserializing Objects

//@author - Nissan
// based on https://www.youtube.com/watch?v=P7XGOBoVzW4
// read here https://stackoverflow.com/questions/49291594/c-munmap-chunk-invalid-pointer
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

class GameState{
    int hp;
    int level;
public:
    GameState(int h=100,int l=1):hp(h),level(l){}

    void info(){ cout <<"hp: " << hp << " level: " << level << endl; }

    friend ostream &operator<<(ostream &os, const GameState &gs) {
        os.write((char*) &gs.hp, sizeof(int));
        os.write((char*) &gs.level, sizeof(int));
        return os;
    }

    friend std::istream& operator>>(std::istream& is, GameState &gs) {
        is.seekg(0);//start from zero
        is.read((char *) &gs.hp, sizeof(int));
        is.read((char *) &gs.level, sizeof(int));
        return is;
    }

};


int main() {
    GameState p1(95, 25);
    GameState p2;

    fstream file("person.bin", ios::binary | ios::in | ios::out | ios::trunc);
    if(!file.is_open())
        cerr << "error opening";

    file << p1;
    file >> p2;

    p2.info();
    return 0;
}

hp: 95 level: 25

More advanced example

├── Figure
│     ├── Triangle (has points)
│ 
├── Point

//based on https://stackoverflow.com/questions/37038909/c-read-write-class-from-to-binary-file
#include <string>
#include <fstream>
#include <iostream>

class Point{
protected:
    int x;
    int y;
public:
    Point():x(0),y(0){}
    Point(int x,int y):x(x),y(y){}

    void write(std::ostream& f){
        // We can just write out the bytes for x and y because, they are primitive types stored in the class
        f.write( (char*)&x, sizeof(x) );
        f.write( (char*)&y, sizeof(y) );
    }
    void read(std::istream& f){
        // We can just read the bytes directly into x and y because, they are primitive types stored in the class
        f.read( (char*)&x, sizeof(x) );
        f.read( (char*)&y, sizeof(y) );
    }

    int getX() const { return x;}

    int getY() const {return y;}
};

class Figure{
    std::string name;
    std::string type;
public:
    Figure(){}
    Figure(std::string name,std::string type):name(name),type(type){}

    void write(std::ostream& f){
        size_t size;
        size = name.size();
        f.write( (char*)&size, sizeof(size_t) );  // size of "name" string
        f.write( (char*)name.c_str(), size );    // "name" string

        size = type.size();
        f.write( (char*)&size, sizeof(size_t) ); // size of "type" string
        f.write( (char*)type.c_str(), size );    // "type" string
    }

    void read(std::istream& f){
        size_t size;
        char *data;

        f.read( (char*)&size, sizeof(size) );
        data = new char[size+1];
        f.read( data, size );
        data[size]='\0';
        name = data;
        delete data;

        f.read( (char*)&size, sizeof(size) );
        data = new char[size+1];
        f.read( data, size );
        data[size]='\0';
        type = data;
        delete data;
    }
};

write() We need to store the data from the string along with the size because to restore it we need to temporarily read it somewhere before storing it in the std::string (istream::read() doesn't read directly to std::string)

read() When we read the string data we need somewhere to store it because we std::string isn't a primitive type. So we

• read the size

• allocate an array

• read the data into the array,

• load the std::string

• and delete the array

class Triangle: public Figure{
private:
    Point p1, p2, p3;
public:
    Triangle(){}
    Triangle(Point x,Point y,Point z,Figure f):p1(x),p2(y),p3(z),Figure(f){}

    void write(std::ostream& f){
        // First write the base class then write the members of this class
        Figure::write(f);
        p1.write(f);
        p2.write(f);
        p3.write(f);
    }
    void read(std::istream& f){
        // First read the base class then read the members of this class
        Figure::read(f);
        p1.read(f);
        p2.read(f);
        p3.read(f);
    }

    friend std::ostream &operator<<(std::ostream &os, const Triangle &tri) {
        os << "p1-> x:" << tri.p1.getX() << ", y:" << tri.p1.getY()
           << "\np2-> x:" << tri.p2.getX() << ", y:" <<tri.p2.getY()
           << "\np3-> x:" << tri.p3.getX() << ", y:" <<tri.p3.getY();
        return os;
    }
};

Lets explain the write():

• 1st we save/write the figure which contains the name and type

• 2nd we save each and every point

class BinaryFile{
    std::string FileName;
    std::fstream File;
public:
    BinaryFile(std::string FileName) : FileName(FileName) {};

    void WriteTriangle(){
        File.open(FileName, std::ios::binary | std::ios::out);
        if(!File)
        {
            std::cerr<<"File error <"<<FileName<<">\n";
            exit(1);
        }
        Triangle trig({1,2},{3,4},{5,6},{"name","type"}); // something new
        trig.write(File);
        File.close();
    }

    Triangle ReadTriangle(){
        File.open(FileName, std::ios::binary | std::ios::in);
        if(!File){
            std::cerr<<"File error <"<<FileName<<">\n";
            exit(1);
        }
        Triangle trig; // default values
        trig.read(File);
        File.close();
        return trig;
    }
};

int main(){
    BinaryFile bin("file.bin");
    bin.WriteTriangle();
    Triangle trig = bin.ReadTriangle();  // at this point trig has the values we stored

    std::cout << trig;
    return 0;
}

p1-> x:1, y:2
p2-> x:3, y:4
p3-> x:5, y:6

SFML version

#include <SFML/Graphics.hpp>
#include <time.h>
#include <list>
#include <cmath>
using namespace sf;

const int W = 1200;
const int H = 800;


//based on https://stackoverflow.com/questions/37038909/c-read-write-class-from-to-binary-file
#include <string>
#include <fstream>
#include <iostream>

class Point{
protected:
    int x;
    int y;
public:
    Point():x(0),y(0){}
    Point(int x,int y):x(x),y(y){}

    void write(std::ostream& f){
        // We can just write out the bytes for x and y because, they are primitive types stored in the class
        f.write( (char*)&x, sizeof(x) );
        f.write( (char*)&y, sizeof(y) );
    }
    void read(std::istream& f){
        // We can just read the bytes directly into x and y because, they are primitive types stored in the class
        f.read( (char*)&x, sizeof(x) );
        f.read( (char*)&y, sizeof(y) );
    }

    int getX() const { return x;}

    int getY() const {return y;}
};

class Figure{
    std::string name;
    std::string type;
public:
    Figure(){}
    Figure(std::string name,std::string type):name(name),type(type){}

    void write(std::ostream& f){
        size_t size;

        // we need to store the data from the string along with the size
        // because to restore it we need to temporarily read it somewhere
        // before storing it in the std::string (istream::read() doesn't
        // read directly to std::string)

        size = name.size();
        f.write( (char*)&size, sizeof(size_t) );
        f.write( (char*)name.c_str(), size );

        size = type.size();
        f.write( (char*)&size, sizeof(size_t) );
        f.write( (char*)type.c_str(), size );
    }

    void read(std::istream& f){
        size_t size;
        char *data;

        // when we read the string data we need somewhere to store it
        // because we std::string isn't a primitive type.  So we read
        // the size, allocate an array, read the data into the array,
        // load the std::string, and delete the array

        f.read( (char*)&size, sizeof(size) );
        data = new char[size+1];
        f.read( data, size );
        data[size]='\0';
        name = data;
        delete data;

        f.read( (char*)&size, sizeof(size) );
        data = new char[size+1];
        f.read( data, size );
        data[size]='\0';
        type = data;
        delete data;
    }
};

class Triangle: public Figure{
private:
    Point p1, p2, p3;
public:
    Triangle(){}
    Triangle(Point x,Point y,Point z,Figure f):p1(x),p2(y),p3(z),Figure(f){}

    void write(std::ostream& f){
        // First write the base class then write the members of this class
        Figure::write(f);
        p1.write(f);
        p2.write(f);
        p3.write(f);
    }
    void read(std::istream& f){
        // First read the base class then read the members of this class
        Figure::read(f);
        p1.read(f);
        p2.read(f);
        p3.read(f);
    }


    void draw(RenderWindow &app){
        sf::ConvexShape convex;

        // resize it to 5 points
        convex.setPointCount(5);

        // define the points
        convex.setPoint(0, sf::Vector2f(p1.getX(), p1.getY()));
        convex.setPoint(1, sf::Vector2f(p2.getX(), p2.getY()));
        convex.setPoint(2, sf::Vector2f(p3.getX(), p3.getY()));

        //===add color===
        convex.setFillColor(sf::Color(150, 50, 250));

        // set a 10-pixel wide orange outline
        convex.setOutlineThickness(10);
        convex.setOutlineColor(sf::Color(250, 150, 100));
        app.draw(convex);
    }


    friend std::ostream &operator<<(std::ostream &os, const Triangle &tri) {
        os << "p1-> x:" << tri.p1.getX() << ", y:" << tri.p1.getY()
           << "\np2-> x:" << tri.p2.getX() << ", y:" <<tri.p2.getY()
           << "\np3-> x:" << tri.p3.getX() << ", y:" <<tri.p3.getY();
        return os;
    }
};

class BinaryFile{
private:
    std::string FileName;
    std::fstream File;
public:
    BinaryFile(std::string FileName) : FileName(FileName) {};

    void WriteTriangle(Triangle& trig){
        File.open(FileName, std::ios::binary | std::ios::out);
        if(!File){
            std::cerr<<"File error <"<<FileName<<">\n";
            exit(1);
        }

        trig.write(File);
        File.close();
    }



    Triangle ReadTriangle(RenderWindow &app,Text& text){
        File.open(FileName, std::ios::binary | std::ios::in);

        //if no file prompt user
        if(!File){
            std::cerr<<"File error <"<<FileName<<">\n";
            text.setString("No file to open");
            app.clear(); //clear screen
            app.draw(text);
            return Triangle({0,0},{0,0},{0,0},{"name","type"});
        }
        Triangle trig; // default values
        trig.read(File);
        File.close();
        return trig;
    }
};

Triangle generateTriangle(){
    srand ( time(0) );
    int random_num = rand() % 10;
    random_num = 3;
    if(random_num >=5){
        return Triangle({100,200},{300,400},{100,400},{"name","type"});
    }else
        return Triangle({200,600},{500,600},{600,100},{"name","type"});

}

int main(){
    srand(time(0));

    sf::ContextSettings settings;
    settings.antialiasingLevel = 8; //take away jaggies

    sf::RenderWindow app(sf::VideoMode(W, H), "SFML shapes", sf::Style::Default, settings);
    app.setFramerateLimit(60);

    //Text on window
    sf::Text text;
    text.setFillColor(sf::Color::White);
    sf::Font font;
    font.loadFromFile("arial.ttf");
    text.setFont(font);


    Triangle trig;
    trig = generateTriangle();

    BinaryFile bin("file.bin");

    /////main loop/////
    while (app.isOpen()){
        Event event;
        while (app.pollEvent(event)){
            if (event.type == Event::Closed)
                app.close();

            if (Keyboard::isKeyPressed(Keyboard::S)){
                app.clear(); //clear screen
                text.setString("Pressed S - save file");
                text.setCharacterSize(24); // in pixels, not points!

                bin.WriteTriangle(trig);
            }
            if (Keyboard::isKeyPressed(Keyboard::O)){
                app.clear(); //clear screen

                text.setString("Pressed O - open file");
                text.setCharacterSize(24); // in pixels, not points!

                trig = bin.ReadTriangle(app,text); //added app,text to display error if no file
                // at this point trig has the values we stored
                std::cout << trig;
            }
            if (Keyboard::isKeyPressed(Keyboard::G)){
                app.clear(); //clear screen
                text.setString("Pressed G - generate triangle");
                trig = generateTriangle();
            }


        }


        //////draw//////
        trig.draw(app);
        app.draw(text);
        app.display();
    }
    return 0;
}

all: main.cpp
    g++ -c main.cpp -std=c++17 && g++ main.o -o sfml-app -lsfml-graphics -lsfml-window -lsfml-system -std=c++17

TODO fix genertaion of triangles

Add Fighter and Ninja

Saving high score tutorial

More tutorials on iostream