Discussion :

[regliss76]

Bonjour à tous,
j'ai besoin pour mon application que l'utilisateur entre une chaîne du type :
(A) Element_X, (B) Element_Y
ou indifféremment
(B) Element_Y, (A) Element_X

J'ai cette chaîne sous la forme d'une std::string.
L'important est :
- qu'il y ait une et une seule virgule (qui sert de séparateur)
- que d'un côté de la virgule il y ait une seule fois la chaîne "(A)" et de l'autre une seule fois la chaîne "(B)", peu importe l'ordre comme indiqué au-dessus

Comment avec les méthodes de string vérifier que ma chaîne est bien de cette forme ?

Puis dans un second temps je souhaite associer Element_X à une string chA et Element_Y à une string chB, tout cela en ayant viré les blancs.

Y a-t-il moyen de faire tout ceci juste avec les méthodes de string ?

Merci d'avance pour votre aide.

[bacelar]

RegEx
http://www.boost.org/doc/libs/1_44_0...tml/index.html

[regliss76]

Euh, je dois faire tout ceci sans boost ni aucune autre librairie...

[bolhrak]

Hello,

Les fonctions de la class string te permettent de faire ce que tu veux :

http://www.cplusplus.com/reference/string/string/

find pour vérifier que ta chaîne est au bon format / qu'il n'y a pas d'occurences en double, substr pour récupérer les sous chaînes qui t'intéressent.

[regliss76]

Pour la vérification de la forme j'ai écrit ceci...

Code C++ :

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
bool CAISBasicDoc::estValide(std::string &str)
	{
	size_t found,found2,found3,found4,found5,found6;
	found = str.find(",");
	if(found==string::npos)
		return false;
	else 
		{
		found2 = str.find(",",found+1);
		if(found2!=string::npos)
			return false;
		else 
			{
			found3 = str.find("(A)");
			found4 = str.find("(B)");
			if(
			   found3 == string::npos 
			   || 
			   found4 == string::npos 
			   || 
			   !((0 <= found3 && found3 < found && found4 > found && found4 < str.length()) || (0 <= found4 && found4 < found && found3 > found && found3 < str.length()))
			   )
			return false;
			else
				{
				found5 = str.find("(A)",found3+1);
		    	found6 = str.find("(B)",found4+1);
				if(found5!=string::npos || found6!=string::npos)
					return false;
				}
			}
		}
	return true;
	}

C'est un peu lourd, mais bon...
Qu'en pensez-vous ?

[bolhrak]

C'est pour ça que boost a développé des lib traitant les chaînes de caractères (tokenizer et RegEx)

Sinon ton code fait ce qu'il faut, par contre récupérer les positions des différentes sous chaînes (par paramètre dans ta fonction par exemple) t'évitera de faire le boulot en double quand tu devras t'occuper du traitement.

[ram-0000]

RegEx
http://www.boost.org/doc/libs/1_44_0...tml/index.html

Et un tuto sur Boost::Regex en C++ : Utilisation de Boost.Regex

[Chessmaster1966]

voici l'algorithme :

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
 
VAR :
	CAR ChaineEntree[255]
	CHAINE chA, chB	
	ENTIER  N, Position, Longueur	
STRUCT :
FONC :	
	DEBUT
		ECRIRE "Saisissez une chaîne au format suivant (ValeurX,ValeurY)"
		LIRE ChaineEntree		
 
		// Vérifie le format de la chaîne
		Longueur <- LongueurChaine(ChaineEntree)
		Position <- -1
		SI Longueur > 0 ALORS
			POUR N <- 0 A Longueur - 1 FAIRE
				SI ChaineEntree[N] = " " OU (ChaineEntree[N] = ',' ET Position <> -1)  ALORS								
					Position <- -1
					SORTIRPOUR
				SINONSI (N > 0 ET ChaineEntree[N] = ',') ET Position = -1 ALORS
					Position <- N				
				FINSI			
			FINPOUR			
		FINSI		
 
 
		SI Position > 0 ALORS			
			// Décompose la chaîne.
			POUR N <- 0 A Position-1 FAIRE
				chA <- chA + ChaineEntree[N]
			FINPOUR
 
			POUR N <- Position + 1 A Longueur -1 FAIRE
				chB <- chB + ChaineEntree[N]
			FINPOUR
 
			ECRIRE "L'objet chA vaut '", chA, "' et l'objet chB vaut '", chB, "'."
		SINON
			ECRIRE "Erreur: La chaîne n'est pas au bon format."
		FINSI				
 
	FIN

[regliss76]

Merci mais cet algo n'est pas complet dans le sens où il ne vérifie pas certaines conditions et qu'il ne traîte pas le cas (B) Element_Y, (A) Elément_X
Sinon j'ai écrit ce bout de code pour construire chA et chB, qu'en pensez-vous ?

