printf mehr als 5-mal schneller als std::cout?

#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;
}

Nun, hier sind die Zeiten für die ersten fünf Läufe:

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

Wie Sie sehen können, mit printf und dann fflushing dauert etwa 5-mal weniger Zeit als mit std::cout.

Obwohl ich es erwartet hatte mit std::cout's << Betreiber zu sein, vielleicht ein wenig langsamer (fast minimal) , ich war nicht bereit für diesen großen Unterschied. Bin ich ein fairer test? Wenn ja, was macht dann der erste test so viel langsamer als die zweite, wenn Sie im wesentlichen genau die gleiche Sache?

Haben Sie ermöglichen die Optimierung?
std::endl in jeder iteration ist eine schlechte Idee. Verwenden '\n'. Sie sind nicht die gleiche Sache.
Er hat flush in der printf-version zu sein, also, dass kann nicht wahr sein?
mögliche Duplikate Frage keine Antwort auf meine wichtigste Frage, **what makes** the first test so much slower than the second one... ich.e warum genau ist die printf schneller?
es hängt davon ab, Realisierung: Für mich cout dann schneller printf, aber nur wenn ich -std=c++0x.
Kann es nicht eine einzige richtige Antwort, andere als die Qualität der Bibliothek Implementierung, die Sie verwenden. Dort wurden ähnliche Fragen wie das verlinkte. Lesen Sie es und Fragen es links zu.
Beachten Sie, dass std::cout << "Hello, World! (" << i << ")" << std::endl; 4 Funktionsaufrufe, während printf ist nur einer. Versuchen Sie printf 5 mal, wie mit cout und sehen, was passiert. Dann werden Sie erkennen, wie viel von der Leistung scheitern wird durch die Funktion Aufrufe, und wie viel durch die Bibliothek selbst.
Deine aktuellen timings sind sinnlos wie der std::cout ist synchronisiert mit stdout und so viel "extra" arbeiten, um die Synchronisation zu gewährleisten. Wenn Sie entkoppelt werden Sie sehen eine Beschleunigung (es ist noch langsamer) std::cout.sync_with_stdio(false);
Es ist ziemlich unfair zu Spülen stdout für jeden printf. Ohne die std::fflush(stdout); die printf Schleife viel schneller. Es ist zwar idiomatisch zu << std::endl ist es nicht idiomatisch zu fflush(stdout). Ahnungslose C++ - Programmierer sind Sie wahrscheinlich cout viel weniger uneffektiv, dann stdout

InformationsquelleAutor ApprenticeHacker | 2012-08-20

c++cout performance printf

9

Für eine echte äpfel-zu-äpfel-Vergleich, re-schreiben Sie Ihren test, so dass die nur, was sich ändert, zwischen den test-Fällen ist die print-Funktion verwendet wird:
```
int main(int argc, char* argv[])
{
    const char* teststring = "Test output string\n";
    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;
}
```
Mit, dass, werden Sie die Prüfung nichts, aber die Unterschiede zwischen den printf und cout - Funktion aufruft. Sie wird nicht entstehen Unterschiede durch mehrere << Anrufe, etc. Wenn Sie versuchen, diese, ich vermute, dass Sie ein wesentlich anderes Ergebnis.
- Hmm, jetzt ist es nur ein Unterschied von etwa 0,06 s. Denke mal, dass beantwortet meine Frage.
- es scheint ein unfairer test. Für printf Abschnitt Sie flushing stdout nach jeder iteration, aber die std::cout code nicht. Sollte wohl hinzufügen << std::flush(); an den std::cout Abschnitt.
- Fügen Sie den folgenden: std::cout.sync_with_stdio(false);
- Dies ist nicht sinnvoll, den Vergleich, wenn der performance-Unterschied zwischen cout und printf ist durch die Formatierung der Zahl, die ich in einen string.
- Wahrscheinlich nicht, aber in diesem Fall meine Prüfung war zu zeigen, dass die mehrere << Betreiber waren die wahrscheinlich Schuldigen, damit ich nicht die Mühe zeigt Beispiel-code, getestet, für andere Dinge. Sie könnte jedoch gelten die gleichen Allgemeinen Prinzip (eliminieren von Variablen zur Vereinfachung des Problems), das problem zu lösen, wenn der int-zu-string-Konvertierung der übeltäter war.
- Wenn der Unterschied durch die viele mehr << Anrufe als printf Anrufe, es ist völlig angemessen zu vergleichen, Sie auf diese Weise. Es ist nicht realistisch zu vereinfachen, die Prüfung der Maße, die Sie haben.
InformationsquelleAutor bta

