Foro de elhacker.net

Hola, muy buenas. Hoy quería poner una solución que quizás no se haya tenido en cuenta. Por ejemplo, es una solución para los problemas como: ¿por qué a veces cuando leo datos de la consola se salta alguna toma de datos? Bueno, la respuesta a eso es que probablemente al introducir datos en algún paso anterior, se han introducido datos de más y esos datos están esperando a salir, por lo que en la siguiente toma de datos, se toman datos del paso anterior.

Bueno, entonces, la solución que he descubierto (yo no la conocía) es usar el método std::istream::sync. Lo que hace este método es sincronizar el búfer interno en el que se almacenan esos datos de pasos anteriores con la toma de datos actual. Entonces, lo que habría que hacer es colocar ese método antes de cualquier toma de datos:

#include <iostream>
 
int main() {
	// Aquí llenaremos el búfer de datos innecesarios para demostrar el uso de std::cin.sync
	std::cout << "Introduzca datos: ";
	std::cin.get();
 
	// ... Código
 
	std::cout << "Introduzca datos de nuevo: ";
	std::cin.sync();
	// Pedimos un carácter y lo imprimimos:
	std::cout << (char)std::cin.get();
 
	return 0;
}

Este código tendría la siguiente salida (en este ejemplo):

Como ven, a pesar de haber llenado el búfer con el carácter 'a', se ha impreso el último carácter leído. Eso demuestra que funciona. Lo que no me queda del todo claro es cómo funciona este método, así que quizás sea ineficiente o algo por el estilo.

Sabiendo esto, ¿alguien sabe si usar todo el rato std::istream::sync tiene algún inconveniente? Gracias!

Preferible usar getline, o ignore.
El funcionamiento de sync depende del tipo de buffer, y de la implementación.
http://ideone.com/UMDA8w (http://ideone.com/UMDA8w)

Entonces, ¿qué es lo que hace exactamente este método? No lo entiendo muy bien

No tengo más que decir que lo que pone en esta wiki: http://en.cppreference.com/w/cpp/io/basic_streambuf/pubsync (http://en.cppreference.com/w/cpp/io/basic_streambuf/pubsync)
istream::sync termina llamando a streambuf::sync.
En general, explica que, en buffers de salida, escribe lo que tenga almacenado (como haría flush). En buffers de entrada, limpia lo almacenado y vuelve a leer.
Por defecto, no hará nada.

De istream: http://en.cppreference.com/w/cpp/io/basic_istream/sync (http://en.cppreference.com/w/cpp/io/basic_istream/sync)

En fin. Un método virtual genérico que, supongo, proveen para que manejes tus buffers.