Printing to the console vs writing to a file (speed)

In C++, which would be faster if repeated, say, 5000 times:

cout << "text!" << endl;

or

my_text_file << "text!" << endl;

(writing to a file vs. cout-ing to the console)

Edit:

I ask because when writing to the console, you see all the 开发者_StackOverflow中文版text being printed which seems like it would slow down the loop. In a file, you arn't seeing the text being printed, which seems as if it would take less time.

Just tested it:

Console: > 2000 ms using endl and \n

File: 40 ms with endl and 4 ms with \n

Writing to a file would be much faster. This is especially true since you are flushing the buffer after every line with endl.

On a side note, you could speed the printing significantly by doing repeating cout << "text!\n"; 5000 times, then flushing the buffer using flush().

It's not that much faster...

A test of 1 million couts with endl (clear buffer):

Results:

console cout time: 2.87001
file cout time: 2.33776

Code:

class Timer
{
        struct timespec startTime, endTime;
        double sec;
public:
        void start();
        void stop();
        double getSec();
};

void Timer::start()
{
        clock_gettime(CLOCK_MONOTONIC, &startTime);
}
void Timer::stop()
{
        clock_gettime(CLOCK_MONOTONIC, &endTime);
        sec = (endTime.tv_sec - startTime.tv_sec);
        sec += (endTime.tv_nsec - startTime.tv_nsec) / 1000000000.0;
}
double Timer::getSec()
{
        return sec;
}


int main(){
        int ntests = 1000000;
        Timer t1 = Timer(), t2 = Timer();

        t1.start();
        for(int c=0;c<ntests;c++)
        {
                cout << "0" << endl;
        }
        t1.stop();

        ofstream out("out.txt");
        streambuf *coutbuf = cout.rdbuf();
        cout.rdbuf(out.rdbuf());
        t2.start();
        for(int c=0;c<ntests;c++)
        {
                cout << "0" << endl;
        }
        t2.stop();
        cout.rdbuf(coutbuf);

        cout << "console cout time: " << t1.getSec() << endl;
        cout << "file cout time: " << t2.getSec() << endl;
}

Build and run:

g++ test.cpp -o test -lrt && ./test && rm out.txt

In addition to console I/O generally being relatively slow, the default configuration of the standard streams cout and cin has some issues that will greatly slow performance if not corrected.

The reason is that the standard mandates that, by default, cout and cin from the C++ iostream library should work alongside stdout and stdin from the C stdio library in the expected way.

This basically means that cout and cin can't do any buffering at all in its internal streambufs and basically forwards all I/O operations over to the C library.

If you want to do anything resembling high performance I/O with the standard streams, you need to turn off this synchronization with

std::ios_base::sync_with_stdio(false);

before doing any I/O.

Writing the same amount of data, with the same buffer size to the console will most definitely be faster than writing to a file.

You can speed up your write speed (both for console output, and file output) by not writing out the buffer with every line (i.e.- don't use std::endl after every line, as it both adds an endline to the stream, and writes the buffer). Instead use "\n" unless you need to ensure the buffer is output for some reason.