typedef struct
{
 ...
} MyStruct;

typedef struct
{
  const char* begin;
  const char* end;
  const char* tail;
} Buffer;

MyStruct* Create_MyStruct(Buffer* pBuffer)
{
  if ( NULL == pBuffer )
    return NULL;

  if ( pBuffer->end < pBuffer->tail + sizeof(MyStruct) )
    return NULL;

  MyStruct* pNewObj = (MyStruct*)pBuffer->tail;
  pBuffer->tail += sizeof(MyStruct);  // _Alignof(MyStruct) ?

  return pNewObj;
}

#define align(x,n) ((char*)(x)+(-(int)(char*)(x)&(n-1)))

uintptr_t uiTail = (uintptr_t)(pBuffer->tail);
uiTail = (uiTail + (_Alignof(MyStruct) - 1)) / _Alignof(MyStruct) * _Alignof(MyStruct); // тут педанты могут ещё проверить на переполнение
char* tail = (сhar*)uiTail; // теперь дальше нужно использовать этот tail вместо (pBuffer->tail)

if ( pBuffer->end < tail + sizeof(MyStruct) ) // тут формально тоже может быть переполнение, на которое можно проверить
    return NULL;


MyStruct* pNewObj = (MyStruct*)tail;

pBuffer->tail = (char*)(pNewObj + 1);

MyStruct* Create_JsnToken(Buffer* pBuffer)
{
  if ( NULL == pBuffer )
    return NULL;

  const int nPadding = (pBuffer->tail - (char*)NULL) % _Alignof(MyStruct);

  if ( pBuffer->end < pBuffer->tail + nPadding + sizeof(MyStruct) )
    return NULL;

  pBuffer->tail += nPadding;

  MyStruct* pNewObj = (MyStruct*)pBuffer->tail;
  pBuffer->tail += sizeof(MyStruct);  

  return pNewObj;
}

W>uintptr_t uiTail = (uintptr_t)(pBuffer->tail);

W>uiTail = (uiTail + (_Alignof(MyStruct) - 1)) % _Alignof(MyStruct); // тут педанты могут ещё проверить на переполнение
// ] uiTail == 20 and _Alignof(MyStruct) == 4 then uiTail == 3 ?

W>char* tail = (сhar*)uiTail; // теперь дальше нужно использовать этот tail вместо (pBuffer->tail)
// char* tail = pBuffer->tail + (сhar*)uiTail; ?

W>if ( pBuffer->end < tail + sizeof(MyStruct) ) // тут формально тоже может быть переполнение, на которое можно проверить
W>    return NULL;

W>MyStruct* pNewObj = (MyStruct*)tail;

W>pBuffer->tail = (char*)(pNewObj + 1); // +1 ? Чего-то я не понимаю... 
W>

W>Занимательно, что функция выделения памяти хранить указатели на const, а выдаёт наружу указатели без const. Интересно, из каких соображений этот const в Buffer появился?

_>>А так можете вручную выравнивать если память линейная

_>>#define align(x,n) ((char*)(x)+(-(int)(char*)(x)&(n-1)))
_>>

   struct A { ... };
   enum { sizeof_A4=(sizeof(struct A)+3)&~3 };
   enum { sizeof_A8=(sizeof(struct A)+7)&~7 };
   enum { sizeof_A16=(sizeof(struct A)+15)&~15 };
   ...
   char *x=0; int dx=123, dxa=dx, a=8;
   x+=dx;
   x=x+(-(int)x&(a-1))); // выравниваем на 8
   x=align(x,a);         // тоже самое - выравниваем на 8
   dxa=(dxa+a-1)&(a-1);  // выравниваем размер на 8
   x+=dxa;               // выравнивание сохраняется

over 90% of all overflow is a bug, and defining wrapping behavior would not have solved the bug.