Converted algorithme en c++

#include <iostream.h> //cin, cout
#include <stdio.h>
#include <stdlib.h> 
#include <string.h>
#include <time.h>  
#include <math.h>
#include <iomanip.h> 
#include <conio.h> 

#include "Jobs.h"

//déclaration des fonctions
void InitRand ();
int Hasard (int min,int max);
void Pause ();
double Distance (int a,int b);


//déclaration des types et fonctions associées
class individu
{
public:
 double eval; //la temps de transport, mise à jour à chaque modif de l'individu
 int NbG; //nombre de gênes de l'individu
 int *genes; //tableau contenant les numéros des jobs parcourues de 0 à NbG-1

 //fonction : calcule le makespan du chaque séquence et la stocke dans eval
 //données : ---
 //return : ---
 //
 void Evalue()
 {
  eval=0;
  for(int i=1;i<NbG;i++)
   eval+=Distance(genes[i-1],genes[i]);
  eval+=Distance(genes[NbG-1],genes[0]);
 }
 
 //fonction : interverti deux gênes de l'individu
 //données : position des 2 gênes
 //return : ---
 //
 void EchangeG(int a,int b)
 {
  int t=genes[a];
  genes[a]=genes[b];
  genes[b]=t;
  Evalue();
 }

 //fonction : test si le job se trouve à la position donnée
 //données : numéro de la job
 //return : true/false
 //
 bool Present(int g)
 {
  For (int i=0; i<NbG;i++)
   If (genes[i] ==g)
    Return (true);
  Return (false);
 }

 //fonction : déplace  une job 
 //données : positions initiale et final de la job
 //return : ---
 //
 void Deplace(int init,int final)
 {
  int v=genes[init];
  if(final>init)
   for(int i=init;i<final;i++)
    genes[i]=genes[i+1];
  else
   for(int i=init;i>final;i--)
    genes[i]=genes[i-1];
  genes[final]=v;
  Evalue();
 }

 //fonction : recherche la position d'une job
 //données : numéro de la job
 //return : position de la job
 //
 int jobPos(int j)
 {
  int p=0;
  while (genes[p]!=j)
   p++;
  return (p);
 }

 //fonction : inverse la job comprise entre deux positions
 //données : les deux positions
 //return : ---
 //
 void Inverse(int p1,int p2)
 {
  if(p1>p2)
  {
   int tmp=p1;
   p1=p2;
   p2=tmp;
  }
  for(int i=0;i<(p2-p1)/2;i++)
   EchangeG(p1+i,p2-i);
  Evalue();
 }

 //fonction : mutation1 - permutation de 2 jobs choisies aléatoirement
 //données : ---
 //return : ---
 //
 void MutInd1()
 {
  EchangeG (Hasard(0,NbG-1), Hasard(0,NbG-1));

 }


 //fonction : opti1 - met la job j à sa position optimale sans modifier le reste du parcours
 //données : ---
 //return : ---
 //
 void OptiInd1(int j)
 {
  Deplace(j,0);
  double e=eval;
  int p=0;
  for(int i=1;i<NbG;i++)
  {
   EchangeG(i-1,i);
   if(eval<e)
   {
    e=eval;
    p=i;
   }
  }
  Deplace(NbG-1,p);
  Evalue ();
 }

 
 //données : nombre max de tentatives
 //return : ---
 
 //fonction : affiche l'éval et le parcours
 //données : ---
 //return : ---
 //
 void Aff1()
 {
  cout << "\nEvaluation : " << eval << "\nGenes : ";
  for(int i=0;i<NbG;i++)
  {
   cout << genes[i] << ' ';
       cout << '\n';
  }
 }

 //fonction : affiche l'éval
 //données : ---
 //return : ---
 
   void Init1(int g)
 {
  NbG=g;
  genes=(int*)malloc(NbG*sizeof(int));
  for(int i=0;i<NbG;i++)
   genes[i]=i;
  for(i=0;i<NbG;i++)
   EchangeG(Hasard(0,NbG-1),Hasard(0,NbG-1));
  Evalue();
 }


 //fonction : constructeur
 //données : nombre de gênes, type d'initialisation
 //return : ---
 //
 individu(int g,int tInit)
 {
  switch(tInit)
  {
  case 1:
   Init1(g);
   break;
  case 2:
   Init2(g);
   break;
  }
 }
};

//fonction : test si égalité des deux individus
//données : les deux individus
//return : true/false
//
bool operator==(individu a,individu b)
{
 a.Evalue();
 b.Evalue();
 if(a.NbG!=b.NbG)
  return(false);
 if(a.eval!=b.eval)
  return(false);
 else
 {
  int i=0;
  while((a.genes[i]==b.genes[i])&(i<a.NbG))
   i++;
  if(i<a.NbG)
   return(false);
  else
   return(true);
 }
}

