Pour passer le temps...

// Class to represent the generated program

#ifndef CPROG_H
#define CPROG_H

// Need the specific node class
#include "..\\Arbre\\CThree.h"

// Configuration files
//const char * FUNCTIONS_FILE = "FuncFile.txt";
//const char * KEYWORD_FILE  = "KeyWordFile.txt";

// Three class
class CProg
{
   public :
      CProg();            // Empty constructor

      CProg * CopyProg();      // Return a copy of the program

      void Generate();      // Generate a random python's program in the current instance

      void Display() const;   // Display the program

   private :
      // A python's program is composed by four modules :
      //         - Import module (as "include" in C/C++)
      //         - Global variable definition
      //         - Functions definitions
      //         - Main module (as "int main() {...}" in C/C++)
      // The genom of our program is only composed by the modules 2 and 3
      CThree * ImportModule;
      CThree * Genom;
      CThree * MainModule;
};

#endif

void Display() const;  // Display the program

#include "..\\Arbre\\CThree.h"

CThree * ImportModule;
      CThree * Genom;
      CThree * MainModule;

CGenome * CGenome::SwapSubTreeMutator()
{
   
   // Clone the genome befor modify it
   CGenome * g = Clone();

   // Choose randomly the node to mute
   int numNodeG = 0;
   do
   {
      numNodeG = 1+(int) (NodeNumber()*rand()/(RAND_MAX+1.0));
   }while (numNodeG == 0);   // Don't cross on the root node

   g->Access(numNodeG);

   if (g->current->isFunc)
   {
      // Choose randomly a function to replace it
      int numFunc = 1+(int) (nbFunction*rand()/(RAND_MAX+1.0));

      strcpy_s(g->current->value, 255, functionList[numFunc]);

   }

   if (g->current->isOp)
   {
      // Choose randomly an operator to replace it
      int numOp = 1+(int) (nbOperator*rand()/(RAND_MAX+1.0));

      strcpy_s(g->current->value, 255, operatorList[numOp]);

   }

   if (g->current->isArg)
   {
      // check the type and replace it
      if (g->current->isFloat)
      {
         // generate a random float
         g->current->value = "0.0";
      }
      else if (g->current->isInt)
      {
         // generate a random int
         int rInt = 1+(int) (RAND_MAX*rand()/(RAND_MAX+1.0));
         _itoa_s(rInt,g->current->value, 255, 10);
      }
   }

   return g;
}

#ifndef CGENOME_H
#define CGENOME_H

// Specific includes
#include "..\\Arbre\\CTree.h"

// Our genome class is a tree
class CGenome : public CTree
{
   public :
      CGenome();                                    // Empty constructor

      CGenome * Mutate();                              // Generate a new genome by mutation from this
      CGenome * CrossOver(CGenome *g);                  // Generate a new genome form this and g

      void Copy (const CGenome *g);                     // Copy the g genome to the current genome
      CGenome * Clone ();                              // Return a copy of the genome
      
      float evalutate();                              // Get the fitness of the genome
      
      void Generate();                              // Generate a random genome

      // Public var
      bool selected;   // Used to select a genome only once

   private :
      float score;

      static char **      testFunctionList;
      static int         nbTestFunction;

      static char **      noOutputFunctionList;
      static char ***      noOutputFunctionParamList;
      static int   *      noOutputFunctionParamNumber;
      static int         nbNoOutputFunction;

      static char **      outputFunctionList;
      static char ***      outputFunctionParamList;
      static int   *      outputFunctionParamNumber;
      static int         nbOutputFunction;

      static char **      unaryOperatorList;
      static int         nbUnaryOperator;

      static char **      variableList;
      static int         nbVariable;

      static char **      binaryOperatorList;
      static int         nbBinaryOperator;

      static char **      unaryKeyWordList;
      static int         nbUnaryKeyWord;

      // Private functions
      // Mutation functions
      CGenome * DestructiveMutator();         // Generate a new genome from this by a detrucive mutation
      CGenome * SwapSubTreeMutator();         // Generate a new genome from this by swaping 2 sub tree

      int chooseVar();                  // Choose randomly to create a new variable or to take an existing and return the index of the variable
};

#endif

// Get every function without output
      f5.getline(line, 255);
      numFunc = 0;
      while(!f5.eof())
      {
         noOutputFunctionList[numFunc] = new char[255];

         // Get the number of arguments
         int cptNbArgs = 0;
         while(line[cptNbArgs] != ';') cptNbArgs++;
         cptNbArgs++;
         char *strNumArgs = new char[255];
         int cptStrNumArg = 0;
         while(line[cptNbArgs] != ',')
         {
            strNumArgs[cptStrNumArg] = line[cptNbArgs];
            cptStrNumArg++;
            cptNbArgs++;
         }
         strNumArgs[cptStrNumArg] = '\0';
         noOutputFunctionParamNumber[numFunc] = atoi(strNumArgs);

         noOutputFunctionParamList[numFunc] = new char *[noOutputFunctionParamNumber[numFunc]];
         for (int i1 = 0; i1 < noOutputFunctionParamNumber[numFunc]; i1++)
            noOutputFunctionParamList[numFunc][i1] = new char [255];

         // Get the function name
         int cptTemp = 0;
         while(line[cptTemp] != ';')
         {
            noOutputFunctionList[numFunc][cptTemp] = line[cptTemp];
            cptTemp++;
         }
         noOutputFunctionList[numFunc][cptTemp] = '\0';
         cptTemp++;

         // get the type of args
         while(line[cptTemp] != ',')      // Catch the first
            cptTemp++;

         int cptTemp2 = 0;
         int numArg = 0;
         while(line[cptTemp] != '\0')
         {
            cptTemp++;
            while(line[cptTemp] != '\0' && line[cptTemp] != ',')
            {
               noOutputFunctionParamList[numFunc][numArg][cptTemp2] = line[cptTemp];
               cptTemp++;
               cptTemp2++;
            }
            numArg++;
         }

         numFunc++;
         f5.getline(line, 255);
      }
      f5.close();

noOutputFunctionParamList[numFunc] = new char *[noOutputFunctionParamNumber[numFunc]];