C++ file-redirection

Question

For faster input, I read that you can do file-redirection and include a file with the cin inputs already set.

In theory it should be used l

Answer 1

[I am just explaining the command line argument used in Question]

You can provide file name as command line input to the executible, but then you need to open them in your code.

Like

You have supplied two command line arguments namely inputfile & outputfile

[ App.exe inputfile outputfile ]

Now in your code

#include<iostream>
#include<fstream>
#include<string>

int main(int argc, char * argv[])
{
   //argv[0] := A.exe
   //argv[1] := inputFile
   //argv[2] := outputFile

   std::ifstream vInFile(argv[1],std::ios::in); 
   // notice I have given first command line argument as file name

   std::ofstream vOutFile(argv[2],std::ios::out | std::ios::app);
   // notice I have given second command line argument as file name

   if (vInFile.is_open())
   {
     std::string line;

     getline (vInFile,line); //Fixing it as per the comment made by MSalters

     while ( vInFile.good() )
     {
         vOutFile << line << std::endl;
         getline (vInFile,line);          
     }
     vInFile.close();
     vOutFile.close();
  }

  else std::cout << "Unable to open file";

  return 0;
}

Answer 2

In addition to original redirection >/ >> and <

You can redirect std::cin and std::cout too.

Like following:

int main()
{
    // Save original std::cin, std::cout
    std::streambuf *coutbuf = std::cout.rdbuf();
    std::streambuf *cinbuf = std::cin.rdbuf(); 

    std::ofstream out("outfile.txt");
    std::ifstream in("infile.txt");

    //Read from infile.txt using std::cin
    std::cin.rdbuf(in.rdbuf());

    //Write to outfile.txt through std::cout 
    std::cout.rdbuf(out.rdbuf());   

    std::string test;
    std::cin >> test;           //from infile.txt
    std::cout << test << "  "; //to outfile.txt

    //Restore back.
    std::cin.rdbuf(cinbuf);   
    std::cout.rdbuf(coutbuf); 

}

Answer 3

To use your code [1] you have to call your program like this:

App.exe < inputfile > outputfile

You can also use:

App.exe < inputfile >> outputfile

In this case the output wouldn't be rewritten with every run of the command, but output will be appended to already existing file.

More information about redirecting input and output in Windows you can find here.

---

Note that the <, > and >> symbols are to be entered verbatim — they are not just for presentation purposes in this explanation. So, for example:

App.exe < file1 >> file2

Answer 4

It is important that you understand the concept of redirection. Redirection reroutes standard input, standard output, and standard error.

The common redirection commands are:

• > redirects standard output of a command to a file, overwriting previous content.

  $ command > file

• >> redirects standard output of a command to a file, appending new content to old content.

  $ command >> file

• < redirects standard input to a command.

  $ command < file

• | redirects standard output of a command to another command.

  $ command | another_command

• 2> redirects standard error to a file.

  $ command 2> file

  $ command > out_file 2> error_file

• 2>&1 redirects stderr to the same file that stdout was redirected to.

  $ command > file 2>&1

You can combine redirection:

# redirect input, output and error redirection
$ command < in_file > out_file  2> error_file
# redirect input and output
$ command < in_file > out_file
# redirect input and error
$ command < in_file 2> error_file
# redirect output and error
$ command > out_file  2> error_file

Even though, it is not part of your question, you can also use other commands are powerful when combined with redirection commands:

• sort: sorts lines of text alphabetically.
• uniq: filters duplicate, adjacent lines of text.
• grep: searches for a text pattern and outputs it.
• sed : searches for a text pattern, modifies it, and outputs it.