Probleme avec setw()

**jmjmjm** · 29/01/2007, 13h45

Bonjour,
Voila j'ai une classe matrice dans laquelle j'ai une fonction affiche pour l'affichage se servant de setw. Jusque la pas de souci. Dans ma classe matrice j'utilise pour les variables une classes fraction qui me retourne un string du type '5/78' et '3' pour les entiers lorsque j'utilise setw pour l'affichage sa merde !!

Exemple (j'utilise setfild('.') pour le debugage :

Code :

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

1
2
3
3.....5.....4
6...454.....9
4.....5/67.....8

PS : Dans l'affichage du forum ca donne pas top mais en gros 5 et 454 sont aligné avec le 5 de 5/67 et le /67 suis et du coup le 8 est décalé !!

Avez vous tout compris et surtout avez vous une solution ??

MERCI et BONNE PROG !!!

**Jean-Marc.Bourguet** · 29/01/2007, 13h57

Donne un exemple minimal (ou rien ne concerne pas ton probleme) et complet (ou nous ne devons rien ajouter pour le reproduire). La tu es beaucoup trop vague.

**Laurent Gomila** · 29/01/2007, 14h01

Etant donné que setw ne concerne que la prochaine injection, et que "5/67" doit en constituer 3 dans ton cas, essaye de passer par une chaîne temporaire pour n'en faire qu'une :

Code :

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

1
2
3
4
5
6
// std::ostream& os
 
std::ostringstream oss;
oss << "5" << "/" << "64";
 
os << setw(10) << oss.str();

**jmjmjm** · 29/01/2007, 14h10

voici le .h de ma classes Fraction :

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
#include <cstdlib>
#include <iostream>
#include <sstream>
 
using namespace std;
 
/////////////////////////////////////////////////////////////////////////////
////                    CLASSE FRACTION BY ASTERIX                       ////
///////////////////////////////////////////////////////////////////////////// 
class fraction {
    private:
      int num;
      int denom;
      int pgcd (int,int);       
      int simplifie();
    public:
      //constructeur : creation de la fraction et simplification
      fraction(int numerateur=1,int denominateur=1); 
      fraction(string);
      //Surdefinition operateur ds la classe
      int operator= (string);
      //Fonction amie : surdéfinition des operateurs
      friend fraction operator+ (fraction, fraction);
      friend fraction operator- (fraction, fraction);
      friend fraction operator* (fraction, fraction);
      friend fraction operator/ (fraction, fraction);
      friend ostream & operator<< (ostream &, fraction);
      friend istream & operator>> (istream &, fraction &);
      //fonction pour l'affichage
      void affiche();
    };

Voici le .cpp de ma classes Fraction :

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
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
 
#include "Fractionnel.h"
#include <cstdlib>
#include <iostream>
#include <sstream>  
 
 
/////////////////////////////////////////////////////////////////////////////
////                    CONSTRUCTEUR DE LA CLASSE                        ////
/////////////////////////////////////////////////////////////////////////////  
fraction::fraction(int numerateur, int denominateur): num(numerateur), denom(denominateur)
{
    num=numerateur;
    denom=denominateur;
    simplifie();
}
 
 
 
fraction::fraction(string entree)
{
    istringstream iss(entree);
    //affectation du numerateur
    iss>>num;
    //puis du denominateur si le / est present sinon denom =1
    char signe;
    iss>>signe;
    iss>>denom;
}
 
 
 
/////////////////////////////////////////////////////////////////////////////
////            FONCTION CLASSE : AFFICHAGE DES VALEURS                  ////
/////////////////////////////////////////////////////////////////////////////  
void fraction::affiche()
{
    if (denom !=1) cout<<num<<"/"<<denom;
      else cout<<num;
}
 
 
 
/////////////////////////////////////////////////////////////////////////////
////               FONCTION CLASSE : CALCUL DU PGCD                      ////
/////////////////////////////////////////////////////////////////////////////      
int fraction::pgcd (int a,int b) 
{
    a=abs(a);b=abs(b);
    int res = 0 ; 
    if ( a == b ) return a;
    if ( a > b ) return (pgcd (a - b , a));
    if ( a < b ) return (pgcd (a , b - a));    
}
 
 
 
/////////////////////////////////////////////////////////////////////////////
////        FONCTION CLASSE : SIMPLIFICATION DE FRACTION                 ////
/////////////////////////////////////////////////////////////////////////////
int fraction::simplifie()
{
    int PGCD=pgcd(num,denom);
    if (PGCD!=1)
      {
      num/=PGCD;
      denom/=PGCD;
      }
}  
 
 
 
/////////////////////////////////////////////////////////////////////////////
////                    SURDEFINITION OPERATEUR =                        ////
/////////////////////////////////////////////////////////////////////////////
int fraction::operator= (string entree)
{
    istringstream iss(entree);
    //affectation du numerateur
    iss>>num;
    //puis du denominateur si le / est present sinon denom =1
    char signe;
    iss>>signe;
    iss>>denom;         
}
 
 
 
/////////////////////////////////////////////////////////////////////////////
////                    SURDEFINITION OPERATEUR +                        ////
///////////////////////////////////////////////////////////////////////////// 
fraction operator+ (fraction a, fraction b)
{
    fraction c;
    if (a.denom==b.denom) 
      {
        c.denom=a.denom;
        c.num=a.num+b.num;
        c.simplifie();
        return c;
      } 
      else {
        c.denom=a.denom*b.denom;
        c.num =a.num*b.denom + b.num*a.denom;
        c.simplifie();
        return c;
      }
}
 
 
 
/////////////////////////////////////////////////////////////////////////////
////                    SURDEFINITION OPERATEUR -                        ////
///////////////////////////////////////////////////////////////////////////// 
fraction operator- (fraction a, fraction b)
    {
    fraction c;
    if (a.denom==b.denom) 
      {
        c.denom=a.denom;
        c.num=a.num-b.num;
        c.simplifie();
        return c;
      } 
      else {
        c.denom=a.denom*b.denom;
        c.num =a.num*b.denom - b.num*a.denom;
        c.simplifie();
        return c;
      }
}
 
 
 
/////////////////////////////////////////////////////////////////////////////
////                    SURDEFINITION OPERATEUR *                        ////
///////////////////////////////////////////////////////////////////////////// 
fraction operator* (fraction a, fraction b)
{
    fraction c;
    c.denom=a.denom*b.denom;
    c.num =a.num*b.num;
    c.simplifie();
    return c;
}
 
 
 
/////////////////////////////////////////////////////////////////////////////
////                    SURDEFINITION OPERATEUR /                        ////
///////////////////////////////////////////////////////////////////////////// 
fraction operator/ (fraction a, fraction b)
{
    fraction c;
    c.denom = a.denom*b.num;
    c.num   = a.num*b.denom;
    c.simplifie();
    return c;
}
 
/////////////////////////////////////////////////////////////////////////////
////                      SURDEFINITION FLOT <<                          ////
///////////////////////////////////////////////////////////////////////////// 
ostream & operator << (ostream & sortie, fraction f)
{
    if (f.denom != 1) sortie << f.num << "/" << f.denom;
      else sortie << f.num;
    return sortie;
}
 
 
 
/////////////////////////////////////////////////////////////////////////////
////                      SURDEFINITION FLOT >>                          ////
///////////////////////////////////////////////////////////////////////////// 
istream& operator >>(istream & entree, fraction & f)
{
    //Conversion de la valeur entree en string     
    string chaine;
    entree>>chaine;
    istringstream iss(chaine);
    //affectation du numerateur
    iss>>f.num;
    //puis du denominateur si le / est present sinon denom =1
    char signe;
    iss>>signe;
    iss>>f.denom;
    return entree;
}

et voici ce que je fais dans la classes matrices :

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
#include "Fractionnel.h"
#include <stdexcept>
#include <iomanip>
 
class Matrice {
   public:
      Matrice (unsigned rows, unsigned cols);
      fraction& operator() (unsigned row, unsigned col);
      fraction  operator() (unsigned row, unsigned col) const;
 
      ~Matrice();                              // Destructeur
      Matrice(const Matrice& m);               // Constructeur de copie
      Matrice& operator= (const Matrice& m);   // Opérateur d'assignement
 
      void Affiche();                          //Fonction pour l'affichage 
 
      friend Matrice operator+(Matrice,Matrice);   
 
   private:
      unsigned rows_, cols_;
      fraction* data;
};
 
inline Matrice::Matrice(unsigned rows, unsigned cols)
    : rows_ (rows)
    , cols_ (cols)
{
    if (rows == 0 || cols == 0)
       throw out_of_range("Erreur la taille de la matrice est de 0 !!");
    data = new fraction[rows * cols];
}
 
inline Matrice::~Matrice()
{
    delete[] data;
}
 
inline fraction& Matrice::operator() (unsigned row, unsigned col)
{
    if (row >= rows_ || col >= cols_)
       throw out_of_range("Indice hors matrice");
    return data[cols_*row + col];
}
 
inline fraction Matrice::operator() (unsigned row, unsigned col) const
{
    if (row >= rows_ || col >= cols_)
       throw out_of_range("Indice hors matrice");
    return data[cols_*row + col];
}
 
void Matrice::Affiche() 
{
     for ( int row=0;row<rows_;row++) {
         for (int col=0;col<cols_;col++) {
             cout <<setw(8) << operator()(row,col);
         }
     cout <<endl;
     }
}

Voila vous avez tout, au passage qu'en penser vous ?? C ma premiere vrai classes (avec surdefinition d'operateur et tout et tout

) j'espere avoir pas fait trop de betises

