For a long time I've been upset with C++ standard input/output. First of all, I heard that fread/fwrite are much faster than everything else, and it's impossible to get good times on problems with huge input or output without using those. Secondly, it's really annoying to write formatting string and ampersands in scanf, especially with many variables to read. Thirdly, the only way to expand I/O to custom types is by overloading << and >> operators on streams, but they are the slowest. I tried to tackle all these issues in my implementation. Remember, that it's targeted for the common use case in programming contests, so it's not as flexible as one might wish.

The code is here Doesn't compile with MSVS.

I apologize in advance to everyone, who will be scrolling through this 500 lines trying to read my solutions. Also it's not advised for people without broad experience with C++ to try to understand the entirety of it (dangerous for your mental health). There are 3 major components.

1. File management

This is done by classes InputFile and OutputFile. Indeed, I use fread/fwrite with a buffer of size 2¹², but there is one catch. fread doesn't work for interactive problems, because input isn't fully buffered there, it's line buffered. I use fgets in this case, but make sure to call correct constructor, it should look like this (input and output are smart pointers):

#ifdef ONLINE_JUDGE
  input.reset(new InputFile(stdin, false));    // usual problem
  input.reset(new InputFile());                // interactive problem
  output.reset(new OutputFile());
#else
  input.reset(new InputFile());                // local testing using a console
  input.reset(new InputFile("input.txt"));     // local testing using a file
  output.reset(new OutputFile());              // output to console
  output.reset(new OutputFile("output.txt"));  // output to a file
#endif

Also it's possible to read or write to a string using InputString and OutputString classes. They are used similarly:

string s;
input.reset(new InputString(s));
output.reset(new OutputString(s));

2. String parsing

Next step is to convert standard types to/from a buffer of characters. To my deepest disappointment, even this problem isn't solved efficiently in standard C++ library. Just look at this benchmarks (situation with atoi and atod is similar):

https://github.com/miloyip/itoa-benchmark
https://github.com/miloyip/dtoa-benchmark

I didn't want to go too deep, so I used the simplest code to read/write integer types similar to this one 16792284. Then, I cheated with double treating it as two integers separated by a decimal point. This approach won't work for huge numbers or precision of more than 18 digits after the decimal point, but I've never seen such cases in the programming contests. All related methods are located inside InputDevice and OutputDevice classes.

3. User interface

Everything above was about being efficient. But the main goal during a contest is to code fast, so I wrapped all the efficiency into functions read/write, similar to scanf/printf. Of course, they offer much more. You don't need to write format strings. Range input and output are supported. You can read a string until the character satisfies some termination criterion. Write will insert delimiters for you automatically and can be configured with setPrecision, setFill and other modifiers similar to the ones in iomanip header. Full list of supported parameters is given in the comment after the code. Here's an example of reading and writing n, m, then n by m character grid (without whitespaces), then array a of length n, then array b of length m:

const int N = 1001;
int n, m;
char s[N][N];
int a[N], b[N];

read(n, m, s, n, a, n, b, m);
writeln(n, m, '\n', setDelimiter("\n"), s, n);
writeln(setDelimiter(", "), a, n, '\n', b, m);

Another feature is extensibility, for example you can create your own Point class, implement read and write methods for it, and use it later combined with all other features, for example read an array and then 2 more points.

template <class T>
struct Point {
  T x, y;

  bool read(InputDevice& input) { return input.read(x, y); }
  int write(OutputDevice& output) const { return output.write(x, ',', y); }
};

// later in the code
const int N = 1001;
int n;
Point<int> p[N], s, t;

read(n, p, n, s, t);
writeln(n, setDelimiter("\n"), p, n, s, setDelimiter(), t);

Speed

I spent a lot of time optimizing the code. To prove it, I included my methods in this benchmark. Below are the results with clang compiler (my methods are named fast).

int, printf         1.34   1.43   1.33
int, cout           7.22   6.78   6.72
int, custom/out     3.41   3.46   3.53
int, fast/out       0.28   0.27   0.28
int, scanf          1.20   1.21   1.14
int, cin           24.93  25.29  26.27
int, custom/in      3.08   3.04   3.02
int, fast/in        0.14   0.14   0.15
double, printf      3.17   3.20   3.16
double, cout       12.60  12.67  12.76
double, fast/out    0.60   0.61   0.59
double, scanf       2.06   2.17   2.00
double, cin        46.38  43.31  45.82
double, fast/in     0.40   0.39   0.36
char, putchar       4.28   4.16   4.24
char, cout          6.37   6.57   6.68
char, fast/out      0.36   0.37   0.37
char, getchar       4.08   4.02   3.83
char, cin           4.95   5.03   5.21
char, fast/in       0.29   0.29   0.28
char *, printf      0.82   0.80   0.80
char *, puts        0.81   0.81   0.81
char *, cout       11.76  11.97  10.93
char *, fast/out    0.22   0.22   0.23
char *, scanf       0.89   0.89   0.93
char *, fgets       0.53   0.53   0.53
char *, cin        23.91  23.44  22.71
char *, fast/in     0.25   0.24   0.25

Update 01/29/2017

• Custom types must implement member functions read and write to be supported.
• read now returns bool success flag instead of number of arguments read.
• Floating point write bug was fixed. It caused errors on numbers like 1 - ε because of rounding.
• is_iterator trait was implemented and SFINAE was improved. This fixed ambiguous overload resolution that happened in some cases.
• write and read methods were moved inside classes to improve flexibility. Out of class methods now simply forward the parameters.
• Oversight was fixed which made calls like write(vector.begin(), vector.size()) impossible, because only int size was supported.
• complex and string are now fully supported.
• Some erroneous calls could compile with unexpected results instead of giving CE. This was fixed.