Code C++ :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
size_t foundA = str.find("(A)");
size_t foundB = str.find("(B)");
size_t foundv = str.find(",");
 
if(foundA < foundB)
	{
	chA = str.substr(foundA + 3, foundv - foundA - 3);
	chB = str.substr(foundB + 3);
	}
else
	{
	chA = str.substr(foundA + 3);
	chB = str.substr(foundB + 3, foundv - foundB - 3);
	}

Je souhaite virer les blancs au début et à la fin de chA et chB, comment faire ?

EDIT : comme ça

Code C++ :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
//suppression des blancs en début et fin de chaîne
		chA = chA.substr(chA.find_first_not_of(" "));
		size_t found1 = chA.find_last_not_of(" ");
		if(found1!=string::npos)
			chA.erase(found1 + 1);
 
 
		chB = chB.substr(chB.find_first_not_of(" "));
		size_t found2 = chB.find_last_not_of(" ");
		if(found2!=string::npos)
			chB.erase(found2 + 1);

[regliss76]

Alors je n'ai plus qu'un souci à régler, c'est la vérification qu'on n'est pas dans le cas "(A) , (B) " ou le contraire, ou encore "(A) , (B) ", etc.
Bref je dois vérifier qu'il y a bien au moins un caractère derrière (A) et (B)....
Pour l'instant ma vérif est comme ceci :

Code C++ :

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
 
bool CAISBasicDoc::estValide(std::string &str)
	{
	size_t found,found2,found3,found4,found5,found6;
	found = str.find(",");
	if(found==string::npos)
		return false;
	else 
		{
		found2 = str.find(",",found+1);
		if(found2!=string::npos)
			return false;
		else 
			{
			found3 = str.find("(A)");
			found4 = str.find("(B)");
			if(
			   found3 == string::npos 
			   || 
			   found4 == string::npos 
			   || 
			   !((0 <= found3 && found3 + 3 < found && found4 > found && found4 + 3 < str.length()) || (0 <= found4 && found4 + 3 < found && found3 > found && found3 + 3 < str.length()))
			   )
			return false;
			else
				{
				found5 = str.find("(A)",found3+1);
		    	found6 = str.find("(B)",found4+1);
				if(found5!=string::npos || found6!=string::npos)
					return false;
				}
			}
		}
	return true;
	}

Une âme charitable pour me donner un coup de co(u)de ?

[regliss76]

Bon j'ai tout regroupé dans une seule méthode, c'est bourrin mais ça marche nickel...tout est vérifié, je crois que je n'ai rien oublié ! Je file le code pour d'éventuels intéressés

Code C++ :

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
 
/*
méthode qui vérifie la validité de la chaîne rentrée par l'utilisateur et si possible construit chA et chB
*/
void CAISBasicDoc::parsage(const string str,string &souschA,string &souschB, bool &estValide)
	{
	estValide = true;
	size_t foundv,foundvdouble,foundA,foundB,foundAdouble,foundBdouble,foundspaceA,foundspaceB,found1,found2;
	foundv = str.find(",");
	if(foundv==string::npos) 
		estValide = false;
	else 
		{
		foundvdouble = str.find(",",foundv+1);
		if(foundvdouble!=string::npos)
			estValide = false;
		else 
			{
			foundA = str.find("(A)");
			foundB = str.find("(B)");
			if(
				foundA == string::npos 
				|| 
				foundB == string::npos 
				|| 
				!((0 <= foundA && foundA + 3 < foundv && foundB > foundv && foundB + 3 < str.length()) || (0 <= foundB && foundB + 3 < foundv && foundA > foundv && foundA + 3 < str.length()))
				)
				estValide = false;
			else
				{
				foundAdouble = str.find("(A)",foundA+1);
				foundBdouble = str.find("(B)",foundB+1);
				if(foundAdouble!=string::npos || foundBdouble!=string::npos)
					estValide = false;
				else 
					{
					if(0 <= foundA && foundA + 3 < foundv && foundB > foundv && foundB + 3 < str.length())
						{
						souschA = str.substr(foundA + 3, foundv - foundA - 3);
						souschB = str.substr(foundB + 3);
						}
					else
						{
						souschA = str.substr(foundA + 3);
						souschB = str.substr(foundB + 3, foundv - foundB - 3);
						}
 
					foundspaceA = souschA.find_last_not_of(" ");
					foundspaceB = souschB.find_last_not_of(" ");
					if (foundspaceA==string::npos || foundspaceB==string::npos) 
						estValide = false; 
					else
						{
						souschA = souschA.substr(souschA.find_first_not_of(" "));
						found1 = souschA.find_last_not_of(" ");
						if(found1!=string::npos)
							souschA.erase(found1 + 1);
 
						souschB = souschB.substr(souschB.find_first_not_of(" "));
						found2 = souschB.find_last_not_of(" ");
						if(found2!=string::npos)
							souschB.erase(found2 + 1);
						}
					}
				}
			}
		}
	}

