Comment rediriger cin et cout vers des fichiers?
Comment puis-je rediriger cin à in.txt et cout à out.txt?
5 réponses
Voici un exemple de ce que vous voulez faire. Lisez les commentaires pour savoir ce que chaque ligne du code fait. Je l'ai testé sur mon pc avec gcc 4.6.1; cela fonctionne bien.
#include <iostream>
#include <fstream>
#include <string>
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
}
Vous pourriez enregistrer et rediriger en une seule ligne comme:
auto cinbuf = std::cin.rdbuf(in.rdbuf()); //save and redirect
Ici std::cin.rdbuf(in.rdbuf()) définit std::cin's buffer sur in.rdbuf(), puis renvoie l'ancien buffer associé à std::cin. La même chose peut être faite avec std::cout - ou n'importe quel flux d'ailleurs.
J'espère que ça aide.
Il suffit d'écrire
#include <cstdio>
#include <iostream>
using namespace std;
int main()
{
freopen("output.txt","w",stdout);
cout<<"write in file";
return 0;
}
En supposant que votre nom de prog compiles est x.exe et $ est le shell système ou invite
$ x <infile >outfile
Prendra l'entrée d'infile et sortira dans outfile .
Voici un extrait de code court pour l'observation cin / cout utile pour la programmation de concours:
#include <bits/stdc++.h>
using namespace std;
int main() {
ifstream cin("input.txt");
ofstream cout("output.txt");
int a, b;
cin >> a >> b;
cout << a + b << endl;
}
Cela donne un avantage supplémentaire que les flux fstreams simples sont plus rapides que les flux stdio synchronisés. Mais cela ne fonctionne que pour la portée de la fonction unique.
La redirection Cin/cout globale peut être écrite comme suit:
#include <bits/stdc++.h>
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();
}
Remarque que ios_base::sync_with_stdio réinitialise également std::cin.rdbuf. Donc l'ordre des questions.
Voir aussi Signification de ios_base::sync_with_stdio(false); cin.cravate (NULL);
Std io les flux peuvent également être facilement ombrés pour la portée du fichier unique, ce qui est utile pour la programmation compétitive:
#include <bits/stdc++.h>
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();
}
, Mais dans ce cas, nous avons à choisir std déclarations, un par un, et d'éviter using namespace std; comme il donnerait erreur d'ambiguïté:
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
^
Voir aussi Comment utilisez-vous correctement les espaces de noms en C++?, Pourquoi "utiliser l'espace de noms std" est-il considéré comme une mauvaise pratique? et comment résoudre une collision de noms entre un espace de noms la fonction?
Essayez ceci pour rediriger cout dans le fichier.
#include <iostream>
#include <fstream>
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;
}
Lire l'article complet Utiliser std::rdbuf pour Rediriger cin et cout