Массив памяти (стек). Определение переменной из данной памяти

using namespace std;
 
int main()
{
  unsigned char* pBuff = new unsigned char[ 512 ];
  size_t offset = 0;
  int* a = new( pBuff + offset ) int;
  offset += sizeof( int );
  double* b = new( pBuff + offset ) double;
  offset += sizeof( double );
  char* c = new( pBuff + offset ) char;
  offset += sizeof( char );
  *a = 12;
  *b = 0.25;
  *c = 'x';
  cout << "Values:\n";
  cout << *a << endl << *b << endl << *c << endl;
  cout << "Adresses:\n";
  cout << a << endl << b << endl << (void*)c << endl;
  cout << "Sizes:\n";
  cout << (unsigned)b - (unsigned)a << endl << (unsigned)c - (unsigned)b << endl;
  cout << "Available " << (unsigned)( pBuff + 511 ) - (unsigned)c << " bytes\n";
  delete[] pBuff;
  return 0;
}

#include <iostream>
using namespace std;
 
template< typename T >
T* allocate( unsigned char* pBuffer, size_t& offset )
{
  T* pRes = new( pBuffer + offset )T;
  offset += sizeof( T );
  return pRes;
}
 
int main()
{
  unsigned char* pBuff = new unsigned char[ 512 ];
  size_t offset = 0;
  int* a = allocate< int >( pBuff, offset );
  double* b = allocate< double >( pBuff, offset );
  char* c = allocate< char >( pBuff, offset );
  *a = 12;
  *b = 0.25;
  *c = 'x';
  cout << "Values:\n";
  cout << *a << endl << *b << endl << *c << endl;
  cout << "Adresses:\n";
  cout << a << endl << b << endl << (void*)c << endl;
  cout << "Sizes:\n";
  cout << (unsigned)b - (unsigned)a << endl << (unsigned)c - (unsigned)b << endl;
  cout << "Available " << (unsigned)( pBuff + 511 ) - (unsigned)c << " bytes\n";
  delete[] pBuff;
  return 0;
}

char a = 1;                           /// 01 00 00 00 b4 05
uint32_t b = 1;                    ///  01 00 00 00 16
uint64_t c = 3;                    /// 03 00 00 00 00 00 00 00 00 00 00 00 78 02 0
printf("%d %d,%d,a,b,c");

#include <iostream>
#include <memory>
#include <bitset>
#include <climits>
#include <cstdint>
 
template<std::size_t N>
struct MyAllocator
{
    static constexpr const std::size_t align_to = 2;
    char data[N]{}; // cleared for visual effect
    static_assert(N%align_to == 0);
    void* p;
    std::size_t sz;
    MyAllocator() : p(data), sz(N) {}
    template<typename T>
    T* aligned_alloc()
    {
        std::size_t a = (sizeof(T) % align_to);
        if (sz >= a + sizeof(T))
        {
            p   = (char*)p + a;
            sz -= a;
            T* result = reinterpret_cast<T*>(p);
            p = (char*)p + sizeof(T);
            sz -= sizeof(T);
            return result;
        }
        return nullptr;
    }
    std::string bin_dump(){
      std::string res;
      for(std::size_t i = 0; i != N; ++i){
         (res += std::bitset<CHAR_BIT>(*(data+i)).to_string()) += ' ';
      }
      return res; 
    }
};
 
int main()
{
    constexpr size_t N{12};
    MyAllocator<N> a;
    using BOOL  = bool;
    using WORD  = uint16_t;
    using DWORD = uint32_t;
    using FLOAT = float;
 
    std::cout << "allocated a.data at " << (void*)a.data
              << " (" << sizeof a.data << " bytes)\n";
 
    // allocate a char
    if (WORD* p = a.aligned_alloc<WORD>())
    {
        *p = 1;
        std::cout << "allocated a WORD at " << (void*)p << '\n';
        std::cout << *p << std::endl;
    }
 
    // allocate an int
    if (DWORD* p = a.aligned_alloc<DWORD>())
    {
        *p = 5;
        std::cout << "allocated an DWORD at " << (void*)p << '\n';
        std::cout << *p << std::endl;
    }
    // allocate an int, aligned at 32-byte boundary
    if (BOOL* p = a.aligned_alloc<BOOL>())
    {
        *p = true;
        std::cout << "allocated an BOOL at " << (void*)p << '\n';
        std::cout << *p << std::endl;
    }
    // allocate an int, aligned at 32-byte boundary
    if (FLOAT* p = a.aligned_alloc<FLOAT>())
    {
        *p = 1.1;
        std::cout << "allocated an FLOAT at " << (void*)p << '\n';
        std::cout << *p << std::endl;
    }
    
    std::cout << "\nDUMP : \n" << a.bin_dump() << std::endl;
}