Partage
  • Partager sur Facebook
  • Partager sur Twitter

Candy

    17 juin 2021 à 10:15:34

    Bonjour,

    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 :

    Candy.cpp

    #include <iostream>
    
    #include "Matrice.h"
    
    int main()
    {
        struct etMatrice stMatrice;
        void InitialisationMatrice(&stMatrice);
        return 0;
    }

    Matrice.cpp

    #include <iostream>
    #include "Matrice.h"
    
    
    void InitialisationMatrice(*struct etMatrice stMatrice)
    {
        struct etCase.dGelatine = rand() % 2 + 1;
        struct etCase.tCouleur[5] = {"J", "V", "B" , "R" , "M"};
        int i;
        int j;
        int k;
        int dGel;
        if(struct etCase.dGelatine == 1)
        {
            dGel = 1;
        }
        else
        {
            dGel = 16;
        }
        for(i = 0; i < TAILLE1; i++)
        {
            for(j = 0; j < TAILLE2; j++)
            {
                k = rand() % 5 + 1; 
                
                struct etCase tMatrice[i][j] == struct etCase.tCouleur[k] ;
            }
        }
    }

    Matrice.h

    #pragma once
    #define TAILLE1 10
    #define TAILLE2 10
    
    
    
    
    struct etCase
    {
        char tCouleur[5];
        int dGelatine;
    };
    
    
    struct etMatrice 
    {
        struct etCase tMatrice[TAILLE1][TAILLE2];
    
    };
    
    void Couleur(struct etMatrice stMatrice);
    void InitialisationMatrice(struct etMatrice stMatrice);
    void Deplacement(struct etMatrice stMatrice, struct etCase stCase);
    void Calcul(struct etMatrice stMatrice);
    void Verification(struct etMatrice stMatrice);

    la console m'indique qu'il y a un problème avec la déclaration de ma fonction initialisation. Merci à toute personne qui pourrais m'aider

    et je tiens aussi à dire que j'avais déjà poster un post sur ce forum mais je m'étais pas assez bien exprimer

    message d'erreur:

    Candy.cpp: In function 'int main()':

    Candy.cpp:8:31: error: variable or field 'InitialisationMatrice' declared void

         void InitialisationMatrice(&stMatrice);

                                                         ^

    Matrice.cpp:5:27: error: variable or field 'InitialisationMatrice' declared void

     void InitialisationMatrice(*struct etMatrice stMatrice)

                                                    ^

    Matrice.cpp:5:29: error: expected primary-expression before 'struct'

     void InitialisationMatrice(*struct etMatrice stMatrice)

                                                     ^~~~~~

    -
    Edité par MohammedHathouti 17 juin 2021 à 10:23:50

    • Partager sur Facebook
    • Partager sur Twitter
      17 juin 2021 à 10:39:20

      Dans ta fonction main (ligne 8) quand on appelle une fonction, on ne met pas le type !

      Edit : C'est plein d'étourderie de ce genre dans ton code ?

      Pourquoi tu mets le mot struct partout ? Met le juste où c'est nécessaire, ça t'évitera beaucoup d'erreur !

      Pourquoi cette étoile (très mal placé) dans la définition de la fonction :

      void InitialisationMatrice(*struct etMatrice stMatrice)

      alors que tu ne l'as pas mise dans la déclaration ?!? 

      Tu n'aurais pas loupé des étapes ?

      -
      Edité par rouloude 17 juin 2021 à 10:52:34

      • Partager sur Facebook
      • Partager sur Twitter
        17 juin 2021 à 13:04:55

        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.

        • Partager sur Facebook
        • Partager sur Twitter

        l'azerty est aux dispositions ce que subversion est aux SCM

          17 juin 2021 à 19:30:34

          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.

          • Partager sur Facebook
          • Partager sur Twitter
            17 juin 2021 à 20:32:38

            Bonjour,

            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ès le 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:

            stCase.dGelatine = rand() % 2 + 1;
            InitialisationMatrice( &stMatrice );
            p_stMatrice->tMatrice[i][j] = stCase.tCouleur[k];

            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.

            • Partager sur Facebook
            • Partager sur Twitter

            En recherche d'emploi.

              18 juin 2021 à 11:35:48

              merci beacoup @Dalfab 

              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 ?

              J'ai un peut modifier mon programme :

              main.cpp

              #include <iostream>
              
              #include "Matrice.h"
              
              int main()
              {
                  struct etMatrice stMatrice;
                  InitialisationMatrice(&stMatrice);
                  return 0;
              }


              Matrice.h

              #pragma once
              #define TAILLE1 10
              #define TAILLE2 10
              
              
              
              
              struct etCase
              {
                  char tCouleur[6];
                  int dGelatine;
              };
              
              
              struct etMatrice 
              {
                  struct etCase tMatrice[TAILLE1][TAILLE2];
              
              };
              
              void Couleur(struct etMatrice stMatrice);
              void InitialisationMatrice(struct etMatrice* p_stMatrice);
              void Deplacement(struct etMatrice stMatrice, struct etCase stCase);
              void Calcul(struct etMatrice stMatrice);
              void Verification(struct etMatrice stMatrice);
              
              struct etMatrice* p_stMatrice;
              struct etCase stCase;



              Matrice.cpp

              #include <iostream>
              #include<string>
              #include "Matrice.h"
              
              
              void InitialisationMatrice(struct etMatrice* p_stMatrice)
              {
                  stCase.dGelatine = rand() % 2 + 1;
                  stCase.tCouleur[6] = {"JVBRM"};
                  int i;
                  int j;
                  int k;
                  int dGel;
                  if(stCase.dGelatine == 1)
                  {
                      dGel = 1;
                  }
                  else
                  {
                      dGel = 16;
                  }
                  for(i = 0; i < TAILLE1; i++)
                  {
                      for(j = 0; j < TAILLE2; j++)
                      {
                          k = rand() % 5 + 1;
                          p_stMatrice->tMatrice[i][j] = stCase.tCouleur[k];
                      }
                  }
              }

              il me semble avoir une erreur dans la déclaration de ma chaine de caractere stCase.tCouleur[6] = {"JVBRM"};

              Erreur: 

              Matrice.cpp: In function 'void InitialisationMatrice(etMatrice*)':

              Matrice.cpp:9:34: error: invalid conversion from 'const char*' to 'char' [-fpermissive]

                   stCase.tCouleur[6] = {"JVBRM"};

                                                                          ^

              Matrice.cpp:27:60: error: no match for 'operator=' (operand types are 'etCase' and 'char')

                           p_stMatrice->tMatrice[i][j] = stCase.tCouleur[k];

                                                                                                               ^

              In file included from Matrice.cpp:3:0:

              Matrice.h:8:8: note: candidate: constexpr etCase& etCase::operator=(const etCase&)

               struct etCase

                             ^~~~~~

              Matrice.h:8:8: note:   no known conversion for argument 1 from 'char' to 'const etCase&'

              Matrice.h:8:8: note: candidate: constexpr etCase& etCase::operator=(etCase&&)

              Matrice.h:8:8: note:   no known conversion for argument 1 from 'char' to 'etCase&&'


              -
              Edité par MohammedHathouti 18 juin 2021 à 13:02:19

              • Partager sur Facebook
              • Partager sur Twitter
                18 juin 2021 à 15:25:05

                Salut !

                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.

                -
                Edité par Umbre37 18 juin 2021 à 15:47:09

                • Partager sur Facebook
                • Partager sur Twitter
                  18 juin 2021 à 17:30:22

                  je comprend pas l'initialisation d'un tableau, si j'ai bien compris mon code doit ressembler à ca :

                  Martice.cpp

                  #include <iostream>
                  #include<string>
                  #include "Matrice.h"
                  
                  
                  void InitialisationMatrice(struct etMatrice* p_stMatrice)
                  {
                      stCase.dGelatine = rand() % 2 + 1;
                      stCase.tCouleur[0] = {"J"};
                      stCase.tCouleur[1] = {"V"};
                      stCase.tCouleur[2] = {"M"};
                      stCase.tCouleur[3] = {"R"};
                      stCase.tCouleur[4] = {"B"};
                      int i;
                      int j;
                      int k;
                      int dGel;
                      if(stCase.dGelatine == 1)
                      {
                          dGel = 1;
                      }
                      else
                      {
                          dGel = 16;
                      }
                      for(i = 0; i < TAILLE1; i++)
                      {
                          for(j = 0; j < TAILLE2; j++)
                          {
                              k = rand() % 5s + 1;
                              p_stMatrice->tMatrice[i][j] = stCase.tCouleur[k];
                          }
                      }
                  }

                  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 constructive est la bienvenue



                  • Partager sur Facebook
                  • Partager sur Twitter
                    19 juin 2021 à 18:53:36

                    MohammedHathouti a écrit:

                    je comprend pas l'initialisation d'un tableau, si j'ai bien compris mon code doit ressembler à ca :

                    Martice.cpp

                    #include <iostream>
                    #include<string>
                    #include "Matrice.h"
                    
                    
                    void InitialisationMatrice(struct etMatrice* p_stMatrice)
                    {
                        stCase.dGelatine = rand() % 2 + 1;
                        stCase.tCouleur[0] = {"J"};
                        stCase.tCouleur[1] = {"V"};
                        stCase.tCouleur[2] = {"M"};
                        stCase.tCouleur[3] = {"R"};
                        stCase.tCouleur[4] = {"B"};
                        int i;
                        int j;
                        int k;
                        int dGel;
                        if(stCase.dGelatine == 1)
                        {
                            dGel = 1;
                        }
                        else
                        {
                            dGel = 16;
                        }
                        for(i = 0; i < TAILLE1; i++)
                        {
                            for(j = 0; j < TAILLE2; j++)
                            {
                                k = rand() % 5s + 1;
                                p_stMatrice->tMatrice[i][j] = stCase.tCouleur[k];
                            }
                        }
                    }

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

                    void InitialisationMatrice(struct etMatrice* p_stMatrice)
                    {//...

                    Concernant ta question sur la déclaration :

                    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.

                    -
                    Edité par Umbre37 19 juin 2021 à 19:25:35

                    • Partager sur Facebook
                    • Partager sur Twitter
                      20 juin 2021 à 8:21:58

                      On n'utilise plus rand en C++ mais les fonctions de l'entête <random>. Pense à suivre un cours de C++ récent.
                      • Partager sur Facebook
                      • Partager sur Twitter

                      l'azerty est aux dispositions ce que subversion est aux SCM

                      Candy

                      × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                      • Editeur
                      • Markdown