Un primer elemento de una respuesta: <iostream> es lento. Maldita sea lento. Obtengo un gran aumento de rendimiento con scanf como se muestra a continuación, pero aún es dos veces más lento que Python.

 #include <iostream> #include <time.h> #include <cstdio> using namespace std; int main() { char buffer[10000]; long line_count = 0; time_t start = time(NULL); int sec; int lps; int read = 1; while(read > 0) { read = scanf("%s", buffer); line_count++; }; sec = (int) time(NULL) - start; line_count--; cerr << "Saw " << line_count << " lines in " << sec << " seconds." ; if (sec > 0) { lps = line_count / sec; cerr << " Crunch speed: " << lps << endl; } else cerr << endl; return 0; }

tl; dr: debido a las diferentes configuraciones predeterminadas en C ++ que requieren más llamadas al sistema.

De forma predeterminada, cin está sincronizado con stdio, lo que hace que evite cualquier almacenamiento en búfer de entrada. Si agrega esto a la parte superior de su principal, debería ver un rendimiento mucho mejor:

 std::ios_base::sync_with_stdio(false);

Normalmente, cuando se almacena en búfer un flujo de entrada, en lugar de leer un carácter a la vez, el flujo se leerá en fragmentos más grandes. Esto reduce el número de llamadas al sistema, que suelen ser relativamente caras. Sin embargo, dado que los stdio e iostreams basados en FILE* a menudo tienen implementaciones separadas y, por lo tanto, búferes separados, esto podría generar un problema si ambos se usaran juntos. Por ejemplo:

 int myvalue1; cin >> myvalue1; int myvalue2; scanf("%d",&myvalue2);

Si cin leyó más entradas de las que realmente necesitaba, entonces el segundo valor entero no estaría disponible para la función scanf , que tiene su propio búfer independiente. Esto conduciría a resultados inesperados.

Para evitar esto, de forma predeterminada, las transmisiones se sincronizan con stdio . Una forma común de lograr esto es hacer que cin lea cada carácter uno a la vez según sea necesario usando las funciones de stdio . Desafortunadamente, esto introduce muchos gastos generales. Para pequeñas cantidades de entrada, esto no es un gran problema, pero cuando lee millones de líneas, la penalización del rendimiento es significativa.

Afortunadamente, los diseñadores de la biblioteca decidieron que también debería poder deshabilitar esta función para obtener un mejor rendimiento si sabía lo que estaba haciendo, por lo que proporcionaron el método sync_with_stdio . Desde este enlace (énfasis añadido):

Si la sincronización está desactivada, los flujos estándar de C++ pueden almacenar en búfer su E/S de forma independiente, lo que puede ser considerablemente más rápido en algunos casos .

En su segundo ejemplo (con scanf() ), la razón por la que esto es aún más lento podría deberse a que scanf("%s") analiza la cadena y busca cualquier carácter de espacio (espacio, tabulador, nueva línea).

Además, sí, CPython hace algo de almacenamiento en caché para evitar lecturas del disco duro.

Reproduje el resultado original en mi computadora usando g++ en una Mac.

Agregar las siguientes declaraciones a la versión de C++ justo antes del ciclo while lo pone en línea con la versión de Python :

 std::ios_base::sync_with_stdio(false); char buffer[1048576]; std::cin.rdbuf()->pubsetbuf(buffer, sizeof(buffer));

sync_with_stdio mejoró la velocidad a 2 segundos, y la configuración de un búfer más grande la redujo a 1 segundo.

Bueno, veo que en tu segunda solución cambiaste de cin a scanf , que era la primera sugerencia que te iba a hacer ( cin es lentooooooooooo). Ahora, si cambia de scanf a fgets , verá otro aumento en el rendimiento: fgets es la función de C++ más rápida para la entrada de cadenas.

Por cierto, no sabía nada de eso de la sincronización, genial. Pero aún deberías probar fgets .

Por cierto, la razón por la que el recuento de líneas para la versión de C++ es uno mayor que el recuento de la versión de Python es que el indicador eof solo se establece cuando se intenta leer más allá de eof. Así que el bucle correcto sería:

 while (cin) { getline(cin, input_line); if (!cin.eof()) line_count++; };

Solo por curiosidad, eché un vistazo a lo que sucede debajo del capó y usé dtruss/strace en cada prueba.

C++

 ./a.out < in Saw 6512403 lines in 8 seconds. Crunch speed: 814050

syscalls sudo dtruss -c ./a.out < in

 CALL COUNT __mac_syscall 1 <snip> open 6 pread 8 mprotect 17 mmap 22 stat64 30 read_nocancel 25958

Pitón

 ./a.py < in Read 6512402 lines in 1 seconds. LPS: 6512402

syscalls sudo dtruss -c ./a.py < in

 CALL COUNT __mac_syscall 1 <snip> open 5 pread 8 mprotect 17 mmap 21 stat64 29

getline , operadores de flujo, scanf , pueden ser convenientes si no le importa el tiempo de carga del archivo o si está cargando archivos de texto pequeños. Pero, si el rendimiento es algo que le importa, realmente debería almacenar todo el archivo en memoria intermedia (suponiendo que quepa).

Aquí hay un ejemplo:

 //open file in binary mode std::fstream file( filename, std::ios::in|::std::ios::binary ); if( !file ) return NULL; //read the size... file.seekg(0, std::ios::end); size_t length = (size_t)file.tellg(); file.seekg(0, std::ios::beg); //read into memory buffer, then close it. char *filebuf = new char[length+1]; file.read(filebuf, length); filebuf[length] = '\0'; //make it null-terminated file.close();

Si lo desea, puede envolver un flujo alrededor de ese búfer para un acceso más conveniente como este:

 std::istrstream header(&filebuf[0], length);

Además, si tiene el control del archivo, considere usar un formato de datos binario plano en lugar de texto. Es más confiable leer y escribir porque no tiene que lidiar con todas las ambigüedades de los espacios en blanco. También es más pequeño y mucho más rápido de analizar.

El siguiente código fue más rápido para mí que el otro código publicado aquí hasta ahora: (Visual Studio 2013, 64 bits, archivo de 500 MB con longitud de línea uniforme en [0, 1000)).

 const int buffer_size = 500 * 1024; // Too large/small buffer is not good. std::vector<char> buffer(buffer_size); int size; while ((size = fread(buffer.data(), sizeof(char), buffer_size, stdin)) > 0) { line_count += count_if(buffer.begin(), buffer.begin() + size, [](char ch) { return ch == '\n'; }); }

Supera todos mis intentos de Python por más de un factor 2.