Inversion lignes de .txt par blocs

Inversion lignes de .txt par blocs - C++ - Programmation

Marsh Posté le 12-09-2014 à 16:56:26    

Bonjour,
J'aimerais connaître une méthode pour inverser des blocs d'un fichier txt
par exemple :
6
1
1
2
2
3
5
4
4
deviendrait :
5
4
4
2
2
3
6
1
1
 
Merci d'avance !

Reply

Marsh Posté le 12-09-2014 à 16:56:26   

Reply

Marsh Posté le 15-09-2014 à 14:13:48    

Bon, manifestement tu inverses les premiers et derniers tiers du fichier.
En supposant que ton fichier tienne en mémoire (bref qu'il ne soit pas énorme) j'ai pondu un truc vite fait qui te montre l'idée de base (mais ne marche que si les blocs a échanger sont de même taille):
 

Code :
  1. #include <algorithm>
  2. #include <fstream>
  3. #include <iostream>
  4. #include <string>
  5. #include <vector>
  6. #include <system_error>
  8. int main()
  9. {
  10.     std::string filename = "data.txt";
  11.     try {
  12.         // on ouvre le fichier
  13.         std::ifstream ifs( filename );
  14.         if (!ifs) {
  15.             throw std::system_error( ENOENT, std::system_category(), filename );
  16.         }
  17.         // on lit son contenu dans un vecteur
  18.         std::vector<std::string> lines;
  19.         lines.reserve(256); // pas de réallocation si moins de 256 lines
  20.         for (std::string line; std::getline( ifs, line ); /* */) {
  21.             lines.push_back( line );
  22.         }
  23.         // on calcule la taille des blocs de début et fin faisant 1/3 des lignes
  24.         unsigned int bloc_size = lines.size()/3;
  25.         // on échange les blocs dans le vecteur
  26.         std::swap_ranges( lines.begin(), lines.begin() + bloc_size, lines.end() - bloc_size );
  27.         // On affiche le résultat
  28.         for ( auto it = lines.begin(); it != lines.end(); ++it ) {
  29.             std::cout << *it << std::endl;
  30.         }
  31.     } catch ( const std::exception & e ) {
  32.         std::cerr << "Error : " << e.what() << "." << std::endl;
  33.     }
  34.     return 0;
  35. }


 
A compiler en C++11 (utilisation du test (!ifs) par exemple).
 
Note: si tu dois permuter des blocs d'entiers dans ton code, il serait peut être plus simple de faire un std::vector<unsigned int> et de faire du swap_ranges directement dessus.
 
A+,


Message édité par gilou le 15-09-2014 à 14:24:17

---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Marsh Posté le 16-09-2014 à 10:43:08    

Merci pour ta réponse.
L'entreprise chez qui je travaille en ce moment ne dispose pas de c++11, du coup j'ai essayé de coder l'ensemble de façon bête et méchante. J'arrive à isoler le dernier bloc, mais quand il s'agit de reparcourir le texte pour récupérer l'avant dernier ça ne marche pas, du coup je me retrouve avec des fichiers textes avec uniquement le dernier bloc...
ci dessous le code commenté :
 

Code :
  1. #include <iostream>
  2. #include <fstream>
  3. #include <string>
  4. #include <stdlib.h>
  5. #include <stdio.h>
  6. #include <sstream>
  8. using namespace std;
  10. int main()
  11. {
  13. ifstream liste("/home/modis/Desktop/Traitement/liste_fichiers_txt.txt", ios::in);//ouverture de la liste de fichiers
  15. if(liste)
  16. {
  17.  string lisligne;
  18.  string filename0, filename1;
  19.  string ligne,of_ligne;
  20.  int n_ligne=40701, i=0,j;
  21.  double double1, double2, double3, double4, double5, double6;
  22.  string s1,s2,s3,s4,s5,s6;
  24. for(j=0;j<185;j++) //185 blocs
  25.   {
  26.  while(getline(liste, lisligne))
  27.  {
  29.    liste >> filename0; //lecture du nom du fichier à ouvrir dans un fichier texte avec l'ensemble des noms
  30.    filename1 = "/home/modis/Desktop/Traitement/fichiers_invers/" + filename0;
  31.    filename0 = "/home/modis/Desktop/Traitement/données_modèles/données_modèles/2011/" + filename0;
  34.    ifstream fichier0(filename0.c_str(), ios::in);
  35.    ofstream fichier1(filename1.c_str(), ios::out | ios::binary);
  38.    if(fichier0 && fichier1)
  39.     {
  43.      while(getline(fichier0, ligne))
  44.      {
  45.          ostringstream oss1,oss2,oss3,oss4,oss5,oss6;
  48.         if(i==n_ligne-2-220*j) //220 lignes par bloc
  49.         {
  50.          fichier0 >> double1 >> double2 >> double3 >> double4 >> double5 >> double6;
  51.          oss1 << double1;
  52.          oss2 << double2;
  53.          oss3 << double3;
  54.          oss4 << double4;
  55.          oss5 << double5; oss6<<double6;
  56.          s1 = oss1.str();
  57.          s2 = oss2.str();
  58.          s3 = oss3.str();
  59.          s4 = oss4.str();
  60.          s5 = oss5.str();
  61.          s6 = oss6.str();
  62.          of_ligne= s1 + " " + s2 + " " + s3 + " " + s4 + " " + s5 + " " + s6 + "\n";
  63.          fichier1 << of_ligne;//ecriture de la ligne dans le fichier output
  64.          //vide les ostringstream        
  65.          oss1.str("" );
  66.          oss2.str("" );
  67.          oss3.str("" );
  68.          oss4.str("" );
  69.          oss5.str("" );
  70.          oss6.str("" );
  72.         }
  73.         else i++;//si je ne suis toujours pas à la ligne voulue
  80.      }
  81.     }
  82.     else
  83.      cerr<<"Impossible d'ouvrir le fichier!1"<<endl;
  84.     i=0;//remise à zero pour reparcourir le fichier
  86.  }
  87. }
  88. }
  89. else
  90.  cerr<<"Impossible d'ouvrir le fichier!2"<<endl;
  92. return 0;
  93. }


 
Je tourne en rond dessus depuis un bon petit moment, j'aimerais juste savoir ce qui empêche de reparcourir le fichier pour prendre un nouveau bloc...
Le but étant d'ouvrir un fichier, de parcourir ses lignes jusqu'à la premiere du bloc voulu, d'écrire ces lignes dans un nouveau fichier. Une fois arrivé à la dernière ligne, on reparcourt le fichier jusqu'à la premiere ligne du bloc au dessus puis on écris la suite etc.
Merci d'avance


Message édité par rattlesnake le 16-09-2014 à 10:52:06
Reply

Marsh Posté le 16-09-2014 à 11:47:41    

Bon, il y a pas mal de problèmes avec ton code et j'aimerais comprendre un peu mieux ce que tu veux faire.
Tu as un fichier avec 185 blocs de 220 lignes (et une ou plusieurs lignes d'en-tête?)
Chaque ligne contient 6 entiers longs (écrits sous format lisible, non binaire).
 
0) Quelle est la taille de ton fichier de départ?
1) une ou plusieurs lignes d'en-tête à ton fichier?
2) quels blocs permutes tu entre eux?  
 le i-ième bloc avec le (i+1)-ième bloc [blocs successifs]?
 le i-ième bloc avec le (220-i)-ième bloc [blocs symmétriques par rapport au milieu du fichier]?
 autre?
