I just got into C++ a few days ago and decided to make a MiniMax based TicTacToe game, I don't really know much about the conventions and best uses of the C++ language so I'd really appreciate any kind of feedback.

Brief summary:

Board: has all the information pertinent to the game. Is used by the main method to paint the window and by the Brain to decide which move to make.

Brain: Container for the MiniMax algorithm with helper methods. The Board is passed as a pointer to the Brain during construction (I don't know how wise this is but it's how I did things in Java).

Main: mainly contains functions to draw the board and get inputs from the user.
Spacebar clears the board, F1 asks for a move, click performs a move.

Don't use raw pointers, make ownership semantics clear

Your Brain class uses a raw pointer to reference a current Board it is supposed to work with. Raw pointers leave us unclear about their ownership and who's responsible for the memory management.

You should rather use a smart pointer like std::unique_ptr<Board> (indicates ownership is transferred to the Brain class), std::shared_ptr<Brain> (indicates ownership is shared) or std::weak_ptr<Brain> (indicates Brain doesn't own that reference). I'll give a sample using std::shared_ptr:

Don't pass complex objects by value

Modern compilers may elide copies for these parameters, though semantics will be more clear and prevent you from accidentally changing those parameters inside the function.

Use const correctness

Since the min() or max() functions never change the state of the Brain class, these should be declared as const member functions:

int min(std::vector<int> v) const;
int max(std::vector<int> v) const;

In fact those functions don't even rely on any state stored in Brain, thus these shouldn't be class members at all but free functions. Best choice would be to use the already existing std::min_element() and std::max_element() functions from the standard library instead.

Prefer operator[] over at() to access container elements by index

The std::vector<T>::at() function introduces bounds checking and will throw an exception if the requested index is out of bounds.

That's nice for debugging purposes with unchecked size beforehand.

For performance reasons you should prefer to do size checks beforehand and use the operator[] overload of the container class at all.