Versuchen Sie dies:

#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;
}

Dann bekomme ich:

> 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

Also den P2 Zeiten nicht ändern.

Aber Sie erhalten eine Verbesserung des P1-Zeiten (also std::cout) mit std::cout.sync_with_stdio(false);. Weil der code nicht mehr zu halten versucht, die beiden stream (std::cout stdout) synchronisiert. Was, wenn Sie schreiben Reine C++ und nur mit std::cout kein problem.

InformationsquelleAutor Martin York

3

verwenden
```
cout << "\n";
```
um zu verhindern, dass die Pufferung. viel schneller

InformationsquelleAutor Jason
1

Etwa 10 Jahren, Scott Meyers getestet, die Effizienz der iostream und scanf/printf. Hängt vom compiler und Umgebung, manchmal scanf/printf ist 20% schneller als die iostream -, manchmal sogar 200% schneller. Aber iostream war nie schneller als scanf/printf. Nach weiteren zwei Beispiele, scanf/printf ist immer noch schneller als die iostream.
Aber Meyers erklärte, dass "Auf ein wirklich nützliches Programm, gäbe es keine Unterschiede."
Laut Google"s Programmier-Stil([http://google-styleguide.googlecode.com/svn/trunk/cppguide.html%5D), Bäche sollten nicht verwendet werden, außer für die Protokollierung.
Ein Ersatz für die iostream-ist encapsule scanf/printf sich.

InformationsquelleAutor Tianze.Chen
0

Ich habe nur ein Programmangebot von 1 computer, also auch nicht viel testen. Jedenfalls, std::cout ist viel schneller auf meinem bauen mit den genauen ausführlichen code. Ich bin mit Cpp14.

Ich denke nur bestimmte Personen haben ein pick für C++. Ja, C ist groß, die Sprache, aber logisch sehe ich nicht, wie printf () kann schneller sein als die std cout. Printf zu tun hat, Umwandlungen von void-Zeiger auf die Laufzeit. Cout bedeutet, dass zur compile-Zeit.
- Wenn iostreams sind in der Tat schneller auf Ihre Plattform zu erhalten, wäre es hilfreich zu wissen, was, die Plattform ist. Der Grund dafür, dass iostreams neigen dazu, viel langsamer als printf ist, dass iostreams benutzen Sie eine riesige Anzahl der Funktionsaufrufe, darunter viele virtuelle Funktionsaufrufe (ein iostream-nicht nichts durch sich selbst, es leitet alles zu einem streambuf virtuelle Funktion). Das ist sehr nützlich, wenn Sie eine Notwendigkeit, um die Umleitung des streams, aber verschwenderisch, wenn Sie ihn nicht benutzen.
- Okay ich weiß wirklich nicht, welche Plattform du dich beziehst, aber ich bin mit Win 10, Intel Celeron CPU G3900, 4 gigs Ram, CPP-14. Sie sollten daran denken, CPP entwickelt sich alle drei Jahre. Eine Menge der Funktionsaufrufe, die kompiliert werden entfernt.
- Die compiler und die C++ standard-Bibliothek sind sehr wichtige details von der Plattform... die CPU (die du erwähnt hast, und enthält auch cache-Informationen) und den RAM (die du erwähnt hast nur die Größe aber nicht die Taktfrequenz, DDR-generation, die Anzahl der Kanäle, oder die Latenz), die weniger wichtig sind in diesem Fall aber haben manchmal einen großen Effekt auf die performance und Optimierung.
InformationsquelleAutor Javene CPP McGowan

Versuchte ich diesen test auf meinem laptop mit Windows 10, WSL Ubuntu, CLion 2018, GCC. Keine Optimierung:

#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;
}

Ergebnisse:

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: Mit std::ios_base::sync_with_stdio(false) und std::cin.tie(nullptr) bringt beide Funktionen auf fast dem gleichen stand.

InformationsquelleAutor AKJ

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.