16

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 like following:

App.exe inputfile outputfile

As far as I understood from C++ Primer book, The following C++ code[1] should be reading cin input from the text file and shouldn't need to any other special indication like[2]

[2]

include <fstream>
ofstream myfile;
myfile.open ();

[1] The following C++ code...

#include <iostream>
int main()
{
    int val;
    std::cin >> val; //this value should be read automatically for inputfile
    std::cout << val;
    return 0;
}

Am I missing something?

Improve this question
1
  • 1
    Yes -- that's not how it should be used. Commented Aug 6, 2013 at 13:32

4 Answers 4

Reset to default
22

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
Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

You can also use App.exe < inputfile >> outputfile. Notice the extra '>'. This way the new output will be appended to the file instead of erasing it's previous contents.
Thanks @gawi, I thought that the < and > were used to indicate a variable or something.
@Jerry You're welcome, btw if you want to speed up your program more you can use printf/scanf functions, or if you really want to speed up reading/writing data use fgets/puts functions (but to do this you must know what you are doing :))
@gawi yeah, now it's still saying bullshit about printf/scanf being faster than cin/cout, but at least it's gramatically correct.
@BartekBanachewicz So in your opinion cin/cout are comparable in execution time to scanf/printf? Maybe they improved it recently, but in the past, even when you disabled synchrinzation: std::ios_base::sync_with_stdio(false); streams were far more slower than printf/scanf functions. I haven't been using c++ for the last few years...
|
5

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); 

}
Improve this answer

Comments

0

[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;
}
Improve this answer

1 Comment

The code adds a spurious last line. When the last read fails, you first write line to vOutFile and only then check vInFile.good(). The correct order in the loop should be : read line, check if read succeeded, write line, goto read
0

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.
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.