3) dans le fichier résultat, les 6 entiers longs sont au même format que dans celui de départ (ie lignes inchangées) ou bien sont ils en binaire?
*) tu utilises quel compilo, avec quelle version, parce que de nos jours, en entreprise, ne pas disposer d'un compilo le supportant, euh... (ce serait C++14, je comprendrais, mais la)
 
Et sinon, mon source précédent n'était pas bien dur à récrire en C++ archaïque:

Code :
  1. #include <algorithm>
  2. #include <fstream>
  3. #include <iostream>
  4. #include <string>
  5. #include <vector>
  6. #include <stdexcept> // <system_error> seulement en C++11
  8. int main()
  9. {
  10.     const std::string filename("blocs.txt" );
  11.     try {
  12.         // on ouvre le fichier
  13.         std::ifstream ifs( filename.c_str() );  // argument du constructeur en string seulement en C++11
  14.         if (ifs.fail()) {  // booleen sur stream seulement en C++11
  15.             throw std::runtime_error( "No such file or directory: " + filename );  // remplacement vu qu'il y a pas de system_error
  16.         }
  17.         // on lit son contenu dans un vecteur
  18.         std::vector<std::string> lines;
  19.         lines.reserve(256); // pas de réallocation si moins de 256 lines
  20.         for (std::string line; std::getline( ifs, line ); /* */) {
  21.             lines.push_back( line );
  22.         }
  23.         // on calcule la taille des blocs de début et fin faisant 1/3 des lignes
  24.         unsigned int bloc_size = lines.size()/3;
  25.         // on échange les blocs dans le vecteur
  26.         std::swap_ranges(lines.begin(), lines.begin() + bloc_size, lines.end() - bloc_size);
  27.         // On affiche le résultat
  28.         for ( std::vector<std::string>::iterator it = lines.begin(); it != lines.end(); ++it ) {  // iterateur a type déduit avec auto seulement en C++11
  29.             std::cout << *it << std::endl;
  30.         }
  31.     } catch ( const std::exception & e ) {
  32.         std::cerr << "Error : " << e.what() << "." << std::endl;
  33.     }
  34.     return 0;
  35. }


