tellg retourne -1

Version imprimable

tellg retourne -1

bonjour,

je voudrais parcourir un fichier en mode binaire à l'aide d'un double tampon
la méthode "carSuiv()", qui doit donner dans l'attribut "c" le caractère suivant, fonctione très bien.
par contre, la méthode reculer, qui doit reculer d'un caractère dans le double tampon, n'arrive pas à lire le fichier d'entrée
pourquoi fichier.tellg() retourne -1?
quelqu'un a une idée?

Code:

1
2
3
4
5
6
7
8
main.cpp
#include <iostream>
#include "lexical.hpp"
 
int main(){
   lexical exemple("test.ors");
   exemple.anaLex();
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
lexical.hpp
#ifndef LEXICAL_HPP
#define LEXICAL_HPP
#include <fstream>
#include <string>
 
constexpr int tailleTampon=8,demiTampon=tailleTampon/2-1,sentinelle1=demiTampon,sentinelle2=tailleTampon-1;
 
class lexical{
public:
   lexical(std::string const& nomFichier);
   void anaLex();
   int getLigne();
private:
   void charger1();
   void charger2();
   void carSuiv();
   void reculer();
   void recule(int n);
   bool debutFichier();
   void echec();
   //enreg mot();
   void getFileSize();
   long tailleFichier;
   char c;
   char tampon[tailleTampon];
   int ligne;
   int posDemi;
   int derniers;
   int debut;
   int etat;
   int enAvant;
   int debutLex;
   std::string representation;
   std::ifstream fichier; /*("test.txt",std::ifstream::binary)*/
};
#endif

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
lexical.cpp
#include <iostream>
#include <fstream>
#include "lexical.hpp"
 
 
 
 
lexical::lexical(std::string const& nomFichier):ligne(1),posDemi(0),derniers(0),debut(0),enAvant(0),debutLex(0){
   fichier.open(nomFichier.c_str(),std::ifstream::binary);
   if(!fichier){
      std::cerr<<"impossible d'ouvrir le fichier"<<std::endl;
      exit(1);
   }
   getFileSize();
   tampon[sentinelle1]=tampon[sentinelle2]=EOF;
   charger1();
   posDemi++;
}
 
void lexical::getFileSize(){
    // sauvegarder la position courante
    long pos = fichier.tellg(); 
    // se placer en fin de fichier
    fichier.seekg( 0 , std::ios_base::end );
    // récupérer la nouvelle position = la taille du fichier
    tailleFichier = fichier.tellg();
    // restaurer la position initiale du fichier
    fichier.seekg( pos,  std::ios_base::beg );
}
 
void lexical::carSuiv(){
   c=tampon[enAvant++];
   debutLex++;
   if(c==EOF){
      if(enAvant==sentinelle1+1){
         if(fichier.tellg()<tailleFichier){
            charger2();
            posDemi++;
            c=tampon[enAvant++];
         }
            // sinon c==EOF
      }
      else if(enAvant==sentinelle2+1)
         if(fichier.tellg()<tailleFichier){
            charger1();
            posDemi++;
            enAvant=1;
            c=tampon[0];
         }
   }
}
void lexical::reculer(){
   std::cout<<fichier.tellg()<<std::endl;
   if(enAvant==0){
      if(posDemi>0){
         enAvant=sentinelle2-1;
         fichier.seekg(-derniers-demiTampon,fichier.cur);
         charger2();
         fichier.seekg(-derniers-demiTampon,fichier.cur);
         posDemi--;
      }
   }  
   else if(enAvant==sentinelle1+1){
      fichier.seekg(-derniers-demiTampon,fichier.cur);
      enAvant=sentinelle1-1;
      charger1();
      fichier.seekg(-derniers-demiTampon,fichier.cur);
      posDemi--;
   }
   else
      enAvant--;
   debutLex--;
}
void lexical::charger1(){
   for(int i=0;i<demiTampon+1;i++)
      tampon[i]=EOF;
   fichier.read(tampon,demiTampon);
   derniers=fichier.gcount();
 
}
 
void lexical::charger2(){
   for(int i=sentinelle1+1;i<tailleTampon;i++)
      tampon[i]=EOF;
   fichier.read(tampon+sentinelle1+1,demiTampon);
   derniers=fichier.gcount();
}
 
void lexical::anaLex(){
   long count=0;
   while(true){
      carSuiv();
      count++;
      if(count==tailleFichier)
         break;
      std::cout<<c;
   }
   reculer();
   while(true){
      reculer();
      carSuiv();
      reculer();
      count--;
      if(count>0)
         break;
      std::cout<<c;
   }
   std::cout<<std::endl;
}

Code:

1
2
test.ors
01234

Code:

1
2
3
4
5
6
sortie sur la console
./a.out 
01234
-1
-1
-1

bonjour,

peut-être que je n'ai pas de réponse à cause de ce qui est hors-sujet dans mon code.
en le résumant par ce qui est utile ici, ça donne ça:

Code:

1
2
3
4
5
6
7
8
9
main.cpp
#include <iostream>
#include "lexical.hpp"
 
 
int main(){
   lexical exemple("test.ors");
   exemple.anaLex();
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
lexical.hpp
#ifndef LEXICAL_HPP
#define LEXICAL_HPP
#include <fstream>
#include <string>
 
constexpr int tailleTampon=8,demiTampon=tailleTampon/2-1,sentinelle1=demiTampon,sentinelle2=tailleTampon-1;
 
class lexical{
public:
   lexical(std::string const& nomFichier);
   void anaLex();
private:
   void charger1();
   void charger2();
   void carSuiv();
   void reculer();
   void getFileSize();
   long tailleFichier;
   char c;
   char tampon[tailleTampon];
   int posDemi;
   int derniers;
   int enAvant;
   std::ifstream fichier; /*("test.txt",std::ifstream::binary)*/
};
#endif

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
lexical.cpp
#include <iostream>
#include <fstream>
#include "lexical.hpp"
 
 
 
 
lexical::lexical(std::string const& nomFichier):posDemi(0),derniers(0),enAvant(0){
   fichier.open(nomFichier.c_str(),std::ifstream::binary);
   if(!fichier){
      std::cerr<<"impossible d'ouvrir le fichier"<<std::endl;
      exit(1);
   }
   getFileSize();
   tampon[sentinelle1]=tampon[sentinelle2]=EOF;
   charger1();
   posDemi++;
}
 
void lexical::getFileSize(){
    // sauvegarder la position courante
    long pos = fichier.tellg(); 
    // se placer en fin de fichier
    fichier.seekg( 0 , std::ios_base::end );
    // récupérer la nouvelle position = la taille du fichier
    tailleFichier = fichier.tellg();
    // restaurer la position initiale du fichier
    fichier.seekg( pos,  std::ios_base::beg );
}
 
void lexical::carSuiv(){
   c=tampon[enAvant++];
 
   if(c==EOF){
      if(enAvant==sentinelle1+1){
         if(fichier.tellg()<tailleFichier){
            charger2();
            posDemi++;
            c=tampon[enAvant++];
         }
            // sinon c==EOF
      }
      else if(enAvant==sentinelle2+1)
         if(fichier.tellg()<tailleFichier){
            charger1();
            posDemi++;
            enAvant=1;
            c=tampon[0];
         }
   }
}
void lexical::reculer(){
   std::cout<<fichier.tellg()<<std::endl;
   if(enAvant==0){
      if(posDemi>0){
         enAvant=sentinelle2-1;
         fichier.seekg(-derniers-demiTampon,fichier.cur);
         charger2();
         fichier.seekg(-derniers-demiTampon,fichier.cur);
         posDemi--;
      }
   }  
   else if(enAvant==sentinelle1+1){
      fichier.seekg(-derniers-demiTampon,fichier.cur);
      enAvant=sentinelle1-1;
      charger1();
      fichier.seekg(-derniers-demiTampon,fichier.cur);
      posDemi--;
   }
   else
      enAvant--;
}
void lexical::charger1(){
   for(int i=0;i<demiTampon+1;i++)
      tampon[i]=EOF;
   fichier.read(tampon,demiTampon);
   derniers=fichier.gcount();
 
}
 
void lexical::charger2(){
   for(int i=sentinelle1+1;i<tailleTampon;i++)
      tampon[i]=EOF;
   fichier.read(tampon+sentinelle1+1,demiTampon);
   derniers=fichier.gcount();
}
 
void lexical::anaLex(){
   long count=0;
   while(true){
      carSuiv();
      count++;
      if(count==tailleFichier)
         break;
      std::cout<<c;
   }
   reculer();
   while(true){
      reculer();
      carSuiv();
      reculer();
      count--;
      if(count>0)
         break;
      std::cout<<c;
   }
   std::cout<<std::endl;
}

Code:

1
2
test.ors
01234

Code:

1
2
3
4
5
6
sortie sur la console
$ ./a.out 
01234
-1
-1
-1

cette fois ça marche: le problème était dans la méthode anaLex():

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void lexical::anaLex(){
   long count=0;
   while(true){
      carSuiv();
      count++;
      if(count==tailleFichier)
         break;
      std::cout<<c;
   }
   reculer();
   while(true){
      reculer();
      carSuiv();
      reculer();
      count--;
      if(count>0)
         break;
      std::cout<<c;
   }
   std::cout<<std::endl;
}

l'erreur est:

Code:

1
2
      if(count>0)
         break;

la bonne méthode anaLex est:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void lexical::anaLex(){
   long count=0;
   while(true){
      carSuiv();
      count++;
      if(count==tailleFichier)
         break;
      std::cout<<c;
   }
   reculer();
   while(true){
      reculer();
      carSuiv();
      reculer();
      count--;
      if(c==EOF)
         break;
      std::cout<<c;
   }
   std::cout<<std::endl;
}

la sortie sur console est maintenant:

Code:

1
2
3
4
$ ./a.out 
01234
 
43210

ce qui est ce que je voulais
résolu