Here is a Tic Tac Toe game in C++ that I have been working on. My questions are as follows:I tested it for bugs, but if you find any, please post the solution!I want to make the code more recursive, in a sense. Instead of having multiple lines of code that do the same things with different values, it would be nice to compress it even more. You see, I'm a minimalist and I'm lazy (fundamental programmer traits!) so less typing is good. I'm wondering if my code follows the best common practices, and what those practices might be. For instance, is using camelCase for variables and something_like_this good for functions? If you have any other comments on the code, please let me know! main.cpp/*Tic Tac Toe Game v1.0Released under the GPL liscence version 2Written by JohnBobSmith*/#include <iostream>#include <limits> //This is required to catch invalid user inputclass tic_tac_toe //A class to contain all our functions{    public: //Allow us to use the functions anywhere    char board[3][3]; //Creates an 2d array for the board    char previousPlayerPiece; //variable used in multiple functions    char previousPlayer2Piece; //varibable used in multiple functions    void init_board()    {        //initializes a blank board        for(int a = 0; a < 3; a++){            std::cout << \n;            for (int b = 0; b < 3; b++){                board[a][b] = '-';                std::cout << board[a][b];            }        }    }    void print_board(char playerPiece, int pos1 = 0, int pos2 = 0)    {        //prints out the updated board when called upon to do so        for(int a = 0; a < 3; a++){            std::cout << \n;            for (int b = 0; b < 3; b++){                board[pos1][pos2] = playerPiece;                std::cout << board[a][b];            }        }    }    int check_for_overlap(int pos1, int pos2, char playerPiece)    {        switch(pos1)        {        case 1:            if (pos2 == 1){                if (board[0][0] != '-'){                    std::cout << \nOVERLAP DETECTED!!!!!! << std::endl;                    return true;                }            }            if (pos2 == 2){                if (board[0][1] != '-'){                    std::cout << \nOVERLAP DETECTED!!!!!! << std::endl;                    return true;                }            }            if (pos2 == 3){                if (board[0][2] != '-'){                    std::cout << \nOVERLAP DETECTED!!!!!! << std::endl;                    return true;                }            }        case 2:            if (pos2 == 1){                if (board[1][0] != '-'){                    std::cout << \nOVERLAP DETECTED!!!!!! << std::endl;                    return true;                }            }            if (pos2 == 2){                if (board[1][1] != '-'){                    std::cout << \nOVERLAP DETECTED!!!!!! << std::endl;                    return true;                }            }            if (pos2 == 2){                if (board[1][2] != '-'){                    std::cout << \nOVERLAP DETECTED!!!!!! << std::endl;                    return true;                }            }        case 3:            if (pos2 == 1){                if (board[2][0] != '-'){                    std::cout << \nOVERLAP DETECTED!!!!!! << std::endl;                    return true;                }            }            if (pos2 == 2){                if (board[2][1] != '-'){                    std::cout << \nOVERLAP DETECTED!!!!!! << std::endl;                    return true;                }            }            if (pos2 == 3){                if (board[2][2] != '-'){                    std::cout << \nOVERLAP DETECTED!!!!!! << std::endl;                    return true;                }            }        }        return false;    }    void update_board(char playerPiece)    {        //updates the board based on user input        int x, y;        std::cout << Enter a position to place the  << playerPiece <<  on the board << std::endl;        while (true){            std::cout << Enter row:  << std::endl;            std::cin >> x;            if (x < 1 || x > 3 || std::cin.fail()){                std::cin.clear();                std::cin.ignore(std::numeric_limits<std::streamsize>::max(),'\n');                std::cout << Your number is invalid. Try again.  << std::endl;            } else {                break;            }        }        while (true)        {            std::cout << Enter col:  << std::endl;            std::cin >> y;            if (y < 1 || y > 3 || std::cin.fail()){                std::cin.clear();                std::cin.ignore(std::numeric_limits<std::streamsize>::max(),'\n');                std::cout << Your number is invalid. Try again.  << std::endl;            } else {                break;            }        }        if (check_for_overlap(x, y, previousPlayerPiece) == true){            x--;y--;print_board(previousPlayer2Piece, x, y);            std::cout << \nThe board has been re-set. Try again! << std::endl;        } else if (check_for_overlap(x, y, previousPlayer2Piece) == true){            x--;y--;print_board(previousPlayerPiece, x, y);            std::cout << \nThe board has been re-set. Try again. << std::endl;        } else {            x--;y--;print_board(playerPiece, x, y);        }    }    /*    This is probably the best way to write    the update board function as it works,    though it would be nice to have parts of    it be more recursive...    */    int check_for_win(char playerPiece)    {        /*slices the board and checks if playerPiece occupies that slot.        If the player makes a line, print that playerPiece has won        and exit the game.*/        if (board[0][0] == playerPiece && board[0][1] == playerPiece && board[0][2] == playerPiece){            std::cout << \nPlayer  << playerPiece <<  wins! << std::endl;            return true;        }        else if(board[1][0] == playerPiece && board[1][1] == playerPiece && board[1][2] == playerPiece){            std::cout << \nPlayer  << playerPiece <<  wins! << std::endl;            return true;        }        else if(board[2][0] == playerPiece && board[2][1] == playerPiece && board[2][2] == playerPiece){            std::cout << \nPlayer  << playerPiece <<  wins! << std::endl;            return true;        }        else if(board[0][0] == playerPiece && board[1][0] == playerPiece && board[2][0] == playerPiece){            std::cout << \nPlayer  << playerPiece <<  wins! << std::endl;            return true;        }        else if(board[0][1] == playerPiece && board[1][1] == playerPiece && board[2][1] == playerPiece){            std::cout << \nPlayer  << playerPiece <<  wins! << std::endl;            return true;        }        else if(board[0][2] == playerPiece && board[1][2] == playerPiece && board[2][2] == playerPiece){            std::cout << \nPlayer  << playerPiece <<  wins! << std::endl;            return true;        }        else if(board[0][0] == playerPiece && board[1][1] == playerPiece && board[2][2] == playerPiece){            std::cout << \nPlayer  << playerPiece <<  wins! << std::endl;            return true;        }        else if(board[0][2] == playerPiece && board[1][1] == playerPiece && board[2][0] == playerPiece){            std::cout << \nPlayer  << playerPiece <<  wins! << std::endl;            return true;        } else {            return false;        }    }};/*Wow, that was repetitive, just differentslices for the board...*/void run_game(){    char letter_o = 'O';    char letter_x = 'X';    tic_tac_toe ttt; //creates an object ttt to be used later    ttt.previousPlayerPiece = letter_x;    ttt.previousPlayer2Piece = letter_o;    std::cout << Welcome to tic tac toe! << std::endl;    std::cout << Here is a blank board:  << std::endl;    ttt.init_board();    while (true){        std::cout << \nPlayer one, it is your turn\n << std::endl;        ttt.update_board(letter_x);        if (ttt.check_for_win(letter_x) == true){            break;        }        std::cout << \nPlayer two, it is your turn\n << std::endl;        ttt.update_board(letter_o);        if (ttt.check_for_win(letter_o) == true){            break;        }    }}int main() //main kicks things off by calling run_game(){    run_game();    return 0;}
Making this Tic Tac Toe implementation more recursive
c++;recursion;tic tac toe
The most obvious improvement will come from the check_for_overlap function. You can replace your entire implementation with:int check_for_overlap(int pos1, int pos2, char playerPiece){    if (board[pos1-1][pos2-1] != '-'){        std::cout << \nOVERLAP DETECTED!!!!!! << std::endl;        return true;    }    return false;}The next thing I noticed was the difference between the user interface (1-based coordinates) and the internal representation (0-based coordinates). This is fine, but your implementation is a bit awkward in this area. You have lines like        x--;y--;print_board(previousPlayer2Piece, x, y);which is a pretty unusual style. An improvement would be:        print_board(previousPlayer2Piece, x-1, y-1);A better implementation might be to get the user input into different variables, such as userRow and userCol. So you would have (omitting your input validation and retry logic):int userRow, userCol;std::cin >> userRow;std::cin >> userCol;int x = userRow - 1;int y = userCol - 1;The == true check is redundant in a couple of places, since your functions already return bool. So instead of    if (check_for_overlap(x, y, previousPlayerPiece) == true){use    if (check_for_overlap(x, y, previousPlayerPiece)){In check_for_win, you can use loops to reduce the amount of code. For example:    for (int i = 0; i < 3; i++) {        if (board[i][0] == playerPiece && board[i][1] == playerPiece && board[i][2] == playerPiece){            std::cout << \nPlayer  << playerPiece <<  wins! << std::endl;            return true;        }    }You can use similar loops to check the column wins.