Bonsoir, j'essaye de m’entraîner à coder pour un contrôle pour demain et je suis bloqué. J'aurai besoin d'un petit coup de main Je suis sous windows (codeblocks)

Le programme que je veux faire est assez simple en soi. L'utilisateur doit écrire une chaîne de caractères avec des parenthèses et le programme doit dire si oui ou non il y a le même nombre de parenthèses fermantes et ouvrantes.

Jusqu'ici c'est assez simple, je sais comment faire. Mais j'aime bien compliquer les choses et je veux en écrire le moins possible dans le main. Au lieu de faire une fonction booléenne et écrire le reste dans le main, j'avais envie d'écrire 3 fonctions. Une pour la saisie, une pour le booléen et une pour recommencer. Mon souhait est de pouvoir recommencer la partie saisie et la vérification booléeenne tant que l'utilisateur n'aura pas saisi une chaîne de caractères avec le même nombre de parenthèses ouvrantes et fermantes.

Mais je galère car la saisie ne se refait pas et il fait tout tout seul sans mon autorisation. Il doit falloir utiliser les fameux pointeurs mais je ne sais jamais trop comment les utiliser (pour moi c'est encore un peu abstrait). Une petite aide serait la bien venue pour ma fonction recommencer. Ainsi qu'un petite explication pratique sur l'utilisation des pointeurs * et &. Une explication "normale" pourrait peut être m'éclairer plus que mon cours actuel...

1. include<iostream>
2. include<string.h>

using namespace std;

void saisir(char ch[51])
{
cout<<"Saisir 50 caracteres max avec parentheses : "<<endl;
cin.get(ch,51);
}

bool verifpar(char ch[51])
{
int longueur=strlen(ch);
int ouverte=0;
int fermee=0;
for(int i=0;i<longueur;i++)
{
if(ch[i]=='(') ouverte++;
if(ch[i]==')') fermee++;
}
if(ouverte==fermee)
{
cout<<"Le nombre de parentheses correspond."<<endl;
return true;
}
else
{
cout<<"Il n'y a pas le meme nombre de parentheses."<<endl;
return false;
}
}

void recommencer(char ch[51])
{
while(verifpar(ch))
{
saisir(ch);
verifpar(ch);
}
}

int main(void)
{
char chaine[51];
recommencer(chaine);
return 0;
}

La prochaine fois va sur http://pastebin.com/ pour clarifier ton code.
Sinon je peux pas t'aider désolé

Je fais pas de C++ mais ton problème a plus l'air d'etre un problème de logique :

Dans ta fonction recommencer, le verifpar dans la boucle ne sert à rien puisque le test consiste a exécuter la fonction au lieu de vérifier une variable (je sais pas si c'est clair )

En gros tu fais soit :
while(verifpar)
saisir();

soit :
while(test)
saisir();
test = verifpar();

Et pour envoyer la meme chaine aux 2 fonctions tu dois utiliser des références (ou pointeurs en C++ je crois)

Le fait est que ta fonction verifpar(ch) est tout le temps appelée si j'ai bien compris. En gros c'est un problème de conception. Tu devrais vérifier la chaine une fois que l'utilisateur appuie sur Entrée, non ?

Déjà ton code est zarb, c'est censé être du C++? Alors déjà tu utilises #include <string> et pas string.h, ensuite tu utilises les string et pas des tableaux de char. Et puis utilise pas "using namespace::std;" parce que le jour où tu seras obligé de l'enlever t'oublieras de mettre std:: devant chaque nom d'entité standard.

Ensuite, quelques problèmes dans la structure du code: avec ton while(), tu fais déjà un premier test de ch alors qu'il n'est même pas initialisé! Il pourrait contenir n'importe quoi, du coup, le fait que tu rentres dans le while ou pas est complètement aléatoire, selon la zone de mémoire dont tu as hérité contenait quelque-chose qui correspondrait à des paranthèses dans une chaîne de caractères ou pas. Donc, utilise plutôt un do {} while() pour initialiser ta chaîne une première fois avec saisir() ou alors fais un appel à saisir() une seule fois avant ta boucle pour l'initialiser.
Ensuite, tu fais un appel à verifpar() dans le while() et ensuite tu le refais dans le bloc appelé par le while, ça sert à rien! mettre un saisir() dans le bloc suffira amplement.
Enfin, la condition du while ne fera pas ce à quoi tu t'attends: la boucle va s'exécuter seulement si verifpar() renvoie vrai, or verifpar() envoie vrai si... il y autant de paranthèses ouvrantes que de fermantes!

Enfin, aucun besoin de pointeurs ou de références ici mais je vais quand même t'expliquer un peu. On va déjà commencer par le pointeur.
Alors, un pointeur c'est une variable qui contient un nombre (en héxadécimal). Ce nombre est interprété comme une adresse: c'est la location d'une autre variable dans la mémoire, c'est-à-dire que si tu stockes dans un pointeur la location d'une autre variable, tu pourras stocker cette variable et l'utiliser depuis quelque-part d'autre sans stocker la variable en elle-même, mais seulement le pointeur!

Des cas où le pointeur est utile c'est par exemple si tu veux stocker une même variable dans plusieurs conteneurs: tu stockes la variable en elle-même dans un conteneur, et un pointeur vers cette variable dans un autre, comme ça tu n'as pas besoin de stocker la variable 2 fois dans chaque conteneur (pour un grand tableau, ça utiliserait beaucoup de place si la variable est une grosse structure par exemple, alors qu'avec un pointeur ca fait juste un nombre de plus à stocker). En plus, le fait de modifier la variable depuis le 1e conteneur ou la variable pointée par le pointeur dans le second conteneur auraient le même effet.

Syntaxiquement, le pointeur s'utilise ainsi:

int var(3);
int *ptr = &var;

L'astérisque (*) après un type permet de spécifier que c'est un pointeur vers ce type (dans ce cas int* veut dire "pointeur vers un int").
L'esperluette, elle, renvoie l'adresse d'une variable (&var renvoie l'adresse dans laquelle var est stockée. Tu peux essayer de l'afficher avec std::cout par exemple pour t'en rendre compte)
Ensuite, une fois que tu as le pointeur, tu peux aller chercher la variable dont l'adresse est stockée de la sorte:

• ptr;

par exemple, tu peux faire que var soit égal à 4 en faisant:

(*ptr)++; //(je mets les paranthèses pour que ce soit clair)

La référence est exactement comme un pointeur, sauf qu'elle est syntaxiquement plus légère mais aussi plus ambigüe:
en prenant l'exemple du dessus avec des références:

int var(3);
int &ref = var;
ref++;

La référence est intelligente, et prend automatiquement l'adresse d'une variable lors de l'assignement, et déréférence (avec un pointeur on déférence en faisant *ptr) automatiquement lors d'un appel de fonction.

en fait la prof veut que :
- on utilise le using namespace std;
- les tableaux de char (censé être meilleur pour l'apprentisssage)
- le string.h : c'est dans mon cours et dans les corrections que la prof fait

Ensuite pour mon problème, je pense que si quelqu'un me faisait la fonction recommencer ça m'aiderai beaucoup à comprendre

void recommencer(char ch[51]) {
do {
saisir(ch);
} while (!verifpar(ch))
}

le string.h c'est vraiment abruti parce que tu mets le .h en C, et en C++ tu le mets pas
après pour les tableaux de char je peux comprendre (d'ailleurs si tu veux 50 caractères c'est char[50] parce que ça va jusqu'à 49 MAIS le 0 compte donc il y a 50 cases au final)
et pour le namespace std boarf ca fait du code plus clair pour des débutants mais c'est vachement chiant quand t'es obligé de l'enlever et t'étais habitué à le mettre

ben en fait je suis aussi un peu coincé pour le string.h car on utilise strlen() et j'ai essayé d'utiliser string à la place et ça ne marche pas.

Autant pour moi, l'équivalent c++ de #include <string.h> est #include <cstring> (je pensais que tu voulais utiliser des string et que c'était pour ça que t'incluais string.h)
et j'ai oublié le point-virgule après le do {} while();

Après tu peux faire une version de ta boucle qui nécessiterait pas d'avoir la longueur de la chaîne:
for(int i=0;ch[i]!=0;i++)
{
if(ch[i]=='(') ouverte++;
if(ch[i]==')') fermee++;
}

Ca va continuer la boucle tant que la chaîne de caractères n'est pas terminée (aka il le caractère suivant n'est pas nul).
Et c'est vrai qu'en incluant le caractère nul, le fait d'avoir 50 caractères nécessite en effet un tableau de 51 bytes de long, une erreur de plus pour moi.