Die Verwendung von scanf () in C ++ - Programmen ist schneller als die Verwendung von cin?

Ich weiß nicht, ob dies der Fall ist, aber als ich FAQ auf einer der Problembereitstellungsseiten las, fand ich etwas, das meine Aufmerksamkeit auf sich zog:

Überprüfen Sie Ihre Eingabe- / Ausgabemethoden. In C ++ ist die Verwendung von cin und cout zu langsam. Verwenden Sie diese, und Sie werden garantiert kein Problem mit einer angemessenen Menge an Eingabe oder Ausgabe lösen können. Verwenden Sie stattdessen printf und scanf.

Kann das bitte jemand klären? Ist die Verwendung von scanf () in C ++ - Programmen wirklich schneller als die Verwendung von cin >> ? Wenn ja, ist es eine gute Praxis, es in C ++ - Programmen zu verwenden? Ich dachte, dass es C-spezifisch ist, obwohl ich gerade C ++ lerne ...

Hier ist ein kurzer Test eines einfachen Falls: Ein Programm zum Lesen einer Liste von Zahlen aus der Standardeingabe und XOR aller Zahlen.

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

Ergebnisse

Mit einem dritten Programm habe ich eine Textdatei mit 33.280.276 Zufallszahlen erstellt. Die Ausführungszeiten sind:

iostream version:  24.3 seconds
scanf version:      6.4 seconds

Das Ändern der Optimierungseinstellungen des Compilers schien die Ergebnisse überhaupt nicht zu ändern.

Also: Es gibt wirklich einen Geschwindigkeitsunterschied.

BEARBEITEN : User Clyfish weist unten darauf hin, dass der Geschwindigkeitsunterschied hauptsächlich auf die Iostream-E / A-Funktionen zurückzuführen ist, die die Synchronisation mit den CI / O-Funktionen aufrechterhalten. Wir können dies mit einem Anruf ausschalten 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;
}

Neue Ergebnisse:

iostream version:                       21.9 seconds
scanf version:                           6.8 seconds
iostream with sync_with_stdio(false):    5.5 seconds

C ++ iostream gewinnt! Es stellt sich heraus, dass diese interne Synchronisierung / Spülung normalerweise die Iostream-E / A verlangsamt. Wenn wir nicht stdio und iostream mischen, können wir es ausschalten, und dann ist iostream am schnellsten.

Der Code: https://gist.github.com/3845568

http://www.quora.com/Is-cin-cout-slower-than-scanf-printf/answer/Aditya-Vishwakarma

Die Leistung von cin/ coutkann langsam sein, da sie sich mit der zugrunde liegenden C-Bibliothek synchronisieren müssen. Dies ist wichtig, wenn sowohl C IO als auch C ++ IO verwendet werden sollen.

Wenn Sie jedoch nur C ++ - E / A verwenden möchten, verwenden Sie einfach die folgende Zeile, bevor Sie E / A-Vorgänge ausführen.

std::ios::sync_with_stdio(false);

Weitere Informationen hierzu finden Sie in den entsprechenden libstdc ++ - Dokumenten .

Wahrscheinlich ist scanf etwas schneller als die Verwendung von Streams. Obwohl Streams viel Typensicherheit bieten und zur Laufzeit keine Formatzeichenfolgen analysieren müssen, hat dies normalerweise den Vorteil, dass keine übermäßigen Speicherzuweisungen erforderlich sind (dies hängt von Ihrem Compiler und Ihrer Laufzeit ab). Das heißt, wenn Leistung nicht Ihr einziges Endziel ist und Sie sich auf dem kritischen Pfad befinden, sollten Sie die sichereren (langsameren) Methoden wirklich bevorzugen.

Es ist ein sehr wohlschmeckender Artikel geschrieben hier von Herb Sutter „ Die String Formatter von Manor Farm “ , die in vielen Details der Leistung des String Formatierer gehen wie sscanfund lexical_castund was für Dinge machte sie laufen langsam oder schnell. Dies ist eine Art Analogie, wahrscheinlich zu den Dingen, die die Leistung zwischen IO im C-Stil und C ++ - Stil beeinträchtigen würden. Der Hauptunterschied zu den Formatierern bestand in der Typensicherheit und der Anzahl der Speicherzuordnungen.