class population
{
public:
 int NbI,NbG; //nombre d'individus et de gênes
 individu *pop; //tableau des individus

/* //fonction : evalue tout les individus (inutile normalement)
 //données : ---
 //return : ---
 //
 void Eval()
 {
  for(int i=0;i<NbI;i++)
   pop[i].Evalue();
 }


*/
 //fonction : calcule l'évaluation moyenne de la population
 //données : ---
 //return : double
 //
 double Evalmoy()
 {
  double t=0;
  for(int i=0;i<NbI;i++)
   t+=pop[i].eval;
  return(t/NbI);
 }

 //fonction : choisir deux jobs
 //données : la position des 2 jobs
 //return : ---
 //
 void EchangeI(int a,int b)
 {
  
  double t=job[a].eval;
  job[a].eval=job[b].eval;
  job[b].eval=t;
  for(int i=0;i<NbG;i++)
  {
   int t=job[a].genes[i];
   job[a].genes[i]=job[b].genes[i];
   job[b].genes[i]=t; 
  }
 }

 //fonction : remplacement d'une job par la copie d'un autre
 //données : la position du job à copier et la position de la copie
 //return : ---
 //
 void CopieI(int a,int b)
 {
  
  job[b].eval=job[a].eval;
  for(int i=0;i<NbG;i++)
  {
   job[b].genes[i]=job[a].genes[i];
  }
 }

 //fonction : fonction auxiliaire pour le tri, renvoie la position du meilleur
 //   job compris entre les position i et NbI-1
 //données : i, point de départ de la recherche
 //return : int
 //
 int Triaux(int i)
 {
  int res=i;
  for(int j=i+1;j<NbI;j++)
   if(job[j].eval<job[res].eval)
    res=j;
  return(res);
 }

 //fonction : tri les individus du meilleur au moins bon par la recherche de la veleur optimale
 //données : ---
 //return : ---
 //
 void Tri()
 {
  for(int i=0;i<NbI;i++)
   EchangeI(i,Triaux(i));
 }

 //fonction : selection1 - tri les individus
 //données : ---
 //return : ---
 //
 void Selection1()
 {
  Tri();
 }

 //fonction : croiseind1 - croisement à 1 point basique
 //données : les positions des deux parents et du fils
 //return : ---
 //
 void CroiseInd1(int P1, int P2, int F)
 {
  int p=Hasard(0,NbG);
  int tmp=0;
  for(int i=0;i<p;i++)
   pop[F].genes[i]=pop[P1].genes[i];
  for(i=p;i<NbG;i++)
   pop[F].genes[i]=NbG;
  for(i=p;i<NbG;i++)
  {
   while(pop[F].Present(pop[P2].genes[tmp]))
    tmp=(tmp+1)%NbG;
   pop[F].genes[i]=pop[P2].genes[tmp];
  }
  pop[F].Evalue();
 }

 
 }

 //fonction : croisepop1 - sélection plus croisement
 //   la moitié de la pop avec conservation des parents
 //données : type de la sélection et du croisement
 //return : ---
 //
 void CroisePop1(int tSelect,int tCrois)
 {
  int i;
  switch(tSelect)
  {
  case 1:
   Selection1();
   break;
  }
  switch(tCrois)
  {
  case 1:
   for(i=NbI/2;i<NbI;i++)
    CroiseInd1(Hasard(0,NbI/2-1),Hasard(0,NbI/2-1),i);
   break;
  case 2:
   for(i=NbI/2;i<NbI;i++)
    CroiseInd2(Hasard(0,NbI/2-1),Hasard(0,NbI/2-1),i);
   break;
  }
 }

 //fonction : mutpop1 - un nombre donné d'individus choisis au hasard subissent
 //   une mutation
 //données : nombre et type de mutation à effectuer
 //return : ---
 //
 void MutPop1(int m,int tMut)
 {
  int i;
  switch(tMut)
  {
  case 1: //mutation par échange de deux gênes
   for(i=0;i<m;i++)
    pop[Hasard(0,NbI-1)].MutInd1();
   break;
  case 2: //mutation par inversion de deux jobs
   for(i=0;i<m;i++)
    pop[Hasard(0,NbI-1)].MutInd2();
   break;
  }
 }

 //fonction : mutpop2 - un nombre donné d'individus choisis au hasard subissent
 //   une mutation + pop déjà triée, dernier remplaçé par copie du meilleur, mutation du meilleur
 //données : nombre et type de mutation à effectuer
 //return : ---
 //
 void MutPop2(int m,int tMut)
 {
  int i;
  switch(tMut) //pop déjà triée, dernier parent remplaçé par copie du meilleur parent, mutation du meilleur
  {
  case 1: //mutation par échange de deux gênes
   CopieI(0,NbI/2-1);
   pop[0].MutInd1();   
   for(i=0;i<m;i++)
    pop[Hasard(0,NbI-1)].MutInd1();
   break;
  case 2: //mutation par inversion des deux jobs
   CopieI(0,NbI/2);
   pop[0].MutInd2();
   for(i=0;i<m;i++)
    pop[Hasard(0,NbI-1)].MutInd2();
   break;
  }
 }

 //fonction : OptiPop1 - optimise la population
 //données : type d'optimisation à utiliser
 //return : ---
 //
 void OptiPop1(int tOpti)
 {
  int i,j;
  double e;
  switch(tOpti)
  {
  
case 1: //optimisation 1 pour les deux  indiv, si pas d'amélioration, passe au     suivant
   j=0;
   do
   {
    e=pop[j].eval;
    for(i=0;i<NbG;i++)
    {
     pop[j].OptiInd1(pop[j].jobPos(i)); 
    }
    j++;
   }while(e==pop[j-1].eval);
   break;
  case 2://optimisation 1 pour tout les indiv et les gènes
   for(j=0;j<NbI;j++)
    for(i=0;i<NbG;i++)
    {
     pop[j].OptiInd1(pop[j].jobsPos(i)); 
    }
   break;
  case 3://optimisation 2 pour tout les indiv (nombre de tentatives == 10)
   for(i=0;i<NbI;i++)
    pop[i].OptiInd2(10);
   break;
  }
 }

 //fonction : affiche tout les individus (eval) 
 //données : ---
 //return : ---
 //
 void Aff1()
 {
  cout << "\nPopulation : ";
  for(int i=0;i<NbI;i++)
  {
   pop[i].Aff1();
   Pause();
  }
 }
 
 //fonction : affiche tout les individus (eval seule)
 //données : ---
 //return : ---
 //
 void Aff2()
 {
  cout << "\nPopulation :";
  for(int i=0;i<NbI;i++)
  {
   pop[i].Aff2();
   if (i%20==19)
    Pause();
  }
 }

 //fonction : tri + affiche l'eval moyenne & le meilleur individu (eval)
 //données : ---
 //return : ---
 //
 void Aff3()
 {
  Tri();
  cout << "\nEvaluation moyenne : " << Evalmoy();
  cout << "\nMeilleure evaluation : ";
  pop[0].Aff1();
 }

 //fonction : tri + affiche l'eval moyenne & le meilleur individu (eval seule)
 //données : ---
 //return : ---
 //
 void Aff4()
 {
  Tri();
  cout << "\nEvaluation moyenne : " << Evalmoy();
  cout << "\nMeilleure evaluation : ";
  pop[0].Aff2();
 }

 //fonction : constructeur
 //données : type d'initialisation
 //return : ---
 //
 population(int i,int g,int tInit)
 {
  NbI=i;
  NbG=g;
  pop=(individu*)malloc(NbI*sizeof(individu));
  for(int j=0;j<NbI;j++)
   switch(tInit)
   {
   case 1: //initialisation aléatoire
    pop[j].Init1(g);
    break;
   
   }
 }
};