A+,

Message cité 1 fois
Message édité par gilou le 16-09-2014 à 12:14:43

---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Marsh Posté le 16-09-2014 à 12:50:31    

Pour ton pb, si on est bien dans le cas d'une inversion de blocs par rapport au milieu du fichier, voici un point de départ (en supposant que ta machine a assez de mémoire pour lire le fichier dans un vector de string, ce qui devrait être je pense le cas).
 

Code :
  1. #include <algorithm>
  2. #include <fstream>
  3. #include <iostream>
  4. #include <string>
  5. #include <vector>
  6. #include <stdexcept>
  8. int main()
  9. {
  10.     const std::string filename("blocs.txt" );
  11.     const unsigned int bloc_size = 220;
  12.     const unsigned int blocs_nb  = 185;
  13.     try {
  14.         // on ouvre le fichier
  15.         std::ifstream ifs( filename.c_str() );
  16.         if (ifs.fail()) {
  17.             throw std::runtime_error( "No such file or directory: " + filename );
  18.         }
  19.         // on lit son contenu dans un vecteur
  20.         std::vector<std::string> lines;
  21.         lines.reserve(40701);
  22.         for (std::string line; std::getline( ifs, line ); /* */) {
  23.             lines.push_back( line );
  24.         }
  25.         for (unsigned int i = 0; i < (int)(blocs_nb/2); ++i) {
  26.             std::swap_ranges(lines.begin() + (i * bloc_size),
  27.                              lines.begin() + ((i+1) * bloc_size),
  28.                              lines.end()   - ((i+1) * bloc_size));
  29.         }
  30.         // On affiche le résultat
  31.         for ( std::vector<std::string>::iterator it = lines.begin(); it != lines.end(); ++it ) {
  32.             std::cout << *it << std::endl;
  33.         }
  34.     } catch ( const std::exception & e ) {
  35.         std::cerr << "Error : " << e.what() << "." << std::endl;
  36.     }
  37.     return 0;
  38. }


 
