Input/output. Remember std::ostream? std::istream std::ostream. std::ostream cin std::istream. namespace std { class ostream { /*...

Transcription

1 Input/output Remember std::ostream? namespace std { class ostream { /*... */ }; } extern istream cin; extern ostream cout; extern ostream cerr; extern ostream clog; 7 / 24 std::istream std::ostream std cout cerr std::ostream cin std::istream clog std

2 Input/output Remember std::ostream? ostream operator << (bool&) : ostream& operator << (int&) : ostream& operator << (double&) : ostream&... write(char*, streamsize) : ostream& 8 / 24 std::ostream int double std::ostream std::ostream write std::ostream

3 Input/output Remember std::ostream? string name = /*... */; std::cout << name << "\n"; namespace std { ostream& operator << (ostream&, const std::string&); } Evaluation: (std::cout << name) << "\n"; (an ostream&) << "\n"; 9 / 24 cout ostream ostream

4 Input/output Remember std::ostream? Can write our own operators: using namespace std; ostream& operator << (ostream& o, Student& s) { o << s.name() << " (" << s.id() << ")"; return o; } 10 / 24 std::ostream

5 Input/output std::istream istream operator >> (bool&) : istream& operator >> (int&) : istream& operator >> (double&) : istream&... read(char*, streamsize) : istream& 11 / 24 std::istream

6 Input/output std::istream string name; unsigned int age; std::cout << "Please enter your name and age: "; std::cin >> name >> age; namespace std { istream& operator >> (istream&, const std::string&); } (std::cin >> name) >> age; (an istream&) >> age; 12 / 24 std::istream std::string int std::ostream

7 Input/output std::istream We can write extraction operators too! std::istream& operator >> (std::istream&, StudentID&); 13 / 24

8 Input/output std::istream using namespace std; istream& operator >> (istream& i, StudentID& id) { /*... */ unsigned int raw; i >> raw; id.year = (raw / ); id.serial = (raw % ); } return i; 14 / StudentID StudentID const

9 std::fstream istream operator >> (bool&) : istream& operator >> (int&) : istream& operator >> (double&) : istream&... read(char*, streamsize) : istream& ostream operator << (bool&) : ostream& operator << (int&) : ostream& operator << (double&) : ostream&... write(char*, streamsize) : ostream& ifstream ofstream fstream 15 / 24 std::fstream std::istream std::ostream fstream ifstream istream fstream ofstream ostream istream ostream fstream

10 Use like any istream or ostream: ifstream file(filename); StudentID id; file >> id; With a couple of caveats: if (not file.good()) { /*... */ } StudentID id; file >> id; if (file.eof()) { /*... */ } 16 / 24 cin cout fstream std::cout close() fstream bad() std::fstream eof() good()

11 Binary file I/O fstream f("tmp.dat", ios::out ios::binary); f.write(somearrayofcharacters, length); f.close(); f.open("tmp.dat", ios::in ios::binary); f.read(somearrayofcharacters, length); f.close(); ostream::read and ostream::write require a char array We only have a StudentID! 17 / 24 read write std::fstream fstream ios::out ios::binary read write char* char char StudentID read write char* char char* Student

12 Binary file I/O Our Student is an object in memory: 18 / 24 Student

13 Binary file I/O We could also look at this object as an array of bytes: 19 / 24 fstream read write

14 Binary file I/O "I know this isn't actually a char[], just trust me." Sounds like a job for... reinterpret_cast 20 / 24 char char StudentID reinterpret_cast

15 Binary file I/O Recall: const_cast : treat const value as non-const static_cast : everything known at compile time dynamic_cast : only fully known at run time 21 / 24 static_cast const_cast double double int const dynamic_cast Shape* Circle Rectangle dynamic_cast Shape* Circle* Shape Circle nullptr std::bad_cast

16 Binary file I/O dynamic_cast convert to a subclass reference/pointer dynamic check: "is this correct?" (safety net) reinterpret_cast convert to any reference/pointer no safety net! 22 / 24 dynamic_cast reinterpret_cast reinterpret_cast

17 Binary file I/O Student s = /*... */; char *rawdata = reinterpret_cast<char*>(&student); f.write(rawdata, sizeof(s)); f.close(); constexpr size_t Length = sizeof(student); char buffer[length]; f.open("tmp.dat", ios::in ios::binary); f.read(buffer, Length); f.close(); Student *s = reinterpret_cast<student*>(buffer); 23 / 24 reinterpret_cast

18 Binary file I/O a bit simplistic assumes complete, contiguous objects what about pointers? vtables? class Foo : public Super { Bar* somedata; }; 24 / 24