Discussion :

[KosenHitatchi]

Coucou tous le monde,
Je fais fasse a un problème enfantin que je ne sais pas comment résoudre.
Lors de ma lecture de fichier, je lit des lignes d'entier, celle-ci peut être suivie d'un caractère préalablement définis.

fichier.txt

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
5 //taille ligne, taille colonne
10 20 30 40 50
10 20 f
30 40 50 10 20
f
5 20 f

Lors ma lecture sert a initialiser une matrice, si dans mon cas f est détecter, alors je dois remplir le reste de ma ligne par 1000. Malheureusement je n'arrive pas a effectuer correctement cette opération.
Principalement sur la détection.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
ifstream sourceFile (FICHIERTEXTE)
if (sourceFile.is_open())
    {
       int taille= 0;
       sourceFile >> taille;
       maMatrice.creation(taille); //creation de ma matrice
       int readBuf; //Buffer de lecture
       for (int lig=0; lig<nbPersonnes; lig++)
        {
            for (int col=0; col<nbPersonnes; col++)
            {
                sourceFile >> readBuf ;
                //l'idee serait de faire une verification du caratère
                if (readBufChar == (int)'f' || readBuf == (int)'F')  //cette condition ne marche pas mais c'est pour donner une idee
                {
                      maMatrice.SetCase_matriceVal(lig,col,readBuf);
                      int newLig=col;
                      for (int newLig; newLig<nbPersonnes; newLig++)
                       {
                           maMatrice.SetCase_matriceVal(lig,newLig,MMAX); // on remplace f et les case qui suivent sur la même ligne par MMAX (valeur maximal possible)
                       }
                          col = newLig;
                  }
                 else
                 {
                       maMatrice.SetCase_matriceVal(lig,col,readBuf);
                 }
             }
        }
    }

Pour avoir un resultat comme cella :

maMatrice

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 10   20   30   40   50
 10   20  1000 1000 1000
 30   40   50   10   20
1000 1000 1000 1000 1000 
  5   20  1000 1000 1000 

Merci pour votre aide.

Cordiallement

[Neckara]

Bonjour,

Est-ce que ce 'f' est réellement utile?
Tu sembles mettre un f à chaque fin de ligne non-complète, dans ce cas là, est-ce qu'avec un getline puis un stringstream (sstream) tu ne peux pas remplir ta matrice et mettre la valeur 1 000 aux éléments manquants ?

[KosenHitatchi]

Merci Neckara pour ta réponse.
Je viens de chercher et je n'ai pas compris comment utiliser le sstream.
Peux tu me l'expliquer par un exemple.

Merci

[Neckara]

La FAQ C++ contient tout ce qu'il faut savoir

http://cpp.developpez.com/faq/cpp/?p...NGS_convert_to
http://cpp.developpez.com/faq/cpp/?p...NGS_convert_to
http://cpp.developpez.com/faq/cpp/?page=SL

Pour plus d'information :
http://www.cplusplus.com/reference/s.../stringstream/

Pour un exemple de code :
http://khayyam.developpez.com/articl...ge=page_2#LIII

Après c'est le genre de chose où il est impératif de savoir chercher et comprendre par soi-même.

[KosenHitatchi]

Merci Neckara pour toute ces docs, mais je suis encore plus perdu, et c'est pas faute d'avoir chercher.

Je penses que le principal problème provient du fait que je n'arrive pas a détecter le 'f' ainsi que sa position dans le string issu de la getline.

Comment fait'on pour détecter le caractère 'f' dans un flux.

Actuellement et fonction de tes indication, je fais :
test.txt

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
1 2 3 4 f
1 4 2 5 3
3 2 f
1 2 3 5 4
2 1 4 3 f

