Voila je viens car, j'ai un petit problème je suis étudiant en informatique et pour mon examen je dois faire un jeu Candy Crush simplifier en c++
malheureusement je bloque, nous devons faire le jeu sous forme de plusieurs fichiers qui doivent être intégré sous forme de structures et comprennent les différentes étapes de la création du jeu.
nous devons avoir un fichier Candy.cpp qui comprend le main
Queue.cpp Matrice.cpp et affichage.cpp
chaque fichier possède un fichier d'en-tête qui contient la déclaration de la structure et le prototypage des fonctions
je ne comprend pas encore l'utilité de la Queue dans notre projet, mais mon problème viens pour le moment de la matrice voici mes codes :
Il y a tellement rien qui va dans ce code (syntaxe, logique) qu'il serait fastidieux de tout énumérer. Écrivez un titre correct aussi lorsque vous postez sur un forum.
En attendant, relisez un cours de C++ (moderne de préférence) avant de continuer et recommencez à zéro.
git is great because Linus did it, mercurial is better because he didn't.
merci @rouloude pour vos critiques constructive, mais je ne sais pas ou c'est nécessaire de mettre le struct et j'utilise l'étoile pour pointer la variable ?
@markand j'ai reçu un cour il y a peut être des notion que je n'ai pas compris mais votre intervention est inutile si vous ne voulez pas m'aider de maniere plus constructive je ne vous oblige pas à écrire.
Dans ton code tu mets des types à des endroits où il ne faut pas. Il te faut bien lire les exemples que tu as dans ton cours. Pour définir/déclarer une variable, déclarer/définir une fonction, ou déclarer un paramètre de fonction. La syntaxe est LE_TYPE nom_de_l_element. Exemples :
void InitialisationMatrice( struct etMatrice* p_stMatrice ); // ici une fonction et son paramètre sont déclarés
struct etMatrice* p_stMatrice;
int x;
Pour signaler un pointeur, l'étoile doit être mise entre le LE_TYPE et le nom_de_l_element.. Pour signaler une fonction, il y une parenthèse ouvrante aprèsle nom_de_l_element. Attention le nom du type peut nécessiter plusieurs mots comme dans :
struct etMatrice* p_stMatrice;
unsigned long y;
Le nom_de_l_element est son nom, il ne peut pas contenir de point. Il n'y a qu'un mot.
Ensuite dans tout le reste du code, tu définis les actions à faire. Le type n'apparaît jamais dans ce cas. Par exemple:
Quand on utilise deux mots séparés par un point (.). Le mot à gauche est le nom d'une variable, le mot à droite est un champ du type de cette variable. Dans ton code tu as souvent un type à gauche. Il n'y a jamais de nom d'un type dans ce cas. On veut agir sur quelque chose, c'est toujours une variable. Quand on utilise la flèche (->), le mot de gauche doit être une variable qui a le type pointeur; comme dans mon exemple.
Avec cela, tu devrais pouvoir reprendre beaucoup de lignes de ton code.
J'aimerai te poser encore une question si cela ne te dérange pas.
void InitialisationMatrice( struct etMatrice* p_stMatrice ); // ici une fonction et son paramètre sont déclarés
struct etMatrice* p_stMatrice;
int x;
lorsque tu une nouvelle variable stMatrice cette variable doit être déclarer dans le fichier.h (la ou se trouve la déclatration de la structure) ou dans le fichier main ?
Quand tu déclares une instance de ta structure, tu n'as pas besoin de remettre le mot clef struct. Ce n'est obligatoire qu'en C, pas en C++.
struct S ; // déclaration de la structure S
struct S
{ /*...*/ } ; // définition de la structure S
void foo(S s)
{ /*...*/ } // définition d'une fonction prenant en paramètre un objet de type S
int main()
{
S s1 ; // déclaration d'un objet de type S;
S* s2 ; // déclaration d'un pointeur de S;
foo(s1) ;
}
MohammedHathouti a écrit:
lorsque tu une nouvelle variable stMatrice cette variable doit être déclarer dans le fichier.h (la ou se trouve la déclatration de la structure) ou dans le fichier main ?
Ta variable doit être déclarée le plus tard possible (juste avant sa première utilisation, si possible) et immédiatement initialisée, si possible.
MohammedHathouti a écrit:
il me semble avoir une erreur dans la déclaration de ma chaine de caractere stCase.tCouleur[6] = {"JVBRM"};
Oui, tCouleur est un tableau de 6 char. On peut accéder à chacun de ces char ainsi :
tCouleur[0] = 'J'; // accès au 1er char du tableau qui prend la valeur 'J'
tCouleur[1] = 'V'; // accès au 2ème char du tableau qui prend la valeur 'V'
//...
tCouleur[6] = {"JVBRM"} // invalide !
Invalide pour deux raisons :
- c'est la 7ème case du tableau (qui n'en fait que 6)
- tCouleur[6] permet d'accéder à un seul caractère, et tu essayes de lui assigner une chaine... (c'est exactement ce que dit le compilateur)
Remarques générales : il faudrait faire attention à la syntaxe, et utiliser des outils plus simples, il y a std::string et std::vector en c++
Pour initialiser un objet, le mieux est certainement d'utiliser un constructeur (éventuellement surchargé) de la classe en question, plutôt qu'une fonction libre.
Ensuite qu'est ce que la déclaration d'une structure
struct S ; // déclaration de la structure S
struct S
{ /*...*/ } ; // définition de la structure S
void foo(S s)
{ /*...*/ } // définition d'une fonction prenant en paramètre un objet de type S
int main()
{
S s1 ; // déclaration d'un objet de type S;
S* s2 ; // déclaration d'un pointeur de S;
foo(s1) ;
}
ici par exemple tu as la définition de ta structure dans laquelle tu à les données membres de la structure
tu as la déclaration d'une nouvelle instance de la structure S
mais je ne comprend juste pas la déclaration de la structure struct S;
Enfin pour répondre a ta dernière remarque je suis les instructions du prof nous n'avons pas encore vu l'orienté objet donc je ne sais pas ce qu'est un constructeur
J'ai un peut du mal à assimiler des choses simple donc toute critique constructiveest la bienvenue
Mais pourquoi ne lis-tu pas simplement mon dernier message ?
stCase.tCouleur[0] = 'J';// et pas {"J"}; !
As-tu compris ma remarque sur la différence entre un char et un tableau de char ?
Pour initialiser un tableau d'un coup, on peut le faire au moment de la déclaration, comme ceci :
char tableau[6] = {"Bonjour"};
Mais dans ton cas ce n'est pas possible, parce que ton tableau est déjà déclaré dans ta structure, c'est pour cela que je te propose d'y accéder élément par élément.
Par ailleurs, j'avais parlé de déclarer les variables au dernier moment, alors pourquoi ceci ? :
int i;
int j;
int k;
J'avais également parlé de l'utilisation de struct, à quoi sert-il ici ? :
Une déclaration permet de faire connaître au compilateur un type (une classe, une structure, une fonction, etc...) et ce, même s'il n'est pas implémenté dans le détail. Par exemple, tu peux compiler ça :
float foo(int const i, char const c, std::string const& s);
int main()
{
foo(12, 't', "bonjour");
return 0;
}
Même si ce que fait la fonction foo n'est pas connu par le compilateur.
Je le mentionnais parce que tu semblais vouloir séparer des fichiers .h et .cpp dans ton premier message. Cette pratique permet justement de compiler des petits bouts de codes séparément, en distinguant déclaration et définition, ce qui permet de gagner du temps dans les gros projets.
Je ne sais pas ce que te dit ton prof, mais vu ton code, je me demande si ce n'est pas un cours de c plutôt que de c++. Te serais-tu trompé de forum ? En c++ on ne code pas comme ça.
On n'utilise plus rand en C++ mais les fonctions de l'entête <random>. Pense à suivre un cours de C++ récent.
git is great because Linus did it, mercurial is better because he didn't.
Candy
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
git is great because Linus did it, mercurial is better because he didn't.
En recherche d'emploi.
git is great because Linus did it, mercurial is better because he didn't.