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 ?