Sujet Précédent Sujet Suivant

Comprendre chaque foction dans ce programme

Fermé
G.info Messages postés 1 Date d'inscription mercredi 12 février 2014 Statut Membre Dernière intervention 12 février 2014 - Modifié par blux le 12/02/2014 à 16:02
 G.info - 12 févr. 2014 à 23:02
bounjour j'ai apres demain une soutenance en programation et j'ai trouve un programme mais je coris qu'il est ecrie en c ++
alors je souaite comprendre chaque foction dans ce programme et me le traduire en language C et merci d'avance
voila le programme 
////////////////////////////////////////////////////////////////////////////
////////////////////// Object cube side ////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

class side
{
public:
 side();
 side(int);

 void rotateRight();
 void rotateLeft();
 void returnLine(char, int&, int&, int&);
 void printLine(int);
 
 void print();

 void changeLine(char, int, int, int);

private:
 int grid[10];  // the grid the colors reside on
 int directionGrid[10];  // used to determine which direction pointing
 int direction; // the current direction the side is pointing
 void color(int); // changes the color to print


};

side::side(int color)
{
 // set the side all to one color, then set each direction a color
 for (int x=1; x<10; x++)
  grid[x]=color;

 direction=0;
}

void side::rotateRight()
{
 direction++;
 if (direction==4)
  direction=0;
}

void side::rotateLeft()
{
 direction--;
 if (direction==-1)
  direction=3;
}

void side::changeLine(char c, int x, int y, int z)
{
 // matrix to hold the grid numbers depending on what direction side is pointing
 int matrix[4][9]={{1,2,3,4,5,6,7,8,9},{7,4,1,8,5,2,9,6,3},
 {9,8,7,6,5,4,3,2,1},{3,6,9,2,5,8,1,4,7}}; 

 // changes the row/column to the new colors
 switch (c)
 {
 case '1':
  grid[matrix[direction][0]]=x;
  grid[matrix[direction][1]]=y;
  grid[matrix[direction][2]]=z;
  break;
 case '2':
  grid[matrix[direction][3]]=x;
  grid[matrix[direction][4]]=y;
  grid[matrix[direction][5]]=z;
  break;
 case '3':
  grid[matrix[direction][6]]=x;
  grid[matrix[direction][7]]=y;
  grid[matrix[direction][8]]=z;
  break;
 case 'a':case 'A':
  grid[matrix[direction][0]]=x;
  grid[matrix[direction][3]]=y;
  grid[matrix[direction][6]]=z;
  break;
 case 'b':case 'B':
  grid[matrix[direction][1]]=x;
  grid[matrix[direction][4]]=y;
  grid[matrix[direction][7]]=z;
  break;
 case 'c':case 'C':
  grid[matrix[direction][2]]=x;
  grid[matrix[direction][5]]=y;
  grid[matrix[direction][8]]=z;
  break;
 }
}

void side::returnLine(char c, int& x, int& y, int& z)
{
 // matrix to hold the grid numbers depending on what direction side is pointing
 int matrix[4][9]={{1,2,3,4,5,6,7,8,9},{7,4,1,8,5,2,9,6,3},
 {9,8,7,6,5,4,3,2,1},{3,6,9,2,5,8,1,4,7}};

 // returns the color of that row/column
 switch (c)
 {
 case '1':
  x=grid[matrix[direction][0]];
  y=grid[matrix[direction][1]];
  z=grid[matrix[direction][2]];
  break;
 case '2':
  x=grid[matrix[direction][3]];
  y=grid[matrix[direction][4]];
  z=grid[matrix[direction][5]];
  break;
 case '3':
  x=grid[matrix[direction][6]];
  y=grid[matrix[direction][7]];
  z=grid[matrix[direction][8]];
  break;
 case 'a':case 'A':
  x=grid[matrix[direction][0]];
  y=grid[matrix[direction][3]];
  z=grid[matrix[direction][6]];
  break;
 case 'b':case 'B':
  x=grid[matrix[direction][1]];
  y=grid[matrix[direction][4]];
  z=grid[matrix[direction][7]];
  break;
 case 'c':case 'C':
  x=grid[matrix[direction][2]];
  y=grid[matrix[direction][5]];
  z=grid[matrix[direction][8]];
  break;
 }
}