[Chessmaster1966]

A régliss76 :

Pourquoi te compliques tu la vie à vouloir saisir des valeurs puis vérifier (A) et (B) et mettre dans le bon objet la valeur correspondante. En programmation il faut veillez à aller toujours au plus simple, du moins c'est mon avis !

L'algo que j'ai posté est effectivement incomplet je n'ai pas évalué tous les cas de figures, c'était juste pour te donner la voie et toi de le compléter ceci dit je met l'algo dans son intégralité et il fonctionne correctement en prenant en charge tous les cas de figures.

Mais je le rappelle il vaut mieux s'obliger à demander à l'utilisateur de saisir directement une chaîne au bon format comme par exemple et je le demande dans mon algo : "ObjetX,ObjetY" tu sais que la première valeur est pour X et la deuxième pour Y il n'y a aucun souci alors pourquoi se compliquer la vie en demandant l'info de cette façon : "(A)ObjetX,(B)ObjetY" et donner la possibiliter de saisir : "(B)ObjetY,(A)ObjetX" ???

Donc voici l'intégralité de l'algorithme :

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
 
NOM : TestFormatAndSplit
ROLE :
	Demander à l'utilisateur d'entrée une chaîne au format "ValeurX,ValeurY".
	1) Vérifier que la chaîne est au bon format.
	2) Si elle n'est pas au bon format afficher un message d'erreur.
	3) Décomposer et affecter ValeurX à un objet chA et ValeurY à un objet chB
	4) Afficher les résultats.
ENTREE :	
SORTIE :		
CONST :
	ENTIER cMax <- 255 
VAR :
	CAR ChaineEntree[cMax]	
	ENTIER  N, Position, Longueur	
	CHAINE chA, chB	
STRUCT :
FONC :	
	ENTIER LongueurChaine( CAR Chaine[])
 
	DEBUT
		ECRIRE "Saisissez une chaîne au format suivant ('ValeurX,ValeurY')"
		LIRE ChaineEntree		
 
		// Vérifie le format de la chaîne
		Longueur <- LongueurChaine(ChaineEntree)
		Position <- -1
		POUR N <- 0 A Longueur - 1 FAIRE
			SI (ChaineEntree[N] = ',' ET N = 0) OU				 
   			   (ChaineEntree[N] = ',' ET N+1 = Longueur) OU
			   (ChaineEntree[N] = ',' ET Position > -1) OU			   
                ChaineEntree[N] = ' '  ALORS 
				Position <- -1  
				SORTIRPOUR
			SINONSI ChaineEntree[N] = ',' ALORS
				Position <- N				
			FINSI			
		FINPOUR					
 
		SI Position > -1 ALORS			
			// Décompose la chaîne.
			chA <-""
			POUR N <- 0 A Position-1 FAIRE
				chA <- chA + ChaineEntree[N]
			FINPOUR
 
			chB <- ""
			POUR N <- Position + 1 A Longueur -1 FAIRE
				chB <- chB + ChaineEntree[N]
			FINPOUR
 
			ECRIRE "L'objet chA vaut '", chA, "' et l'objet chB vaut '", chB, "'."
		SINON
			ECRIRE "Erreur: La chaîne n'est pas au bon format."
		FINSI				
 
	FIN

[regliss76]

Mais je le rappelle il vaut mieux s'obliger à demander à l'utilisateur de saisir directement une chaîne au bon format comme par exemple et je le demande dans mon algo : "ObjetX,ObjetY" tu sais que la première valeur est pour X et la deuxième pour Y il n'y a aucun souci alors pourquoi se compliquer la vie en demandant l'info de cette façon : "(A)ObjetX,(B)ObjetY" et donner la possibiliter de saisir : "(B)ObjetY,(A)ObjetX" ???

En fait, tout ceci vient du fait que ma chaîne est une chaîne produite par un logiciel et que l'utilisateur n'aura qu'à la copier/coller dans mon application.
Le logiciel peut produire aussi bien "(A)ObjetX,(B)ObjetY" que "(B)ObjetY,(A)ObjetX" ou pourquoi pas "(A) Objet X , (B) Objet Y".
Donc tout ce boulot c'est pour éviter à l'utilisateur de remettre la chaîne dans un format précis ! C'est une de mes contraintes, donc je l'ai respectée, je ne me suis pas compliqué la vie pour mon bon plaisir !!!