¿Cómo redirigir cin y cout a los archivos?

¿Cómo puedo redireccionar cin a in.txt y cout a out.txt ?

Aquí hay un ejemplo práctico de lo que quiere hacer. Lea los comentarios para saber qué hace cada línea en el código. Lo probé en mi pc con gcc 4.6.1; funciona bien.

 #include  #include  #include  void f() { std::string line; while(std::getline(std::cin, line)) //input from the file in.txt { std::cout << line << "\n"; //output to the file out.txt } } int main() { std::ifstream in("in.txt"); std::streambuf *cinbuf = std::cin.rdbuf(); //save old buf std::cin.rdbuf(in.rdbuf()); //redirect std::cin to in.txt! std::ofstream out("out.txt"); std::streambuf *coutbuf = std::cout.rdbuf(); //save old buf std::cout.rdbuf(out.rdbuf()); //redirect std::cout to out.txt! std::string word; std::cin >> word; //input from the file in.txt std::cout << word << " "; //output to the file out.txt f(); //call function std::cin.rdbuf(cinbuf); //reset to standard input again std::cout.rdbuf(coutbuf); //reset to standard output again std::cin >> word; //input from the standard input std::cout << word; //output to the standard input } 

Puede guardar y redirigir en una sola línea como:

 auto cinbuf = std::cin.rdbuf(in.rdbuf()); //save and redirect 

Aquí std::cin.rdbuf(in.rdbuf()) establece std::cin's buffer de std::cin's en in.rdbuf() y luego regresa el viejo buffer asociado con std::cin . Lo mismo se puede hacer con std::cout , o cualquier secuencia para el caso.

Espero que ayude.

Solo escribe

 #include  #include  using namespace std; int main() { freopen("output.txt","w",stdout); cout<<"write in file"; return 0; } 

suponiendo que su comstack el nombre del progtwig es x.exe y $ es el shell del sistema o indicador

 $ x outfile 

tomará entrada de archivo y dará salida a archivo externo.

Aquí hay un fragmento de código corto para sombrear cin / cout útil para concursos de progtwigción:

 #include  using namespace std; int main() { ifstream cin("input.txt"); ofstream cout("output.txt"); int a, b; cin >> a >> b; cout << a + b << endl; } 

Esto proporciona un beneficio adicional de que los flujos directos simples son más rápidos que los trenes stdio sincronizados. Pero esto funciona solo para el scope de la función individual.

La redirección global cin / cout se puede escribir como:

 #include  using namespace std; void func() { int a, b; std::cin >> a >> b; std::cout << a + b << endl; } int main() { ifstream cin("input.txt"); ofstream cout("output.txt"); // optional performance optimizations ios_base::sync_with_stdio(false); std::cin.tie(0); std::cin.rdbuf(cin.rdbuf()); std::cout.rdbuf(cout.rdbuf()); func(); } 

Tenga en cuenta que ios_base::sync_with_stdio también restablece std::cin.rdbuf . Entonces el orden importa.

Ver también Significado de ios_base :: sync_with_stdio (false); cin.tie (NULL);

Las streams de Std io también se pueden sombrear fácilmente para el scope del archivo único, que es útil para la progtwigción competitiva:

 #include  using std::endl; std::ifstream cin("input.txt"); std::ofstream cout("output.txt"); int a, b; void read() { cin >> a >> b; } void write() { cout << a + b << endl; } int main() { read(); write(); } 

Pero en este caso tenemos que elegir las declaraciones std una por una y evitar el using namespace std; ya que daría error de ambigüedad:

 error: reference to 'cin' is ambiguous cin >> a >> b; ^ note: candidates are: std::ifstream cin ifstream cin("input.txt"); ^ In file test.cpp std::istream std::cin extern istream cin; /// Linked to standard input ^ 

Consulte también ¿Cómo usa correctamente los espacios de nombres en C ++? , ¿Por qué "usar el espacio de nombres estándar" se considera una mala práctica? y ¿Cómo resolver una colisión de nombre entre un espacio de nombres C ++ y una función global?

Intenta esto para redirigir cout al archivo.

 #include  #include  int main() { /** backup cout buffer and redirect to out.txt **/ std::ofstream out("out.txt"); auto *coutbuf = std::cout.rdbuf(); std::cout.rdbuf(out.rdbuf()); std::cout << "This will be redirected to file out.txt" << std::endl; /** reset cout buffer **/ std::cout.rdbuf(coutbuf); std::cout << "This will be printed on console" << std::endl; return 0; } 

Lea el artículo completo Use std :: rdbuf para redirigir cin y cout