Partage
  • Partager sur Facebook
  • Partager sur Twitter

invalid types 'int[int]' for array subscript

    9 janvier 2019 à 3:28:48

    Le compilateur a parlé (j'ai supprimé conio.h d'où le décalage sur les lignes)

    test.cpp: Dans la fonction « void loadBrain() »:
    test.cpp:60:30: warning: comparaison d'expressions entières de types signés différents: « int » et « std::__cxx1998::vector<float, std::allocator<float> >::size_type » {aka « long unsigned int »} [-Wsign-compare]
             for(int cnt = 0; cnt < brain.connections.size(); cnt++)
                              ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~
    test.cpp: Dans la fonction « void saveBrain() »:
    test.cpp:81:26: warning: comparaison d'expressions entières de types signés différents: « int » et « std::__cxx1998::vector<float, std::allocator<float> >::size_type » {aka « long unsigned int »} [-Wsign-compare]
             for(cnt = 0; cnt < brain.connections.size(); cnt++);
                          ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~
    test.cpp:81:9: warning: cette instruction « for » ne protège pas… [-Wmisleading-indentation]
             for(cnt = 0; cnt < brain.connections.size(); cnt++);
             ^~~
    test.cpp:82:9: note: …cette instruction, mais l'indentation de cette dernière est trompeuse car elle fait croire qu'elle est gardée par le « for »
             {
             ^
    test.cpp: Dans la fonction « void generateBrain() »:
    test.cpp:109:26: warning: comparaison d'expressions entières de types signés différents: « int » et « std::__cxx1998::vector<float, std::allocator<float> >::size_type » {aka « long unsigned int »} [-Wsign-compare]
         for(int cnt = 0; cnt < brain.connections.size(); cnt++)
                          ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~
    test.cpp:114:68: warning: utilisation d'un vieux style de transtypage vers « float » [-Wold-style-cast]
                     putConnectionValue(cnt1, cnt2, cnt3, (((float)rand()/(float)(RAND_MAX)) * 2) - 1);
                                                                        ^
                                                            -------------
                                                            static_cast<float> (rand())
    test.cpp:114:86: warning: utilisation d'un vieux style de transtypage vers « float » [-Wold-style-cast]
                     putConnectionValue(cnt1, cnt2, cnt3, (((float)rand()/(float)(RAND_MAX)) * 2) - 1);
                                                                                          ^
                                                                          -----------------
                                                                          static_cast<float> ((RAND_MAX))
    test.cpp: Dans la fonction « int main() »:
    test.cpp:120:41: warning: zéro comme constante de pointeur nul [-Wzero-as-null-pointer-constant]
         srand (static_cast <unsigned> (time(0)));
                                             ^
    test.cpp:125:30: warning: la conversion de « std::basic_istream<char>::int_type » {aka « int »} vers « char » peut changer la valeur [-Wconversion]
             choice = std::cin.get();
                      ~~~~~~~~~~~~^~
    test.cpp: Au niveau global:
    test.cpp:140:1: warning: la macro « debug » n’est pas utilisée [-Wunused-macros]
     }
     ^

    Et un des warnings est clairement une erreur. Il faut activer les avertissements.

    > r
    Starting program: /home/jonathan/rawdisk2/a.out 
    [Thread debugging using libthread_db enabled]
    Using host libthread_db library "/usr/lib/libthread_db.so.1".
    [L]oad brain_file
    [G]enerate a random brain_file
    [Q]uit program
    g
    Number of layers:3
    Number of node in layer 1: 3
    Number of node in layer 2: 3
    Number of node in layer 3: 3
    /usr/sbin/../lib64/gcc/x86_64-pc-linux-gnu/8.2.1/../../../../include/c++/8.2.1/debug/vector:417:
    Error: attempt to subscript container with out-of-bounds index 100, but 
    container only holds 0 elements.
    
    Objects involved in the operation:
        sequence "this" @ 0x0x5555560202e0 {
          type = std::__debug::vector<float, std::allocator<float> >;
        }
    
    Program received signal SIGABRT, Aborted.
    0x00007ffff7aabd7f in raise () from /usr/lib/libc.so.6
    > bt
    #0  0x00007ffff7aabd7f in raise () from /usr/lib/libc.so.6
    #1  0x00007ffff7a96672 in abort () from /usr/lib/libc.so.6
    #2  0x00007ffff7e946c6 in __gnu_debug::_Error_formatter::_M_error (this=0x555556020380 <__gnu_debug::_Error_formatter::_M_at(char const*, unsigned int)::__formatter>) at /build/gcc/src/gcc/libstdc++-v3/src/c++11/debug.cc:1069
    #3  0x0000555555698600 in std::__debug::vector<float, std::allocator<float> >::operator[] (this=0x5555560202e0 <brain+64>, __n=100) at /usr/sbin/../lib64/gcc/x86_64-pc-linux-gnu/8.2.1/../../../../include/c++/8.2.1/debug/vector:417
    #4  0x0000555555695059 in putConnectionValue (xbrain_layer=1, xbrain_line=0, xbrain_column=0, connection_value=-0.225964546) at test.cpp:41
    #5  0x0000555555697baa in generateBrain () at test.cpp:114
    #6  0x000055555569814e in main () at test.cpp:132

    Tu devrais aussi regarder comment fonctionne un débogueur pour trouver les erreurs (ici c'est gdb)

    • Partager sur Facebook
    • Partager sur Twitter
      11 janvier 2019 à 21:26:17

      Voilà ! Tout marche maintenant !

      une erreur dans le for de loadBrain et un ';' après celle dans saveBrain; et puis 2 ou 3 truc pour corriger les warnings...

      #include <iostream>
      #include <fstream>
      #include <conio.h>
      #include <string.h>
      #include <time.h>
      #include <stdlib.h>
      #include <assert.h>
      #include <math.h>
      #include <vector>
      
      using namespace std;
      
      #define debug 0
      #define NB_NEURONS_IN_FIRST_COLUMN 10
      
      typedef struct{
          int nb_layers;
          std::vector<int> nb_neurons;
          std::vector<float> connections;
      }_brain;
      
      typedef struct{
          int board[8][8];
          bool turn;
          bool black_king_side_castle;
          bool black_queen_side_castle;
          bool white_king_side_castle;
          bool white_queen_side_castle;
          int column_en_passant;
      }_chess_board;
      
      _brain brain;
      int NB_NEURONS_MAX;
      
      float getConnectionValue(unsigned int xbrain_layer, unsigned int xbrain_line, unsigned int xbrain_column)
      {
          return brain.connections[(NB_NEURONS_MAX * NB_NEURONS_MAX * xbrain_layer) + (NB_NEURONS_MAX * xbrain_line) + xbrain_column];
      }
      
      void putConnectionValue(unsigned int xbrain_layer, unsigned int xbrain_line, unsigned int xbrain_column, float connection_value)
      {
          brain.connections[(NB_NEURONS_MAX * NB_NEURONS_MAX * xbrain_layer) + (NB_NEURONS_MAX * xbrain_line) + xbrain_column] = connection_value;
      }
      
      void loadBrain()
      {
          int temp_nb_neurons;
          float temp_connection;
          ifstream brain_file("brain_file.txt", ios::in);
          if(brain_file)
          {
              brain_file >> brain.nb_layers;
              NB_NEURONS_MAX = 0;
              for(int cnt = 0; cnt < brain.nb_layers; cnt++)
              {
                  brain_file >> temp_nb_neurons;
                  brain.nb_neurons.push_back(temp_nb_neurons);
                  if(temp_nb_neurons > NB_NEURONS_MAX)
                      NB_NEURONS_MAX = temp_nb_neurons;
              }
              for(int cnt = 0; cnt < NB_NEURONS_MAX * NB_NEURONS_MAX * (brain.nb_layers - 1); cnt++)
              {
                  brain_file >> temp_connection;
                  brain.connections.push_back(temp_connection);
              }
              brain_file.close();
          }
          else
              cerr << "Impossible d'ouvrir le fichier !" << endl;
      }
      
      void saveBrain()
      {
          unsigned int cnt2;
          ofstream brain_file("brain_file.txt", ios::out | ios::trunc);
          if(brain_file)
          {
              brain_file << brain.nb_layers << endl;
              for(int cnt1 = 0; cnt1 < brain.nb_layers - 1; cnt1++)
                  brain_file << brain.nb_neurons[cnt1] << ' ';
              brain_file << brain.nb_neurons[brain.nb_layers - 1] << endl;
              for(cnt2 = 0; cnt2 < brain.connections.size(); cnt2++)
                  brain_file << brain.connections[cnt2] << ' ';
              brain_file.close();
          }
          else
              cerr << "Impossible d'ouvrir le fichier !" << endl;
      }
      
      void generateBrain()
      {
          int temp_nb_neurons;
          cout << "Number of layers:";
          cin >> brain.nb_layers;
          brain.nb_layers = brain.nb_layers + 2;
          brain.nb_neurons.push_back(NB_NEURONS_IN_FIRST_COLUMN);
          NB_NEURONS_MAX = NB_NEURONS_IN_FIRST_COLUMN;
          for(int cnt1 = 1; cnt1 < brain.nb_layers - 1; cnt1++)
          {
              cout << "Number of node in layer " << cnt1 << ": ";
              cin >> temp_nb_neurons;
              brain.nb_neurons.push_back(temp_nb_neurons);
              if(temp_nb_neurons > NB_NEURONS_MAX)
                  NB_NEURONS_MAX = temp_nb_neurons;
          }
          brain.nb_neurons.push_back(1);
          for(int cnt = 0; cnt < NB_NEURONS_MAX * NB_NEURONS_MAX * (brain.nb_layers - 1); cnt++)
              brain.connections.push_back(0);
          for(int cnt1 = 0; cnt1 < brain.nb_layers - 1; cnt1++)
          {
              for(int cnt2 = 0; cnt2 < brain.nb_neurons[cnt1]; cnt2++)
              {
                  for(int cnt3 = 0; cnt3 < brain .nb_neurons[cnt1 + 1]; cnt3++)
                      putConnectionValue(cnt1, cnt2, cnt3, (((float)rand()/(float)(RAND_MAX)) * 2) - 1);
              }
          }
      
          saveBrain();
      }
      
      int main()
      {
          srand (static_cast <unsigned> (time(0)));
          char choice;
          cout << "[L]oad brain_file" << endl << "[G]enerate a random brain_file" << endl << "[Q]uit program" << endl;
          do
          {
              choice = _getch();
              switch(choice)
              {
                  case 'l':
                      loadBrain();
                  break;
                  case 'g':
                      generateBrain();
                  break;
                  default:
                  break;
              }
          }while(choice != 'l' && choice != 'g' && choice != 'q');
          return 0;
      }

      J'ai du refaire fonctionner mon débogueur car il n'était pas détecté.

      Et ce que mon prof disait est vraiment du C++ les fonctions f.write... mais c'est en faisant mes propre recherches que j'ai codé du C !

      • Partager sur Facebook
      • Partager sur Twitter
        11 janvier 2019 à 21:41:46

        Oui, mais ton code reste du C
        • Partager sur Facebook
        • Partager sur Twitter
        Developpeur Ruby/Crystal chez Plezi. Less if, more power.
          11 janvier 2019 à 22:00:12

          fread, fwrite peuvent être utilisées en C++, parce qu'historiquement la bibliothèque standard de C est incluse dans celle de C++. Mais, car il y a un mais, C++ propose une autre approche qui colle mieux avec l'esprit du langage et ses spécificités, ce sont les flux (ofstream/ifstream pour les flux fichiers). La notion de flux telle que présentée par C++ est indépendante de celle de fichier, par son biais je peux travailler de la même façon avec n'importe quel périphérique E/S. Au niveau de mes objets je me fous complètement que les E/S soient faites sur un fichier, une connexion réseau, une base de données, un GUI, le code est le même, ce sont les spécialisations des flux qui font la différence. C'est quasiment le seul intérêt de la POO (je définis une abstraction métier que je spécialise, ce qui me permet de travailler avec un grosse partie de mon code qui es purement générique, je l'ai écrite une fois elle servira pour tous les cas sans que j'ai à en changer une virgule).

          Ton prof t'as raconté des conneries, la bonne pratique en C++, c'est de travailler avec des flux. Les flux peuvent s'interfacer avec les autres éléments de la bibliothèque standard pour former un ensemble cohérent, si tu penses bien ton truc adieu les cast void* sans la moindre garantie, tu implémentes les extracteurs qui vont bien et tu obtiens à l'arrivée un truc robuste qui tient la route et les performances, et qui cerise sur le gâteau est relativement facile à tester tout en étant générique.

          -
          Edité par int21h 11 janvier 2019 à 22:10:22

          • Partager sur Facebook
          • Partager sur Twitter
          Mettre à jour le MinGW Gcc sur Code::Blocks. Du code qui n'existe pas ne contient pas de bug
            11 janvier 2019 à 22:39:20

            Ok merci pour les précisions, de toute façon je trouve ça aussi plus simple avec des flux !

            Par contre il me disait que je pouvais utiliser f.read et f.write (le '.' en plus) propre au C++, je ne pense pas que ça fasse une grande différence mais je le précise tout de même.

            Et j'ai aussi modifié la déclaration du vector pour avoir un vrai vector à 3 dimensions et non un simili fait avec un vector unidimensionnel.

            #include <iostream>
            #include <fstream>
            #include <conio.h>
            #include <string.h>
            #include <time.h>
            #include <stdlib.h>
            #include <assert.h>
            #include <math.h>
            #include <vector>
            
            using namespace std;
            
            #define debug 0
            #define NB_NEURONS_IN_FIRST_COLUMN 10
            
            typedef struct{
                int nb_layers;
                std::vector<int> nb_neurons;
                std::vector< vector< vector<float> > > connections;
            }_brain;
            
            typedef struct{
                int board[8][8];
                bool turn;
                bool black_king_side_castle;
                bool black_queen_side_castle;
                bool white_king_side_castle;
                bool white_queen_side_castle;
                int column_en_passant;
            }_chess_board;
            
            _brain brain;
            int NB_NEURONS_MAX;
            
            void loadBrain()
            {
                int temp_nb_neurons;
                float temp_connection;
                ifstream brain_file("brain_file.txt", ios::in);
                if(brain_file)
                {
                    brain_file >> brain.nb_layers;
                    NB_NEURONS_MAX = 0;
                    for(int cnt = 0; cnt < brain.nb_layers; cnt++)
                    {
                        brain_file >> temp_nb_neurons;
                        brain.nb_neurons.push_back(temp_nb_neurons);
                        if(temp_nb_neurons > NB_NEURONS_MAX)
                            NB_NEURONS_MAX = temp_nb_neurons;
                    }
                    for(int cnt1 = 0; cnt1 < brain.nb_layers - 1; cnt1++)
                    {
                        brain.connections.push_back(vector< vector< float > >());
                        for(int cnt2 = 0; cnt2 < brain.nb_neurons[cnt1]; cnt2++)
                        {
                            brain.connections[cnt1].push_back(vector< float >());
                            for(int cnt3 = 0; cnt3 < brain .nb_neurons[cnt1 + 1]; cnt3++)
                            {
                                brain_file >> temp_connection;
                                brain.connections[cnt1][cnt2].push_back(temp_connection);
                            }
                        }
                    }
                    brain_file.close();
                }
                else
                    cerr << "Impossible d'ouvrir le fichier !" << endl;
            }
            
            void saveBrain()
            {
                ofstream brain_file("brain_file.txt", ios::out | ios::trunc);
                if(brain_file)
                {
                    brain_file << brain.nb_layers << endl << endl;
                    for(int cnt1 = 0; cnt1 < brain.nb_layers; cnt1++)
                        brain_file << brain.nb_neurons[cnt1] << ' ';
                    brain_file << endl << endl;
                    for(int cnt1 = 0; cnt1 < brain.nb_layers - 1; cnt1++)
                    {
                        for(int cnt2 = 0; cnt2 < brain.nb_neurons[cnt1]; cnt2++)
                        {
                            for(int cnt3 = 0; cnt3 < brain .nb_neurons[cnt1 + 1]; cnt3++)
                                brain_file << brain.connections[cnt1][cnt2][cnt3] << ' ';
                            brain_file << endl;
                        }
                    brain_file << endl;
                    }
                    brain_file.close();
                }
                else
                    cerr << "Impossible d'ouvrir le fichier !" << endl;
            }
            
            void generateBrain()
            {
                int temp_nb_neurons;
                cout << "Number of layers:";
                cin >> brain.nb_layers;
                brain.nb_layers = brain.nb_layers + 2;
                brain.nb_neurons.push_back(NB_NEURONS_IN_FIRST_COLUMN);
                NB_NEURONS_MAX = NB_NEURONS_IN_FIRST_COLUMN;
                for(int cnt1 = 1; cnt1 < brain.nb_layers - 1; cnt1++)
                {
                    cout << "Number of node in layer " << cnt1 << ": ";
                    cin >> temp_nb_neurons;
                    brain.nb_neurons.push_back(temp_nb_neurons);
                    if(temp_nb_neurons > NB_NEURONS_MAX)
                        NB_NEURONS_MAX = temp_nb_neurons;
                }
                brain.nb_neurons.push_back(1);
                for(int cnt1 = 0; cnt1 < brain.nb_layers - 1; cnt1++)
                {
                    brain.connections.push_back(vector< vector< float > >());
                    for(int cnt2 = 0; cnt2 < brain.nb_neurons[cnt1]; cnt2++)
                    {
                        brain.connections[cnt1].push_back(vector< float >());
                        for(int cnt3 = 0; cnt3 < brain .nb_neurons[cnt1 + 1]; cnt3++)
                            brain.connections[cnt1][cnt2].push_back((((float)rand()/(float)(RAND_MAX)) * 2) - 1);
                    }
                }
                saveBrain();
            }
            
            int main()
            {
                srand (static_cast <unsigned> (time(0)));
                char choice;
                cout << "[L]oad brain_file" << endl << "[G]enerate a random brain_file" << endl << "[Q]uit program" << endl;
                do
                {
                    choice = _getch();
                    switch(choice)
                    {
                        case 'l':
                            loadBrain();
                        break;
                        case 'g':
                            generateBrain();
                        break;
                        default:
                        break;
                    }
                }while(choice != 'l' && choice != 'g' && choice != 'q');
                for (size_t i = 0; i < brain.connections.size(); i++)
                    for (size_t j = 0; j < brain.connections[i].size(); j++)
                        for (size_t k = 0; k < brain.connections[i][j].size(); k++)
                            cout << "brain.connections[" << i << "][" << j << "][" << k << "] = " << brain.connections[i][j][k] << endl; 
                return 0;
            }

            necros211 a écrit:

            Oui, mais ton code reste du C

            par contre si tu peux m’éclairer je ne vois pas où ?



            -
            Edité par ThéoSarda1 11 janvier 2019 à 22:41:46

            • Partager sur Facebook
            • Partager sur Twitter
              12 janvier 2019 à 2:32:40

              Y'a du mieux, même si c'est procédural.

              Il reste encore à virer ceci:

                  // Pas bien
              using namespace std;    
              
                  // pas bien
              #define NB_NEURONS_IN_FIRST_COLUMN 10
              
                  // Horrible !! 
              _brain brain;
              int NB_NEURONS_MAX;



              • Partager sur Facebook
              • Partager sur Twitter
                12 janvier 2019 à 3:54:39

                • les defines -> vraie variable constante (const ou mieux, constexpr).
                • include <string.h> -> include <cstring> (et les autres). Les includes provenant du C ont un en-tête C++ préfixés par c et sans .h. Au passage, même pas sûr que tu aies besoin de cstring.
                • typedef struct { ... } XX; -> clairement une syntaxe du C, en C++ on fait struct XX { ... };
                • rand()/srand() -> <random>
                • Et tous les avertissements que le compilateur peut retourner lorsqu'il est bien configuré (c’est-à-dire avec un maximum d'avertissement).

                -
                Edité par jo_link_noir 12 janvier 2019 à 3:55:30

                • Partager sur Facebook
                • Partager sur Twitter
                  12 janvier 2019 à 18:17:14

                  j'ai corrigé le code mais je n'arrive pas supprimer 'using namespace std;' sans avoir des erreurs sur les 'ifstream' et 'ofstream', et le 'typedef' non-plus

                  #include <iostream>
                  #include <fstream>
                  #include <conio.h>
                  #include <cstring>
                  #include <ctime>
                  #include <cstdlib>
                  #include <cassert>
                  #include <cmath>
                  #include <vector>
                  #include <sstream>
                  
                  using namespace std;
                  
                  typedef struct{
                      int nb_layers;
                      std::vector<int> nb_neurons;
                      std::vector< std::vector< std::vector<float> > > connections;
                  }_brain;
                  
                  typedef struct{
                      int board[8][8];
                      bool turn;
                      bool black_king_side_castle;
                      bool black_queen_side_castle;
                      bool white_king_side_castle;
                      bool white_queen_side_castle;
                      int column_en_passant;
                  }_chess_board;
                  
                  const int NB_NEURONS_IN_FIRST_COLUMN = 10;
                  
                  std::string IntToString(int a)
                  {
                      ostringstream temp;
                      temp << a;
                      return temp.str();
                  }
                  
                  bool is_file_empty(std::string file_name)
                  {
                      bool file_empty;
                      ifstream brain_file(file_name.c_str(), ios::in);
                      if(brain_file)
                          file_empty = false;
                      else
                          file_empty = true;
                      brain_file.close();
                      return file_empty;
                  }
                  
                  void loadBrain(_brain& xbrain)
                  {
                      int temp_nb_neurons;
                      int brain_number;
                      float temp_connection;
                      bool file_empty;
                      std::string file_name;
                      do
                      {
                          std::cout << "Choose the brain you wanna load: ";
                          std::cin >> brain_number;
                          file_name = "brain_file.txt";
                              file_name.insert(10, IntToString(brain_number));
                          file_empty = is_file_empty(file_name);
                      }
                      while(file_empty);
                      ifstream brain_file(file_name.c_str(), ios::in);
                      if(brain_file)
                      {
                          brain_file >> xbrain.nb_layers;
                          std::cout << xbrain.nb_layers;
                          for(int cnt = 0; cnt < xbrain.nb_layers; cnt++)
                          {
                              brain_file >> temp_nb_neurons;
                              xbrain.nb_neurons.push_back(temp_nb_neurons);
                          }
                          for(int cnt1 = 0; cnt1 < xbrain.nb_layers - 1; cnt1++)
                          {
                              xbrain.connections.push_back(vector< vector< float > >());
                              for(int cnt2 = 0; cnt2 < xbrain.nb_neurons[cnt1]; cnt2++)
                              {
                                  xbrain.connections[cnt1].push_back(vector< float >());
                                  for(int cnt3 = 0; cnt3 < xbrain.nb_neurons[cnt1 + 1]; cnt3++)
                                  {
                                      brain_file >> temp_connection;
                                      xbrain.connections[cnt1][cnt2].push_back(temp_connection);
                                  }
                              }
                          }
                          brain_file.close();
                      }
                      else
                          std::cerr << "Impossible d'ouvrir le fichier !" << endl;
                  }
                  
                  std::string emptyFileFinder()
                  {
                      unsigned int index = 0;
                      bool file_empty;
                      std::string file_name;
                      do
                      {
                          file_name = "brain_file.txt";
                          file_name.insert(10, IntToString(index));
                          file_empty = is_file_empty(file_name);
                          index++;
                      }
                      while(!file_empty);
                      return file_name;
                  }
                  
                  void saveBrain(_brain xbrain)
                  {
                      std::string file_name = emptyFileFinder();
                      ofstream brain_file(file_name.c_str(), ios::out | ios::trunc);
                      if(brain_file)
                      {
                          brain_file << xbrain.nb_layers << endl << endl;
                          for(int cnt1 = 0; cnt1 < xbrain.nb_layers; cnt1++)
                              brain_file << xbrain.nb_neurons[cnt1] << ' ';
                          brain_file << endl << endl;
                          for(int cnt1 = 0; cnt1 < xbrain.nb_layers - 1; cnt1++)
                          {
                              for(int cnt2 = 0; cnt2 < xbrain.nb_neurons[cnt1]; cnt2++)
                              {
                                  for(int cnt3 = 0; cnt3 < xbrain.nb_neurons[cnt1 + 1]; cnt3++)
                                      brain_file << xbrain.connections[cnt1][cnt2][cnt3] << ' ';
                                  brain_file << endl;
                              }
                          brain_file << endl;
                          }
                          brain_file.close();
                      }
                      else
                          std::cerr << "Impossible d'ouvrir le fichier !" << endl;
                  }
                  
                  void randomBrainGenerator(_brain& xbrain)
                  {
                      int temp_nb_neurons;
                      std::cout << "Number of layers:";
                      std::cin >> xbrain.nb_layers;
                      xbrain.nb_layers = xbrain.nb_layers + 2;
                      xbrain.nb_neurons.push_back(NB_NEURONS_IN_FIRST_COLUMN);
                      for(int cnt1 = 1; cnt1 < xbrain.nb_layers - 1; cnt1++)
                      {
                          std::cout << "Number of node in layer " << cnt1 << ": ";
                          std::cin >> temp_nb_neurons;
                          xbrain.nb_neurons.push_back(temp_nb_neurons);
                      }
                      xbrain.nb_neurons.push_back(1);
                      for(int cnt1 = 0; cnt1 < xbrain.nb_layers - 1; cnt1++)
                      {
                          xbrain.connections.push_back(vector< vector< float > >());
                          for(int cnt2 = 0; cnt2 < xbrain.nb_neurons[cnt1]; cnt2++)
                          {
                              xbrain.connections[cnt1].push_back(vector< float >());
                              for(int cnt3 = 0; cnt3 < xbrain.nb_neurons[cnt1 + 1]; cnt3++)
                                  xbrain.connections[cnt1][cnt2].push_back((((float)rand()/(float)(RAND_MAX)) * 2) - 1);
                          }
                      }
                  }
                  
                  void generateBrain(_brain& xbrain)
                  {
                      randomBrainGenerator(xbrain);
                      saveBrain(xbrain);
                  }
                  
                  int main()
                  {
                      srand (static_cast <unsigned> (time(0)));
                      _brain brain;
                      char choice;
                      std::cout << "[L]oad brain_file" << endl << "[G]enerate a random brain_file" << endl << "[Q]uit program" << endl;
                      do
                      {
                          choice = _getch();
                          switch(choice)
                          {
                              case 'l':
                                  loadBrain(brain);
                              break;
                              case 'g':
                                  generateBrain(brain);
                              break;
                              default:
                              break;
                          }
                      }while(choice != 'l' && choice != 'g' && choice != 'q');
                      for (size_t i = 0; i < brain.connections.size(); i++)
                          for (size_t j = 0; j < brain.connections[i].size(); j++)
                              for (size_t k = 0; k < brain.connections[i][j].size(); k++)
                                  std::cout << "brain.connections[" << i << "][" << j << "][" << k << "] = " << brain.connections[i][j][k] << endl;
                      return 0;
                  }
                  



                  -
                  Edité par ThéoSarda1 12 janvier 2019 à 18:19:35

                  • Partager sur Facebook
                  • Partager sur Twitter
                    12 janvier 2019 à 18:26:17

                    Met `std::` devant.

                    De plus retire `cstdlib` `ctime` `cstring` `conio.h` et `cmath`

                    • Partager sur Facebook
                    • Partager sur Twitter
                    Developpeur Ruby/Crystal chez Plezi. Less if, more power.
                      12 janvier 2019 à 19:08:49

                      Je peux juste enlever <cmath> sans erreurs, de plus je peux mettre des "std::" devant les "string", "vector" ect mais pas les "ifstream" et "ofstream".

                      Je ne comprends pas pourquoi tu veux que j'enlève ces library alors qu'elles servent partout dans mon code ?

                      • Partager sur Facebook
                      • Partager sur Twitter
                        12 janvier 2019 à 20:19:45

                        Car ce n'est pas du C++ mais du C.

                        Ce serais pas un mal de retirer cette compatibilité . . . (reve irréalisable :colere:)

                        Je serais ton professeur, je t'avoue que meme avec un code fonctionnel tu n'aurais pas énormément de point.

                        Pour la longueur des fonctions et ton nombre de if, je t'aurais mis juste la moyenne, avec -4 de penalite pour tout ce `C` tu te retrouverais a 6/20

                        • Partager sur Facebook
                        • Partager sur Twitter
                        Developpeur Ruby/Crystal chez Plezi. Less if, more power.
                          12 janvier 2019 à 20:48:18

                          Bah merci ça fait toujours plaisir, donnes-moi plutôt des solutions plutôt que de me blâmer sur tel ou tel point et je ne comprends pas non-plus pourquoi le C est un problème, ou alors il y a des équivalents en C++ que je ne connais pas ?

                          Je tiens aussi à préciser que je ne fait pas d'études en informatique mais en électronique et en informatique INDUSTRIELLE où on apprends notamment le C et un petit peu le C++ donc mon Prof n'aura pas ce genre d'exigences, et s'il les avait ce ne serait pas justifié car j'ai appris tout seul ce que je programme actuellement.

                          Et puis le nombre de 'if' ? Pardon j'en ai mis 3 qui testent si le fichier est bien ouvert !

                          Je sais que ça part d'une bonne intention mais ta réponse ne m'aide pas au contraire.

                          -
                          Edité par ThéoSarda1 12 janvier 2019 à 20:59:54

                          • Partager sur Facebook
                          • Partager sur Twitter
                            12 janvier 2019 à 22:35:41

                            Je n'ai pas grand chose a ajouter par rapport a ce que mes collègues on écrit plus haut.

                            Conseil, utilise beaucoup plus tes objets, en général, 60% des `if` sont évitable.

                            Les autres librairies ont ete cite plus haut, tu n'as qu'as les piocher.

                            • Partager sur Facebook
                            • Partager sur Twitter
                            Developpeur Ruby/Crystal chez Plezi. Less if, more power.
                              13 janvier 2019 à 3:11:50

                              Dans Informatique Industrielle, il y a Informatique, donc désolé, mais les exigences sont justifiées ;) De toute façon, vouloir faire du C ou du C++ sans ces exigences, c'est du suicide. C++ et encore plus C, sont des langages de programmation qui ne tolèrent vraiment pas l'à peu près. Tu te prépares à l'informatique industrielle, au niveau de la rigueur, c'est probablement pas loin de l'exigence maximale, n'oublie pas que si tu te rates, c'est la production d'une usine entière qui peut partir à la poubelle... La responsabilité est énorme!

                              Mon conseil, c'est de découper ton code en fonctions les plus courtes possibles, 2 if dans une fonction, c'est très souvent un de trop, 2 boucles, idem. Plus une fonction est courte et simple, plus elle est facile à écrire, à comprendre et aussi à tester et à debugger. Diviser pour régner telle est la règle ;)

                              -
                              Edité par int21h 13 janvier 2019 à 3:15:29

                              • Partager sur Facebook
                              • Partager sur Twitter
                              Mettre à jour le MinGW Gcc sur Code::Blocks. Du code qui n'existe pas ne contient pas de bug
                                13 janvier 2019 à 16:03:31

                                Je connais les exigences en informatique industrielle, et elle diffèrent pas mal de tout ce que vous m'avez dit dans ce forum, par exemple on nous encourage à utiliser des 'typedef' et les if ne sont pas un problème surtout dans le cas de MAE ou de Grafcet, je ne dit pas qu'il y en a pas mais elles diffèrent grandement de la programmation "non-industrielle" c'est pourquoi la question des attentes de mon prof (d'informatique industrielle) n'est pas vraiment pertinente, je ne cherche pas à justifier ce que je code mais ce n'est pas très encourageant de lire que son code vaut 6/20 sans connaitre le contexte. Je code avec les outils que j'ai appris et que j'apprends et déjà ce code est très loin de tout ce qu'on a fait en info indus.

                                Ceci étant dit,

                                - j'ai beau relire toute la conversation je ne vois pas de substituts pour les librairies que j'utilise

                                - je ne vois toujours pas où y a-t-il trop de 'if'

                                - j'ai réduit les sous-programmes et ai enfin réussi à supprimer le 'using namespace std;'

                                #include <iostream>
                                #include <fstream>
                                #include <conio.h>
                                #include <cstring>
                                #include <ctime>
                                #include <cstdlib>
                                #include <cassert>
                                #include <vector>
                                #include <sstream>
                                
                                typedef struct{
                                    size_t nb_layers;
                                    std::vector<size_t> nb_neurons;
                                    std::vector< std::vector< std::vector<float> > > connections;
                                }_brain;
                                
                                typedef struct{
                                    int board[8][8];
                                    bool turn;
                                    bool black_king_side_castle;
                                    bool black_queen_side_castle;
                                    bool white_king_side_castle;
                                    bool white_queen_side_castle;
                                    int column_en_passant;
                                }_chess_board;
                                
                                typedef std::vector<_chess_board> _next_moves;
                                
                                const int NB_NEURONS_IN_FIRST_COLUMN = 10;
                                
                                std::string IntToString(int a)
                                {
                                    std::ostringstream temp;
                                    temp << a;
                                    return temp.str();
                                }
                                
                                bool is_file_empty(std::string file_name)
                                {
                                    bool file_empty;
                                    std::ifstream brain_file(file_name.c_str(), std::ios::in);
                                    if(brain_file)
                                        file_empty = false;
                                    else
                                        file_empty = true;
                                    brain_file.close();
                                    return file_empty;
                                }
                                
                                std::string chooseBrain()
                                {
                                    std::string file_name;
                                    bool file_empty;
                                    int brain_number;
                                    do
                                    {
                                        std::cout << "Choose the brain you wanna load: ";
                                        std::cin >> brain_number;
                                        file_name = "brains/brain_file.txt";
                                            file_name.insert(17, IntToString(brain_number));
                                        file_empty = is_file_empty(file_name);
                                    }
                                    while(file_empty);
                                    return file_name;
                                }
                                
                                void loadNbLayers(std::ifstream& xbrain_file, _brain xbrain)
                                {
                                    xbrain_file >> xbrain.nb_layers;
                                }
                                
                                void loadNbNeurons(std::ifstream& xbrain_file, _brain xbrain)
                                {
                                    size_t temp_nb_neurons;
                                    for(size_t cnt = 0; cnt < xbrain.nb_layers; cnt++)
                                    {
                                        xbrain_file >> temp_nb_neurons;
                                        xbrain.nb_neurons.push_back(temp_nb_neurons);
                                    }
                                }
                                
                                void loadConnections(std::ifstream& xbrain_file, _brain xbrain)
                                {
                                    float temp_connection;
                                    for(size_t cnt1 = 0; cnt1 < xbrain.nb_layers - 1; cnt1++)
                                    {
                                        xbrain.connections.push_back(std::vector< std::vector<float> >());
                                        for(size_t cnt2 = 0; cnt2 < xbrain.nb_neurons[cnt1]; cnt2++)
                                        {
                                            xbrain.connections[cnt1].push_back(std::vector<float>());
                                            for(size_t cnt3 = 0; cnt3 < xbrain.nb_neurons[cnt1 + 1]; cnt3++)
                                            {
                                                xbrain_file >> temp_connection;
                                                xbrain.connections[cnt1][cnt2].push_back(temp_connection);
                                            }
                                        }
                                    }
                                }
                                
                                void loadBrain(_brain xbrain, std::string xfile_name)
                                {
                                    std::ifstream brain_file(xfile_name.c_str(), std::ios::in);
                                    if(brain_file)
                                    {
                                        loadNbLayers(brain_file, xbrain);
                                        loadNbNeurons(brain_file, xbrain);
                                        loadConnections(brain_file, xbrain);
                                        brain_file.close();
                                    }
                                    else
                                        std::cerr << "Impossible d'ouvrir le fichier !" << std::endl;
                                }
                                
                                void chooseAndLoadBrain(_brain xbrain)
                                {
                                    std::string file_name = chooseBrain();
                                    loadBrain(xbrain, file_name);
                                }
                                
                                std::string emptyFileFinder()
                                {
                                    unsigned int index = 0;
                                    bool file_empty;
                                    std::string file_name;
                                    do
                                    {
                                        file_name = "brains/brain_file.txt";
                                        file_name.insert(17, IntToString(index));
                                        file_empty = is_file_empty(file_name);
                                        index++;
                                    }
                                    while(!file_empty);
                                    return file_name;
                                }
                                
                                void saveNbLayers(std::ofstream& xbrain_file, _brain xbrain)
                                {
                                    xbrain_file << xbrain.nb_layers << std::endl << std::endl;
                                }
                                
                                void saveNbNeurons(std::ofstream& xbrain_file, _brain xbrain)
                                {
                                    for(size_t cnt1 = 0; cnt1 < xbrain.nb_layers; cnt1++)
                                        xbrain_file << xbrain.nb_neurons[cnt1] << ' ';
                                    xbrain_file << std::endl << std::endl;
                                }
                                
                                void saveConnections(std::ofstream& xbrain_file, _brain xbrain)
                                {
                                    for(size_t cnt1 = 0; cnt1 < xbrain.nb_layers - 1; cnt1++)
                                    {
                                        for(size_t cnt2 = 0; cnt2 < xbrain.nb_neurons[cnt1]; cnt2++)
                                        {
                                            for(size_t cnt3 = 0; cnt3 < xbrain.nb_neurons[cnt1 + 1]; cnt3++)
                                                xbrain_file << xbrain.connections[cnt1][cnt2][cnt3] << ' ';
                                            xbrain_file << std::endl;
                                        }
                                    xbrain_file << std::endl;
                                    }
                                }
                                
                                void saveBrain(_brain xbrain)
                                {
                                    std::string file_name = emptyFileFinder();
                                    std::ofstream brain_file(file_name.c_str(), std::ios::out | std::ios::trunc);
                                    if(brain_file)
                                    {
                                        saveNbLayers(brain_file, xbrain);
                                        saveNbNeurons(brain_file, xbrain);
                                        saveConnections(brain_file, xbrain);
                                        brain_file.close();
                                    }
                                    else
                                        std::cerr << "Impossible d'ouvrir le fichier !" << std::endl;
                                }
                                
                                void dimensionningBrain(_brain xbrain)
                                {
                                    size_t temp_nb_neurons;
                                    std::cout << "Number of layers:";
                                    std::cin >> xbrain.nb_layers;
                                    xbrain.nb_layers = xbrain.nb_layers + 2;
                                    xbrain.nb_neurons.push_back(NB_NEURONS_IN_FIRST_COLUMN);
                                    for(size_t cnt1 = 1; cnt1 < xbrain.nb_layers - 1; cnt1++)
                                    {
                                        std::cout << "Number of node in layer " << cnt1 << ": ";
                                        std::cin >> temp_nb_neurons;
                                        xbrain.nb_neurons.push_back(temp_nb_neurons);
                                    }
                                    xbrain.nb_neurons.push_back(1);
                                }
                                
                                void generateRandomConnectionValues(_brain xbrain)
                                {
                                    for(size_t cnt1 = 0; cnt1 < xbrain.nb_layers - 1; cnt1++)
                                    {
                                        xbrain.connections.push_back(std::vector< std::vector<float> >());
                                        for(size_t cnt2 = 0; cnt2 < xbrain.nb_neurons[cnt1]; cnt2++)
                                        {
                                            xbrain.connections[cnt1].push_back(std::vector<float>());
                                            for(size_t cnt3 = 0; cnt3 < xbrain.nb_neurons[cnt1 + 1]; cnt3++)
                                                xbrain.connections[cnt1][cnt2].push_back((((float)rand()/(float)(RAND_MAX)) * 2) - 1);
                                        }
                                    }
                                }
                                
                                void randomBrainGenerator(_brain xbrain)
                                {
                                    dimensionningBrain(xbrain);
                                    generateRandomConnectionValues(xbrain);
                                }
                                
                                void generateBrain(_brain xbrain)
                                {
                                    randomBrainGenerator(xbrain);
                                    saveBrain(xbrain);
                                }
                                
                                void selectBrainCreationMethod(_brain xbrain)
                                {
                                    char choice;
                                    std::cout << "[L]oad brain_file" << std::endl << "[G]enerate a random brain_file" << std::endl << "[Q]uit program" << std::endl;
                                    do
                                    {
                                        choice = _getch();
                                        switch(choice)
                                        {
                                            case 'l':
                                                chooseAndLoadBrain(xbrain);
                                            break;
                                            case 'g':
                                                generateBrain(xbrain);
                                            break;
                                            default:
                                            break;
                                        }
                                    }while(choice != 'l' && choice != 'g' && choice != 'q');
                                }
                                
                                void selectAction(_brain xbrain)
                                {
                                    char choice;
                                    std::cout << "[P]lay against AI" << std::endl << "[E]volve AI" << "[R]ate a custom chessboard" << std::endl << "[Q]uit program" << std::endl;
                                    do
                                    {
                                        choice = _getch();
                                        switch(choice)
                                        {
                                            case 'p':
                                                //playAgainstAI(brain);
                                            break;
                                            case 'e':
                                                //evolution(brain);
                                            break;
                                            case 'r':
                                                //rateChessBoard(brain);
                                            default:
                                            break;
                                        }
                                    }while(choice != 'p' && choice != 'e' && choice != 'r' && choice != 'q');
                                }
                                
                                int main()
                                {
                                    srand (static_cast <unsigned> (time(0)));
                                    _brain brain;
                                    selectBrainCreationMethod(brain);
                                    selectAction(brain);
                                    return 0;
                                }
                                

                                -
                                Edité par ThéoSarda1 13 janvier 2019 à 16:43:07

                                • Partager sur Facebook
                                • Partager sur Twitter
                                  13 janvier 2019 à 16:41:51

                                  Je n'ai pas suivi la conversation, donc quelques remarques rapides.

                                  ThéoSarda1 a écrit:

                                  par exemple on nous encourage à utiliser des 'typedef'

                                  L'utilisation de typedef pour déclarer une classe est un reliquat du C. C'est pas recommandé de l'utiliser et c'est meme explicitement interdit en C++17.

                                  https://en.cppreference.com/w/cpp/language/typedef 

                                  The typedef specifier cannot be combined with any other 
                                  specifier except for type-specifiers.
                                  
                                  The typedef-names are aliases for existing types, and are 
                                  not declarations of new types. Typedef cannot be used to 
                                  change the meaning of an existing type name (including a 
                                  typedef-name). Once declared, a typedef-name may only be 
                                  redeclared to refer to the same type again. Typedef names 
                                  are only in effect in the scope where they are visible: 
                                  different functions or class declarations may define 
                                  identically-named types with different meaning.
                                  
                                  The typedef specifier may not appear in a declaration that 
                                  does not contain a declarator.
                                  
                                  typedef struct X {}; // ill-formed [C++17]

                                  ThéoSarda1 a écrit:

                                  Je connais les exigences en informatique industrielle, et elle diffèrent pas mal de tout ce que vous m'avez dit dans ce forum

                                  Il existe differente normes dans le dev pro, mais globalement, les idées principales sont les memes : eviter les bugs et les couts de maintenance imporants. https://fr.wikipedia.org/wiki/Qualit%C3%A9_logicielle 

                                  La lisibilité d'un code est un critère important de qualité. Si on a du mal a lire un code, on aura du mal aussi a voir les bugs.

                                  Des choses très simples, comme tes variables (inutilement) non initialisées, c'est un risque de comportement indéterminé (UB undefined behavior), donc de comportement non désiré du logiciel.

                                  Et il doit y avoir encore pas mal de choses qui posent problème.

                                  En vrac :

                                  - IntToString ne sert a rien, il existe une fonction std::to_string

                                  - c_str() dans fstream ne sert a rien depuis le C++11

                                  - passer brain par copie dans saveBrain, c'est moche

                                  Bon, a force, j'ai perdu le fil, je ne sais plus quel est le problème.

                                  Quelques warnings de plus :

                                  prog.cc:79:56: warning: implicit conversion changes signedness: 'int' to 'std::__1::vector<int, std::__1::allocator<int> >::size_type' (aka 'unsigned long') [-Wsign-conversion]
                                              for(int cnt2 = 0; cnt2 < xbrain.nb_neurons[cnt1]; cnt2++)
                                                                       ~~~~~~            ^~~~
                                  prog.cc:81:36: warning: implicit conversion changes signedness: 'int' to 'std::__1::vector<std::__1::vector<std::__1::vector<float, std::__1::allocator<float> >, std::__1::allocator<std::__1::vector<float, std::__1::allocator<float> > > >, std::__1::allocator<std::__1::vector<std::__1::vector<float, std::__1::allocator<float> >, std::__1::allocator<std::__1::vector<float, std::__1::allocator<float> > > > > >::size_type' (aka 'unsigned long') [-Wsign-conversion]
                                                  xbrain.connections[cnt1].push_back(vector< float >());
                                                  ~~~~~~             ^~~~
                                  prog.cc:82:65: warning: implicit conversion changes signedness: 'int' to 'std::__1::vector<int, std::__1::allocator<int> >::size_type' (aka 'unsigned long') [-Wsign-conversion]
                                                  for(int cnt3 = 0; cnt3 < xbrain.nb_neurons[cnt1 + 1]; cnt3++)
                                                                           ~~~~~~            ~~~~~^~~
                                  prog.cc:85:40: warning: implicit conversion changes signedness: 'int' to 'std::__1::vector<std::__1::vector<std::__1::vector<float, std::__1::allocator<float> >, std::__1::allocator<std::__1::vector<float, std::__1::allocator<float> > > >, std::__1::allocator<std::__1::vector<std::__1::vector<float, std::__1::allocator<float> >, std::__1::allocator<std::__1::vector<float, std::__1::allocator<float> > > > > >::size_type' (aka 'unsigned long') [-Wsign-conversion]
                                                      xbrain.connections[cnt1][cnt2].push_back(temp_connection);
                                                      ~~~~~~             ^~~~
                                  prog.cc:85:46: warning: implicit conversion changes signedness: 'int' to 'std::__1::vector<std::__1::vector<float, std::__1::allocator<float> >, std::__1::allocator<std::__1::vector<float, std::__1::allocator<float> > > >::size_type' (aka 'unsigned long') [-Wsign-conversion]
                                                      xbrain.connections[cnt1][cnt2].push_back(temp_connection);
                                                      ~~~~~~                   ^~~~
                                  prog.cc:103:42: warning: implicit conversion changes signedness: 'unsigned int' to 'int' [-Wsign-conversion]
                                          file_name.insert(10, IntToString(index));
                                                               ~~~~~~~~~~~ ^~~~~
                                  prog.cc:119:45: warning: implicit conversion changes signedness: 'int' to 'std::__1::vector<int, std::__1::allocator<int> >::size_type' (aka 'unsigned long') [-Wsign-conversion]
                                              brain_file << xbrain.nb_neurons[cnt1] << ' ';
                                                            ~~~~~~            ^~~~
                                  prog.cc:123:56: warning: implicit conversion changes signedness: 'int' to 'std::__1::vector<int, std::__1::allocator<int> >::size_type' (aka 'unsigned long') [-Wsign-conversion]
                                              for(int cnt2 = 0; cnt2 < xbrain.nb_neurons[cnt1]; cnt2++)
                                                                       ~~~~~~            ^~~~
                                  prog.cc:125:65: warning: implicit conversion changes signedness: 'int' to 'std::__1::vector<int, std::__1::allocator<int> >::size_type' (aka 'unsigned long') [-Wsign-conversion]
                                                  for(int cnt3 = 0; cnt3 < xbrain.nb_neurons[cnt1 + 1]; cnt3++)
                                                                           ~~~~~~            ~~~~~^~~
                                  prog.cc:126:54: warning: implicit conversion changes signedness: 'int' to 'std::__1::vector<std::__1::vector<std::__1::vector<float, std::__1::allocator<float> >, std::__1::allocator<std::__1::vector<float, std::__1::allocator<float> > > >, std::__1::allocator<std::__1::vector<std::__1::vector<float, std::__1::allocator<float> >, std::__1::allocator<std::__1::vector<float, std::__1::allocator<float> > > > > >::size_type' (aka 'unsigned long') [-Wsign-conversion]
                                                      brain_file << xbrain.connections[cnt1][cnt2][cnt3] << ' ';
                                                                    ~~~~~~             ^~~~
                                  prog.cc:126:60: warning: implicit conversion changes signedness: 'int' to 'std::__1::vector<std::__1::vector<float, std::__1::allocator<float> >, std::__1::allocator<std::__1::vector<float, std::__1::allocator<float> > > >::size_type' (aka 'unsigned long') [-Wsign-conversion]
                                                      brain_file << xbrain.connections[cnt1][cnt2][cnt3] << ' ';
                                                                    ~~~~~~                   ^~~~
                                  prog.cc:126:66: warning: implicit conversion changes signedness: 'int' to 'std::__1::vector<float, std::__1::allocator<float> >::size_type' (aka 'unsigned long') [-Wsign-conversion]
                                                      brain_file << xbrain.connections[cnt1][cnt2][cnt3] << ' ';
                                                                    ~~~~~~                         ^~~~
                                  prog.cc:154:52: warning: implicit conversion changes signedness: 'int' to 'std::__1::vector<int, std::__1::allocator<int> >::size_type' (aka 'unsigned long') [-Wsign-conversion]
                                          for(int cnt2 = 0; cnt2 < xbrain.nb_neurons[cnt1]; cnt2++)
                                                                   ~~~~~~            ^~~~
                                  prog.cc:156:32: warning: implicit conversion changes signedness: 'int' to 'std::__1::vector<std::__1::vector<std::__1::vector<float, std::__1::allocator<float> >, std::__1::allocator<std::__1::vector<float, std::__1::allocator<float> > > >, std::__1::allocator<std::__1::vector<std::__1::vector<float, std::__1::allocator<float> >, std::__1::allocator<std::__1::vector<float, std::__1::allocator<float> > > > > >::size_type' (aka 'unsigned long') [-Wsign-conversion]
                                              xbrain.connections[cnt1].push_back(vector< float >());
                                              ~~~~~~             ^~~~
                                  prog.cc:157:61: warning: implicit conversion changes signedness: 'int' to 'std::__1::vector<int, std::__1::allocator<int> >::size_type' (aka 'unsigned long') [-Wsign-conversion]
                                              for(int cnt3 = 0; cnt3 < xbrain.nb_neurons[cnt1 + 1]; cnt3++)
                                                                       ~~~~~~            ~~~~~^~~
                                  prog.cc:158:60: warning: use of old-style cast [-Wold-style-cast]
                                                  xbrain.connections[cnt1][cnt2].push_back((((float)rand()/(float)(RAND_MAX)) * 2) - 1);
                                                                                             ^      ~~~~~~
                                  prog.cc:158:74: warning: use of old-style cast [-Wold-style-cast]
                                                  xbrain.connections[cnt1][cnt2].push_back((((float)rand()/(float)(RAND_MAX)) * 2) - 1);
                                                                                                           ^      ~~~~~~~~~~
                                  prog.cc:158:36: warning: implicit conversion changes signedness: 'int' to 'std::__1::vector<std::__1::vector<std::__1::vector<float, std::__1::allocator<float> >, std::__1::allocator<std::__1::vector<float, std::__1::allocator<float> > > >, std::__1::allocator<std::__1::vector<std::__1::vector<float, std::__1::allocator<float> >, std::__1::allocator<std::__1::vector<float, std::__1::allocator<float> > > > > >::size_type' (aka 'unsigned long') [-Wsign-conversion]
                                                  xbrain.connections[cnt1][cnt2].push_back((((float)rand()/(float)(RAND_MAX)) * 2) - 1);
                                                  ~~~~~~             ^~~~
                                  prog.cc:158:42: warning: implicit conversion changes signedness: 'int' to 'std::__1::vector<std::__1::vector<float, std::__1::allocator<float> >, std::__1::allocator<std::__1::vector<float, std::__1::allocator<float> > > >::size_type' (aka 'unsigned long') [-Wsign-conversion]
                                                  xbrain.connections[cnt1][cnt2].push_back((((float)rand()/(float)(RAND_MAX)) * 2) - 1);
                                                  ~~~~~~                   ^~~~
                                  prog.cc:171:41: warning: zero as null pointer constant [-Wzero-as-null-pointer-constant]
                                      srand (static_cast <unsigned> (time(0)));
                                                                          ^
                                                                          nullptr
                                  20 warnings generated.



                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                  Pour poser des questions ou simplement discuter informatique, vous pouvez rejoindre le discord NaN.
                                    13 janvier 2019 à 16:42:33

                                    `cstdlib` => `iostream`

                                    `ctime` => `chrono`

                                    `cstring` => `string`

                                    `conio.h` => T'en a juste pas besoin . . . C'est pas portable

                                    `cmath` => T'en a pas vraiment besoin, utilise une librairie pour des matrices


                                    Pour ce qui est des `if`, au taff on a une regle qui s'avere assez vrais.


                                    Pour une fonction, le `nombre de bug = 2^nombre de if`

                                    Ton switch case dans le main cause de la difficulte de lecture.

                                    Ligne 116 ton `if` rajoute inutilement de la complexite a cette fonction, alors qu'elle ne devrais pas etre appeller si le contenu c'est pas bon.

                                    T'a des 3 boucles for complexe a lire. (Genre les Range loop c'est so 2011) fait une fonction prenant une lambda avec les positions si t'en as vraiment besoin, mais cela me parrait inutile.

                                    T'a des typedef qui peuvent etre retirer.

                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                    Developpeur Ruby/Crystal chez Plezi. Less if, more power.
                                      13 janvier 2019 à 16:54:22

                                      Wow vous m'aidez beaucoup les gens !

                                      Comment je remplace le getch_ sans le conio.h ?

                                      comment supprimer l'erreur ici:

                                          srand (static_cast <unsigned> (time(0)));

                                                                                                               ^

                                                                                                            nullptr

                                      plus une petite question est-ce-que openclassroom est un site fiable ? car beaucoup des corrections que j'ai du apporter viennent de là

                                      PS je ne pouvais pas utiliser "to_string" car je n'étais pas en c++11

                                      -
                                      Edité par ThéoSarda1 13 janvier 2019 à 17:30:17

                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        13 janvier 2019 à 17:30:48

                                        Et tu trouve ca normal de ne pas avoir C++11 en 2019?

                                        Et non, le cours de C++ d'openclassrooms est a fuir.

                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                        Developpeur Ruby/Crystal chez Plezi. Less if, more power.
                                          13 janvier 2019 à 17:34:50

                                          je ne suis pas très au courant de l'actu sur le c++

                                          ok je comprends mieux !

                                          sinon que dites-vous de

                                             cppreference.com

                                             cplusplus.com

                                             stack overflow

                                             developpez.net

                                          sinon voilà le code à jour

                                          #include <iostream>
                                          #include <fstream>
                                          #include <conio.h>
                                          #include <string>
                                          #include <chrono>
                                          #include <cassert>
                                          #include <vector>
                                          #include <sstream>
                                          
                                          typedef struct{
                                              size_t nb_layers;
                                              std::vector<size_t> nb_neurons;
                                              std::vector< std::vector< std::vector<float> > > connections;
                                          }_brain;
                                          
                                          typedef struct{
                                              int board[8][8];
                                              bool turn;
                                              bool black_king_side_castle;
                                              bool black_queen_side_castle;
                                              bool white_king_side_castle;
                                              bool white_queen_side_castle;
                                              int column_en_passant;
                                          }_chess_board;
                                          
                                          const int NB_NEURONS_IN_FIRST_COLUMN = 10;
                                          
                                          bool is_file_empty(std::string file_name)
                                          {
                                              bool file_empty;
                                              std::ifstream brain_file(file_name.c_str(), std::ios::in);
                                              if(brain_file)
                                                  file_empty = false;
                                              else
                                                  file_empty = true;
                                              brain_file.close();
                                              return file_empty;
                                          }
                                          
                                          std::string chooseBrain()
                                          {
                                              std::string file_name;
                                              bool file_empty;
                                              int brain_number;
                                              do
                                              {
                                                  std::cout << "Choose the brain you wanna load: ";
                                                  std::cin >> brain_number;
                                                  file_name = "brains/brain_file.txt";
                                                      file_name.insert(17, std::to_string(brain_number));
                                                  file_empty = is_file_empty(file_name);
                                              }
                                              while(file_empty);
                                              return file_name;
                                          }
                                          
                                          void loadNbLayers(std::ifstream& xbrain_file, _brain xbrain)
                                          {
                                              xbrain_file >> xbrain.nb_layers;
                                          }
                                          
                                          void loadNbNeurons(std::ifstream& xbrain_file, _brain xbrain)
                                          {
                                              size_t temp_nb_neurons;
                                              for(size_t cnt = 0; cnt < xbrain.nb_layers; cnt++)
                                              {
                                                  xbrain_file >> temp_nb_neurons;
                                                  xbrain.nb_neurons.push_back(temp_nb_neurons);
                                              }
                                          }
                                          
                                          void loadConnections(std::ifstream& xbrain_file, _brain xbrain)
                                          {
                                              float temp_connection;
                                              for(size_t cnt1 = 0; cnt1 < xbrain.nb_layers - 1; cnt1++)
                                              {
                                                  xbrain.connections.push_back(std::vector< std::vector<float> >());
                                                  for(size_t cnt2 = 0; cnt2 < xbrain.nb_neurons[cnt1]; cnt2++)
                                                  {
                                                      xbrain.connections[cnt1].push_back(std::vector<float>());
                                                      for(size_t cnt3 = 0; cnt3 < xbrain.nb_neurons[cnt1 + 1]; cnt3++)
                                                      {
                                                          xbrain_file >> temp_connection;
                                                          xbrain.connections[cnt1][cnt2].push_back(temp_connection);
                                                      }
                                                  }
                                              }
                                          }
                                          
                                          void loadBrain(_brain xbrain, std::string xfile_name)
                                          {
                                              std::ifstream brain_file(xfile_name.c_str(), std::ios::in);
                                              if(brain_file)
                                              {
                                                  loadNbLayers(brain_file, xbrain);
                                                  loadNbNeurons(brain_file, xbrain);
                                                  loadConnections(brain_file, xbrain);
                                                  brain_file.close();
                                              }
                                              else
                                                  std::cerr << "Impossible d'ouvrir le fichier !" << std::endl;
                                          }
                                          
                                          void chooseAndLoadBrain(_brain xbrain)
                                          {
                                              std::string file_name = chooseBrain();
                                              loadBrain(xbrain, file_name);
                                          }
                                          
                                          std::string emptyFileFinder()
                                          {
                                              unsigned int index = 0;
                                              bool file_empty;
                                              std::string file_name;
                                              do
                                              {
                                                  file_name = "brains/brain_file.txt";
                                                  file_name.insert(17, std::to_string(index));
                                                  file_empty = is_file_empty(file_name);
                                                  index++;
                                              }
                                              while(!file_empty);
                                              return file_name;
                                          }
                                          
                                          void saveNbLayers(std::ofstream& xbrain_file, _brain xbrain)
                                          {
                                              xbrain_file << xbrain.nb_layers << std::endl << std::endl;
                                          }
                                          
                                          void saveNbNeurons(std::ofstream& xbrain_file, _brain xbrain)
                                          {
                                              for(size_t cnt1 = 0; cnt1 < xbrain.nb_layers; cnt1++)
                                                  xbrain_file << xbrain.nb_neurons[cnt1] << ' ';
                                              xbrain_file << std::endl << std::endl;
                                          }
                                          
                                          void saveConnections(std::ofstream& xbrain_file, _brain xbrain)
                                          {
                                              for(size_t cnt1 = 0; cnt1 < xbrain.nb_layers - 1; cnt1++)
                                              {
                                                  for(size_t cnt2 = 0; cnt2 < xbrain.nb_neurons[(unsigned int)cnt1]; cnt2++)
                                                  {
                                                      for(size_t cnt3 = 0; cnt3 < xbrain.nb_neurons[(unsigned int)cnt1 + 1]; cnt3++)
                                                          xbrain_file << xbrain.connections[(unsigned int)cnt1][(unsigned int)cnt2][(unsigned int)cnt3] << ' ';
                                                      xbrain_file << std::endl;
                                                  }
                                              xbrain_file << std::endl;
                                              }
                                          }
                                          
                                          void saveBrain(_brain xbrain)
                                          {
                                              std::string file_name = emptyFileFinder();
                                              std::ofstream brain_file(file_name.c_str(), std::ios::out | std::ios::trunc);
                                              if(brain_file)
                                              {
                                                  saveNbLayers(brain_file, xbrain);
                                                  saveNbNeurons(brain_file, xbrain);
                                                  saveConnections(brain_file, xbrain);
                                                  brain_file.close();
                                              }
                                              else
                                                  std::cerr << "Impossible d'ouvrir le fichier !" << std::endl;
                                          }
                                          
                                          void dimensionningBrain(_brain xbrain)
                                          {
                                              size_t temp_nb_neurons;
                                              std::cout << "Number of layers:";
                                              std::cin >> xbrain.nb_layers;
                                              xbrain.nb_layers = xbrain.nb_layers + 2;
                                              xbrain.nb_neurons.push_back(NB_NEURONS_IN_FIRST_COLUMN);
                                              for(size_t cnt1 = 1; cnt1 < xbrain.nb_layers - 1; cnt1++)
                                              {
                                                  std::cout << "Number of node in layer " << cnt1 << ": ";
                                                  std::cin >> temp_nb_neurons;
                                                  xbrain.nb_neurons.push_back(temp_nb_neurons);
                                              }
                                              xbrain.nb_neurons.push_back(1);
                                          }
                                          
                                          void generateRandomConnectionValues(_brain xbrain)
                                          {
                                              for(size_t cnt1 = 0; cnt1 < xbrain.nb_layers - 1; cnt1++)
                                              {
                                                  xbrain.connections.push_back(std::vector< std::vector<float> >());
                                                  for(size_t cnt2 = 0; cnt2 < xbrain.nb_neurons[cnt1]; cnt2++)
                                                  {
                                                      xbrain.connections[cnt1].push_back(std::vector<float>());
                                                      for(size_t cnt3 = 0; cnt3 < xbrain.nb_neurons[cnt1 + 1]; cnt3++)
                                                          xbrain.connections[cnt1][cnt2].push_back(((rand()/(RAND_MAX)) * 2.) - 1.);
                                                  }
                                              }
                                          }
                                          
                                          void randomBrainGenerator(_brain xbrain)
                                          {
                                              dimensionningBrain(xbrain);
                                              generateRandomConnectionValues(xbrain);
                                          }
                                          
                                          void generateBrain(_brain xbrain)
                                          {
                                              randomBrainGenerator(xbrain);
                                              saveBrain(xbrain);
                                          }
                                          
                                          void selectBrainCreationMethod(_brain xbrain)
                                          {
                                              char choice;
                                              std::cout << "[L]oad brain_file" << std::endl << "[G]enerate a random brain_file" << std::endl << "[Q]uit program" << std::endl;
                                              do
                                              {
                                                  choice = _getch();
                                                  switch(choice)
                                                  {
                                                      case 'l':
                                                          chooseAndLoadBrain(xbrain);
                                                      break;
                                                      case 'g':
                                                          generateBrain(xbrain);
                                                      break;
                                                      default:
                                                      break;
                                                  }
                                              }while(choice != 'l' && choice != 'g' && choice != 'q');
                                          }
                                          
                                          void selectAction(/*_brain xbrain*/)
                                          {
                                              char choice;
                                              std::cout << "[P]lay against AI" << std::endl << "[E]volve AI" << "[R]ate a custom chessboard" << std::endl << "[Q]uit program" << std::endl;
                                              do
                                              {
                                                  choice = _getch();
                                                  switch(choice)
                                                  {
                                                      case 'p':
                                                          //playAgainstAI(brain);
                                                      break;
                                                      case 'e':
                                                          //evolution(brain);
                                                      break;
                                                      case 'r':
                                                          //rateChessBoard(brain);
                                                      default:
                                                      break;
                                                  }
                                              }while(choice != 'p' && choice != 'e' && choice != 'r' && choice != 'q');
                                          }
                                          
                                          
                                          int main()
                                          {
                                              srand (static_cast <unsigned> (time(0)));
                                              _brain brain;
                                              selectBrainCreationMethod(brain);
                                              selectAction(/*brain*/);
                                              return 0;
                                          }
                                          

                                          je ne sais pas enlever l'erreur au niveau de time(0)

                                          et je ne sais pas comment enlever les typedef ni le getch_ du conio.h

                                          -
                                          Edité par ThéoSarda1 13 janvier 2019 à 17:37:30

                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            13 janvier 2019 à 17:42:11

                                            Salut,

                                            ThéoSarda1 a écrit:

                                            Je connais les exigences en informatique industrielle, et elle diffèrent pas mal de tout ce que vous m'avez dit dans ce forum, par exemple on nous encourage à utiliser des 'typedef'

                                            Dans les définitions de classes et de structures ? cela m'étonnerait bien fort. A moins que l'on fasse du C et non du C++

                                            Et ceux qui te disent que

                                            Mais de toutes façons, C et C++ c'est la même chose

                                            n'auront décidément rien compris au C++

                                            et les if ne sont pas un problème surtout dans le cas de MAE ou de Grafcet, je ne dit pas qu'il y en a pas mais elles diffèrent grandement de la programmation "non-industrielle"

                                            Un if, ca donne toujours une alternative, et donc deux possibilités, car il y a toujours soit

                                            • la possibilité de faire quelque chose si la condition est remplie ET
                                            • la possibilité de ne rien faire si elle n'est pas remplie (ce qui est aussi une possibilité)

                                            soit

                                            • la possibilité de faire quelque chose si la condition est remplie ET
                                            • la possibiilté de faire autre chose si la conditions n'est pas remplie

                                            Dans le meilleur des cas, le nombre de possibilités (et de chemins d'exécution possibles) évolue donc de manière proportionnelle au nombre de tests (pour N tests, tu te retrouve avec 2N chemins d'exécution possibles).

                                            Dans le pire des cas, le nombre de possibilités (et de chemins d'exécution possibles) évoluera de manière exponentielle (pour 8 tests, tu peux très bien te retrouver avec ... 256 chemins d'exécution possibles).

                                            Ne vient donc pas dire que les if ne sont pas un problème, car c'est bel et bien un problème réel :  quand tu mets une logique en place, c'est pour obtenir un résultat clairement identifié et reproductible à partir d'une situation donnée.

                                            Si tu veux t'assurer que ton application donnera le résultat espérer, tu dois pouvoir t'assurer que tous les chemins d'exécution fourniront le résultat attendu.

                                            Et cela signifie que tu dois pouvoir tester chaque situation possible.

                                            Or, s'il est facile de déterminer les situations auxquelles nous seront confrontés avec une condition (elle est remplie, ou  non, il y a donc "quelque chose" qui doit être fait, ou "autre chose" qui devra être fait ... voire, ou "rien du tout" qui devra être fait), la multiplication "comme des petits pains" des tests te mettra dans une position dans laquelle, au mieux, tu en viendra à tester trois fois la même possibilité (ce qui n'est pas vraiment utile) et, au pire, tu en viendra à oublier la une bonne moitié des possibilités offertes

                                             Albert Einsthin l'a dit en son temps :

                                            Il faut rendre les choses aussi complexes que nécessaire, mais guère plus

                                            Ce qu'il voulait dire, c'est que l'on n'a pas vraiment le choix: nous sommes généralement confrontés à des problèmes tellement complexes que la solution qu'il faut y apporter ne peut souvent qu'être complexe.

                                            Mais il faut toujours veiller à garder la solution "la plus simple possible", si on veut arriver à quelque chose d'efficace et d'utile.

                                            La multiplication des tests ne permet pas de garder notre solution "la plus simple possible".

                                            c'est pourquoi la question des attentes de mon prof (d'informatique industrielle) n'est pas vraiment pertinente, je ne cherche pas à justifier ce que je code mais ce n'est pas très encourageant de lire que son code vaut 6/20 sans connaitre le contexte.

                                            La remarque est peut-être un peu abrupte, mais elle est justifiée

                                            La seule chose que l'on puisse dire à ce sujet, c'est de ne pas prendre cette remarque comme une attaque personnelle, mais bien comme une incitation à faire mieux!

                                            Enormément de remarques, d'améliorations potentielles t'ont été faites au cours de cette discussion.

                                            Prends le temps de les relire, de les comprendre et de les appliquer.

                                            Si tu ne les comprends pas, n'hésites pas à poser des questions, car il est vrai que de nombreuses remarques sont parfois "trop générales" pour être facilement comprises.

                                            Et surtout, gardes bien en tête que nous sommes tous passés par là: nous avons tous écrit du code aussi mauvais que le tien! Et nous en avons tous payé les conséquences

                                            Dis toi qu'en corrigeant tes habitudes (et ton code) maintenant, tu te facilite la vie pour les quarante ans à venir, parce que les habitudes que nous cherchons à te faire prendre te permettront, quand tu auras atteint l'age de la pension, de décider de relire le code que tu auras (corrigé) écrit aujourd'hui, de le comprendre et de l'apprécier

                                            Je code avec les outils que j'ai appris et que j'apprends et déjà ce code est très loin de tout ce qu'on a fait en info indus.

                                            Et nous en sommes bien conscients!

                                            Mais dis toi bien que nous étions exactement dans la même situation que toi il y a "quelques années" (une vingtaine pour certains d'entre nous), même si nous ne sommes pas tous issus de la filière info indus.

                                            Dis toi que nous avons appris exactement le même genre de C++ que toi, et que nous avons galéré un max pour "désapprendre" ce que l'on avait appris afin de pouvoir commencer à faire réellement du C++.

                                            Ben oui, les habitudes, ca a la peau dure!

                                            Et c'est la raison pour laquelle nous nous battons pour que tu prennes directement les bonnes habitudes, pour que notre expérience puisse au moins faciliter la vie et l'apprentissage des plus jeunes.

                                            Ceci étant dit,

                                            - j'ai beau relire toute la conversation je ne vois pas de substituts pour les librairies que j'utilise

                                            - je ne vois toujours pas où y a-t-il trop de 'if'

                                            - sinon ok pour réduire les sous-programmes, je m'y atèle.

                                            -
                                            Edité par ThéoSarda1 il y a 5 minutes

                                            C'est parce que tu cherche le mauvais éléments...  Ce ne sont pas les "if" en particulier que tu dois chercher, mais les tests en général (dont les boucles).

                                            Mais, si tu veux voir où il y en a trop, voici un exemple tiré de ton code:

                                            if(brain_file)
                                                {
                                                    brain_file >> xbrain.nb_layers;
                                                    std::cout << xbrain.nb_layers;
                                                    for(int cnt = 0; cnt < xbrain.nb_layers; cnt++)
                                                    {
                                                        brain_file >> temp_nb_neurons;
                                                        xbrain.nb_neurons.push_back(temp_nb_neurons);
                                                    }
                                                    for(int cnt1 = 0; cnt1 < xbrain.nb_layers - 1; cnt1++)
                                                    {
                                                        xbrain.connections.push_back(vector< vector< float > >());
                                                        for(int cnt2 = 0; cnt2 < xbrain.nb_neurons[cnt1]; cnt2++)
                                                        {
                                                            xbrain.connections[cnt1].push_back(vector< float >());
                                                            for(int cnt3 = 0; cnt3 < xbrain.nb_neurons[cnt1 + 1]; cnt3++)
                                                            {
                                                                brain_file >> temp_connection;
                                                                xbrain.connections[cnt1][cnt2].push_back(temp_connection);
                                                            }
                                                        }
                                                    }
                                                    brain_file.close();
                                                }

                                            sur les 24 lignes de ce code, tu as un test "vrai faux" (le if (brain_file)) et quatre tests dus à des boucles.

                                            Parmis ces quatre tests dus à des boucles, trois des boucles sont imbriquées les unes dans les autres!  Cela rend ta logique beaucoup trop complexe.

                                            En plus, ces vingt-quatre lignes impliquent:

                                            • que tu fais de l'affichage
                                            • que tu fais de l'extraction de données à partir d'un fichier
                                            • que tu interprètes les données extraites
                                            • que tu garde une trace en mémoire des données interprétées pour "une utilisation ultérieure"

                                            Cela, mon cher ami, cela implique que tu donne au moins quatre responsabilités à ta fonction. Et cela en fait donc au moins trois de trop.

                                            Il y a en effet un principe primordial à garder en tête et à appliquer en toutes circonstances (en fait, il y en a quatre de plus que celui là, mais passons): le principe dit "de la responsabilité unique":

                                            Chaque donnée, chaque type de donnée, chaque fonction, chaque "fonctionnalité" (pour utiliser un terme tout à fait générique ne peut avoir qu'une et une seule responsabilité

                                            Autrement dit, si tu as une fonction qui s'occupe de l'affichage, elle ne doit s'occuper que de cela, et de rien d'autre.

                                            Si tu as une fonction qui extrait des données d'un fichier, elle ne doit s'occuper que de cela et de rien d'autre: elle  doit renvoyer "quelque chose" qui représente les données telles qu'elles se présentaient dans le fichier.

                                            Si tu as une fonction qui interprète des données (extraites depuis un fichier), pour leur donner un "sens utile" au reste du traitement, elle ne doit s'occuper que de cela, et de rien d'autres (on s'attend cependant à ce qu'elle renvoie "une trace" de toutes les données qu'elle aura interprétées" ;) )

                                            Si tu as une fonction qui s'occupe de manipuler les données interprétées, elle ne doit... devines quoi?

                                            Vois désormais tu plus où moins "par où ton code blesse"?

                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                            Ce qui se conçoit bien s'énonce clairement. Et les mots pour le dire viennent aisément.Mon nouveau livre : Coder efficacement - Bonnes pratiques et erreurs  à éviter (en C++)Avant de faire ce que tu ne pourras défaire, penses à tout ce que tu ne pourras plus faire une fois que tu l'auras fait
                                              13 janvier 2019 à 17:54:44

                                              ThéoSarda1 a écrit:

                                              sinon que dites-vous de

                                                 cppreference.com

                                                 cplusplus.com

                                                 stack overflow

                                                 developpez.net

                                              cpprefernce : oui

                                              cpluplus : le cours non, la doc oui. (Mais c'est la meme chose que cppreference - peut etre pas aussi a jour ?)

                                              SO : oui

                                              Dvp : le forum et la FAQ oui. Les cours non

                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                              Pour poser des questions ou simplement discuter informatique, vous pouvez rejoindre le discord NaN.
                                                13 janvier 2019 à 18:23:21

                                                OK je vois tu peux voir mon message précédant je pense avoir bien séparé mes fonctions.

                                                Oui en info indus on voit peut de C++ et beaucoup de C mais même en C++ ils nous disaient d'utiliser des typedef, (remarque on en a fait très peu car ce n'est pas le coeur de notre formation), on n'à même pas vu les classes, je vient de me souvenir de la formulation "du C codé en C++".

                                                "les 'for' sont des 'if' !" ça m'éclaire sur pas mal de messages mais je ne vois pas comment je peux parcourir un vecteur à trois dimension sans ces boucles. Et puis dans ce cas il n'y a pas 2 chemins je pense c'est le même chemin emprunté un certain nombre de fois (même si c'est peut-être très mal dit)

                                                Je suis navré si j'ai pu paraître sur la défensive, je prends note de toutes les infos que vous m'offrez. Il m'arrive de m'impatienter quand on me souligne plein de problèmes et que quand je demande des solutions à ces problèmes on me répond simplement "ton code vaut 6" (je caricature un peu), je ne cherche pas à me défendre mais je reste bloqué longtemps sur ces problèmes donc je propose des solutions par moi-même qui du coup peuvent (et à raison) irriter la plupart d'entre vous.

                                                je renote les problèmes pour faire le point:

                                                   les typedef c'est mal --> comment je m'en défait ?

                                                   les if (et donc les boucles imbriquées) c'est mal --> comment je parcours ce vecteur 3d sans ?

                                                   conio.h c'est mal --> j'ai un getch dans mes menus, y a-t-il une alternative ?

                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                  13 janvier 2019 à 18:36:31

                                                  ThéoSarda1 a écrit:

                                                  Oui en info indus on voit peut de C++ et beaucoup de C mais même en C++ ils nous disaient d'utiliser des typedef

                                                  Tu parles des entreprises ou de tes profs d'info qui te disent ca ?

                                                  Beaucoup de profs sont juste pas a jour de leur connaissances et connaissent pas le milieu pro.

                                                  Faire du C avec un compilateur C++, ca fait pas du C++.

                                                  Malheureusement, beaucoup de ceux qui continuent le C++ professionnellement sont obligés d'oublier ce qu'ils ont appris a l'ecole et doivent tout reapprendre. C'est dommage, mais c'est comme ca.

                                                  ThéoSarda1 a écrit:

                                                  les typedef c'est mal --> comment je m'en défait ?

                                                  Tu n'as juste pas besoin de typedef.

                                                  struct mastructure {
                                                      ...
                                                  };
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                  Pour poser des questions ou simplement discuter informatique, vous pouvez rejoindre le discord NaN.
                                                    13 janvier 2019 à 18:53:44

                                                    "Faire du C avec un compilateur C++, ca fait pas du C++."

                                                    oui je sais bien mais c'est pourquoi mes prof demande d'utiliser des typedef je pense.

                                                    struct mastructure {
                                                        ...
                                                     
                                                    
                                                    };



                                                    Si je fais ça, j'ai cette erreur

                                                    error: expected primary-expression before '.' token|

                                                    à chaque fois que j'utilise brain.qquchose

                                                    -
                                                    Edité par ThéoSarda1 13 janvier 2019 à 18:55:41

                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                      13 janvier 2019 à 18:57:15

                                                      Cela definie un type. Il faut aussi creer une variable.

                                                      Honnetement, entre choix volontaire ou incompétence, j'ai malheureusement vu plus souvent le second cas.

                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                      Pour poser des questions ou simplement discuter informatique, vous pouvez rejoindre le discord NaN.
                                                        13 janvier 2019 à 19:06:30

                                                        quelle est la différence entre typedef et struct simple

                                                        -
                                                        Edité par ThéoSarda1 13 janvier 2019 à 19:08:10

                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                          13 janvier 2019 à 19:10:36

                                                          L'une est légale en C++, l'autre est un reliquat historique.

                                                          C'est presqu'un détail. Mais en termes de maintenance du code, cela veut dire que tu pourrais avoir des problèmes avec typedef (en particulier, comme je l'ai dit, parce que ce n'est plus valide en C++17 et le compilateur pourra produire une erreur. Et donc il faudra modifier le code)

                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                          Pour poser des questions ou simplement discuter informatique, vous pouvez rejoindre le discord NaN.
                                                            13 janvier 2019 à 19:18:04

                                                            okay ! merci !

                                                            du coup il me reste

                                                            • les for imbriqués c'est mal --> comment je parcours ce vecteur à trois dimensions ?
                                                            • conio.h c'est mal --> que mets-je à la place de getch ?

                                                            j'ai trouvé ça pour le getch()

                                                            qu'en pensez-vous ?

                                                            #include <stdio.h>
                                                            #include <windows.h>
                                                            
                                                            char getCh()
                                                            {
                                                              HANDLE hStdin = GetStdHandle (STD_INPUT_HANDLE);
                                                              INPUT_RECORD irInputRecord;
                                                              DWORD dwEventsRead;
                                                              CHAR cChar;
                                                            
                                                              while(ReadConsoleInputA (hStdin, &irInputRecord, 1, &dwEventsRead)) /* Read key press */
                                                                if (irInputRecord.EventType == KEY_EVENT
                                                            	&&irInputRecord.Event.KeyEvent.wVirtualKeyCode != VK_SHIFT
                                                            	&&irInputRecord.Event.KeyEvent.wVirtualKeyCode != VK_MENU
                                                            	&&irInputRecord.Event.KeyEvent.wVirtualKeyCode != VK_CONTROL)
                                                                {
                                                                  cChar = irInputRecord.Event.KeyEvent.uChar.AsciiChar;
                                                            	ReadConsoleInputA (hStdin, &irInputRecord , 1, &dwEventsRead); /* Read key release */
                                                            	return cChar;
                                                                }
                                                              return EOF;
                                                            }



                                                            -
                                                            Edité par ThéoSarda1 13 janvier 2019 à 19:27:37

                                                            • Partager sur Facebook
                                                            • Partager sur Twitter
                                                              13 janvier 2019 à 19:46:09

                                                              ThéoSarda1 a écrit:

                                                              les for imbriqués c'est mal --> comment je parcours ce vecteur à trois dimensions ?

                                                              Il aurait déjà fallu créer des types précis pour chaque "niveau" de ton imbrication. Et par extension, une fonction pour chaque niveau.

                                                              Pour les trucs non-conventionnels de manipulation de la console, voir du côté de ncurses et les équivalents sur les différents OS.

                                                              • Partager sur Facebook
                                                              • Partager sur Twitter
                                                              Posez vos questions ou discutez informatique, sur le Discord NaN | Tuto : Preuve de programmes C

                                                              invalid types 'int[int]' for array subscript

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