std::endl

Inserisce un carattere in linea di fondo campo os sequenza di emissione e vampate come se chiamando os.put(os.widen('\n')) seguita da os.flush().

Si tratta di un solo output manipolatore di I / O, può essere chiamato con espressioni quali out << std::endl per qualsiasi out di std::basic_ostream tipo.

Questo manipolatore può essere usato per produrre una linea di uscita immediatamente, ad esempio durante la visualizzazione di uscita da un processo di lunga durata, la registrazione delle attività di più thread o la registrazione di attività di un programma che potrebbe bloccarsi in modo imprevisto. Un filo esplicito std::cout è necessario anche prima di una chiamata a std::system, se il processo generato esegue qualsiasi schermata I / O (un esempio comune è std::system("pause") su Windows). Nella maggior parte degli altri soliti interattivi I / O scenari, std::endl è ridondante se utilizzato con std::cout perch�� ogni input da std::cin, uscita std::cerr, o cessazione programma forza una chiamata a std::cout.flush(). L'uso di std::endl al posto di '\n', incoraggiato da alcune fonti, può significativamente degradare le prestazioni di uscita.

In molte implementazioni, lo standard output è line-buffered, e '\n' scrittura provoca un colore in ogni caso, a meno che non std::cout.sync_with_stdio(false) è stato giustiziato. In tali situazioni, endl inutile degrada solo le prestazioni del file di output non standard output.

Gli esempi di codice in questo follow Bjarne Stroustrup wiki a Flushing lo standard output solo se necessario.

Quando una linea incompleta di uscita deve essere lavata, il manipolatore std::flush può essere utilizzato.

Quando tutti i caratteri di uscita deve essere lavata, il manipolatore std::unitbuf può essere utilizzato.

os (riferimento al flusso dopo la manipolazione)

#include <iostream>
#include <chrono>
template<typename Diff>
void log_progress(Diff d)
{
    std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(d).count()
              << " ms passed" << std::endl;
}
int main()
{
    std::cout.sync_with_stdio(false); // on some platforms, stdout flushes on \n
    volatile int sink=0;
 
    auto t1 = std::chrono::high_resolution_clock::now();
    for(int j=0; j<5; ++j)
    {
        for(int n=0; n<10000; ++n)
            for(int m=0; m<20000; ++m)
                sink += m*n; // do some work
        auto now = std::chrono::high_resolution_clock::now();
        log_progress(now - t1);
    }
}

487 ms passed
974 ms passed
1470 ms passed
1965 ms passed
2455 ms passed