Make an array that was initalised in main accessible to other functions

The simplest solution is to declare board (and base, assuming it will be used for something in the future) at file scope, often referred to as "global scope":

static int base = 0;
static char board[5][9] = { "  |  |  ", "--+--+--", "  |  |  ", "--+--+--", "  |  |  " };

void updateBoard(int a);

int main(void)
{
    int turn = 0;

    // ...

They are declared static, meaning that they will only be visible to code within this file, and cannot be accessed from other files of the same program.
I have removed the #define's. The keywords public and private do not exist in C; they are generally only used in languages which support object-oriented (or class-based) programming. The keyword static does exist, but has a different meaning depending on the context. It is best not re-defined.
Note that the second dimension should be 9: 8 characters and 1 null-terminator.

The downside of having variables at file scope is that they are visible in the entire file, and with multiple functions modifying their contents it can become difficult to oversee and reason about the behavior of the program.

Perhaps the best solution is to keep board and base declared in main, and to pass them to updateBoard. Although this immediately introduces some more advanced C-concepts. Adding the necessary additional arguments/parameters to the function prototype and function call is probably familiar to you. The problem is that array arguments convert to pointers (see here, often called "array-to-pointer decay"). This means that sizeof no longer provides the size of the entire array, but the size of the pointer to the first element of the array. In the solution below, this is resolved by obtaining the dimensions once in main, storing these in variables and passing these values to the function. This is, arguably, a better solution than using the sizeof calculation everywhere. And once the variables are set, this will work with dynamically allocated arrays as well.

// Forward declaring the function, so main knows it exists
void updateBoard(char board[5][9], size_t nRows, size_t nCols, int base, int a);

int main(void)
{
    int base = 0;

    // Note the 9 for the second dimension
    char board[5][9] = { "  |  |  ", "--+--+--", "  |  |  ", "--+--+--", "  |  |  " };
    int turn = 0;

    // Initializing the variables for the dimensions...
    size_t nRows = sizeof(board) / sizeof(board[0]);
    size_t nCols = sizeof(board[0]) / sizeof(board[0][0]);

    // ...which we can now use here as well...
    for (size_t row = 0; row < nRows; row++) {
        for (size_t col = 0; col < nCols; col++)
            printf("%c", board[row][col]);
        printf("\n");
    }
    printf("Player1's turn\n ");
    fflush(stdout);
    scanf("%i", &turn);

    // ... and here, along with passing board and base.
    updateBoard(board, nRows, nCols, base, turn);
}

void updateBoard(char board[5][9], size_t nRows, size_t nCols, int base, int a){
    switch (a) {
        // ... code omitted for brevity ...
    }

    // Use the passed dimension values here
    for (size_t row = 0; row < nRows; row++) {
        for (size_t col = 0; col < nCols; col++)
            printf("%c", board[row][col]);
        printf("\n");
    }
    base = 1;
}

With passing variables like this, there is an important distinction between passing variables by reference and passing them by value. Perhaps this is a good next topic to look into on your C journey, along with static and "string literal"/"null-terminator".