**Jean-Marc.Bourguet** · 29/01/2007, 14h14

(Pour le minimal, j'ai deja vu mieux).

Le probleme est bien celui evoque par Laurent. Soit tu prends sa solution, soit tu modifies ton operator<< pour qu'il prenne la largeur du champs en compte (en recuperant la valeur actuelle et la repartissant l'espace prevu entre les trois sorties que tu fais).

**jmjmjm** · 29/01/2007, 14h21

Merci a toi pour la reponse rapide, comme adapter la solution de laurent ?? je ne vois pas je dois modifier ma sortir dans mon Fraction.cpp c bien ca ??
Sinon je ne comprend pas bien ce que tu me conseil toi

(pour le simplifie c pas top le fait d'utiliser le PGCD ??, je ne vois pas trop comment faire autrement )

**Laurent Gomila** · 29/01/2007, 15h16

Par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void Matrice::Affiche() 
{
     for ( int row=0;row<rows_;row++) {
         for (int col=0;col<cols_;col++) {
             std::ostringstream oss;
             oss << operator()(row,col);
             cout <<setw(8) << oss.str();
         }
     cout <<endl;
     }
}

**jmjmjm** · 29/01/2007, 16h04

Merci ça marche niquel c trop bien :!!

Probleme avec setw()

C++

Discussions similaires

Partager

Partager