C/C++,Java 重定向输入输出流至文件

在我们做Online Judge的时候，OJ基本上都是用标准输入输出。但如果每次调试的时候也都是从控制台输入数据，那就太浪费时间了。

我们可以重定向标准输入，调试的时候从文件读数据，提交的时候从标准读。

在C语言中，

方法比较简单。使用函数freopen()，  freopen是被包含与stdio.h头文件中，用于重定向输入输出流的函数。该函数可以在不改变代码原貌的情况下改变输入输出环境，但使用时应当保证流是可靠的。 

freopen("data.in","r",stdin);
freopen("data.out","w",stdout);
这样就把标准输入重定向到了data.in文件，标准输出重定向到了data.out文件。
这两句代码之后，scanf函数就会从data.in文件里读，而printf函数就会输出到data.out文件里了。

代码示例：

[cpp]  view plain  copy

 

1. #include <iostream>  
2. #include <cstdio> //包含语言重定向函数freopen的库  
3. using namespace std;  
4. int main()  
5. {  
6.  //正式提交代码时，删除下面两项就行了  
7.  freopen("input.txt","r",stdin); //重定向输入流  
8.     freopen("output.txt","w",stdout); //重定向输出流  
9.  /* input.txt 文件内容如下： 
10.  2 
11.  1 1 
12.  2 2  
13.  */  
14.  int n;  
15.  int a,b;  
16.  cin>>n;  
17.  for(int i=0; i<n; ++i){  
18.   cin>>a>>b;  
19.   cout<<a+b<<endl;  
20.  }  
21.  /* output输出文件 
22.  2 
23.  4 
24.  */  
25.     return 0;  
26. }  

C++语言中：

对流重定向有两个重载函数：
streambuf* rdbuf () const;
streambuf* rdbuf (streambuf*)
就相当于get/set方法。

code：

streambuf *backup;
ifstream fin;
fin.open("data.in");
backup = cin.rdbuf();   // back up cin's streambuf
cin.rdbuf(fin.rdbuf()); // assign file's streambuf to cin
// ... cin will read from file
cin.rdbuf(backup);     // restore cin's original streambuf

代码示例：

[cpp]  view plain  copy

 

1. #include <iostream>  
2. #include <fstream>  
3. #include <string>  
4.   
5. void f()  
6. {  
7.     std::string line;  
8.     while(std::getline(std::cin, line))  //input from the file in.txt  
9.     {  
10.         std::cout << line << "\n";   //output to the file out.txt  
11.     }  
12. }  
13. int main()  
14. {  
15.     std::ifstream in("input.txt");  
16.     std::streambuf *cinbuf = std::cin.rdbuf(); //save old buf  
17.     std::cin.rdbuf(in.rdbuf()); //redirect std::cin to in.txt!  
18.   
19.     std::ofstream out("output.txt");  
20.     std::streambuf *coutbuf = std::cout.rdbuf(); //save old buf  
21.     std::cout.rdbuf(out.rdbuf()); //redirect std::cout to out.txt!  
22.   
23.     std::string word;  
24.     std::cin >> word;           //input from the file in.txt  
25.     std::cout << word << "  ";  //output to the file out.txt  
26.   
27.     f(); //call function  
28.   
29.   
30.     std::cin.rdbuf(cinbuf);   //reset to standard input again  
31.     std::cout.rdbuf(coutbuf); //reset to standard output again  
32.   
33.     std::cin >> word;   //input from the standard input  
34.     std::cout << word;  //output to the standard input  
35. }  

Java语言中：

Java的标准输入/输出分别通过System.in和System.out来代表，在默认的情况下分别代表键盘和显示器，当程序通过System.in来获得输入时，实际上是通过键盘获得输入。当程序通过System.out执行输出时，程序总是输出到屏幕。
在System类中提供了三个重定向标准输入/输出的方法
static void setErr(PrintStream err) 重定向“标准”错误输出流
static void setIn(InputStream in)    重定向“标准”输入流
static void setOut(PrintStream out)重定向“标准”输出流
下面程序通过重定向标准输出流，将System.out的输出重定向到文件输出，而不是在屏幕上输出。

示例代码：

[java]  view plain  copy

 

1. package edu.ustc.demo.test;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.FileNotFoundException;  
5. import java.io.FileOutputStream;  
6. import java.io.PrintStream;  
7. import java.util.Scanner;  
8.   
9. public class Redirect {  
10.     public static void main(String args[]) throws FileNotFoundException {  
11.           
12.         FileInputStream fis = new FileInputStream("input.txt");  
13.         System.setIn(fis);  
14.           
15.         PrintStream ps = new PrintStream(new FileOutputStream("output.txt"));  
16.         System.setOut(ps);  
17.           
18.         Scanner sc = new Scanner(System.in);  
19.         while (sc.hasNextLine()) {  
20.             System.out.println(sc.nextLine());  
21.         }  
22.   
23.     }  
24. }  

参考文章：

http://hi.baidu.com/gluce/item/d5d4f2340263d04c3175a12f

http://blog.csdn.net/zhy_cheng/article/details/7891142