Ich habe gerade einen Abend damit verbracht, an einem Problem bei UVa Online zu arbeiten (Factovisors, ein sehr interessantes Problem, probieren Sie es aus):

http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=35&page=show_problem&problem=1080

Ich habe TLE (Zeitlimit überschritten) für meine Einsendungen erhalten. Auf diesen Online-Richterseiten zur Problemlösung haben Sie ein Zeitlimit von 2-3 Sekunden, um potenziell Tausende von Testfällen zu bearbeiten, die zur Bewertung Ihrer Lösung verwendet werden. Bei rechenintensiven Problemen wie diesem zählt jede Mikrosekunde.

Ich habe den vorgeschlagenen Algorithmus verwendet (siehe in den Diskussionsforen für die Site), bekam aber immer noch TLEs.

Ich habe nur "cin >> n >> m" in "scanf ("% d% d ", & n, & m)" und die wenigen winzigen "couts" in "printfs" geändert, und mein TLE wurde zu "Accepted"!

Ja, es kann einen großen Unterschied machen, insbesondere wenn die Fristen kurz sind.

Wenn Sie sich sowohl für die Leistung als auch für die Formatierung von Zeichenfolgen interessieren, schauen Sie sich die FastFormat- Bibliothek von Matthew Wilson an .

edit - Link zur Accu-Veröffentlichung in dieser Bibliothek: http://accu.org/index.php/journals/1539

Es gibt stdio-Implementierungen ( libio ), die FILE * als C ++ - Streambuf und fprintf als Parser im Laufzeitformat implementieren. IOstreams müssen nicht im Laufzeitformat analysiert werden. Dies geschieht alles zur Kompilierungszeit. Wenn die Backends gemeinsam genutzt werden, ist zu erwarten, dass iostreams zur Laufzeit schneller ist.

Ja, iostream ist langsamer als cstdio.
Ja, Sie sollten cstdio wahrscheinlich nicht verwenden, wenn Sie in C ++ entwickeln.
Allerdings gibt es noch schnellere Möglichkeiten, E / A zu erhalten als scanf, wenn Sie sich nicht für Formatierung, Typensicherheit, bla, bla, bla ... interessieren.

Dies ist beispielsweise eine benutzerdefinierte Routine, um eine Nummer von STDIN abzurufen:

inline int get_number()
{
    int c;        
    int n = 0;

    while ((c = getchar_unlocked()) >= '0' && c <= '9')
    {
        // n = 10 * n + (c - '0');
        n = (n << 3) + ( n << 1 ) + c - '0';
    }
    return n;
}

Das Problem ist, dass cinviel Overhead erforderlich ist, da Sie über Abständen eine Abstraktionsschicht erhalten scanf(). Sie sollten nicht scanf()over verwenden, cinwenn Sie C ++ - Software schreiben, da dies gewünscht cinist. Wenn Sie Leistung wünschen, würden Sie wahrscheinlich sowieso keine E / A in C ++ schreiben.

Die Anweisungen cinund die coutallgemeine Verwendung scheinen langsamer als scanfund printfin C ++ zu sein, aber tatsächlich sind sie SCHNELLER!

Die Sache ist die : In C ++, wenn Sie verwenden cinund coutein Synchronisationsvorgang erfolgt standardmäßig, der sicherstellt , dass , wenn Sie beide verwenden scanfund cinin Ihrem Programm, dann werden sie beide arbeiten synchron miteinander. Dieser Synchronisierungsvorgang benötigt Zeit. Daher cinund coutscheinen langsamer zu sein.

Wenn der Synchronisierungsprozess jedoch so eingestellt ist, dass er nicht stattfindet, cinist er schneller als scanf.