J'ai testé vite fait sur un fichier de 7 blocs de 3 lignes, et ça marchait sans pb.
 
A+,

Message cité 1 fois
Message édité par gilou le 16-09-2014 à 12:53:42

---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Marsh Posté le 16-09-2014 à 13:04:20    

gilou a écrit :

Bon, il y a pas mal de problèmes avec ton code et j'aimerais comprendre un peu mieux ce que tu veux faire.
Tu as un fichier avec 185 blocs de 220 lignes (et une ou plusieurs lignes d'en-tête?)
Chaque ligne contient 6 entiers longs (écrits sous format lisible, non binaire).
 
0) Quelle est la taille de ton fichier de départ?
1) une ou plusieurs lignes d'en-tête à ton fichier?
2) quels blocs permutes tu entre eux?  
 le i-ième bloc avec le (i+1)-ième bloc [blocs successifs]?
 le i-ième bloc avec le (220-i)-ième bloc [blocs symmétriques par rapport au milieu du fichier]?
 autre?
3) dans le fichier résultat, les 6 entiers longs sont au même format que dans celui de départ (ie lignes inchangées) ou bien sont ils en binaire?
*) tu utilises quel compilo, avec quelle version, parce que de nos jours, en entreprise, ne pas disposer d'un compilo le supportant, euh... (ce serait C++14, je comprendrais, mais la)
 
Et sinon, mon source précédent n'était pas bien dur à récrire en C++ archaïque:

Code :
  1. #include <algorithm>
  2. #include <fstream>
  3. #include <iostream>
  4. #include <string>
  5. #include <vector>
  6. #include <stdexcept> // <system_error> seulement en C++11
  8. int main()
  9. {
  10.     const std::string filename("blocs.txt" );
  11.     try {
  12.         // on ouvre le fichier
  13.         std::ifstream ifs( filename.c_str() );  // argument du constructeur en string seulement en C++11
  14.         if (ifs.fail()) {  // booleen sur stream seulement en C++11
  15.             throw std::runtime_error( "No such file or directory: " + filename );  // remplacement vu qu'il y a pas de system_error
  16.         }
  17.         // on lit son contenu dans un vecteur
  18.         std::vector<std::string> lines;
  19.         lines.reserve(256); // pas de réallocation si moins de 256 lines
  20.         for (std::string line; std::getline( ifs, line ); /* */) {
  21.             lines.push_back( line );
  22.         }
  23.         // on calcule la taille des blocs de début et fin faisant 1/3 des lignes
  24.         unsigned int bloc_size = lines.size()/3;
  25.         // on échange les blocs dans le vecteur
  26.         std::swap_ranges(lines.begin(), lines.begin() + bloc_size, lines.end() - bloc_size);
  27.         // On affiche le résultat
  28.         for ( std::vector<std::string>::iterator it = lines.begin(); it != lines.end(); ++it ) {  // iterateur a type déduit avec auto seulement en C++11
  29.             std::cout << *it << std::endl;
  30.         }
  31.     } catch ( const std::exception & e ) {
  32.         std::cerr << "Error : " << e.what() << "." << std::endl;
  33.     }
  34.     return 0;
  35. }


A+,


 
 
0) Mes fichiers font 1.3 Mo environ, 186 blocs de 220 lignes soit 40920 lignes en tout
1) Pas d'en-tête, uniquement des mesures sous formes de 6 doubles par ligne
2) Je ne cherche pas à permuter les blocs par rapport au central mais supposons que j'aie 6 blocs :
1
2
3
4
5
6
Je voudrais que ça devienne
6
5
4
3
2
1
3) Qu'ils soient en binaire serait encore mieux (étant donné que je compte utiliser le nouveau fichier pour le transformer en fichier binaire), mais déjà rien que la permutation serait un gros pas en avant
 
Merci beaucoup

Reply

Marsh Posté le 16-09-2014 à 13:28:27    

