虽然循环不退出但条件为真

Question

I'm here beacause i have a C project where i need to make a Tic Tac Toe.

What I do here is that i ask the first player where he wants to play, I print the board then I check if there is a diagonal (only the \\ diagonal is implemented yet) of the same player, if there is etat = true.

The problem is in the while loop, if compteur = 9 or etat = true it doesn't leave the loop and i don't understand why. I have tried with debuger and those condition are true.

printTab() is a simple printf function saisieInt() is a function with scanf and verification that the number isn't <1 or >9

Am I a monkey ?

int main()  
{  
  int tab[COTE][COTE] = { 0 };  
  int compteur = 0, 
  joueur = 1,
  choix;  
  bool etat=false;
  printf("commande : ");
  choix = saisieInt();
  compteur++;

  while ( compteur < 9 || etat != true) {
///position where to place the piece///////////////////////////////
    int colonne = choix % 3;
    int ligne = choix / 3;
    tab[ligne][colonne - 1] = joueur;
///////////////////////////////////////////////

    printTab(tab);

///switch between the 2 players///////////////////////////////
    if (joueur == 1)
      joueur = 2;
    else
      joueur = 1;
///////////////////////////////////////////////

///check if one has a diagonal line //////////////////////////
    if (compteur >= 6) {
      int compteurdiag = 0;
      for (int i = 0; i < COTE; i++) {
        if (tab[i][i] == joueur) {
          compteurdiag++;
        }
        else {
          compteurdiag = 0;
        }
        if (compteurdiag == COTE)
          {
            etat = true;
          }
      }
    }
///////////////////////////////////////////////
//if (etat == false) {
    printf("compteur : %d commande : ", compteur);
    choix = saisieInt();
    compteur++;
//}
  }
  printf("compteur : %d termine\n", compteur);
}

void printTab(int t[COTE][COTE]) {
    int i, j;
    puts("\n|---|---|---|");
    for (i = 0; i < COTE; i++) {
        for (j = 0; j < COTE; j++) {
            printf("|%2d ", t[i][j]);
        }
        puts("|");
        for (j = 0; j < COTE; j++) {
            printf("|---");
        }
        puts("|");
    }
}


int saisieInt() {
    int valeur, n;
    n = scanf("%d", &valeur);
    while (n != 1  || valeur > 9) {
        printf("Attention, erreur de saisie\nRechoisissez : ");
        while (getchar() != '\n');
        n = scanf("%d", &valeur);
    }
    return(valeur);
}

Answer 1

Having

 int colonne = choix % 3; 

supposing choix a positive number colonne values from 0 to 2

In

  tab[ligne][colonne - 1] = joueur; 

when colonne is 0 you modify tab[ligne - 1][2] or out of the array, this is why you do not find 3 aligned cases when in theory it is the case

just do

tab[ligne][colonne] = joueur;

---

Here a proposal :

#include <stdio.h>

#define COTE 3

void printTab(int (*tab)[COTE])
{
  for (int l = 0; l != COTE; ++l) {
    for (int c = 0; c != COTE; ++c) {
      printf("[%c]", *(" XO" + tab[l][c]));
    }
    putchar('\n');
  }
  putchar('\n');
}

