Question: I don't know if this is true, but when I was reading FAQ on one of the problem providing sites, I found something, that poke my attention:

> 
> Check your input/output methods. In C++, using cin and cout is too slow. Use these, and you will guarantee not being able to solve any problem with a decent amount of input or output. Use printf and scanf instead.
> 
> 
> 

Can someone please clarify this? Is really using *scanf()* in C++ programs faster than using *cin >> something* ? If yes, that is it a good practice to use it in C++ programs? I thought that it was C specific, though I am just learning C++...

Answer: 
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 seconds
scanf 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](https://stackoverflow.com/a/15939289/462335) 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 seconds
scanf version:                           6.8 seconds
iostream 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>
The statements `cin` and `cout` in general use seem to be slower than `scanf` and `printf` in C++, but actually they are FASTER!

The thing is: In C++, whenever you use `cin` and `cout`, a synchronization process takes place by default that makes sure that if you use both `scanf` and `cin` in your program, then they both work in sync with each other. This sync process takes time. Hence `cin` and `cout` APPEAR to be slower.

However, if the synchronization process is set to not occur, `cin` is faster than `scanf`.

To skip the sync process, include the following code snippet in your program right in the beginning of `main()`:

```
std::ios::sync_with_stdio(false);

```

Visit [this site](http://www.cplusplus.com/reference/ios/ios_base/sync_with_stdio/) for more information.