gilou a écrit :

Pour ton pb, si on est bien dans le cas d'une inversion de blocs par rapport au milieu du fichier, voici un point de départ (en supposant que ta machine a assez de mémoire pour lire le fichier dans un vector de string, ce qui devrait être je pense le cas).
 

Code :
  1. #include <algorithm>
  2. #include <fstream>
  3. #include <iostream>
  4. #include <string>
  5. #include <vector>
  6. #include <stdexcept>
  8. int main()
  9. {
  10.     const std::string filename("blocs.txt" );
  11.     const unsigned int bloc_size = 220;
  12.     const unsigned int blocs_nb  = 185;
  13.     try {
  14.         // on ouvre le fichier
  15.         std::ifstream ifs( filename.c_str() );
  16.         if (ifs.fail()) {
  17.             throw std::runtime_error( "No such file or directory: " + filename );
  18.         }
  19.         // on lit son contenu dans un vecteur
  20.         std::vector<std::string> lines;
  21.         lines.reserve(40701);
  22.         for (std::string line; std::getline( ifs, line ); /* */) {
  23.             lines.push_back( line );
  24.         }
  25.         for (unsigned int i = 0; i < (int)(blocs_nb/2); ++i) {
  26.             std::swap_ranges(lines.begin() + (i * bloc_size),
  27.                              lines.begin() + ((i+1) * bloc_size),
  28.                              lines.end()   - ((i+1) * bloc_size));
  29.         }
  30.         // On affiche le résultat
  31.         for ( std::vector<std::string>::iterator it = lines.begin(); it != lines.end(); ++it ) {
  32.             std::cout << *it << std::endl;
  33.         }
  34.     } catch ( const std::exception & e ) {
  35.         std::cerr << "Error : " << e.what() << "." << std::endl;
  36.     }
  37.     return 0;
  38. }


 
J'ai testé vite fait sur un fichier de 7 blocs de 3 lignes, et ça marchait sans pb.
 
A+,


 
Tiens, j'ai bien l'impression que ça marche ça ! je fais quelques essais et je vous tiens tout de suite au jus !!

Reply

Marsh Posté le 16-09-2014 à 14:39:28    

Dans ton cas, il faudrait faire:
const unsigned int blocs_nb  = 186;
 