int main()
{
  int tab[COTE][COTE] = { 0 };
  int joueur = 1, compteur = 0;

  printTab(tab);

  do {
    int l, c;

    printf("player %d, enter line and column (1..%d) : ", joueur, COTE);
    if ((scanf("%d %d", &l, &c) != 2) ||
        (l < 1) || (c < 1) ||
        (l > COTE) || (c > COTE) ||
        (tab[l - 1][c - 1] != 0)) {
      while (getchar() != '\n')
        ;
      puts("illegal position or not free");
    else {
      tab[l - 1][c - 1] = joueur;

      printTab(tab);      

      /* done ? */
      for (l = 0; l != COTE; ++l) {
        int j = tab[l][0];

        if (j != 0) {
          for (c = 1; ; c += 1) {
            if (c == COTE) {
              printf("joueur %d gagne\n", j);
              return 0;
            }
            if (tab[l][c] != j)
              break;
          }
        }
      }
      for (c = 0; c != COTE; ++c) {
        int j = tab[0][c];

        if (j != 0) {
          for (l = 1; ; l += 1) {
            if (l == COTE) {
              printf("joueur %d gagne\n", j);
              return 0;
            }
            if (tab[l][c] != j)
              break;
          }
        }
      }

      int j;

      j = tab[0][0];
      if (j != 0) {
        for (l = 0; ; l += 1) {
          if (l == COTE) {
            printf("joueur %d gagne\n", j);
            return 0;
          }
          if (tab[l][l] != j)
            break;
        }
      }

      j = tab[0][COTE - 1];
      if (j != 0) {
        for (l = 0; ; l += 1) {
          if (l == COTE) {
            printf("joueur %d gagne\n", j);
            return 0;
          }
          if (tab[l][COTE - l - 1] != j)
            break;
        }
      }

      if (++joueur == 3)
        joueur = 1;

      compteur += 1;
    }
  } while (compteur != COTE*COTE-1);

  puts("partie nulle");
}

Compilation and execution :

/tmp % gcc -pedantic -Wextra ttt.c
/tmp % ./a.out
[ ][ ][ ]
[ ][ ][ ]
[ ][ ][ ]

player 1, enter line and column (1..3) : a 2
illegal position or not free
player 1, enter line and column (1..3) : 1 4
illegal position or not free
player 1, enter line and column (1..3) : 1 1
[X][ ][ ]
[ ][ ][ ]
[ ][ ][ ]

player 2, enter line and column (1..3) : 2 1
[X][ ][ ]
[O][ ][ ]
[ ][ ][ ]

player 1, enter line and column (1..3) : 1 1
illegal position or not free
player 1, enter line and column (1..3) : 1 3
[X][ ][X]
[O][ ][ ]
[ ][ ][ ]

player 2, enter line and column (1..3) : 3 2
[X][ ][X]
[O][ ][ ]
[ ][O][ ]

player 1, enter line and column (1..3) : 2 1
illegal position or not free
player 1, enter line and column (1..3) : 1 2
[X][X][X]
[O][ ][ ]
[ ][O][ ]

joueur 1 gagne

/tmp % ./a.out
[ ][ ][ ]
[ ][ ][ ]
[ ][ ][ ]

player 1, enter line and column (1..3) : 1 1
[X][ ][ ]
[ ][ ][ ]
[ ][ ][ ]

player 2, enter line and column (1..3) : 2 2
[X][ ][ ]
[ ][O][ ]
[ ][ ][ ]

player 1, enter line and column (1..3) : 3 3
[X][ ][ ]
[ ][O][ ]
[ ][ ][X]

player 2, enter line and column (1..3) : 1 2
[X][O][ ]
[ ][O][ ]
[ ][ ][X]

player 1, enter line and column (1..3) : 3 2
[X][O][ ]
[ ][O][ ]
[ ][X][X]

player 2, enter line and column (1..3) : 3 1
[X][O][ ]
[ ][O][ ]
[O][X][X]

player 1, enter line and column (1..3) : 2 3
[X][O][ ]
[ ][O][X]
[O][X][X]

player 2, enter line and column (1..3) : 1 3
[X][O][O]
[ ][O][X]
[O][X][X]

joueur 2 gagne

edit : oupps you already put the question solved, I loose my time for a useless proposal :-(

Answer 2

Your condition for the loop is broken:

while ( compteur < 9 || etat != true) {

This means: While you haven't done the 9th move yet or there is not matching diagonal, continue.

If you have 9 moves but no winner, it still goes on. Also if you have a diagonal line but less than 9 moves, continue as well.

You must terminate if one of the conditions is true, not both.

while ( compteur < 9 && etat != true) {

Note: This is the reason for the problem you stated in your question. Nevertheless the error pointed out by bruno also has to be fixed to avoid undefined behaviour and potential crashes etc..