void side::printLine(int x)
{
 int matrix[4][9]={{1,2,3,4,5,6,7,8,9},{7,4,1,8,5,2,9,6,3},
 {9,8,7,6,5,4,3,2,1},{3,6,9,2,5,8,1,4,7}};


 for(int y=x*3; y<x*3+3; y++)
 {
  color(grid[matrix[direction][y]]);
  cout<<char(178)<<char(178)<<char(178)<<COLOR::NORMAL;
 }
}

void side::print()
{
 // matrix to hold the grid numbers depending on what direction side is pointing
 int matrix[4][9]={{1,2,3,4,5,6,7,8,9},{7,4,1,8,5,2,9,6,3},
 {9,8,7,6,5,4,3,2,1},{3,6,9,2,5,8,1,4,7}};

 cout<<"\t\t    A   B   C"<<endl<<endl;

 for (int x=0; x<2; x++)
 {
  cout<<((x==0) ? "\t\t 1 " : "\t\t   ");
  for(int y=0; y<3; y++)
  {
   color(grid[matrix[direction][y]]);
   cout<<char(178)<<char(178)<<char(178)<<" "<<COLOR::NORMAL;
  }
  cout<<endl;
 }
 cout<<endl;
 for (x=0; x<2; x++)
 {
  cout<<((x==0) ? "\t\t 2 " : "\t\t   ");
  for(int y=3; y<6; y++)
  {
   color(grid[matrix[direction][y]]);
   cout<<char(178)<<char(178)<<char(178)<<" "<<COLOR::NORMAL;
  }
  cout<<endl;
 }
 cout<<endl;
 for (x=0; x<2; x++)
 {
  cout<<((x==0) ? "\t\t 3 " : "\t\t   ");
  for(int y=6; y<9; y++)
  {
   color(grid[matrix[direction][y]]);
   cout<<char(178)<<char(178)<<char(178)<<" "<<COLOR::NORMAL;
  }
  cout<<endl;
 }
 cout<<COLOR::NORMAL<<endl<<endl;
}

void side::color(int c)
{
 switch (c)
 {
 case 1: cout<<COLOR::GREEN;
  break;
 case 2: cout<<COLOR::RED;
  break;
 case 3: cout<<COLOR::BLUE;
  break;
 case 4: cout<<COLOR::YELLOW;
  break;
 case 5: cout<<COLOR::WHITE;
  break;
 case 6: cout<<COLOR::PURPLE;
  break;
 }
}


////////////////////////////////////////////////////////////////////////////
////////////////////// Object cube /////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////


class cube
{
public:
 cube();
 void rotate(char);
 void printfront();
 void twist(string);
 void mix();
 void printAll();

private:
 vector <side> cubeVec;
};

cube::cube()
{
 // create six new sides and set the directions for each side
 side empty(0);
 side greenside(1);
 side redside(2);
 side blueside(3);
 side yellowside(4);
 side whiteside(5);
 side purpleside(6);

 // add to the vector of sides
 cubeVec.push_back(empty);
 cubeVec.push_back(greenside);
 cubeVec.push_back(redside); 
 cubeVec.push_back(blueside); 
 cubeVec.push_back(yellowside); 
 cubeVec.push_back(whiteside);
 cubeVec.push_back(purpleside);
 

}

void cube::printfront()
{
 cubeVec[1].print();
}

void cube::printAll()
{
 int x,y;
 cout<<"             A  B  C"<<endl;

 for (x=3; x>=2; x--)
 {
  for (y=0; y<3; y++)
  {
   cout<<"            ";
   cubeVec[x].printLine(y);
   cout<<endl;
   cout<<"            ";
   cubeVec[x].printLine(y);
   cout<<endl;
  }
  cout<<endl;
 }

 for (x=0; x<3; x++)
 {
  cout<<x+1<<" ";
  cubeVec[5].printLine(x);
  cout<<" ";
  cubeVec[1].printLine(x);
  cout<<" ";
  cubeVec[6].printLine(x);
  cout<<endl<<"  ";
  cubeVec[5].printLine(x);
  cout<<" ";
  cubeVec[1].printLine(x);
  cout<<" ";
  cubeVec[6].printLine(x);
  cout<<endl;
 }
 cout<<endl;

 for (x=0; x<3; x++)
 {
  cout<<"            ";
  cubeVec[4].printLine(x);
  cout<<endl;
  cout<<"            ";
  cubeVec[4].printLine(x);
  cout<<endl;
 }
 cout<<endl;
}





