Vérification et découpage d'une string

Version imprimable

06/09/2010, 15h00
regliss76

Vérification et découpage d'une string

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.
06/09/2010, 15h07
bacelar

RegEx
http://www.boost.org/doc/libs/1_44_0...tml/index.html
06/09/2010, 15h19
regliss76

Euh, je dois faire tout ceci sans boost ni aucune autre librairie...:(
06/09/2010, 15h36
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.

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

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
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 ?

06/09/2010, 16h02
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.
06/09/2010, 16h08
ram-0000

Citation:

Envoyé par bacelar

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

voici l'algorithme :

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
 
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

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:

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:

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);

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:

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 ? :)

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:

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);
						}
					}
				}
			}
		}
	}

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:

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

09/09/2010, 11h53
regliss76

Citation:

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 !!! ;)