et ajouter une vérification (a laquelle j'ai pensé après coup)
// on vérifie la cohérence
 if (bloc_size * blocs_nb != lines.size() ) {
     throw std::logic_error( "Le parametrage par bloc est incoherent avec le nombre de lignes du fichier" );
 }
 
après avoir fait la copie et avant de faire le swap.
 
A+,


---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Marsh Posté le 16-09-2014 à 14:42:55    

Et tu m'as toujours pas dit quel compilo (et sa version) tu utilisais.
A+,


---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Marsh Posté le 16-09-2014 à 15:23:22    

En tapant g++ -v j'obtiens "gcc version 4.3.2 (Debian 4.3.2-1.1)"
 
J'ai une dernière petite question !
Les lignes sont de la forme :
12.5 158.3 12.0 15.1 159.2 0.0
Y a-t il moyen de les lire les double séparement (afin de pouvoir les stocker en binaire dans un autre fichier)
lecture façon :

Code :
  1. fichier0 >> double1 >> double2 >> double3 >> double4 >> double5 >> double6;


Merci encore !

Reply

Marsh Posté le 16-09-2014 à 15:23:22   

Reply

Marsh Posté le 16-09-2014 à 16:01:30    

Ah oui, le compilo date de 6 ans. Pour un truc gratuit comme gcc/g++ c'est un peu bête de ne pas avoir une version a jour, car C++11 corrige et améliore un très grand nombre de chose (le constructeur des fstream qui n'accepte pas les std::string comme argument par exemple, c'est horripilant).
A+,


---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Marsh Posté le 16-09-2014 à 16:14:39    

Bon déjà, sans rentrer dans les histoires de binaires, ce que tu veux faire devrait ressembler à ceci
(pas testé a 100%, mais a 90%, vu que je n'ai ni tes sources ni tes paths sur ma machine).
 

Code :
  1. #include <algorithm>
  2. #include <fstream>
  3. #include <iostream>
  4. #include <string>
  5. #include <vector>
  6. #include <stdexcept>
  9. std::vector<std::string> get_files(const std::string& file)
  10. {
  11.     std::ifstream ifs( file.c_str() );
  12.     if (ifs.fail()) {
  13.         throw std::runtime_error( "Echec a l'ouverture du fichier " + file );
  14.     }
  15.     std::vector<std::string> filelist;
  16.     for (std::string line; std::getline( ifs, line ); ) {
  17.         filelist.push_back( line );
  18.     }
  19.     return filelist;
  20. }
  22. void swap_blocs(const std::string& infile, const std::string& outfile, unsigned int blocs_nb, unsigned int bloc_size)
  23. {
  24.     // on ouvre le fichier en entree
  25.     std::ifstream ifs( infile.c_str() );
  26.     if (ifs.fail()) {
  27.         throw std::runtime_error( "No such file or directory: " + infile );
  28.     }
  29.     // on lit son contenu dans un vecteur
  30.     std::vector<std::string> lines;
  31.     lines.reserve(40921);
  32.     for (std::string line; std::getline( ifs, line ); /* */) {
  33.         lines.push_back( line );
  34.     }
  35.     for (unsigned int i = 0; i < (unsigned int)(blocs_nb/2); ++i) {
  36.         std::swap_ranges(lines.begin() + (i * bloc_size),
  37.                          lines.begin() + ((i+1) * bloc_size),
  38.                          lines.end()   - ((i+1) * bloc_size));
  39.     }
  40.     // on ouvre le fichier en sortie
  41.     std::ofstream ofs( outfile.c_str() );
  42.     if (ofs.fail()) {
  43.         throw std::runtime_error( "No such file or directory: " + outfile );
  44.     }
  45.     // on écrit ligne à ligne dedans
  46.     for ( std::vector<std::string>::iterator it = lines.begin(); it != lines.end(); ++it ) {
  47.         ofs << *it << std::endl;
  48.     }
  49. }
  51. int main()
  52. {
  53.     // données initiales
  54.     const std::string base_dir( "/home/modis/Desktop/Traitement/" );
  55.     const std::string in_dir("fichiers_invers/" );
  56.     const std::string out_dir("données_modèles/données_modèles/2011/" );
  57.     const std::string liste("liste_fichiers_txt.txt" );
  58.     const unsigned int bloc_size = 220;
  59.     const unsigned int blocs_nb  = 186;
  62.     try {
  63.         std::vector<std::string> filelist = get_files(base_dir + liste);
  64.         for ( std::vector<std::string>::iterator it = filelist.begin(); it != filelist.end(); ++it ) {
  65.             swap_blocs( base_dir + in_dir + *it, base_dir + out_dir + *it, blocs_nb, bloc_size);
  66.         }
  67.     } catch ( const std::exception & e ) {
  68.         std::cerr << "Erreur : " << e.what() << "." << std::endl;
  69.     }
  70.     return 0;
  71. }


Toute erreur détectée déclenchera l'arrêt du programme (tu peux coder un autre comportement, fichier de log...)
A+,


Message édité par gilou le 16-09-2014 à 16:16:37

---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Marsh Posté le 16-09-2014 à 18:53:07    

Bon, le même modifié pour lire en interne comme des doubles et non du texte, et pour écrire en binaire.
Sans garanties, mais au vu de mes tests, ça devrait être bon.
 

Code :
  1. #include <algorithm>
  2. #include <fstream>
  3. #include <iostream>
  4. #include <iterator>
  5. #include <sstream>
  6. #include <string>
  7. #include <vector>
  8. #include <stdexcept>
  11. std::vector<std::string> get_files(const std::string& file)
  12. {
  13.     std::ifstream ifs( file.c_str() );
  14.     if (ifs.fail()) {
  15.         throw std::runtime_error( "Echec a l'ouverture du fichier " + file );
  16.     }
  17.     std::vector<std::string> filelist;
  18.     for (std::string line; std::getline( ifs, line ); ) {
  19.         filelist.push_back( line );
  20.     }
  21.     return filelist;
  22. }
  24. void swap_blocs(const std::string& infile, const std::string& outfile, unsigned int blocs_nb, unsigned int bloc_size)
  25. {
  26.     // on ouvre le fichier en entree
  27.     std::ifstream ifs( infile.c_str() );
  28.     if (ifs.fail()) {
  29.         throw std::runtime_error( "Echec a l'ouverture du fichier " + infile );
  30.     }
  31.     // on lit son contenu dans un vecteur de vecteur de doubles
  32.     std::vector<std::vector<double> > lines;
  33.     lines.reserve(40921);
  34.     for (std::string line; std::getline( ifs, line ); /* */) {
  35.         std::istringstream iss( line );
  36.         std::vector<double> numbers;
  37.         numbers.reserve( 6 );
  38.         // on parse les doubles en input et on les range dans le vecteur
  39.         std::copy( std::istream_iterator<double>(iss), std::istream_iterator<double>(), std::back_inserter( numbers ) );
  40.         // on range le vecteur dans le vecteur
  41.         lines.push_back( numbers );
  42.     }
  43.     // On procède au swap des blocs
  44.     for (unsigned int i = 0; i < (unsigned int)(blocs_nb/2); ++i) {
  45.         std::swap_ranges( lines.begin() + (i * bloc_size),
  46.                          lines.begin() + ((i+1) * bloc_size),
  47.                          lines.end()   - ((i+1) * bloc_size) );
  48.     }
  49.     // on ouvre le fichier en sortie
  50.     std::ofstream ofs;
  51.     ofs.open( outfile.c_str(), std::ios::binary );
  52.     if (ofs.fail()) {
  53.         throw std::runtime_error( "Echec a l'ouverture du fichier " + outfile );
  54.     }
  55.     for (std::vector<std::vector<double> >::iterator  it = lines.begin(); it != lines.end(); ++it) {
  56.         for (std::vector<double>::iterator  dt = (*it).begin(); dt != (*it).end(); ++dt) {
  57.             // on écrit un double en binaire. Note: l'endiannesss dépendra de l'OS
  58.             ofs.write( reinterpret_cast<char*>( &(*dt) ), sizeof( double ) );
  59.         }
  60.         // ?? je ne connais pas ton format cible
  61.         ofs << std::endl;
  62.     }
  63. }
  65. int main()
  66. {
  67.     // données initiales
  68.     const std::string base_dir( "/home/modis/Desktop/Traitement/" );
  69.     const std::string in_dir("fichiers_invers/" );
  70.     const std::string out_dir("données_modèles/données_modèles/2011/" );
  71.     const std::string liste("liste_fichiers_txt.txt" );
  72.     const unsigned int bloc_size = 220;
  73.     const unsigned int blocs_nb  = 186;
  75.     try {
  76.         std::vector<std::string> filelist = get_files(base_dir + liste);
  77.         for ( std::vector<std::string>::iterator it = filelist.begin(); it != filelist.end(); ++it ) {
  78.             swap_blocs( base_dir + in_dir + *it, base_dir + out_dir + *it, blocs_nb, bloc_size);
  79.         }
  80.     } catch ( const std::exception & e ) {
  81.         std::cerr << "Erreur : " << e.what() << "." << std::endl;
  82.     }
  83.     return 0;
  84. }


 
A+,


Message édité par gilou le 16-09-2014 à 19:15:16

---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed