Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1721 connectés 

  FORUM HardWare.fr
  Programmation
  C

  Compilation error: invalid operands to binary != ...

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

Compilation error: invalid operands to binary != ...

n°2299467
g-orwell
Posté le 20-04-2017 à 22:03:53  profilanswer
 

Hello tout le monde,
 
J'essaye d'aider ma soeur en première année d'informatique mais là ça dépasse mes connaissances.
A la compilation elle rencontre l'erreur ci dessous:
error: invalid operands to binary != (have 'piece_t' and 'int')
Pourriez vous m'expliquer simplement ce qui cloche dans son code?

Code :
  1. #define JOUEUR_1 1
  2. #define JOUEUR_0 0
  3. #define JOUEUR_VIDE -1
  4. #define PIECE_NON_PROMUE 0
  5. #define PIECE_PROMUE 1
  6. #define FAUX 0
  7. #define VRAI 1
  8. #define VIDE -1
  9. #define T 11
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <ctype.h>
  14. struct piece_s
  15. {
  16. int joueur;
  17. int type;
  18. int statut;
  19. }; typedef struct piece_s piece_t;
  21. struct coordonnees_s
  22. {
  23. int x; // ligne du tableau;
  24. int y; // colonne du tableau;
  25. }; typedef struct coordonnees_s coordonnees_t;
  27. typedef struct coup_s coup_t; //maillon de coups
  28. struct coup_s
  29. {
  30. coordonnees_t depart; //sauvegarder les coordonees de la piece de depart
  31. coordonnees_t arrivee; //sauvegarder les coordonnees d'arriver la piece
  32. int promotion; //booleen
  33. int capture; //booleen
  34. coup_t *suivant;
  35. coup_t *precedant;
  36. };
  38. struct liste_s
  39. {
  40. coup_t *debut;
  41. int nb_de_coups;
  42. coup_t *fin; //ladresse de fin du dernier maillon
  43. }; typedef struct liste_s liste_t;
  45. struct partie_s
  46. {
  47. piece_t tablier[T][T]; // T=taille
  48. liste_t coup_joue;
  49. int bool_joueur;
  50. int joueur;
  51. }; typedef struct partie_s partie_t;
  53. typedef struct maillon_capture_s maillon_capture_t;
  54. struct maillon_capture_s
  55. {
  56.     coordonnees_t depart; //sauvegarder les coordonees de la piece de depart
  57. coordonnees_t arrivee; //sauvegarder les coordonnees d'arriver la piece
  58.     int promotion; //booleen
  59. int capture; //booleen
  60. coordonnees_t coord_capture;
  61. maillon_capture_t *suivant;
  62. };
  63. typedef struct liste_capture_s liste_capture_t;
  64. struct liste_capture_s
  65. {
  66. liste_capture_t *liste_capture;
  67. maillon_capture_t *debut;
  68. int taille;
  69. };
  71. //c'est un pointeur qui nous permetra de sauvegarder la position de la derniere piece mise dans la reserve
  72. liste_capture_t *liste_capture;
  74. //prend en arguments un joueur, un type et un statut, et renvoie une piece.
  75. piece_t piece_creer(int joueur, int type, int statut);
  77. //prend en argument une piece et renvoie son joueur.
  78. int piece_joueur(piece_t piece);
  80. //prend en argument un caractere et renvoie la piece correspondante.
  81. piece_t piece_identifier(char type);
  83. //prend en argument une piece et renvoie le caractere qui lui est associe.
  84. char piece_caractere(piece_t piece);
  86. //prend en argument une piece et affiche le caractere qui lui est associe .
  87.   void piece_afficher(piece_t piece);
  88. //
  89. void changer_joueur(partie_t *partie);
  92. //
  93. void changer_statut(piece_t *piece);
  95. //
  96. int case_vide(piece_t caase);
  98. //
  99. void modifier_case(partie_t *partie, piece_t piece, coordonnees_t coord );
  101. //
  102. void affiche_plateau(partie_t *partie);
  104. //
  105. void deplacemet(partie_t *partie, coordonnees_t coord_de_depart, coordonnees_t coord_darrivee);
  107. //
  108. void annuler_deplacement(partie_t *partie);
  110. //
  111. int* saisie_case();
  113. //
  114. partie_t *partie_creer();
  116. //
  117. coup_t *extraire_debut_liste(liste_t *liste);
  119. //
  120. void partie_detruire(partie_t *partie);
  122. //
  123. void partie_sauvegarder(partie_t* partie, const char* chemain);
  125. //
  126. char partie_charger(partie_t* partie, const char* chemain);
  128. //
  129. partie_t *partie_nouvelle();
  134. piece_t piece_creer(int joueur, int type, int statut)
  135. {
  136. piece_t piece;
  137. piece.joueur=joueur;
  138. piece.type=type;
  139. piece.statut=statut;
  140. return piece;
  141. }
  142. //**********************************************_________________________************************************************
  143.  
  144. int piece_joueur(piece_t piece)
  145. {
  146. return piece.joueur;
  147. }
  148.  
  149. //**********************************************_________________________*************************************************
  150.  
  151. piece_t piece_identifier(char type)
  152. {
  153. int i=0;
  154. char tab_type[]= "malloc(15*sizeof(char))";
  155. piece_t piece=piece_creer(JOUEUR_VIDE,'.',VIDE);
  156.  
  157. strcpy(tab_type,"plnbrsgkdjcfta" );
  158.  
  159. if(isupper(type))
  160. {
  161.  for(i=0;i<8; i++)
  162.  {
  163.   if(toupper(tab_type[i])==type)
  164.   {
  165.    return piece_creer(JOUEUR_0,type,PIECE_PROMUE);
  166.   }
  167.  }
  168.  for(i=0; i<14; i++)
  169.  {
  170.   if (toupper(tab_type[i])==type)
  171.   {
  172.    return piece_creer(JOUEUR_0, type, PIECE_PROMUE);
  173.   }
  174.  }
  175. }
  176. else
  177. {
  178.  for (i = 0; i < 8; ++i)
  179.  {
  180.   return piece_creer(JOUEUR_1, type, PIECE_PROMUE);
  181.  }
  182. }
  183.  
  184. return piece;
  185. }
  186. //*********************************************_________________________**************************************************
  187.  
  188. char piece_caractere(piece_t piece)
  189. {
  190. return piece.type;
  191. }
  192.  
  193. //*********************************************_________________________****************************************************
  194.  
  195. void piece_afficher(piece_t piece)
  196. {
  197. printf("%3c",piece.type );
  198. }
  199.  
  200. //***********************************************________________________*******************************************************//
  201. int case_vide(piece_t caase)
  202. {
  203. if (caase.type == '.')
  204. {
  205.  return 1;
  206. }
  207. else
  208. {
  209.  return 0;
  210. }
  211. }
  212.  
  213.  
  214. //*************************************___________________________________**********************************/
  215.  
  216. void modifier_case(partie_t *partie, piece_t piece, coordonnees_t coord )
  217. {
  218. partie->tablier[coord.x][coord.y]=piece;
  219. }
  220.  
  221. //*************************************_____________________________________********************//
  222.  
  223. void changer_joueur ( partie_t *partie)
  224. {
  225. if ( partie->joueur ==0)
  226. {
  227.  partie->joueur=1;
  228. }
  229. else
  230. {
  231.  partie->joueur=0;
  232. }
  233. }
  234.  
  235. //**************************************________________________________________******************************//
  236.  
  237. void affiche_plateau(partie_t *partie)
  238. {
  239. int i,j;
  240. printf("  " );
  241. for(i=0; i<T; i++)
  242. {
  243.  printf("%3d", i);
  244. }
  245. printf("\n" );
  246. for (i = 0; i < T; ++i)
  247. {
  248.  printf("%2d\n", i);
  249.  
  250.  for ( j = 0; i < T; ++i)
  251.  {
  252.   piece_afficher(partie->tablier[i][j]);
  253.  }
  254.  printf("\n" );
  255. }
  256. }
  257.  
  258. //***********************************______________________________*****************************//
  259. void changer_statut(piece_t *piece)
  260. {
  261. char *tab1=malloc(7*sizeof(char));
  262. char *tab2=malloc(7*sizeof(char));
  263. int i=0;
  264.  
  265. strcpy(tab1, "djcfta" );
  266. strcpy(tab2, "plnbrs" );
  267.  
  268. if (isupper(piece->type))
  269. {
  270.  for (i = 0; i <6; ++i)
  271.  {
  272.   tab1[i]=toupper(tab1[i]);
  273.   tab2[i]=toupper(tab2[i]);
  274.  }
  275. }
  276. if (piece->statut ==PIECE_PROMUE)
  277. {
  278.  for ( i = 0; i < 6; ++i)
  279.  {
  280.   if (tab1[i]==piece->type)
  281.   {
  282.    piece->type=tab2[i];
  283.    break;
  284.  
  285.   }
  286.  }
  287. }
  288. if (isupper(piece->type))
  289.   {
  290.    for (i = 0; i < 6; ++i)
  291.    {
  292.     tab1[i]=toupper(tab1[i]);
  293.     tab2[i]=toupper(tab2[i]);
  294.    }
  295.   }
  296.   if (piece->statut==PIECE_PROMUE)
  297.   {
  298.    for ( i = 0; i < 6; ++i)
  299.    {
  300.     if (tab1[i]==piece->type)
  301.     {
  302.      piece->type=tab2[i];
  303.      break;
  304.     }
  305.    }
  306.    piece->statut=PIECE_NON_PROMUE;
  307.   }
  308.   else
  309.   {
  310.    for (i = 0; i < 6; ++i)
  311.    {
  312.     if (tab2[i]==piece->type)
  313.     {
  314.      piece->type=tab1[i];
  315.      break;
  316.     }
  317.    }
  318.    piece->statut=PIECE_PROMUE;
  319.  
  320.   }
  321.   free(tab1);
  322.   free(tab2);
  323. }
  324. //****************************************************_________________________________________*******************************//
  325. void deplacemet(partie_t *partie, coordonnees_t coord_de_depart, coordonnees_t coord_darrivee)
  326. {
  327.  
  328. int i=0,j=0;
  329. int bool_capture=FAUX, bool_promotion=FAUX, reponse=FAUX;
  330. coup_t *nv_coup=malloc(sizeof(coup_t));
  331.  
  332. if(!case_vide(partie->tablier[coord_darrivee.x][coord_darrivee.y]))
  333. {
  334.  if (partie->bool_joueur==JOUEUR_1)
  335.  {
  336.   j=1;
  337.   i=T-1;
  338.   while(!case_vide(partie->tablier[i][j]) && (j<T-1))
  339.   {
  340.    j++;
  341.   }
  342.   while(!case_vide(partie->tablier[i][j]) && (i>0))
  343.   {
  344.    i--;
  345.   }
  346.   partie->tablier[coord_darrivee.x][coord_darrivee.y].joueur=JOUEUR_0;
  347.  }
  348.  else
  349.  {
  350.   i=0;
  351.   j=T-2;
  352.  
  353.   while(!case_vide(partie->tablier[i][j]) && (j>0))
  354.   {
  355.    j--;
  356.   }
  357.   while(!case_vide(partie->tablier[i][j]) && (i<T-1))
  358.   {
  359.    i++;
  360.   }
  361.   partie->tablier[coord_darrivee.x][coord_darrivee.y].joueur=JOUEUR_1;
  362.  }
  363.  bool_capture=VRAI;
  364.  
  365.  maillon_capture_t *nv_coup=malloc(sizeof(nv_coup));
  366.  nv_coup->coord_capture.x=i;
  367.  nv_coup->coord_capture.y=j;
  368.  if (liste_capture->T != 0)
  369.  {
  370.   nv_coup->suivant = liste_capture->debut;
  371.  }
  372.  else
  373.  {
  374.   nv_coup->suivant=NULL;
  375.  }
  376.  liste_capture->debut=nv_coup;
  377.  liste_capture->T=T++;
  378.  if(isupper(partie->tablier[i][j].type))
  379.  {
  380.   partie->tablier[i][j].type=tolower(partie->tablier[i][j].type);
  381.  }
  382.  else
  383.  {
  384.   partie->tablier[i][j].type=toupper(partie->tablier[i][j].type);
  385.  }
  386.  
  387.  modifier_case(partie,partie->tablier[coord_de_depart.x][coord_de_depart.y],coord_de_depart);
  388.  modifier_case(partie,partie->tablier[T-1][0],coord_de_depart);
  389.  
  390.  
  391.  if (partie->tablier[coord_darrivee.x][coord_darrivee.y].statut == PIECE_NON_PROMUE)
  392.  {
  393.   if (partie->tablier[coord_darrivee.x][coord_darrivee.y].type != 'G' && partie->tablier[coord_darrivee.x][coord_darrivee.y] != 'K' && partie->tablier[coord_darrivee.x][coord_darrivee.y].type != 'g' && partie->tablier[coord_darrivee.x][coord_darrivee.y] != 'k')
  394.  
  395.   {
  396.    if ((partie->bool_joueur == JOUEUR_1 && coord_darrivee.x < 4) || (partie->bool_joueur == JOUEUR_0 && coord_darrivee.x > 6))
  397.    {
  398.     if (tolower(partie->tablier[coord_darrivee.x][coord_darrivee.y].type == 'p') && (coord_darrivee.x == 1 || coord_darrivee.x ==9))
  399.     {
  400.      changer_statut(&partie->tablier[coord_darrivee.x][coord_darrivee.y]);
  401.      bool_promotion = VRAI;
  402.     }
  403.     else if ((partie->tablier[coord_darrivee.x][coord_darrivee.y].type == 'l') && (coord_darrivee.x == 1) || (partie->tablier[coord_darrivee.x][coord_darrivee.y].type == 'L' && coord_darrivee.x == 9))
  404.     {
  405.      changer_statut(&partie->tablier[coord_darrivee.x][coord_darrivee.y]);
  406.      bool_promotion = VRAI;
  407.     }
  408.     else if ((partie->tablier[coord_darrivee.x][coord_darrivee.y].type == 'n' && coord_darrivee.x < 3) || (partie->tablier[coord_darrivee.x][coord_darrivee.y].type == 'N' && coord_darrivee.x > 7))
  409.     {
  410.      changer_statut(&partie->tablier[coord_darrivee.x][coord_darrivee.y]);
  411.      bool_promotion = VRAI;
  412.     }
  413.     else
  414.     {
  415.      do
  416.      {
  417.       printf("voulez vous proumouvoire la piece jouee ? \n si oui tappez : 1\n si non tappez : 0\n" );
  418.       scanf("%d",&reponse);
  419.      }while(reponse != VRAI && reponse != FAUX);
  420.  
  421.      if (reponse)
  422.      {
  423.       changer_statut(&partie->tablier[coord_darrivee.x][coord_darrivee.y]);
  424.       bool_promotion = VRAI;
  425.  
  426.      }
  427.     }
  428.  
  429.    }
  430.   }
  431.  }
  432.  
  433.  nv_coup->promotion=bool_promotion;
  434.  nv_coup->capture=bool_capture;
  435.  nv_coup->depart=coord_de_depart;
  436.  nv_coup->arrivee=coord_darrivee;
  437.  
  438.  ajouter_coup_fin(partie,nv_coup);
  439. }
  440. }
  441.  
  442. /************************************************_____________________________******************************************/
  443.  
  444. void annuler_deplacement(partie_t *partie)
  445. {
  446. coup_t *dernier_coup=partie->coup_joue.fin;
  447.  
  448. if (partie->coup_joue.nb_de_coups != 1)
  449. {
  450.  dernier_coup->precedant->suivant=NULL;
  451.  partie->coup_joue.fin=dernier_coup->precedant;
  452. }
  453.  
  454. partie->coup_joue.nb_de_coups--;
  455.  
  456.  
  457. modifier_case(partie,partie->tablier[dernier_coup->arrivee.x][dernier_coup->arrivee.y], dernier_coup->depart);
  458. modifier_case(partie,partie->tablier[T-1][0],dernier_coup->arrivee);
  459.  
  460. if (dernier_coup->capture == VRAI)
  461. {
  462.  dernier_coup = liste_capture->debut;
  463.  modifier_case(partie,partie->tablier[liste_capture->debut->coord_capture.x][liste_capture->debut->coord_capture.y],dernier_coup->arrivee);
  464.  modifier_case(partie,partie->tablier[T-1][0],liste_capture->debut->coord_capture);
  465.  liste_capture->debut=dernier_coup->suivant;
  466.  dernier_coup->suivant=NULL;
  467.  liste_capture->T--;
  468.  free(dernier_coup);
  469.  
  470.  partie->tablier[dernier_coup->arrivee.x][dernier_coup->arrivee.y].joueur=(partie->bool_joueur+1)%2;
  471. }
  472. if (isupper(partie->tablier[dernier_coup->arrivee.x][dernier_coup->arrivee.y].type))
  473. {
  474.  partie->tablier[dernier_coup->arrivee.x][dernier_coup->arrivee.y].type=tolower(partie->tablier[dernier_coup->arrivee.x][dernier_coup->arrivee.y].type);
  475. }
  476. else
  477. {
  478.  partie->tablier[dernier_coup->arrivee.x][dernier_coup->arrivee.y].type=toupper(partie->tablier[dernier_coup->arrivee.x][dernier_coup->arrivee.y].type);
  479. }
  480.  
  481. if (dernier_coup->promotion==PIECE_PROMUE)
  482. {
  483. changer_statut(&partie->tablier[dernier_coup->depart.x][dernier_coup->depart.y]);
  484. }
  485.  
  486. free(dernier_coup);
  487.  
  488. while(partie->bool_joueur==partie->tablier[dernier_coup->arrivee.x][dernier_coup->arrivee.y].joueur)
  489. {
  490. dernier_coup=extraire_fin_liste(&partie->coup_joue);
  491. changer_statut(&partie->tablier[dernier_coup->arrivee.x][dernier_coup->arrivee.y]);
  492.  
  493. free(dernier_coup);
  494. }
  495. }
  496.  
  497. //**************************************************_________________________________***************************//
  498. int* saisie_case() {
  499.     int* saisie = calloc(6, sizeof(int));
  500. printf("Veuillez entrer l'un des choix suivants :\n\t1. Effectuer un deplacement\n\t2. Annuler le dernier deplacement\n\t3. Quitter la partie\n...? " );
  501. scanf("%u", &saisie[0]);
  502. while (saisie[0] < 1 || saisie[0] > 3)
  503.         {  printf("Erreur, aucun numero correspondant, veuillez recommencer\n...? " );
  504.  scanf("%u", &saisie[0]);
  505. }
  506.  
  507. if (saisie[0] == 1) {
  508.  printf("Entrez les coordonnees de depart et d'arrivee sous forme de quatre entiers consecutifs et de 1 pour une demande de promotion avant le deplacement, qui sera attribue seulement si possible, 0 sinon\nExemple : 2 5 3 6 1 deplace la piece situee en (2, 5) en (3, 6) avec une demande de promotion\n...? " );
  509.  scanf("%u %u %u %u %u", &saisie[1], &saisie[2], &saisie[3], &saisie[4], &saisie[5]);
  510.  while (saisie[1] > 10 || saisie[2] > 10 || saisie[3] > 10 || saisie[4] > 10 || saisie[5] > 1) {
  511.   printf("Erreur toutes les coordonnees doivent etre comprises entre 0 et 10 et la demande de promotion 1 ou 0, entrez a nouveau\n...? " );
  512.   scanf("%u %u %u %u %u", &saisie[1], &saisie[2], &saisie[3], &saisie[4], &saisie[5]);
  513.  }
  514. }
  515.  
  516. return saisie;
  517. }
  518.  
  519. //********************************************______________________________________************************************//
  520.  
  521. partie_t *partie_creer()
  522. {
  523.     partie_t *partie =  malloc(sizeof(*partie_t));
  524.  
  525.     partie->coup_joue.debut=NULL;
  526.     partie->coup_joue.fin=NULL;
  527.     partie->coup_joue.nb_de_coups=0;
  528.  
  529.     return partie;
  530. }


 
Merci par avance pour votre aide  


---------------
G-Orwell
mood
Publicité
Posté le 20-04-2017 à 22:03:53  profilanswer
 

n°2299472
gilou
Modérateur
Modzilla
Posté le 20-04-2017 à 23:06:06  profilanswer
 

piece_t piece_creer(int joueur, int type, int statut)
{
piece_t piece;
piece.joueur=joueur;
piece.type=type;
piece.statut=statut;
return piece;
}
 
Sauf que tu ne crées rien ici.
 
A+,


---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
n°2299473
rat de com​bat
attention rongeur méchant!
Posté le 20-04-2017 à 23:09:26  profilanswer
 

Eh ben, en voila du code.

 

Tu as activé les warnings sur ton compilateur? Obligatoire!!!

 

Premier problème:
>#define T 11
>liste_capture->T
Heu... Ca risque pas de fonctionner ça. :o C'est peut-être "liste_capture->taille"? J'ai pas vérifié si c'est logique.

 

edit: Envoyé trop tôt...

 

Ce machin

Code :
  1. if (partie->tablier[coord_darrivee.x][coord_darrivee.y].type != 'G' && partie->tablier[coord_darrivee.x][coord_darrivee.y] != 'K' && partie->tablier[coord_darrivee.x][coord_darrivee.y].type != 'g' && partie->tablier[coord_darrivee.x][coord_darrivee.y] != 'k')

