Comment redirect cin et cout en fichiers?

Comment puis-je redirect cin vers in.txt et cout vers out.txt ?

Voici un exemple concret de ce que vous voulez faire. Lisez les commentaires pour savoir ce que fait chaque ligne du code. Je l’ai testé sur mon pc avec gcc 4.6.1; ça fonctionne bien.

 #include  #include  #include  void f() { std::ssortingng 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 pouvez enregistrer et redirect 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 tampon de std::cin's sur in.rdbuf() puis renvoie l'ancien tampon associé à std::cin . La même chose peut être faite avec std::cout - ou n'importe quel stream d'ailleurs.

J'espère que cela pourra aider.

Ecrivez

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

en supposant que votre nom de prog comstack est x.exe et $ est le shell du système ou l’invite

 $ x outfile 

va prendre en charge de l’infile et va sortir en fichier.

Voici un extrait de code pour l’observation de cin / cout utile à la programmation de concours:

 #include  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 stream simples sont plus rapides que les stream stdio synchronisés. Mais cela ne fonctionne que pour la scope de la fonction unique.

La redirection globale cin / cout peut être écrite comme suit:

 #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(); } 

Notez que ios_base::sync_with_stdio réinitialise également std::cin.rdbuf . Donc l'ordre compte.

Voir aussi Signification de ios_base :: sync_with_stdio (false); cin.tie (NULL);

Les stream std io peuvent également être facilement surveillés pour la scope d'un seul fichier, ce qui est utile pour la programmation concurrentielle:

 #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(); } 

Mais dans ce cas, nous devons choisir les déclarations std une par une et éviter d' using namespace std; comme cela donnerait une 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 "using namespace std" est-il considéré comme une mauvaise pratique? Comment résoudre une collision de noms entre un espace de noms C ++ et une fonction globale?

Essayez ceci pour redirect cout en fichier.

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

Lire l'article complet Utilisez std :: rdbuf pour redirect cin et cout