### Combining Win Checks into a Single Function Now that we've written individual functions to check rows, columns, and diagonals, our next task is to combine these checks into a single function that determines if there's a winner. This function will serve as the central point for win detection in our Tic-Tac-Toe game. #### Why Combine Checks? Combining all win checks into one function provides several benefits: 1. **Code Organization**: Keeps all win-related logic in one place 2. **Efficiency**: Reduces redundant checks by returning immediately when a winner is found 3. **Maintainability**: Easier to modify or extend win conditions in the future #### The Function Structure We'll create a function called `checkWinner` that: 1. First checks rows for a win 2. Then checks columns 3. Finally checks both diagonals 4. Returns the winning player ('X' or 'O') or ' ' if no winner #### Implementation Code ```cpp // Function to check all rows for a win char checkRows(const char board[3][3]) { for (int i = 0; i < 3; i++) { if (board[i][0] != ' ' && board[i][0] == board[i][1] && board[i][1] == board[i][2]) { return board[i][0]; } } return ' '; } // Function to check all columns for a win char checkColumns(const char board[3][3]) { for (int i = 0; i < 3; i++) { if (board[0][i] != ' ' && board[0][i] == board[1][i] && board[1][i] == board[2][i]) { return board[0][i]; } } return ' '; } // Function to check both diagonals for a win char checkDiagonals(const char board[3][3]) { // Check main diagonal (top-left to bottom-right) if (board[0][0] != ' ' && board[0][0] == board[1][1] && board[1][1] == board[2][2]) { return board[0][0]; } // Check anti-diagonal (top-right to bottom-left) if (board[0][2] != ' ' && board[0][2] == board[1][1] && board[1][1] == board[2][0]) { return board[0][2]; } return ' '; } // Main function to check for a winner char checkWinner(const char board[3][3]) { char winner = ' '; // Check rows first winner = checkRows(board); if (winner != ' ') { return winner; } // If no row winner, check columns winner = checkColumns(board); if (winner != ' ') { return winner; } // If no column winner, check diagonals winner = checkDiagonals(board); if (winner != ' ') { return winner; } // If no winner found return ' '; } ``` #### How It Works 1. **checkRows**: Iterates through each row to see if all three positions in a row are the same and not empty 2. **checkColumns**: Similar to rows but checks vertically instead of horizontally 3. **checkDiagonals**: Checks both the main diagonal (top-left to bottom-right) and the anti-diagonal (top-right to bottom-left) 4. **checkWinner**: Calls each of these functions in sequence and returns as soon as a winner is found #### Testing the Function To ensure our win checking works correctly, we should test various scenarios: 1. A board where X has won in a row 2. A board where O has won in a column 3. A board where X has won in a diagonal 4. A board with no winner 5. A completely filled board (tie condition) Example test cases: ```cpp // Test row win char testBoardRow[3][3] = { {'X', 'X', 'X'}, {'O', 'O', ' '}, {' ', ' ', ' '} }; cout << "Row winner: " << checkWinner(testBoardRow) << endl; // Should output 'X' // Test column win char testBoardCol[3][3] = { {'O', ' ', ' '}, {'O', ' ', ' '}, {'O', ' ', ' '}, }; cout << "Column winner: " << checkWinner(testBoardCol) << endl; // Should output 'O' // Test diagonal win char testBoardDiag[3][3] = { {'X', 'O', ' '}, {' ', 'X', ' '}, {' ', ' ', 'X'}, }; cout << "Diagonal winner: " << checkWinner(testBoardDiag) << endl; // Should output 'X' ``` #### Next Steps Now that we've implemented the win checking system, our next steps should be: 1. Implementing the tie condition check 2. Integrating the win detection with our game loop 3. Adding win announcements and game statistics #### Further Reading - [Tic Tac Toe Game Logic](https://en.wikipedia.org/wiki/Tic-tac-toe) - [C++ Functions](https://www.cplusplus.com/doc/tutorial/functions/) - [C++ Multidimensional Arrays](https://www.cplusplus.com/doc/tutorial/arrays/) This implementation provides a robust win checking system that will work efficiently with our Tic-Tac-Toe game. The clear separation of concerns makes it easy to maintain and extend in the future.