Discussion :

[walidaydi]

bon soir,
j'ai ecrivé ce bout de code en c++.l'affichage et le suivant:
500G50 500 Press any key to continue
normalement dans ma programme j'ai demandé de n'est pas affiché les caractere (isalpha()).mais il faire apparaitre la lettre G.
je voulez juste affiché les nombre qui suit la lettre F.

le programme est ci joint.

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
 
#include <iostream.h>		// pour CIN & COUT
#include <iomanip.h>		// pour le format de ces flux
#include <windows.h>		// pour utiliser les API32
#include <stdio.h>			// pour exploiter les Entrées/Sorties standards
#include <conio.h>			// pour exploiter les Entrées/Sorties standards
//#include "RS_232.h"
//#include "send.h"
#include <fstream>
#include <string>
#include <cstring> 
#include <sstream>
#include <math.h>
#include <stdlib.h>
 
using namespace std;
#define P 5	
#define Vmax 1000		//  maximum velocity
void Ffunction(int *i, string line, int *V);
//void Gfunction(int *i, string line,int *V,double *X0,double *Y0,double *Z0);
int i,j,space;
int main () 
{
	double X0=0,Y0=0,Z0=0;
    int V=0;
 
/*******************pour ouvrir un fichier */
 
  string line;
 
  ifstream myfile ("example.txt");
 
  if (myfile.is_open())
  {
	  while (! myfile.eof() )  //teste fin fichier
    {
      getline (myfile,line);
 
 
 
	  space=0;
			for(i=0;space<1;i++)
			{
 
				switch (line[i])
				{
					case 'F':	Ffunction(&i,line,&V);
								break;
 
				//	case 'G':	Gfunction(&i,line,&V,&X0,&Y0,&Z0);
								break;
 
					case '\0':	space = 1;			// end of line
				}
 
			}
 
 
 
    }
 
    myfile.close();
  }
 
  else cout << "Unable to open file"; 
 
  return 0;
 
}
 
//************************ F function(determination de la vitesse)
 
void Ffunction(int *i, string line, int *V)			//(cursor position, read line, last velocity)
 
{
	char velocity [100]={0};
	//char direction;
	int j, space=0;
 
	*i=*i+1;
 
	for (j=0;space<1;*i=*i+1,j++)
	{
		if (line[*i]=='\0' || isalpha(line[*i])>0)	
			space = 1;
 
		else
			velocity[j] = line[*i];
			cout<<line[*i];
	}
	stringstream(velocity) >> *V;//convert velocity (string) to int (*V) 
	*i=*i-1;
 
}

MERCI D'AVANCE

[screetch]

il manque des { } autour du code apres le "else"
n'oublie pas que l'indentation n'est pas partie de la grammaire en C++

[koala01]

Salut, et bienvenue sur le forum

Avant toute choses, je voudrais attirer ton attention sur les en-têtes que tu inclus...

En effet, on y trouve, pèle-mêle, des en-têtes obsolètes (datant d'avant la standardisation), des en-tête "modernes" (datant d'après la standardisation), des en-têtes C et même des en-tête C propriétaires et tout à fait non portables...

Bref, la première chose à faire serait déjà de faire un peu le ménage là dedans ...

Ainsi, on a:

