web-dev-qa-db-fra.com

Redirection de fichier C++

Pour une entrée plus rapide, j'ai lu que vous pouvez faire file-redirection et inclure un fichier avec les entrées cin déjà définies.

Il théorie devrait être utilisé comme suit

App.exe inputfile outputfile

Pour autant que je sache dans le livre d’introduction au C++, le code C++ suivant [1] devrait lire les entrées cin du fichier texte et ne devrait nécessiter aucune autre indication spéciale telle que [2].

[2]

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

[1] Le code C++ suivant ...

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

Est-ce que je manque quelque chose?

c++file
14
zurfyx

Pour utiliser votre code [1], vous devez appeler votre programme comme suit:

App.exe < inputfile > outputfile

Vous pouvez aussi utiliser:

App.exe < inputfile >> outputfile

Dans ce cas, la sortie ne sera pas réécrite à chaque exécution de la commande, mais la sortie sera ajoutée au fichier existant.

Plus d’informations sur la redirection des entrées et des sorties dans Windows, vous pouvez trouver ici .

Notez que les symboles <, > et >> doivent être entrés verbatim - ils ne servent pas uniquement à des fins de présentation dans cette explication. Donc, par exemple:

App.exe < file1 >> file2
17
gawi

En plus de la redirection d'origine >/>> et <

Vous pouvez également rediriger std::cin et std::cout.

Comme suit:

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

}
5
P0W

[Je viens d'expliquer l'argument de ligne de commande utilisé dans la question]

Vous pouvez fournir un nom de fichier en tant qu'entrée de ligne de commande à l'exécutable, mais vous devez ensuite les ouvrir dans votre code. 

Comme

Vous avez fourni deux arguments de ligne de commande, à savoir inputfile et outputfile.

[App.exe inputfile outputfile]

Maintenant dans votre 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;
}
0
Dr. Xperience

Il est important que vous compreniez le concept de redirection . La redirection redirige l'entrée standard, la sortie standard et l'erreur standard.

Les commandes de redirection courantes sont les suivantes:

  • > redirige la sortie standard d'une commande vers un fichier, en remplaçant le contenu précédent.

    $ command > file

  • >> redirige la sortie standard d'une commande vers un fichier, en ajoutant un nouveau contenu à l'ancien contenu.

    $ command >> file

  • < redirige l'entrée standard vers une commande.

    $ command < file

  • | redirige la sortie standard d'une commande vers une autre commande.

    $ command | another_command

  • 2> redirige l'erreur standard vers un fichier.

    $ command 2> file

    $ command > out_file 2> error_file

  • 2>&1 redirige stderr vers le même fichier que stdout a été redirigé.

    $ command > file 2>&1

Vous pouvez combiner la 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

Même si cela ne fait pas partie de votre question, vous pouvez également utiliser d'autres commandes plus puissantes lorsqu'elles sont combinées à des commandes de redirection:

  • sort : trie les lignes de texte par ordre alphabétique.
  • uniq : filtre les doublons, les lignes de texte adjacentes.
  • grep : recherche un modèle de texte et le renvoie.
  • sed : recherche un modèle de texte, le modifie et le renvoie.
0
lmiguelvargasf