Styjun

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <ctime>

int main(int argc, char* argv[])

 std::clock_t start;
 double duration; 

 std::cout << "Starting std::cout test." << std::endl;
 start = std::clock();

 for (int i = 0; i < 1000; i++)
 
 std::cout << "Hello, World! (" << i << ")" << std::endl;
 

 duration = (std::clock() - start) / (double) CLOCKS_PER_SEC;

 std::cout << "Ending std::cout test." << std::endl;
 std::cout << "Time taken: " << duration << std::endl;

 std::system("pause");

 std::cout << "Starting std::printf test." << std::endl;
 start = std::clock();

 for (int i = 0; i < 1000; i++)
 
 std::printf("Hello, World! (%i)n", i);
 std::fflush(stdout);
 

 duration = (std::clock() - start) / (double) CLOCKS_PER_SEC;

 std::cout << "Ending std::printf test." << std::endl;
 std::cout << "Time taken: " << duration << std::endl;

 system("pause");

 return 0;

Now, here are the times for the first five runs:

• std::cout test: 1.125 s ; printf test: 0.195 s


• std::cout test: 1.154 s ; printf test: 0.230 s


• std::cout test: 1.142 s ; printf test: 0.216 s


• std::cout test: 1.322 s ; printf test: 0.221 s


• std::cout test: 1.108 s ; printf test: 0.232 s

As you can see, using printf and then fflushing takes about 5 times less time than using std::cout.

Although I did expect using std::cout's << operator to be perhaps a little slower (almost minimal) , I wasn't prepared for this huge difference. Am I making a fair test? If so, then what makes the first test so much slower than the second one, if they essentially do the exact same thing?

For a true apples-to-apples comparison, re-write your test so that the only thing changing between the test cases is the print function being used:

int main(int argc, char* argv[])

 const char* teststring = "Test output stringn";
 std::clock_t start;
 double duration;

 std::cout << "Starting std::cout test." << std::endl;
 start = std::clock();

 for (int i = 0; i < 1000; i++)
 std::cout << teststring;
 /* Display timing results, code trimmed for brevity */

 for (int i = 0; i < 1000; i++) 
 std::printf(teststring);
 std::fflush(stdout);
 
 /* Display timing results, code trimmed for brevity */
 return 0;

With that, you will be testing nothing but the differences between the printf and cout function calls. You won't incur any differences due to multiple << calls, etc. If you try this, I suspect that you'll get a much different result.

Try this:

#include <cstdlib>
#include <cstdio>
#include <ctime>
#include <iostream>

int main(int argc, char* argv[])

#if defined(NOSYNC)
 std::cout.sync_with_stdio(false);
#endif

 std::cout << "Starting std::cout test." << std::endl;

 std::clock_t start = std::clock();

 for (int i = 0; i < 1000; i++)
 
 std::cout << "Hello, World! (" << i << ")" << std::endl;
 

 clock_t mid = std::clock();

 for (int i = 0; i < 1000; i++)
 
 std::printf("Hello, World! (%i)n", i); 
 std::fflush(stdout);
 

 std::clock_t end = std::clock();

 std::cout << "Time taken: P1 " << ((mid-start)*1.0/CLOCKS_PER_SEC) << std::endl;

 std::cout << "Time taken: P2 " << ((end-mid)*1.0/CLOCKS_PER_SEC) << std::endl;


 return 0;

Then I get:

> g++ -O3 t13.cpp
> ./a.out
# lots of lines deleted
Time taken: P1 0.002517
Time taken: P2 0.001872

> g++ -O3 t13.cpp -DNOSYNC 
> ./a.out
# lots of lines deleted
Time taken: P1 0.002398
Time taken: P2 0.001878

So the P2 times do not change.

But you get an improvement of the P1 times (ie std::cout) using std::cout.sync_with_stdio(false);. Becuase the code no longer tries to keep the two stream (std::cout stdout) synchronized. Which if you are writing pure C++ and only using std::cout not a problem.

use

cout << "n";

to prevent buffering. much faster

About 10 years ago, Scott Meyers tested the efficiency of iostream and scanf/printf. Depends on the compiler and environment, sometimes scanf/printf is 20% faster than iostream, sometimes even 200% faster. But iostream was never faster than scanf/printf. According to other two given examples, scanf/printf is still faster than iostream.
However, Meyers said that "On a really useful program, there would be no differences."
According to Google''s programming style([http://google-styleguide.googlecode.com/svn/trunk/cppguide.html]), streams should not be used except for logging.
A replacement for iostream is to encapsule scanf/printf yourself.

I only have a programming range of 1 computer, so not much testing. Anyhow, std::cout is way more faster on my build using the exact verbose code. I am using Cpp14.

I just think certain people have a pick for C++. Yes C is great language but logically I don't see how printf can be faster than std cout. Printf has to do type conversions from void pointer on runtime. Cout does that at compile time.

I tried this test on my laptop, running Windows 10, WSL Ubuntu, CLion 2018, GCC. No optimization:

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <ctime>

int main(int argc, char *argv[]) 
 std::ios_base::sync_with_stdio(false);
 std::cin.tie(nullptr);
 std::clock_t start;
 double duration1, duration2;

 std::cout << "Starting std::cout test.n";
 start = std::clock();

 for (int i = 0; i < 100000; i++) 
 std::cout << "Hello, World! (" << i << ")" << std::endl;
 

 duration1 = (std::clock() - start) / (double) CLOCKS_PER_SEC;

 std::cout << "Starting std::printf test.n";
 start = std::clock();

 for (int i = 0; i < 100000; i++) 
 std::printf("Hello, World! (%i)n", i);
 std::fflush(stdout);
 

 duration2 = (std::clock() - start) / (double) CLOCKS_PER_SEC;

 std::cout << "Time taken: cout " << duration1 << std::endl;
 std::cout << "Time taken Printf: " << duration2 << std::endl;

 return 0;

Results:

Test1: Cout: 2.25, Printf: 2.45312 (Cout run first)
Test2: Cout: 2.42188, Printf: 2.07812 (Printf Run first)
Test3: Cout: 2.26562, Printf: 2.25 (Cout run first)
Test4: Cout 2.46875, Printf: 2.57812 (Printf run first)

TL;DR: Using std::ios_base::sync_with_stdio(false) and std::cin.tie(nullptr) brings both functions to almost the same stand.