Ya estoy listo. Gracias a todos los que respondieron

Aquí dejo el código completo del juego para los que lo analice el que quiera o quiera ver como funciona, depurarlo, etc.
Aún me falta agregarle para poder jugar con un solo jugador contra la CPU.
El que quiera también puede modificarlo y postearlo aquí, para ir viendo las distintas versiones y los errores que cometí.

Ah!, por si a alguien le llega a servir, para la MAC creo (estoy seguro en un 80%) de que es _MAC.

Código Fuente:


//¿En que plataforma estamos trabajando?
#ifdef _WIN32
#define EN_WINDOWS
#elif linux
#define EN_LINUX
#endif

#include <iostream>

#ifdef EN_WINDOWS
#include <Windows.h>
#endif

#ifdef EN_WINDOWS
#define LIMPIAR_CONSOLA() limpiarConsola()
#elif EN_LINUX
#define LIMPIAR_CONSOLA() system("clear")
#endif

using namespace std;

//El tamaño de la fila o la
//columna respectivamente
const int FILA = 3;
const int COLUMNA = 3;

/////////////////////////////// Prototipos ///////////////////////////////

#ifdef EN_WINDOWS
//Limpia la consola (solo windows)
void limpiarConsola();
#endif
//Inicializa los valores del array del juego
void inicializarGato(char cCuadros[FILA][COLUMNA]);
//Imprime el gato
void imprimirGato(const char cCuadros[FILA][COLUMNA]);
//Espera a que el usuario pulse ENTER
void esperar();
//Realiza la jugada del jugador
//retorna true si se realizo la jugada y false en caso contrario
bool jugadaJugador(char cCuadros[FILA][COLUMNA],
                              char cNumeroCuadro,
                              char cCharJugador);
//Comprueba si algún jugador ha ganado
//retorna el número del jugador que ha ganado
//y retorna -1 si ninguno a ganado
int comprobarVictoria(const char cCuadros[FILA][COLUMNA],
                                     const char *cCharJugadores);
//Comprueba si han empatado
bool comprobarEmpate(const char cCuadros[FILA][COLUMNA],
                                    const char *cCharJugadores);


int main()
{
       char cCuadro[FILA][COLUMNA];  //Array del juego (gato)
       char cCharJugador[2] = { 'X', 'O' }; //El char a usar por el jugador
       char cResJugarOtraVez[20];    //Respuesta si jugar otra vez
       char cResDosJugadores[20];         //Respuesta si 2 jugadores o no
       char cJugadaJugador[20];         //Es la jugada del jugador actual
       unsigned int uiTurnoJugador = 0;    //El turno del jugador
       int iJugadorGanador;                //El jugador que gano la partida
       bool bJugarOtraVez = false;  //Si resonde si a "¿Jugar otra vez?"
       bool bDosJugadores = false;         //Si se juega con dos jugadores
       bool bJuegoTerminado = false; //Si termina el juego o no

    do  //Se ejecutara mientras bJugarOtraVez sea true
    {
        LIMPIAR_CONSOLA();
        inicializarGato(cCuadro);

        cout << "\xa8Jugar\xa0n 2 jugadores? (S/N): ";
        cin >> cResDosJugadores;

        if (cResDosJugadores[0] == 'S' || cResDosJugadores[0] == 's')
            bDosJugadores = true;
        else
            bDosJugadores = false;

        //Loop del juego
        do
        {
            LIMPIAR_CONSOLA();
            imprimirGato(cCuadro);

            //Se ejecuta mientras se haga una jugada correcta
            do
            {
                cout << "Jugador " << uiTurnoJugador + 1 << " juega: ";
                cin >> cJugadaJugador;

                //Si no es un número
                if (cJugadaJugador[0] < '0' || cJugadaJugador[0] > '9')
                {
                    cout << endl;
                    cout << "Debe realizar una jugada correcta" << endl;
                    esperar();
                    continue;
                }

                //Si la jugada ya se realizó
                if (!jugadaJugador(
                    cCuadro,
                    cJugadaJugador[0],
                    cCharJugador[uiTurnoJugador])
                    )
                {
                    cout << endl;
                    cout << "Ese n\xa3mero ya esta ocupado!" << endl;
                    cout << endl;
                    esperar();
                    continue;
                }

                break;
            } while (true);

            //Si hay un empate
            if (comprobarEmpate(cCuadro, cCharJugador))
            {
                cout << endl;
                cout << "Ha habido un empate!";
                cout << endl;
                esperar();
                break;
            }

            iJugadorGanador = comprobarVictoria(cCuadro, cCharJugador);
            //Si alguien a ganado
            if (iJugadorGanador != -1)
            {
                cout << endl;
                cout << "El jugador " << iJugadorGanador + 1 << " ha ganado!";
                cout << endl;
                bJuegoTerminado = true;
                esperar();
            }
            else
                bJuegoTerminado = false;
            if (uiTurnoJugador == 0)
                uiTurnoJugador = 1;
            else
                uiTurnoJugador = 0;
        } while (!bJuegoTerminado);

      cout << "\xa8Jugar otra vez\? (S/N): ";
      cin >> cResJugarOtraVez;

        if (cResJugarOtraVez[0] == 'S' || cResJugarOtraVez[0] == 's')
            bJugarOtraVez = true;
        else
            bJugarOtraVez = false;

        //Si responde que sí
        if (cResJugarOtraVez[0] == 'S'
        || cResJugarOtraVez[0] == 's')
            bJugarOtraVez = true;
        else
            bJugarOtraVez = false;
    } while (bJugarOtraVez);

       return EXIT_SUCCESS;
}

////////////////////////////// Definiciones //////////////////////////////

#ifdef EN_WINDOWS
//Limpia la consola (solo windows)
void limpiarConsola()
{
       HANDLE hOutPut;       //Manejador de salida de la consola
       CONSOLE_SCREEN_BUFFER_INFO csbi; //Información de la consola
       COORD coord = { 0, 0 };        //Desde donde empezar a borrar

       hOutPut = GetStdHandle(STD_OUTPUT_HANDLE);
       GetConsoleScreenBufferInfo(hOutPut, &csbi);

       //Limpia la consola
       FillConsoleOutputCharacter(
              hOutPut,
              '\000',
              csbi.dwSize.X * csbi.dwSize.Y,
              coord,
              NULL
              );
       //Situa el cursor en el inicio del lugar borrado
       SetConsoleCursorPosition(hOutPut, coord);
}
#endif

//Inicializa los valores del array del juego
void inicializarGato(char cCuadros[FILA][COLUMNA])
{
       char cNumero = '1'; //Es el número que se escribirá en el array

       //Escribe los valores en el array
       for (int fila = FILA - 1; fila >= 0; fila--)
       {
              for (int columna = 0; columna < COLUMNA; columna++)
              {
                     cCuadros[fila][columna] = cNumero;
                     //Pasa al otro número
                     cNumero++;
              } //for
       } //for
}

//Imprime el gato
void imprimirGato(const char cCuadros[FILA][COLUMNA])
{
       for (int fila = 0; fila < FILA; fila++)
       {
              for (int columna = 0; columna < COLUMNA; columna++)
              {
                     cout << cCuadros[fila][columna];

                     //Si no es la ultima columna
                     if (columna < COLUMNA - 1)
                            cout << "|";
              } //for

              cout << endl;
              //Si no es la ultima fila
              if (fila < FILA - 1)
                     cout << "-+-+-";
              cout << endl;
       } //for
}

//Espera a que el usuario pulse ENTER
void esperar()
{
       cin.sync();
       cin.get();
       cin.sync();
}

//Realiza la jugada del jugador
//retorna true si se realizo la jugada y false en caso contrario
bool jugadaJugador(char cCuadros[FILA][COLUMNA],
                              char cNumeroCuadro,
                              char cCharJugador)
{
       //Recorre todo el gato y busca el caracter,
       //si lo encuentra lo reemplaza por el caracter
       //del jugador correspondiente
       for (int fila = 0; fila < FILA; fila++)
       {
              for (int columna = 0; columna < COLUMNA; columna++)
              {
                     if (cCuadros[fila][columna] == cNumeroCuadro)
                     {
                            cCuadros[fila][columna] = cCharJugador;
                            LIMPIAR_CONSOLA();
                            imprimirGato(cCuadros);
                            return true;
                     } //if
              } //for
       } //for

       return false;
}

//Comprueba si algún jugador ha ganado
//retorna el número del jugador que ha ganado
//y retorna -1 si ninguno a ganado
int comprobarVictoria(const char cCuadros[FILA][COLUMNA],
                                     const char *cCharJugadores)
{
       enum JUGADOR
       {
              JUGADOR1,
              JUGADOR2
       };

       //Comprueba gatos horizontalmente
       for (int fila = 0; fila < FILA; fila++)
       {
              if (cCuadros[fila][0] == cCuadros[fila][1]
              && cCuadros[fila][1] == cCuadros[fila][2])
              {
                     if (cCuadros[fila][0] == cCharJugadores[0])
                            return JUGADOR1;
                     else if (cCuadros[fila][0] == cCharJugadores[1])
                            return JUGADOR2;
              }
       }

       //Comprueba gatos verticalmente
       for (int columna = 0; columna < COLUMNA; columna++)
       {
              if (cCuadros[0][columna] == cCuadros[1][columna]
              && cCuadros[1][columna] == cCuadros[2][columna])
              {
                     if (cCuadros[0][columna] == cCharJugadores[0])
                            return JUGADOR1;
                     else if (cCuadros[0][columna] == cCharJugadores[1])
                            return JUGADOR2;
              }
       }

       if (cCuadros[0][0] == cCuadros[1][1]
       && cCuadros[1][1] == cCuadros[2][2])
       {
              if (cCuadros[0][0] == cCharJugadores[0])
                     return JUGADOR1;
              else if (cCuadros[0][0] == cCharJugadores[1])
                     return JUGADOR2;
       }
       else if (cCuadros[0][2] == cCuadros[1][1]
       && cCuadros[1][1] == cCuadros[2][0])
       {
              if (cCuadros[0][2] == cCharJugadores[0])
                     return JUGADOR1;
              else if (cCuadros[0][2] == cCharJugadores[1])
                     return JUGADOR2;
       }

       return -1; //No encontrado
}

//Comprueba si han empatado
bool comprobarEmpate(const char cCuadros[FILA][COLUMNA],
                                    const char *cCharJugadores)
{
       //Si alguien ganó no hay empate
       if (comprobarVictoria(cCuadros, cCharJugadores) != -1)
              return false;

       for (int fila = 0; fila < FILA; fila++)
       {
              for (int columna = 0; columna < COLUMNA; columna++)
              {
                     if (cCuadros[fila][columna] != cCharJugadores[0]
                     && cCuadros[fila][columna] != cCharJugadores[1])
                     {
                            return false;
                     }
              } //for
       } //for

       //Empate
       return true;
}


Saludos

Esto, en vez de en el foro, deberías haberlo puesto como proyecto en Aula Virtual . Pulsa en el botón gAp abajo, y verás la sección.

Crea el proyecto con la opción para optimizar si quieres que colaboremos entre todos en la pizarra.

Por cierto, en linux sólo me funcionó modificándolo así:

Código Fuente:


#include <iostream>


using namespace std;

//El tamaño de la fila o la
//columna respectivamente
const int FILA = 3;
const int COLUMNA = 3;

/////////////////////////////// Prototipos ///////////////////////////////

//Inicializa los valores del array del juego
void inicializarGato(char cCuadros[FILA][COLUMNA]);
//Imprime el gato
void imprimirGato(const char cCuadros[FILA][COLUMNA]);
//Espera a que el usuario pulse ENTER
void esperar();
//Realiza la jugada del jugador
//retorna true si se realizo la jugada y false en caso contrario
bool jugadaJugador(char cCuadros[FILA][COLUMNA],
                              char cNumeroCuadro,
                              char cCharJugador);
//Comprueba si algún jugador ha ganado
//retorna el número del jugador que ha ganado
//y retorna -1 si ninguno a ganado
int comprobarVictoria(const char cCuadros[FILA][COLUMNA],
                                    const char *cCharJugadores);
//Comprueba si han empatado
bool comprobarEmpate(const char cCuadros[FILA][COLUMNA],
                                    const char *cCharJugadores);


