Using scanf() in C++ programs is faster than using cin?

Here's a quick test of a simple case: a program to read a list of numbers from standard input and XOR all of the numbers.

iostream version:

#include <iostream>int main(int argc, char **argv) {  int parity = 0;  int x;  while (std::cin >> x)    parity ^= x;  std::cout << parity << std::endl;  return 0;}

scanf version:

#include <stdio.h>int main(int argc, char **argv) {  int parity = 0;  int x;  while (1 == scanf("%d", &x))    parity ^= x;  printf("%d\n", parity);  return 0;}

Results

Using a third program, I generated a text file containing 33,280,276 random numbers. The execution times are:

iostream version:  24.3 secondsscanf version:      6.4 seconds

Changing the compiler's optimization settings didn't seem to change the results much at all.

Thus: there really is a speed difference.

EDIT: User clyfish points out below that the speed difference is largely due to the iostream I/O functions maintaining synchronization with the C I/O functions. We can turn this off with a call to std::ios::sync_with_stdio(false);:

#include <iostream>int main(int argc, char **argv) {  int parity = 0;  int x;  std::ios::sync_with_stdio(false);  while (std::cin >> x)    parity ^= x;  std::cout << parity << std::endl;  return 0;}

New results:

iostream version:                       21.9 secondsscanf version:                           6.8 secondsiostream with sync_with_stdio(false):    5.5 seconds

C++ iostream wins! It turns out that this internal syncing / flushing is what normally slows down iostream i/o. If we're not mixing stdio and iostream, we can turn it off, and then iostream is fastest.

The code: https://gist.github.com/3845568

http://www.quora.com/Is-cin-cout-slower-than-scanf-printf/answer/Aditya-Vishwakarma

Performance of cin/cout can be slow because they need to keep themselves in sync with the underlying C library. This is essential if both C IO and C++ IO is going to be used.

However, if you only going to use C++ IO, then simply use the below line before any IO operations.

std::ios::sync_with_stdio(false);

For more info on this, look at the corresponding libstdc++ docs.

Probably scanf is somewhat faster than using streams. Although streams provide a lot of type safety, and do not have to parse format strings at runtime, it usually has an advantage of not requiring excessive memory allocations (this depends on your compiler and runtime). That said, unless performance is your only end goal and you are in the critical path then you should really favour the safer (slower) methods.

There is a very delicious article written here by Herb Sutter "The String Formatters of Manor Farm" who goes into a lot of detail of the performance of string formatters like sscanf and lexical_cast and what kind of things were making them run slowly or quickly. This is kind of analogous, probably to the kind of things that would affect performance between C style IO and C++ style. The main difference with the formatters tended to be the type safety and the number of memory allocations.