Bonjour,

Pouvez-vous me dire si il est possible de mettre dans cette boucle while, où "verifP" est une fonction qui renvoi un std::string, la condition :

si "verifP" est égale à "o" ou à "O" la boucle continue.

Parce que dans cette configuration je ne trouve pas la solution.

Merci.

bool jouer (std::vector <std::string>& dicoVe)
{

    while( verifP () == "o" )
    {
        partie (dicoVe);
    }
    return 0;
}

Merci pour ta réponse,

Mais je ne comprends pas bien comment cette fonction va pouvoir me permettre de résoudre le problème de double condition.

Je l’écrits "o" et "O" , j'ai les 2 états en chaine de caractère. 

Mon problème c'est comment demander de comparer "verifP" avec "o" et "O".

Tu y a peut-être répondu mais j'ai besoin d'un peu plus d'aide pour comprendre alors .

Comparer "verifP" avec "o" et "O" n'est pas forcément très aisé. VerifP est une fonction qui retourne une valeur. On peut envisager une autre approche, plutôt que de comparer "verifP" à "o" et "O", on pourrait se débrouiller pour transformer le résultat de verifP de telle sorte que si le retour de verifP est "O", on va le transformer en "o" ;) 

Il ne resterait alors plus qu'a comparer le résultat de cette transformation avec "o", c'est là que tolower va s'avérer utile

-
Edité par int21h 20 novembre 2017 à 23:23:57

Hooooooooooo,

en voilà une idée qu'elle est  bonne ! merci

Je me rends compte que l'esprit logique va mettre du temps à s'installer dans cette petite tête

Salut,

Ceci dit, il y a une autre possibilité: récupérer le résultat renvoyé par ta fonction vérifP (qu'il faudrait d'ailleurs renommer, pour que son nom indique ce qu'elle fait: on se doute qu'elle vérifie "quelque chose", mais P, moi, ca ne me dit absolument rien ) dans une variable locale, que l'on pourra ensuite comparer avec toutes les valeurs que l'on veut.

Seulement, il se peut que cela mette aussi ton esprit à contribution, pour savoir quand faire appel à cette fonction ou -- qui sait -- pour décider de changer le type de ta boucle

bool jouer (std::vector <std::string>& dicoVe)
{
 
    while( verifP () == "O" || verifP () == "o")
    {
        partie (dicoVe);
    }
    return 0;
}

Merci pour ces précisions Koala01,

Mais j'ai opté pour ta première proposition. Changer de type de boucle engendrait beaucoup trop de changement dans la suite du code.

Mister Mad, j'avais déjà essayé cette solution mais, comme le dit koala01, la fonction VerifP se lance 2 x ce qui est un problème dans ce code.

Merci de votre aide  .

lio2609 a écrit:

Merci pour ces précisions Koala01,

Mais j'ai opté pour ta première proposition. Changer de type de boucle engendrait beaucoup trop de changement dans la suite du code.

Mister Mad, j'avais déjà essayé cette solution mais, comme le dit koala01, la fonction VerifP se lance 2 x ce qui est un problème dans ce code.

Merci de votre aide  .

Absolument pas!!! il suffirait d'une boucle do... while à la place d'une boucle while, et le tour serait joué

Je sais pas, moi, quelque chose comme

std::string result;
do{
    result = verifP();
    if(result = "o" || result== "O")
        partie(dicoVe);
} while(result = "o" || result== "O");

n'aurait aucue espèce d'incidence sur le reste du code

Mais, ce type de boucle serait sans doute bien plus en rapport avec ce que tu veux effectivement faire...

-
Edité par koala01 22 novembre 2017 à 15:14:14

Pfffffffff,

Ça parait si simple quand tu l'as devant les yeux...

Je suis désespérant .

Je n'avais pas vu les contraintes, désolé. Dans ce cas, plus propre et simple:

bool jouer(std::vector <std::string>& dicoVe)
	{

		for (string result = verifP(); result == "O" || result == "o"; result = verifP())
		{
			partie(dicoVe);
		}
		return 0;
	}

-
Edité par Mister Mad 22 novembre 2017 à 16:03:50