any 1 can help put on this..?i cant determine who is the winner when 3 x or 3 0 meet..

/*
Tic-Tac-Toe
     This program will allow 2 players to play a game of tic-tac-toe.
     Input: Interactive keyboard input from the players.
     Output: The tic-tac-toe board   
*/
#include <iostream>
#include <iomanip>
using namespace std;
const int SIZE = 3;                         //size of tic-tac-toe board array
const int SIZE2 = 2;                        //size of tic-tac-toe piece array
void display_board(const char[][SIZE]);     //displays board
void get_location(int&, int&,const int, const char[]); 
                                            //gets location from player
bool check_valid(const char[][SIZE], int, int);        
                                            //checks for valid location
bool check_win(const char[][SIZE],const int, const char[]);
                                            //checks if players wins
bool check_row(const char[][SIZE],const int, const char[]);
                                            //checks for win on each row
bool check_column(const char[][SIZE],const int, const char[]);
                                            //checks for win on each column
void check_diagonal();
                                            //checks for on both diaganols
int main()
{
    char board[SIZE][SIZE] = {'*','*','*','*','*','*','*','*','*'},//tic-tac-toe board
         mark[SIZE2] = {'X', 'O'};          //both tic-tac-toe pieces
    int count = 0,                          //move counter
        r,                                  //row
        c,                                  //column
        p;                                  //player
    bool valid,                             //valid move variable
         winner = false;                    //winner variable

    while(!winner && count < 9)
    {
        for(p = 1; p < SIZE; p++)
        {
            if(count < 9)
            {
                count++;
                display_board(board);
                get_location(r, c, p, mark);
                valid = check_valid(board, r, c);
                while(!valid)
                {
                    cout << "Sorry, please choose another row and column."
                         << endl << "Row(1-3): ";
                    cin >> r;
                    cout << endl << "Column(1-3): ";
                    cin >> c;
                    valid = check_valid(board, r, c);
                }

                board[r - 1][c - 1] = mark[p - 1];
                winner = check_win(board, p, mark);
                if(winner) 
                {
                    display_board(board);
                    break;
                }
            }

        }
    }

    if(winner)
        {
            cout << "Winner is Player " << p << "!" << endl << endl;
        }
        else if(count == 9)
        {
            display_board(board);
            cout << "Players Tied!" << endl << endl;
        }

    system("PAUSE");
    return 0;
}
//*****************************************************************************
//function display_board
//parameters: board(char array)
//returns: void
//*****************************************************************************  
void display_board(const char board[SIZE][SIZE])
{
     cout << endl << "    1   2   3" << endl <<endl
          << " 1  " << board[0][0] << " | " << board[0][1] << " | " 
          << board[0][2] << endl
          << "   ---|---|---" << endl
          << " 2  " << board[1][0] << " | " << board[1][1] << " | " 
          << board[1][2] << endl
          << "   ---|---|---" << endl
          << " 3  " << board[2][0] << " | " << board[2][1] << " | " 
          << board[2][2] << endl << endl;
}
//*****************************************************************************
//function get_location
//parameters: row(int), column(int), player(int), and mark(char array)
//returns: row(int) and column(int)
//*****************************************************************************  
void get_location(int& r, int& c,const int p, const char mark[SIZE2])
{
     cout << "Player " << p << " (" << mark[p - 1] << ") choose the row "
          << "and column of your next move."
          << endl << "Row(1-3): ";
     cin >> r;
     cout << endl << "Column(1-3): ";
     cin >> c;
}     
//*****************************************************************************
//function check_valid
//parameters: board(char array), row(int), and column(int)
//returns: bool(true or false)
//*****************************************************************************  
bool check_valid(const char board[SIZE][SIZE], int r, int c)
{
     if(r >= 1 && r <= SIZE && c >= 1 && c <= SIZE &&
        board[r - 1][c - 1] != 'X' && board[r - 1][c - 1] != 'O')    
     {
         return true;
     }
     else
     {
         return false;
     }
}
//*****************************************************************************
//function check_win
//parameters: board(char array), player(int), and mark(char array)
//returns: bool(true or false)
//*****************************************************************************  
bool check_win(const char board[SIZE][SIZE],const int p, const char mark[SIZE2])
{
     bool win;                              //local variable
     win = check_row(board, p, mark);
     if(win)
     {
          return true;
     }
     win = check_column(board, p, mark);
     if(win)
     {
          return true;
     }
     win = check_diagonal();
     if(win)
     {
          return true;
     }
     return false;

}    
//*****************************************************************************
//function check_row
//parameters: board(char array), player(int), and mark(char array)
//returns: bool(true or false)
//*****************************************************************************  
bool check_row(const char board[SIZE][SIZE],const int p, const char mark[SIZE2])     
{
     for(int r = 0; r < SIZE; r++)
     {
          if(board[r][0] == mark[p - 1] &&
             board[r][1] == mark[p - 1] &&
             board[r][2] == mark[p - 1])
          {
               return true;
          }
          else
          {
               return false;
          }
     }
}
//*****************************************************************************
//function check_column
//parameters: board(char array), player(int), and mark(char array)
//returns: bool(true or false)
//*****************************************************************************  
bool check_column(const char board[SIZE][SIZE],const int p, 
                  const char mark[SIZE2])     
{
     for(int c = 0; c < SIZE; c++)
     {
          if(board[0][c] == mark[p - 1] && 
             board[1][c] == mark[p - 1] &&
             board[2][c] == mark[p - 1])
          {
               return true;
          }
          else
          {
               return false;
          }
     } 
}
//*****************************************************************************
//function check_diagonal
//parameters: board(char array), player(int), and mark(char array)
//returns: bool(true or false)
//*****************************************************************************  
void check_diagonal()
{
     if(board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[0][0] != 0)
     {
         p = board[0][0];
         return;
     }

You have 'const' p in your formal parameters of your check_diagnal function. I don't know if that's the only reason because my compiler has thrown up a few other errors.

Actually, i put that problem in myself. Sorry

Then, what should we correct it in order to run nicely?

I was just trying to install a compiler that i prefer....

Looking at the first problem i would say that your check_diagonals should return a bool.

Then i would say that within that function the 2D array needs to be passed in like the other two check functions.

Then remove the 'const' from const int p in that functions parameters. Now it compiles.

can u write out the code here..not very get..wat u means..

I ran it once and it played ok.

bool check_diagonal(const char board[SIZE][SIZE],int p, const char mark[SIZE2])
{
    cout << "Check Diagonal" << endl;

    if(board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[0][0] != 0)
    {
        p = board[0][0];
        return true;
    }
   else
   {
        return false;
   }
}

Actually you don't need that p =[0][0] assignment so the const can stay in.

Thank you for reading the READ BEFORE POSTING CODE thread at the top of the forum.

We look forward to your custom in future lifetimes.
Signed
The Magrathean defence committee.