ifs.seekg(0, std::ios::end);

size_t size = ifs.tellg();

data_read.resize(size);

ifs.seekg(0);

ifs.read(&data_read[0], size);

ifs.close();

// # Scope

{

/*

{

int s = 1;

struct s {int i;};

assert(s == 1);

// ERROR

//s t = {1};

struct s t = {1};

assert(t.i == 1);

int c = 1;

class c { public: int i; };

assert(c == 1);

// ERROR

//c u = {1};

class c u = {1};

assert(u.i == 1);

}

}

/*

{

int i = 0, j = 1, k = 2;

(i = j) = k;

assert(i == 2);

assert(j == 1);

assert(k == 2);

// ERROR: as in C, most other operators do not return lvalues

//(i + j) = k;

}

/*

/*

{

// Vector class. Has overhead, but probably the best option given its flexibility.

// #array class. No overhead. Fixed size. Template based.

{

// WARN: double brackets required TODO why

//std::array<int, 3> a{0, 1, 2};

std::array<int, 3> a{{0, 1, 2}};

assert(a.size() == 3);

}

// Method which I don't understand.

{

//template<class T, size_t N>

//size_t size(T (&)[N]) { return N; }

}

}

/*

{

std::srand(time(NULL));

{

int i = 1;

i = std::rand();

// ERROR: the size would not be fixed

//int is[i];

}

{

// Compile time constant since the literal 1 is a constant expression.

const int ci = 1;

// Cannot do that, so the size is fixed!

//ci = 2;

int is[ci];

}

// ERROR: the compiler is able to see that ci is not a compile time constant

{

const int ci = std::rand();

//int is[ci];

}

}

/*

{

{

//cin >> i;

//int is4[i];

}

{

// ERROR: may not be initialized

//cin >> i;

//int is4[i] = {1, 2};

}

}

// # enum

{

// Unlike C, already does typedef, no need to write enum all the time.

{

enum E {A, B, C};

E e = A;

}

#if __cplusplus >= 201103L

// Set storage size.

{

enum E : char {A, B, C};

assert(sizeof(E) == sizeof(char));

}

#endif

}

// # for

{

//you can define i inside the for scope only

int is[] = {0, 1, 2};

for (int i=0; i<3; i++)

{

assert(i == is[i]);

// ERROR: already declared in this scope

//int i;

}

}

// # stdlib

//

// # Standard library

{

/*

{

/*

{

std::cout << "cout" << std::endl;

std::cerr << "cerr" << std::endl;

std::clog << "clog" << std::endl;

}

/*

{

//std::cout << "Enter an integer:" << endl;

//std::cin >> i;

//std::cout << i << std::endl;

}

// This is how a very explicit usage of `<<` would look like

{

std::stringstream ss;

//TODO0 how to get his working?

//std::operator<<<std::ostream,std::string>(ss, "explicit");

std::operator<<(std::operator<<(ss, "explicit "), "call");

}

// #<< left shift overload

{

}

// #>> right shift overload istream

// Get input out of streams into string.

// Overloaded for many different types of inputs: <http://www.cplusplus.com/reference/istream/istream/operator%3E%3E/>

{

// char*, std::string

// - skip whitespace as defined by `isspace`.

// - read until first whitespace found

{

std::stringstream ss("ab cd\tef \t\ngh i.;)j");

std::string s;

ss >> s;

assert(s == "ab");

ss >> s;

assert(s == "cd");

ss >> s;

assert(s == "ef");

ss >> s;

assert(s == "gh");

ss >> s;

assert(s == "i.;)j");

}

// Numeric types: int, float.

// - skip whitespace as defined by `isspace`.

// - read until cannot be part of the type anymore (TODO what does that mean exactly?)

{

std::stringstream ss("1.0 2 \n \t 3.0f 4a a");

float f;

std::string s;

ss >> f;

assert(f == 1.0f);

ss >> f;

assert(f == 2.0f);

ss >> f;

assert(f == 3.0f);

// f suffix is not part of floats

ss >> s;

assert(s == "f");

ss >> f;

// TODO what happens? Error checking.

}

// Since `>>` returns the istream, it is possible to chain calls:

{

std::stringstream ss("1 1.5 2");

int i, j;

float f;

ss >> i >> f >> j;

assert(i == 1);

assert(f == 1.5);

assert(j == 2);

}

}

/*

{

/*

{

std::stringstream ss;

ss << std::boolalpha << true;

assert(ss.str() == "true");

ss.str("");

ss << std::noboolalpha << true;

assert(ss.str() == "1");

ss.str("");

//default is noboolalpha

ss << true;

assert(ss.str() == "1");

ss.str("");

}

/*

{

std::stringstream ss;

ss << std::boolalpha;

ss << true;

assert(ss.str() == "true");

ss.str("");

//does not clear earlier passed options

ss << true;

assert(ss.str() == "true");

ss.str("");

ss << std::noboolalpha;

ss << true;

assert(ss.str() == "1");

ss.str("");

}

/*

{

std::stringstream ss;

int i = 12;

ss.width(4);

ss.fill(' ');

ss << std::left << i;

assert(ss.str() == "12 ");

ss.str("");

ss << std::right << i;

//assert(ss.str() == " 12");

//why fails?

ss.str("");

}

/*

{

std::stringstream ss;

ss << std::hex << 10;

assert(ss.str() == "a");

ss.str("");

ss << std::oct << 10;

assert(ss.str() == "12");

ss.str("");

ss << std::dec << 10;

assert(ss.str() == "10");

ss.str("");

ss << 10;

assert(ss.str() == "10");

ss.str("");

}

/*

{

std::stringstream ss;

ss.precision(3);

float f = 1.2345;

//none is the default

ss << f;

assert(ss.str() == "1.23");

ss.str("");

ss << std::fixed << f;

assert(ss.str() == "1.235");

ss.str("");

ss << std::scientific << f;

assert(ss.str() == "1.235e+00");

ss.str("");

/*

{

ss.unsetf(std::ios_base::floatfield);

ss << f;

assert(ss.str() == "1.23");

ss.str("");

}

}

}

/*

{

std::string path("fileio.tmp");

std::string data("ab\n\nc\n");

// Write to file.

{

std::ofstream ofs(path);

if (ofs) {

ofs << data;

ofs.close();

} else {

ios_write_fail(path);

}

}

/*

{

std::ifstream ifs(path);

if (ifs) {

std::string data_read;

read_file(ifs, data_read);

assert(data_read == data);

} else {

ios_read_fail(path);

}

}

/*

{

std::string data = "abc\ndef\n";

std::string src_path = "src.tmp";

std::string dst_path = "dst.tmp";

// Create input file.

{

std::ofstream src(src_path, std::ios::binary);

src << data;

// 2 times 4 Gb.

//for (int i = 0; i < 2; i++) {

//for (int j = 0; j < 0xFFFFFFFF; j++) {

//src << std::hex << j;

//}

//}

src.close();

}

// Copy.

std::ifstream src(src_path, std::ios::binary);

std::ofstream dst(dst_path, std::ios::binary);

dst << src.rdbuf();

src.close();

dst.close();

// Check copy.

{

std::ifstream dst(dst_path, std::ios::binary);

std::string data_read;

read_file(dst, data_read);

assert(data_read == data);

src.close();

}

}

/*

{

}

// # Append to file

{

std::ofstream ofs(path);

if (ofs) {

ofs << data;

ofs.close();

} else {

ios_write_fail(path);

}

/*

//ofs.clear()

ofs.open(path, std::ios::app);

if (ofs) {

ofs << data;

ofs.close();

} else {

ios_write_fail(path);

}

std::ifstream ifs(path);

if (ifs) {

std::string data_read;

read_file(ifs, data_read);

assert(data_read == data + data);

} else {

ios_read_fail(path);

}

}

/*

{

// TODO

//std::string path("binary.tmp");

//std::vector<int> data{0x123, 0x456};

//std::vector<int>::size_type size = data.size();

//std::vector<int> data_read(size);

//std::ofstream ofs(path, std::ios::binary);

//if (ofs) {

//ofs.write(&data[0], size);

//ofs.close();

//} else {

//ios_write_fail(path);

//}

//std::ifstream ifs(path);

//if (ifs) {

//std::string data_read;

//read_file(ifs, data_read);

//assert(data_read == data);

//} else {

//ios_read_fail(path);

//}

}

/*

{

std::string path("i_dont_exist.tmp");

std::ifstream ifs(path);

if (ifs) {

} else {

try {

throw std::ios_base::failure("Error: Could not write to file: " + path);

} catch (std::ios_base::failure e) {

std::clog << e.what() << std::endl;

}

}

}

// # ios::in: flag automatically set for ifstream, but not fstream

//http://stackoverflow.com/questions/7463410/is-iosin-needed-for-ifstreams-opened-in-binary-mode

}

}

/*

}

/*

return EXIT_SUCCESS;

// global/static destructors happen at exit time.