monCode.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
        maMatrice.ConstructionMatrice();
        affichage(maMatrice);
        nbPersonnes = maMatrice.Get_nbPersonnes(); // mesure de securitée en cas ou la variable aurait été modifiée
        int readBuf = 0;//Buffer de lecture
        string stringTemp;
        for (int lig=0; lig<nbPersonnes; lig++)
        {
            getline(sourceFile,stringTemp);
            cout<<"String ligne : "<<lig<<" => "<<stringTemp<<endl;   //Pourquoi pour lig= 0 string ligne = non definis
            stringstream oss(stringTemp);
            cout<<"     ligne : "<<lig<<" => "<<oss.str()<<endl;
            for (int col=0; col<nbPersonnes; col++)
            {
                if (oss.peek() == 'f')
                {
                    cout<<"detection f a la ligne "<<lig<<" colonne "<<col<<endl;
                    oss >> readBuf; //afin de faire avancer la tête de lecture
                    col = nbPersonnes;//on arrete la boucle
                }
                else
                {
                    oss>>readBuf;
                    cout<<"     redbuf ligne "<<lig<<" colonne "<<col<<" = "<<readBuf<<endl;
                    maMatrice.SetCase_matriceVal(lig,col,readBuf);
                }
            }
        }

Log d'execution

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
###########################################
_nbPersonnes : 5         _typePbm : 1
 ---_matriceVal ---
    5 5 5 5 5
    5 5 5 5 5
    5 5 5 5 5
    5 5 5 5 5
    5 5 5 5 5
###########################################
String ligne : 0 =>
     ligne : 0 =>
     redbuf ligne 0 colonne 0 = 0
     redbuf ligne 0 colonne 1 = 0
     redbuf ligne 0 colonne 2 = 0
     redbuf ligne 0 colonne 3 = 0
     redbuf ligne 0 colonne 4 = 0
String ligne : 1 => 1 2 3 4 f
     ligne : 1 => 1 2 3 4 f
     redbuf ligne 1 colonne 0 = 1
     redbuf ligne 1 colonne 1 = 2
     redbuf ligne 1 colonne 2 = 3
     redbuf ligne 1 colonne 3 = 4
     redbuf ligne 1 colonne 4 = 4
String ligne : 2 => 1 4 2 5 3
     ligne : 2 => 1 4 2 5 3
     redbuf ligne 2 colonne 0 = 1
     redbuf ligne 2 colonne 1 = 4
     redbuf ligne 2 colonne 2 = 2
     redbuf ligne 2 colonne 3 = 5
     redbuf ligne 2 colonne 4 = 3
String ligne : 3 => 3 2 f
     ligne : 3 => 3 2 f
     redbuf ligne 3 colonne 0 = 3
     redbuf ligne 3 colonne 1 = 2
     redbuf ligne 3 colonne 2 = 2
     redbuf ligne 3 colonne 3 = 2
     redbuf ligne 3 colonne 4 = 2
String ligne : 4 => 1 2 3 5 4
     ligne : 4 => 1 2 3 5 4
     redbuf ligne 4 colonne 0 = 1
     redbuf ligne 4 colonne 1 = 2
     redbuf ligne 4 colonne 2 = 3
     redbuf ligne 4 colonne 3 = 5
     redbuf ligne 4 colonne 4 = 4
Valeur max : 5
---maMatriceSolution---
###########################################
_nbPersonnes : 5         _typePbm : 1
 ---_matriceVal ---
    0 0 0 0 0
    1 2 3 4 4
    1 4 2 5 3
    3 2 2 2 2
    1 2 3 5 4
###########################################
 
----------Fin de programme---------
 
Process returned 0 (0x0)   execution time : 0.148 s
Press any key to continue.

Plusieurs questions :
Pour la premiere ligne n'est'elle lue que durant la seconde iteration ?

Ensuite pourquoi oss.peek='f' n'est'il pas reconnu ?

Enfin pourquoi la valeur des case egale ou superieur a la position de f, on leur valeur modifier a 4 ?
Sachant que toutes les cases sont initialisée a MMAX lors de la création de la matrice.


J’espère que vous pourrez m'aider car je pédale dans mon code depuis un bon bout de temps.

Merci

Kosen

[Neckara]

Bonjour,