void cube::rotate(char c)
{
 // rotates the cube in the direction stated
 side oldcolor=cubeVec[1];
 switch (c)
 {
 case 'u':case 'U':
  cubeVec[1]=cubeVec[4];
  cubeVec[4]=cubeVec[3];
  cubeVec[3]=cubeVec[2];
  cubeVec[2]=oldcolor;

  cubeVec[5].rotateLeft();
  cubeVec[6].rotateRight();
  break;

 case 'd':case 'D':
  cubeVec[1]=cubeVec[2];
  cubeVec[2]=cubeVec[3];
  cubeVec[3]=cubeVec[4];
  cubeVec[4]=oldcolor;

  cubeVec[6].rotateLeft();
  cubeVec[5].rotateRight();
  break;

 case 'r':case 'R':
  cubeVec[1]=cubeVec[5];
  cubeVec[5]=cubeVec[3];
  cubeVec[5].rotateRight();
  cubeVec[5].rotateRight();
  cubeVec[3]=cubeVec[6];
  cubeVec[3].rotateRight();
  cubeVec[3].rotateRight();
  cubeVec[6]=oldcolor;

  cubeVec[2].rotateLeft();
  cubeVec[4].rotateRight();
  break;

 case 'l':case 'L':
  cubeVec[1]=cubeVec[6];
  cubeVec[6]=cubeVec[3];
  cubeVec[6].rotateRight();
  cubeVec[6].rotateRight();
  cubeVec[3]=cubeVec[5];
  cubeVec[3].rotateRight();
  cubeVec[3].rotateRight();
  cubeVec[5]=oldcolor;

  cubeVec[4].rotateLeft();
  cubeVec[2].rotateRight();
  break;
 }
}