int main()
{
      char cCuadro[FILA][COLUMNA];  //Array del juego (gato)
      char cCharJugador[2] = { 'X', 'O' }; //El char a usar por el jugador
      char cResJugarOtraVez[20];    //Respuesta si jugar otra vez
      char cResDosJugadores[20];        //Respuesta si 2 jugadores o no
      char cJugadaJugador[20];        //Es la jugada del jugador actual
      unsigned int uiTurnoJugador = 0;    //El turno del jugador
      int iJugadorGanador;                //El jugador que gano la partida
      bool bJugarOtraVez = false;  //Si resonde si a "¿Jugar otra vez?"
      bool bDosJugadores = false;        //Si se juega con dos jugadores
      bool bJuegoTerminado = false; //Si termina el juego o no

    do  //Se ejecutara mientras bJugarOtraVez sea true
    {
        inicializarGato(cCuadro);

        cout << "¨Jugar n 2 jugadores? (S/N): ";
        cin >> cResDosJugadores;

        if (cResDosJugadores[0] == 'S' || cResDosJugadores[0] == 's')
            bDosJugadores = true;
        else
            bDosJugadores = false;

        //Loop del juego
        do
        {
            imprimirGato(cCuadro);

            //Se ejecuta mientras se haga una jugada correcta
            do
            {
                cout << "Jugador " << uiTurnoJugador + 1 << " juega: ";
                cin >> cJugadaJugador;

                //Si no es un número
                if (cJugadaJugador[0] < '0' || cJugadaJugador[0] > '9')
                {
                    cout << endl;
                    cout << "Debe realizar una jugada correcta" << endl;
                    esperar();
                    continue;
                }

                //Si la jugada ya se realizó
                if (!jugadaJugador(
                    cCuadro,
                    cJugadaJugador[0],
                    cCharJugador[uiTurnoJugador])
                    )
                {
                    cout << endl;
                    cout << "Ese n£mero ya esta ocupado!" << endl;
                    cout << endl;
                    esperar();
                    continue;
                }

                break;
            } while (true);

            //Si hay un empate
            if (comprobarEmpate(cCuadro, cCharJugador))
            {
                cout << endl;
                cout << "Ha habido un empate!";
                cout << endl;
                esperar();
                break;
            }

            iJugadorGanador = comprobarVictoria(cCuadro, cCharJugador);
            //Si alguien a ganado
            if (iJugadorGanador != -1)
            {
                cout << endl;
                cout << "El jugador " << iJugadorGanador + 1 << " ha ganado!";
                cout << endl;
                bJuegoTerminado = true;
                esperar();
            }
            else
                bJuegoTerminado = false;
            if (uiTurnoJugador == 0)
                uiTurnoJugador = 1;
            else
                uiTurnoJugador = 0;
        } while (!bJuegoTerminado);

      cout << "¨Jugar otra vez? (S/N): ";
      cin >> cResJugarOtraVez;

        if (cResJugarOtraVez[0] == 'S' || cResJugarOtraVez[0] == 's')
            bJugarOtraVez = true;
        else
            bJugarOtraVez = false;

        //Si responde que sí
        if (cResJugarOtraVez[0] == 'S'
        || cResJugarOtraVez[0] == 's')
            bJugarOtraVez = true;
        else
            bJugarOtraVez = false;
    } while (bJugarOtraVez);

      return 0;
}

////////////////////////////// Definiciones //////////////////////////////


//Inicializa los valores del array del juego
void inicializarGato(char cCuadros[FILA][COLUMNA])
{
      char cNumero = '1'; //Es el número que se escribirá en el array

      //Escribe los valores en el array
      for (int fila = FILA - 1; fila >= 0; fila--)
      {
              for (int columna = 0; columna < COLUMNA; columna++)
              {
                    cCuadros[fila][columna] = cNumero;
                    //Pasa al otro número
                    cNumero++;
              } //for
      } //for
}

//Imprime el gato
void imprimirGato(const char cCuadros[FILA][COLUMNA])
{
      for (int fila = 0; fila < FILA; fila++)
      {
              for (int columna = 0; columna < COLUMNA; columna++)
              {
                    cout << cCuadros[fila][columna];

                    //Si no es la ultima columna
                    if (columna < COLUMNA - 1)
                            cout << "|";
              } //for

              cout << endl;
              //Si no es la ultima fila
              if (fila < FILA - 1)
                    cout << "-+-+-";
              cout << endl;
      } //for
}

//Espera a que el usuario pulse ENTER
void esperar()
{
      cin.sync();
      cin.get();
      cin.sync();
}

//Realiza la jugada del jugador
//retorna true si se realizo la jugada y false en caso contrario
bool jugadaJugador(char cCuadros[FILA][COLUMNA],
                              char cNumeroCuadro,
                              char cCharJugador)
{
      //Recorre todo el gato y busca el caracter,
      //si lo encuentra lo reemplaza por el caracter
      //del jugador correspondiente
      for (int fila = 0; fila < FILA; fila++)
      {
              for (int columna = 0; columna < COLUMNA; columna++)
              {
                    if (cCuadros[fila][columna] == cNumeroCuadro)
                    {
                            cCuadros[fila][columna] = cCharJugador;
                            imprimirGato(cCuadros);
                            return true;
                    } //if
              } //for
      } //for

      return false;
}

//Comprueba si algún jugador ha ganado
//retorna el número del jugador que ha ganado
//y retorna -1 si ninguno a ganado
int comprobarVictoria(const char cCuadros[FILA][COLUMNA],
                                    const char *cCharJugadores)
{
      enum JUGADOR
      {
              JUGADOR1,
              JUGADOR2
      };

      //Comprueba gatos horizontalmente
      for (int fila = 0; fila < FILA; fila++)
      {
              if (cCuadros[fila][0] == cCuadros[fila][1]
              && cCuadros[fila][1] == cCuadros[fila][2])
              {
                    if (cCuadros[fila][0] == cCharJugadores[0])
                            return JUGADOR1;
                    else if (cCuadros[fila][0] == cCharJugadores[1])
                            return JUGADOR2;
              }
      }

      //Comprueba gatos verticalmente
      for (int columna = 0; columna < COLUMNA; columna++)
      {
              if (cCuadros[0][columna] == cCuadros[1][columna]
              && cCuadros[1][columna] == cCuadros[2][columna])
              {
                    if (cCuadros[0][columna] == cCharJugadores[0])
                            return JUGADOR1;
                    else if (cCuadros[0][columna] == cCharJugadores[1])
                            return JUGADOR2;
              }
      }

      if (cCuadros[0][0] == cCuadros[1][1]
      && cCuadros[1][1] == cCuadros[2][2])
      {
              if (cCuadros[0][0] == cCharJugadores[0])
                    return JUGADOR1;
              else if (cCuadros[0][0] == cCharJugadores[1])
                    return JUGADOR2;
      }
      else if (cCuadros[0][2] == cCuadros[1][1]
      && cCuadros[1][1] == cCuadros[2][0])
      {
              if (cCuadros[0][2] == cCharJugadores[0])
                    return JUGADOR1;
              else if (cCuadros[0][2] == cCharJugadores[1])
                    return JUGADOR2;
      }

      return -1; //No encontrado
}

//Comprueba si han empatado
bool comprobarEmpate(const char cCuadros[FILA][COLUMNA],
                                    const char *cCharJugadores)
{
      //Si alguien ganó no hay empate
      if (comprobarVictoria(cCuadros, cCharJugadores) != -1)
              return false;

      for (int fila = 0; fila < FILA; fila++)
      {
              for (int columna = 0; columna < COLUMNA; columna++)
              {
                    if (cCuadros[fila][columna] != cCharJugadores[0]
                    && cCuadros[fila][columna] != cCharJugadores[1])
                    {
                            return false;
                    }
              } //for
      } //for

      //Empate
      return true;
}

Sin las modificaciones, el compilador de code::blocks me da mil errores. No entiendo el
return EXIT_SUCCESS;
en lugar del
return 0; de siempre, cuando el primero da error, y éste último no.
Un saludo.

Buenas
Como ha dicho CHuLoYo, da problemas para compilar en linux.
Debería ser:

Código Fuente:


#ifdef _WIN32
#define EN_WINDOWS
#elif __unix__
#define EN_LINUX
#endif

#include <iostream>

#ifdef EN_WINDOWS
#include <Windows.h>
#elif defined (EN_LINUX)
#include <stdlib.h>
#endif

#ifdef EN_WINDOWS
#define LIMPIAR_CONSOLA() limpiarConsola()
#elif defined (EN_LINUX)
#define LIMPIAR_CONSOLA() system("clear")
#endif


Faltaba la librería stdlib en la que se definen la función system y EXIT_SUCCESS.
La explicación al defined aqui:
http://embdev.net/topic/150763
http://www.cyrius.com/journal/gcc

Así compila y funciona bien :D.
EDITO. Donde he puesto __unix__ puede ser linux.

En cuanto a la Inteligencia artificial. Para empezar podrías hacer una que escoja una casilla al azar. Luego ya la complicarás :P.

¡Saludos!

Si, yo también estoy trabajando en "inteligencia artificial" con PHP, concretamente en el juego de bouzas:

http://www.bouzas2.es

Cuando entras a una batalla (por ejemplo el malote), va por turnos. Primero se mueve bouzas y dispara, luego se mueve el enemigo y dispara, y así continuamente. El enemigo tiene una zona de acción en un eje X_max=3 e Y_max=4.
Hice tres randoms, uno para el movimiento en X, otro para el movimiento en Y, y otro para el arma utilizada.
De esta forma consigo esa "inteligencia artificial" que tal vez tú necesites.
De todas formas, la IA que he creado es para los enemigos más débiles. Los enemigos más fuertes se moverán hacia el eje X donde esté Bouzas, o por lo menos lo más aproximado posible, y utilizará pociones de recuperación de vida si la necesita (if ( vidaActual<=10 ) ) y utilizará el arma que más afecte a Bouzas en el momento.

Un saludo.

Que raro por que yo siempre he usado las constantes EXIT_SUCCESS y la función system incluyendo solo la librería iostream (en C++) y en codeblocks, visual c++, dev c++ y todos me han compilado perfectamente supongo que en LINUX es distinto. En todo caso gracias por las sugerencias.

Nunca pude, en la función "comprobarVictoria" hacerlo con un loop, creo que no es posible, ahí lo dejo haber si alguien le resulta. (Ya lo deje con las modificaciones para que funcione en linux, si alguien tiene problemas me avisa):

Código Fuente:


//¿En que plataforma estamos trabajando?
#ifdef _WIN32
#define EN_WINDOWS
#elif defined(__unix__)
#define EN_LINUX
#endif

#include <iostream>

#ifdef EN_WINDOWS
#include <Windows.h>
#elif defined(EN_LINUX)
#include <cstdlib>
#endif

#ifdef EN_WINDOWS
#define LIMPIAR_CONSOLA() limpiarConsola()
#elif defined(EN_LINUX)
#define LIMPIAR_CONSOLA() system("clear")
#endif

using namespace std;

//El tamaño de la fila o la
//columna respectivamente
const int FILA = 3;
const int COLUMNA = 3;

/////////////////////////////// Prototipos ///////////////////////////////

#ifdef EN_WINDOWS
//Limpia la consola (solo windows)
void limpiarConsola();
#endif
//Inicializa los valores del array del juego
void inicializarGato(char cCuadros[FILA][COLUMNA]);
//Imprime el gato
void imprimirGato(const char cCuadros[FILA][COLUMNA]);
//Espera a que el usuario pulse ENTER
void esperar();
//Realiza la jugada del jugador
//retorna true si se realizo la jugada y false en caso contrario
bool jugadaJugador(char cCuadros[FILA][COLUMNA],
                              char cNumeroCuadro,
                              char cCharJugador);
//Comprueba si algún jugador ha ganado
//retorna el número del jugador que ha ganado
//y retorna -1 si ninguno a ganado
int comprobarVictoria(const char cCuadros[FILA][COLUMNA],
                                     const char *cCharJugadores);
//Comprueba si han empatado
bool comprobarEmpate(const char cCuadros[FILA][COLUMNA],
                                    const char *cCharJugadores);


int main()
{
       char cCuadro[FILA][COLUMNA];  //Array del juego (gato)
       char cCharJugador[2] = { 'X', 'O' }; //El char a usar por el jugador
       char cResJugarOtraVez[20];    //Respuesta si jugar otra vez
       char cResDosJugadores[20];         //Respuesta si 2 jugadores o no
       char cJugadaJugador[20];         //Es la jugada del jugador actual
       unsigned int uiTurnoJugador = 0;    //El turno del jugador
       int iJugadorGanador;                //El jugador que gano la partida
       bool bJugarOtraVez = false;  //Si resonde si a "¿Jugar otra vez?"
       bool bDosJugadores = false;         //Si se juega con dos jugadores
       bool bJuegoTerminado = false; //Si termina el juego o no

    do  //Se ejecutara mientras bJugarOtraVez sea true
    {
        LIMPIAR_CONSOLA();
        inicializarGato(cCuadro);

        cout << "¨Jugar n 2 jugadores? (S/N): ";
        cin >> cResDosJugadores;

        if (cResDosJugadores[0] == 'S' || cResDosJugadores[0] == 's')
            bDosJugadores = true;
        else
            bDosJugadores = false;

        //Loop del juego
        do
        {
            LIMPIAR_CONSOLA();
            imprimirGato(cCuadro);

            //Se ejecuta mientras se haga una jugada correcta
            do
            {
                cout << "Jugador " << uiTurnoJugador + 1 << " juega: ";
                cin >> cJugadaJugador;

                //Si no es un número
                if (cJugadaJugador[0] < '0' || cJugadaJugador[0] > '9')
                {
                    cout << endl;
                    cout << "Debe realizar una jugada correcta" << endl;
                    esperar();
                    continue;
                }

                //Si la jugada ya se realizó
                if (!jugadaJugador(
                    cCuadro,
                    cJugadaJugador[0],
                    cCharJugador[uiTurnoJugador])
                    )
                {
                    cout << endl;
                    cout << "Ese n£mero ya esta ocupado!" << endl;
                    cout << endl;
                    esperar();
                    continue;
                }

                break;
            } while (true);

            //Si hay un empate
            if (comprobarEmpate(cCuadro, cCharJugador))
            {
                cout << endl;
                cout << "Ha habido un empate!";
                cout << endl;
                esperar();
                break;
            }

            iJugadorGanador = comprobarVictoria(cCuadro, cCharJugador);
            //Si alguien a ganado
            if (iJugadorGanador != -1)
            {
                cout << endl;
                cout << "El jugador " << iJugadorGanador + 1 << " ha ganado!";
                cout << endl;
                bJuegoTerminado = true;
                esperar();
            }
            else
                bJuegoTerminado = false;
            if (uiTurnoJugador == 0)
                uiTurnoJugador = 1;
            else
                uiTurnoJugador = 0;
        } while (!bJuegoTerminado);

      cout << "¨Jugar otra vez? (S/N): ";
      cin >> cResJugarOtraVez;

        if (cResJugarOtraVez[0] == 'S' || cResJugarOtraVez[0] == 's')
            bJugarOtraVez = true;
        else
            bJugarOtraVez = false;

        //Si responde que sí
        if (cResJugarOtraVez[0] == 'S'
        || cResJugarOtraVez[0] == 's')
            bJugarOtraVez = true;
        else
            bJugarOtraVez = false;
    } while (bJugarOtraVez);

       return EXIT_SUCCESS;
}

////////////////////////////// Definiciones //////////////////////////////

#ifdef EN_WINDOWS
//Limpia la consola (solo windows)
void limpiarConsola()
{
       HANDLE hOutPut;       //Manejador de salida de la consola
       CONSOLE_SCREEN_BUFFER_INFO csbi; //Información de la consola
       COORD coord = { 0, 0 };        //Desde donde empezar a borrar

       hOutPut = GetStdHandle(STD_OUTPUT_HANDLE);
       GetConsoleScreenBufferInfo(hOutPut, &csbi);

       //Limpia la consola
       FillConsoleOutputCharacter(
              hOutPut,
              '',
              csbi.dwSize.X * csbi.dwSize.Y,
              coord,
              NULL
              );
       //Situa el cursor en el inicio del lugar borrado
       SetConsoleCursorPosition(hOutPut, coord);
}
#endif

//Inicializa los valores del array del juego
void inicializarGato(char cCuadros[FILA][COLUMNA])
{
       char cNumero = '1'; //Es el número que se escribirá en el array

       //Escribe los valores en el array
       for (int fila = FILA - 1; fila >= 0; fila--)
       {
              for (int columna = 0; columna < COLUMNA; columna++)
              {
                     cCuadros[fila][columna] = cNumero;
                     //Pasa al otro número
                     cNumero++;
              } //for
       } //for
}

//Imprime el gato
void imprimirGato(const char cCuadros[FILA][COLUMNA])
{
       for (int fila = 0; fila < FILA; fila++)
       {
              for (int columna = 0; columna < COLUMNA; columna++)
              {
                     cout << cCuadros[fila][columna];

                     //Si no es la ultima columna
                     if (columna < COLUMNA - 1)
                            cout << "|";
              } //for

              cout << endl;
              //Si no es la ultima fila
              if (fila < FILA - 1)
                     cout << "-+-+-";
              cout << endl;
       } //for
}

//Espera a que el usuario pulse ENTER
void esperar()
{
       cin.sync();
       cin.get();
       cin.sync();
}

//Realiza la jugada del jugador
//retorna true si se realizo la jugada y false en caso contrario
bool jugadaJugador(char cCuadros[FILA][COLUMNA],
                              char cNumeroCuadro,
                              char cCharJugador)
{
       //Recorre todo el gato y busca el caracter,
       //si lo encuentra lo reemplaza por el caracter
       //del jugador correspondiente
       for (int fila = 0; fila < FILA; fila++)
       {
              for (int columna = 0; columna < COLUMNA; columna++)
              {
                     if (cCuadros[fila][columna] == cNumeroCuadro)
                     {
                            cCuadros[fila][columna] = cCharJugador;
                            LIMPIAR_CONSOLA();
                            imprimirGato(cCuadros);
                            return true;
                     } //if
              } //for
       } //for

       return false;
}

//Comprueba si algún jugador ha ganado
//retorna el número del jugador que ha ganado
//y retorna -1 si ninguno a ganado
int comprobarVictoria(const char cCuadros[FILA][COLUMNA],
                                     const char *cCharJugadores)
{
       enum JUGADOR
       {
              JUGADOR1,
              JUGADOR2
       };

       //Comprueba gatos horizontalmente
       for (int fila = 0; fila < FILA; fila++)
       {
              if (cCuadros[fila][0] == cCuadros[fila][1]
              && cCuadros[fila][1] == cCuadros[fila][2])
              {
                     if (cCuadros[fila][0] == cCharJugadores[0])
                            return JUGADOR1;
                     else if (cCuadros[fila][0] == cCharJugadores[1])
                            return JUGADOR2;
              }
       }

       //Comprueba gatos verticalmente
       for (int columna = 0; columna < COLUMNA; columna++)
       {
              if (cCuadros[0][columna] == cCuadros[1][columna]
              && cCuadros[1][columna] == cCuadros[2][columna])
              {
                     if (cCuadros[0][columna] == cCharJugadores[0])
                            return JUGADOR1;
                     else if (cCuadros[0][columna] == cCharJugadores[1])
                            return JUGADOR2;
              }
       }

       if (cCuadros[0][0] == cCuadros[1][1]
       && cCuadros[1][1] == cCuadros[2][2])
       {
              if (cCuadros[0][0] == cCharJugadores[0])
                     return JUGADOR1;
              else if (cCuadros[0][0] == cCharJugadores[1])
                     return JUGADOR2;
       }
       else if (cCuadros[0][2] == cCuadros[1][1]
       && cCuadros[1][1] == cCuadros[2][0])
       {
              if (cCuadros[0][2] == cCharJugadores[0])
                     return JUGADOR1;
              else if (cCuadros[0][2] == cCharJugadores[1])
                     return JUGADOR2;
       }

       return -1; //No encontrado
}

//Comprueba si han empatado
bool comprobarEmpate(const char cCuadros[FILA][COLUMNA],
                                    const char *cCharJugadores)
{
       //Si alguien ganó no hay empate
       if (comprobarVictoria(cCuadros, cCharJugadores) != -1)
              return false;

       for (int fila = 0; fila < FILA; fila++)
       {
              for (int columna = 0; columna < COLUMNA; columna++)
              {
                     if (cCuadros[fila][columna] != cCharJugadores[0]
                     && cCuadros[fila][columna] != cCharJugadores[1])
                     {
                            return false;
                     }
              } //for
       } //for

       //Empate
       return true;
}


ChuLoYo, voy a tomar tu sugerencia de ponerlo en el aula virtual.

EDITO: Ya está puesto en el Aula Virtual en C++ y Para optimizar

Saludos

Te he dejado un comentario en la pizarra. Es importante tenerlo todo así.

Un saludo.

ChuLoYo, en los codigos del Aula Virtual (todos los codigos) se ven todos desordenados y no se entiende nada, he probado con safari, google chrome, firefox y en todos se ve igual.
¿Por que será?

Aquí una imagen:


Saludos

Lo has editado? Yo cuando lo metí quedó bien. Ya me encargo yo, gracias por avisar.

No, no lo he editado.
Y en todos se me ve así.

Saludos