//fonction : initialise le générateur de nombre aléatoire
//données : ---
//return : ---
//
void InitRand()
{
  srand(time(NULL));
}

//fonction : renvoie un nombre aléatoire compris entre min et max inclus
//données : min et max
//return : la valeur aléatoire
//
int Hasard(int min,int max)
{
 return((max-min)*rand()/RAND_MAX+min);

}

//fonction : attente appuie sur touche
//données : ---
//return : ---
//
void Pause()        
{
   char c;
   printf("\n - - - - - - - - - - - - - - Appuyez sur une touche - - - - - - - - - - - - - -\n");
   c = getch();
}                   

//fonction : renvoie la distance (temps de transport) entre deux jobs (calc dans le tableau Dist)
//données : numéro des 2 jobs
//return : double
//
double Distance(int a,int b)
{
 return(Dist[a][b]);
}

#include <iostream.h>
#include <fstream.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <ios.h>

#include "AG-Data.h"

char *nfRes = "Résultat.txt"; //nom du fichier
char *nfInd = "Individu.txt"; //nom du fichier

//fonction : création des fichiers
//données : ---
//return : ---
//
void InitEnr ()
{
 fstream fRes(nfRes,ios::out|ios::trunc);
 fstream fInd(nfInd,ios::out|ios::trunc);
}

//fonction : inscrit la génération, la meilleure évaluation et l'évaluation moyenne
//données : la population et le numéro de génération
//return : ---
//
void Enrres (population P,int n)
{
 //P.Tri();
 fstream fRes(nfRes,ios::app);
 fRes << n << ';' << P.pop[0].eval << ';' << P.Evalmoy()<< '\n';

}

//fonction : inscrit un individu et son évaluation
//données : l'individu
//return : ---
//
void Enrind (individu I)
{
 fstream fInd(nfInd,ios::app);
 //I.Evalue();
 fInd << "\nEvaluation : " << I.eval << '\n';
 for(int i=0;i<I.NbG;i++)
  fInd << I.genes[i] << '-';
 fInd << '\n';

}


//fonction : crée un fichier de visualisation pour un individu
//données : l'individu, le nom du fichier à créer
//return : ---
//
void Enrvisual (individu I,char* Nom)
{
 fstream fVis(Nom,ios::out|ios::trunc);
 fVis << "<html>\n<head>\n<title>defi</title>\n</head>\n<body bgcolor=\"#ffffff\">\n<applet code=\"DisplayTsp.class\" width=400 height=400>\n"
   << "<param name = Problem value = \"default\">\n<param name = Parcours value =";
 for(int i=0;i<I.NbG;i++)
  fVis << I.genes[i] << '-';
 fVis << ">\n<hr>\n</applet><b