Um den Synchronisierungsvorgang zu überspringen, fügen Sie gleich zu Beginn des folgenden Codeausschnitts in Ihr Programm ein main():

std::ios::sync_with_stdio(false);

Besuchen Sie diese Website für weitere Informationen.

#include <stdio.h>
#include <unistd.h>

#define likely(x)       __builtin_expect(!!(x), 1)
#define unlikely(x)     __builtin_expect(!!(x), 0)

static int scanuint(unsigned int* x)
{
  char c;
  *x = 0;

  do
  {
      c = getchar_unlocked();
      if (unlikely(c==EOF)) return 1;
  } while(c<'0' || c>'9');

  do
  {
      //*x = (*x<<3)+(*x<<1) + c - '0';
      *x = 10 * (*x) + c - '0';
      c = getchar_unlocked();
      if (unlikely(c==EOF)) return 1;
  } while ((c>='0' && c<='9'));

  return 0;
}

int main(int argc, char **argv) {

  int parity = 0;
  unsigned int x;

  while (1 != (scanuint(&x))) {
    parity ^= x;
  }
  parity ^=x;
  printf("%d\n", parity);

  return 0;
}

Es gibt einen Fehler am Ende der Datei, aber dieser C-Code ist dramatisch schneller als die schnellere C ++ - Version.

paradox@scorpion 3845568-78602a3f95902f3f3ac63b6beecaa9719e28a6d6 ▶ make test        
time ./xor-c < rand.txt
360589110

real    0m11,336s
user    0m11,157s
sys 0m0,179s
time ./xor2-c < rand.txt
360589110

real    0m2,104s
user    0m1,959s
sys 0m0,144s
time ./xor-cpp < rand.txt
360589110

real    0m29,948s
user    0m29,809s
sys 0m0,140s
time ./xor-cpp-noflush < rand.txt
360589110

real    0m7,604s
user    0m7,480s
sys 0m0,123s

Das ursprüngliche C ++ dauerte 30 Sekunden, der C-Code 2 Sekunden.

Natürlich ist es lächerlich, cstdio über iostream zu verwenden. Zumindest wenn Sie Software entwickeln (wenn Sie bereits C ++ über C verwenden, gehen Sie den ganzen Weg und nutzen Sie die Vorteile, anstatt nur unter den Nachteilen zu leiden).

Aber in der Online-Jury, in der Sie keine Software entwickeln, erstellen Sie ein Programm, das in der Lage sein sollte, Dinge zu tun, die Microsoft-Software in 3 Sekunden in 60 Sekunden erreichen muss !!!

In diesem Fall lautet die goldene Regel also (natürlich, wenn Sie mit Java nicht noch mehr Probleme bekommen).

• Verwenden Sie c ++ und nutzen Sie die gesamte Kraft (und Schwere / Langsamkeit), um das Problem zu lösen
• Wenn Sie zeitlich begrenzt sind, ändern Sie die Cins und Couts für printfs und scanfs (wenn Sie mithilfe der Klassenzeichenfolge Fehler machen, drucken Sie wie folgt: printf (% s, mystr.c_str ());
• Wenn Sie immer noch zeitlich begrenzt sind, versuchen Sie, einige offensichtliche Optimierungen vorzunehmen (z. B. zu viele eingebettete Funktionen für / while / dowhiles oder rekursive Funktionen zu vermeiden). Stellen Sie außerdem sicher, dass Sie an zu großen Referenzobjekten vorbeikommen ...
• Wenn Sie immer noch zeitlich begrenzt sind, versuchen Sie, std :: -Vektoren und -Sätze für c-Arrays zu ändern.
• Wenn Sie immer noch zeitlich begrenzt sind, fahren Sie mit dem nächsten Problem fort ...

Selbst wenn scanfes schneller wäre als cin, wäre es egal. Die meiste Zeit lesen Sie von der Festplatte oder der Tastatur. Das Einfügen der Rohdaten in Ihre Anwendung dauert um Größenordnungen länger als das Verarbeiten scanfoder cinVerarbeiten.