Pourquoi chercher compliqué ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
for (int lig=0; lig<nbPersonnes; lig++)
{
            getline(sourceFile,stringTemp);
            stringstream oss(stringTemp);
            int col = 0;
            int valeur;
            while( oss >> valeur)
                      maMatrice.SetCase_matriceVal(lig,col++,valeur);
            if( col != nbPersonnes)
                      std::cout << "il y a un f" << std::endl;
 
}

[KosenHitatchi]

Merci sa marche.
Petite question afin de comprendre :

stringTemp comporte toute la ligne jusqu'à '\n', et de ce fait oss aussi.
Comment se fait'il que le caractère 'f' ne soit pas incorporé dans valeur?

La réponse intuitive serait la suivante, les deux types sont different donc on stocke pas la valeur de 'f'.
Pourquoi la valeur ascii de 'f' n'est elle pas récupérée dans ce cas-ci?

Enfin, comment faudra t'il traiter une ligne tel que celle-ci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

10 20 y 30 40 x y

Ou y et x des valeurs a modifier.

Je serait tenté de faire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
getline(sourceFile,stringTemp);
stringstream oss(stringTemp);
int col = 0;
char monCharTemp;
if(oss>>monCharTemp == 'x')
{
      maMatrice.SetCase_matriceVal(lig,col++,v_X);
}
if(oss>>monCharTemp == 'y')
{
      maMatrice.SetCase_matriceVal(lig,col++,v_Y);
}
else
{
      maMatrice.SetCase_matriceVal(lig,col++,(int)monCharTemp);
}

Merci

[Bousk]

valeur est un int, l'opérateur >> a été surchargé et s'il ne peut pas lire un int il te retournera faux. (enfin il me semble que c'est plus compliqué que ça, il est sensé retourner l'objet pour pouvoir chainer les appels, donc faut gérer du flag d'erreur normalement non ?)
Tout simplement.
Si tu veux lire ton f, il faut le lire dans un char.

Si le format du fichier se complexifie, il faut complexifier la logique de lecture.

http://www.cplusplus.com/reference/i...perator%3E%3E/

[Neckara]

valeur est un int, l'opérateur >> a été surchargé et s'il ne peut pas lire un int il te retournera faux. (enfin il me semble que c'est plus compliqué que ça, il est sensé retourner l'objet pour pouvoir chainer les appels, donc faut gérer du flag d'erreur normalement non ?)

Les opérateur >> et << lorsqu'ils sont utilisé sur un flux de la STL retournent une référence sur le flux.
Ensuite lors d'un if(stream >> value) le flux est implicitement convertie en void * grâce à un opérateur de convertion (operator(void *) si je ne me trompe pas) qui est à son tour convertit en bool.

Lorsqu'on fait : if( ! stream >> value), on utilise l'opérateur ! qui a été redéfini pour les flux et qui retourne un booléen.

Ces différents opérateurs ne retourneront pas vrai ou faux si l'opération a échouée mais si le flux est valide ie si good() retourne true.
Pour plus de détails cf : http://www.cplusplus.com/reference/ios/ios/
En particulier : clear(), eof(), bad(), fail(), operator void *, operator!

[koala01]

salut,

Les opérateur >> et << lorsqu'ils sont utilisé sur un flux de la STL retournent une référence sur le flux.
Ensuite lors d'un if(stream >> value) le flux est implicitement convertie en void * grâce à un opérateur de convertion (operator(void *) si je ne me trompe pas) qui est à son tour convertit en bool.

Lorsqu'on fait : if( ! stream >> value), on utilise l'opérateur ! qui a été redéfini pour les flux et qui retourne un booléen.

Ces différents opérateurs ne retourneront pas vrai ou faux si l'opération a échouée mais si le flux est valide ie si good() retourne true.
Pour plus de détails cf : http://www.cplusplus.com/reference/ios/ios/
En particulier : clear(), eof(), bad(), fail(), operator void *, operator!

En fait, tu as directement l'opérateur ! qui est de type booleen

[Bousk]

Effectivement, je l'ai vu quelques minutes après
http://www.cplusplus.com/reference/i...erator_voidpt/