• les en-tetes "modernes"
  
  • <fstream>
  • <string>
  • <cstring> qui est, à mon sens inutile (permet d'utiliser les fonctions C de manipulation des chaines, fournies par <string>, et bien moins intéressante que les fonctions membres de la classe string )
  • <sstream>
• les en-tetes "obsolètes"
  <iostream.h> à remplacer par <isotream> (sans ".h")
  <iomanip.h> à remplacer par <iomanip> (sans ".h")
• les en-tetes C
  
  • <windows.h> à mon sens inutile: tu n'utilise pas de fonctions propres à l'api windows (il est d'ailleurs inclus de manière indirecte par de nombreux fichiers )
  • <stdio.h> inutile: fait double emploi avec<fstream>
  • <stdlib.h> inutile: fait double emploi avec <iostream>
  • <math.h> inutile : rien dans le code n'indique que tu en aies besoin
• les en-têtes propriétaires et non portables
  • <conio.h> fait finalement double emploi avec <iostream> et <iomanip>

Au final, les inclusions pourraient se limiter à

Code :

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

1
2
3
4
#include <iostream> //pour cin et cout
#include <iomanip> // pour isalpha
#include <string> // pour gérer efficacement les chaines de caractères
#include <sstream> // pour les flux de conversions

Ensuite, je voudrais attirer ton attention sur plusieurs point d'ordre tout à fait générale:

D'abord, l'idéal est d'éviter les define pour définir des constantes...

En effet, la directive #define se contente de remplacer un terme par un autre dans le code, mais n'assure aucune vérification de type.

On préférera bien souvent définir une variable globale comme étant d'un type particulier et en précisant qu'il s'agit d'une constante.

Ainsi, tes deux #define (P et Vmax) seraient définis de manière bien plus intéressante sous la forme de

Code :

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

1
2
/* unsigned */ int const P = 5;
/* unsigned */ int const Vmax = 1000;

D'un autre coté, je ne suis pas intimement persuadé qu'il soit intéressant de déclarer i, j et space comme étant des variables globales...

Au passage, je n'aime pas énormément les déclaration successives, ne serait-ce que pour la lisibilité du code... Il est si simple de "louper" le fait qu'une variable est déclarée.

Je préfère fortement n'avoir qu'une déclaration / définition / instruction par ligne, ce qui nous donnerait pour i, j et space quelque chose porche de

Code :

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

1
2
3
int i;
int j;
int k;

qui est bien plus lisible et qui revient strictement au même du point de vue des performances

(la remarque vaut d'ailleurs pour la ligne double X0=0,Y0=0,Z0=0; aussi )

En effet, l'idéal est toujours d'éviter au maximum les variables globales.

Par contre, si i, j et space doivent être transmises ensemble, rien ne t'empêche de créer une structure qui les regroupe, sous une forme proche de

Code :

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

1
2
3
4
5
6
struct data
{
    int i;
    int j;
    int space;
};

En outre, il serait peut être intérssant de réfléchir à des noms plus explicites sur la valeur représentée par tes différentes variables, i, j, X0, Y0, Z0 pourraient facilement être renommées

Les structures devraient, idéalement, être transmises sous la forme de références aux fonctions, éventuellement constantes, si elles n'ont pas vocation à être modifiées par la fonction appelée, afin d'éviter les copies inutiles, qui sont gourmandes non seulement en temps d'exécution mais également en terme de mémoire.

Le passage de line comme argument à la fonction devrait donc prendre la forme d'une référence constante.

Fait en outre attention au fait que tu "cache" systématiquement certaines variables:

La variable globale i est cachée dans Ffunction par le paramètre (qui est un pointeur sur un entier) nommé i, et les variables globales j et space sont cachées par les variables du même nom déclarée dans Ffunction.

Ainsi que screetch l'a fait remarquer, l'indentation ne fait pas partie de la grammaire du langage, mais, il faut prendre en compte qu'elle apporte une aide des plus efficace à la (re) lecture du code...

Tu devrais donc prendre l'habitude de respecter une politique stricte d'indentation de ton code tout au long d'un même projet, le but étant que les instructions se trouvant à un même niveau d'imbrication se trouvent alignées entre elles.

Ceci étant dit, il est fortement déconseillé de créer une boucle basée sur le test de fichier.eof()...

surtout si tu utilise en priorité la fonction getline, car tu peux avantageusement remplacer le tout par

Code :

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

1
2
3
4
while(std::getline(myfile,line))
{
    /* ce qu'il faut faire */
}

Comme il y a beaucoup à dire, je te conseillerais fortement de faire un tour du coté de la partie de la FAQ dédiée à l'utilisation des fichiers

En outre trouve ta boucle

Code :

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

for(i=0;space<1;++i)

non seulement surprenante, mais particulièrement dangereuse...

En effet, si on transcrit cette instruction en français, cela revient à dire

Je prend un compteur, que j'initialise à 0 et que j'incrémente à chaque passage, mais... je ne vérifie jamais la valeur de ce compteur (par contre, je vérifie la valeur d'une autre valeur )

Cela ne te parrait-il pas quelque peu surprenant

D'autant plus que tu peux parfaitement t'éviter d'avoir à tester si tu arrive à la fin de la chaine de caractère: la classe string dispose de la fonction membre size() qui te permet de connaitre le nombre de caractères significatifs

Ta boucle pourrait donc facilement être écrite sous la forme de

Code :

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

for(i=0;i<line.size();++i)

et le cas "case '\0'" purement et simplement supprimé (fais toutefois attention au fait que i doit alors etre de type size_t (unsigned int) )

Tout comme je trouve "contre nature" de passer i sous la forme de pointeur à Ffunction afin de lui permettre de le modifier...

D'abord parce que cela t'oblige à écrire un horrible

Code :

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

*i=*i+1;

et autre *i dans Ffunction, (en plus de t'obliger à passer "l'adresse de i" à Ffunction), ensuite parce que, tant qu'à faire, tu pourrait le passer par valeur et faire en sorte que Ffunction renvoie la valeur modifiée, sous une forme proche de (en tenant compte de ma remarque concernant les structures et du fait qu'il est préférable de travailler avec un size_t)

Code :

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

size_t Ffunction(size_t i, string const &  line, int *V);

L'appel de la fonction devenant alors

Code :

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

i= Ffunction(i,line,&V);

Vient ensuite le cas de Ffunction elle-même...

Si j'ai bien compris, son but est de récupérer tous les chiffre de la ligne lue afin d'en sortir un entier représentant la vélocité...

Sais tu que les stringstream que tu utilise "justement" dans la fonction permettent de faire cela directement

En effet, tu peux très bien (c'est le but des flux de conversions stringstream) partir d'une chaine de caractères et la convertir en n'importe quel type primitif (avec vérification de type) sous une forme de

Code :

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

1
2
3
4
std::stringstream ss;
ss<<laChaineAConvertir;
int value;
ss>>value;

Autrement dit, tout ton code pourrait au final se limiter à

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 <iostram> // pour l'affichage
#include <string> // pour les chaines de caractères
#include <sstram> // pour les conversions
#include <fstream> // pour les fichiers
/* par facilité */
using namespace std; /*NOTA : JAMAIS dans un fichier d'en-tête ;) */
int main()
{
    ifstream myfile("example.txt");
    /* si le fichier n'est pas ouvert, on sort sur une erreur */
    if(!myfile)
        return 1;
    string line;
    while(getline(myfile,line))
    {
        /* il faut convertir line... passons la à un flux de conversion */
        stringstream ss;
        ss<< line;
        /* et récupérons les vélocités */
        int velocity;
        while(line>>velocity)
            cout<<velocity<<endl;
        /* voir, s'il y a un caractère qui n'est pas un espace entre les 
         * vélocités 
         */
        char c;
        while(line>>velocity>>c)
            cout<<velocity<<endl;
    }
    return 0;
}