il lui manque des bouts, je suppose que c'est

Code :
  1. if (partie->tablier[coord_darrivee.x][coord_darrivee.y].type != 'G' && partie->tablier[coord_darrivee.x][coord_darrivee.y].type != 'K' && partie->tablier[coord_darrivee.x][coord_darrivee.y].type != 'g' && partie->tablier[coord_darrivee.x][coord_darrivee.y].type != 'k')

.

 

Et tu peux apparamment pas faire un ++ sur un #define.

 

Après le reste à toi de voir, j'ai pas le temps ni l'envie de comprendre 500 lignes de code. :o

 

Active les warnings (GCC: -Wall) (et prends les en compte :o )


Message édité par rat de combat le 20-04-2017 à 23:14:06
n°2299475
g-orwell
Posté le 20-04-2017 à 23:26:23  profilanswer
 

Merci à vous deux.
Merci à toi rat de combat.
il manquait en effet .type  à la ligne que tu as indiqué.


---------------
G-Orwell

Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C

  Compilation error: invalid operands to binary != ...

 

Sujets relatifs
[Java] Erreur CompilationNom avec espace -----> problème de compilation
[Help] Compilation cross plateform (RaspberryPi / Ubuntu)problème invalid syntaxe
Dupral erreur internal server error 500 après installation?compilation de gcc 5.3.0
erreur soap InvalidSecurityAn error occurred when verifying securityErreur de compilation, incompatibilité de type
error(MSB3073) dans visual studio a partir d'unreal engine 
Plus de sujets relatifs à : Compilation error: invalid operands to binary != ...

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.113 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR