Basic TicTacToe implementation in C++
This is not at all a bad effort for someone new to the C++ language.  Here are some things that may help you improve your program.
Use the required #includes
The code uses std::fill which means that it should #include &lt;algorithm&gt;.  It was not difficult to infer, but it helps reviewers if the code is complete.
Eliminate global variables where practical
The code declares and uses a global variable, board.  Global variables obfuscate the actual dependencies within code and make maintainance and understanding of the code that much more difficult.  It also makes the code harder to reuse.  For all of these reasons, it's generally far preferable to eliminate global variables and to instead pass pointers to them.  That way the linkage is explicit and may be altered more easily if needed.  One could create the board within main and then pass a pointer or reference to it to the other routines that need it, or better yet, see the next suggestion.
Use a C++ object
Rather than using the global variable board and then having separate functions that manipulate that variable such as drawBoard() and placeMarker() in an object-oriented language such as C++ we can gather these together into an object.  That might look something like this:
class Board {
public:
    Board();
    void drawBoard();
    void placeMarker(bool isPlayerOne, int row, int col);
    bool checkValidInput(int row, int col);
    bool checkWon(int row, int col);
    static constexpr char PLAYER_ONE_MARKER = 'X';
    static constexpr char PLAYER_TWO_MARKER = 'O';
    static constexpr char UNFILLED_MARKER = ' ';
    static constexpr size_t numrows = 3;
    static constexpr size_t numcols = 3;
    static constexpr unsigned max_turns = numrows * numcols;
private:
    char board[3][3];
};

Eliminate &quot;magic numbers&quot;
There are a few numbers in the code, such as 3 and 2 that have a specific meaning in their particular context.  By using named constants such as numrows or numcols, the program becomes easier to read and maintain.
Don't use std::endl if you don't really need it
The difference betweeen std::endl and '\n' is that '\n' just emits a newline character, while std::endl actually flushes the stream.  This can be time-consuming in a program with a lot of I/O and is rarely actually needed.  It's best to only use std::endl when you have some good reason to flush the stream and it's not very often needed for simple programs such as this one.  Avoiding the habit of using std::endl when '\n' will do will pay dividends in the future as you write more complex programs with more I/O and where performance needs to be maximized.
Consider using a standard container
There is little reason in modern C++ to use a plain array rather than a standard container such as std::array.  I'd suggest that board could be this instead:
std::array&lt;char,max_turns&gt; board;

The initialization would then be much more easily written:
std::fill(board.begin(), board.end(), UNFILLED_MARKER);

Note that this form would require the conversion of row,column coordinates but if this is placed in an object, that detail can easily be isolated to within the object.
Don't use ALL_CAPS for constants
The use ALL_CAPS for constants defined as macros has been common practice for decades.  To avoid misleading readers of your program, non-macro constants should not be ALL_CAPS.  See ES.9 for details.