void cube::twist(string s)
{
 // twists a row or column in the direction stated
 if (toupper(s[0])!='A' && toupper(s[0])!='B' && toupper(s[0])!='C' &&
  toupper(s[0])!='1' && toupper(s[0])!='2' && toupper(s[0])!='3')
 {
  return;
 }
 if ((toupper(s[0])=='A' || toupper(s[0])=='B' || toupper(s[0])=='C') &&
  toupper(s[1])!='U' && toupper(s[1])!='D')
 {
  return;
 }
 if ((toupper(s[0])=='1' || toupper(s[0])=='2' || toupper(s[0])=='3') &&
  toupper(s[1])!='R' && toupper(s[1])!='L')
 {
  return;
 }

 int x, y, z;
 int dx, dy, dz;

 cubeVec[1].returnLine(s[0],x,y,z);

 if (toupper(s[0])=='A' || toupper(s[0])=='B' || toupper(s[0])=='C')
 {
  if (toupper(s[1])=='U')
  {
   cubeVec[2].returnLine(s[0],dx,dy,dz);
   cubeVec[2].changeLine(s[0],x,y,z);
   cubeVec[3].returnLine(s[0],x,y,z);
   cubeVec[3].changeLine(s[0],dx,dy,dz);
   cubeVec[4].returnLine(s[0],dx,dy,dz);
   cubeVec[4].changeLine(s[0],x,y,z);
   cubeVec[1].changeLine(s[0],dx,dy,dz);
   if (toupper(s[0])=='A')
    cubeVec[5].rotateLeft();

   if (toupper(s[0])=='C')
    cubeVec[6].rotateRight();
  }
  else if (toupper(s[1])=='D')
  {
   cubeVec[4].returnLine(s[0],dx,dy,dz);
   cubeVec[4].changeLine(s[0],x,y,z);
   cubeVec[3].returnLine(s[0],x,y,z);
   cubeVec[3].changeLine(s[0],dx,dy,dz);
   cubeVec[2].returnLine(s[0],dx,dy,dz);
   cubeVec[2].changeLine(s[0],x,y,z);
   cubeVec[1].changeLine(s[0],dx,dy,dz);
   if (toupper(s[0])=='A')
    cubeVec[5].rotateRight();

   if (toupper(s[0])=='C')
    cubeVec[6].rotateLeft();
  }
 }
 else if (toupper(s[0])=='1' || toupper(s[0])=='2' || toupper(s[0])=='3')
 {
  if (toupper(s[1])=='R')
  {
   cubeVec[6].returnLine(s[0],dx,dy,dz);
   cubeVec[6].changeLine(s[0],x,y,z);
   if (toupper(s[0])=='1')
   {
    cubeVec[3].returnLine('3',z,y,x);
    cubeVec[3].changeLine('3',dz,dy,dx);
   }
   else if (toupper(s[0])=='3')
   {
    cubeVec[3].returnLine('1',z,y,x);
    cubeVec[3].changeLine('1',dz,dy,dx);
   }
   else
   {
    cubeVec[3].returnLine('2',z,y,x);
    cubeVec[3].changeLine('2',dz,dy,dx);
   }

   cubeVec[5].returnLine(s[0],dx,dy,dz);
   cubeVec[5].changeLine(s[0],x,y,z);
   cubeVec[1].changeLine(s[0],dx,dy,dz);
   if (toupper(s[0])=='1')
    cubeVec[2].rotateLeft();

   if (toupper(s[0])=='3')
    cubeVec[4].rotateRight();
  }
  else if (toupper(s[1])=='L')
  {
   cubeVec[5].returnLine(s[0],dx,dy,dz);
   cubeVec[5].changeLine(s[0],x,y,z);
   if (toupper(s[0])=='1')
   {
    cubeVec[3].returnLine('3',z,y,x);
    cubeVec[3].changeLine('3',dz,dy,dx);
   }
   else if (toupper(s[0])=='3')
   {
    cubeVec[3].returnLine('1',z,y,x);
    cubeVec[3].changeLine('1',dz,dy,dx);
   }
   else
   {
    cubeVec[3].returnLine('2',z,y,x);
    cubeVec[3].changeLine('2',dz,dy,dx);
   }

   cubeVec[6].returnLine(s[0],dx,dy,dz);
   cubeVec[6].changeLine(s[0],x,y,z);
   cubeVec[1].changeLine(s[0],dx,dy,dz);
   if (toupper(s[0])=='1')
    cubeVec[2].rotateRight();

   if (toupper(s[0])=='3')
    cubeVec[4].rotateLeft();
  }
 }
 
 
}

void cube::mix()
{
 // randomly mixes the cube
 for (int x=0; x<100; x++)
 {

  if (rand()%100<20)
  {
   switch(rand()%4)
   {
   case 0: rotate('u');
    break;
   case 1: rotate('d');
    break;
   case 2: rotate('r');
    break;
   case 3: rotate('l');
    break;
   }
  }
  else
  {
   switch(rand()%6)
   {
   case 0: twist("1r");
    break;
   case 1: twist("2r");
    break;
   case 2: twist("3r");
    break;
   case 3: twist("ad");
    break;
   case 4: twist("bd");
    break;
   case 5: twist("cd");
    break;
   }
  }
 }
}

1 réponse

Réponse 1 / 1
blux Messages postés 26703 Date d'inscription dimanche 26 août 2001 Statut Modérateur Dernière intervention 4 mars 2025 3 328
12 févr. 2014 à 16:03
Salut,

si tu ne sais pas la différence entre le C et le C++, tu n'as strictement rien à faire en soutenance de programmation.
0
G.info
12 févr. 2014 à 23:02
je vous remerciez de me repondre
mais j'ai compris la plus part des fonction
j'ai besoin de comprendre c'est quoi l'utilite de la fonction grid () dans ce programme et aussi la foction cout
0

Discussions similaires

GWXUX a cessé de fonctionner
ikam -
Adakhum -

9 réponses
A quoi sert l'application Bonjour?
patrick -
Ysis -

4 réponses
Programme python
PIROYOLO -
PIROYOLO -

4 réponses