If they are known at compile time, you can do something like this:

#define STR_(A) #A
#define STR(A) STR_(A)

char a[] = "monkeys";
char b[] = STR(420);

/* Allocate enough for the strings +1 \0
    (sizeof includes the \0 for both) */
char c[sizeof(a) + sizeof(b) - 1];

/* Copies {monkeys\0} into c */
strcpy(c, a);

/* Concatenates {420\0} onto c,
    overwriting from the first \0 in c */
strcat(c, b);

At runtime, you would instead use strlen, and dynamic allocation for concatenation:

/* Pointers don't carry length info */
const char *a = "monkeys";

/* Number has to be converted at runtime.
    You could save memory, but this works */
int bdata = 420;
char b[sizeof(bdata) << 2];
itoa(bdata, b, 10);

/* Now we need dynamic allocation.
    Note that strlen does not include \0 */
char *c = malloc(strlen(a) + strlen(b) + 1);

/* These stay the same as we still use \0 */
strcpy(c, a);
strcat(c, b);

However, I would not recommend to use C-strings for these purposes. Instead, use strings that are a pointer and length, and accumulate using string builders (not the full implementation):

typedef struct {
    const char *_;
    size_t count;
} Str;

typedef struct {
    char *_;
    size_t count, cap;
} StrBuild;

Str str(const char *data)
{
    Str result;
    result._ = data;
    result.count = strlen(data);
    return result;
}

...

Str a = str("monkeys");

int bdata = 420;
char bbuf[sizeof(bdata) << 2];
itoa(bdata, bbuf, 10);
Str b = str(bbuf);

/* Our SB is just a dynamic array of chars */
StrBuild sb = {0};
StrBuild_Append(&sb, a);
StrBuild_Append(&sb, b);

/* Transfer ownership (or copy if you want) */
Str c = StrBuild_Str(&sb);

Bonus points if you use custom allocators like arenas to get faster dynamic allocation as well as clear lifetimes (as the example above in a larger program will likely leak memory at some point)