Использование memcpy для перемещения заголовков блоков в начало блоков в хранилище без памяти - возможно ли это?

Question

В настоящее время я изучаю динамическое выделение памяти и пытаюсь кодировать свой собственный распределитель динамической памяти, используя язык C.

Я изучал с оригинальной книгой K & R, и их неограниченный динамический распределительочень интересно, с одним исключением: я не могу найти способ получить заголовки блоков в свободной памяти хранилища, выделенной с помощью sbrk ().Вместо размещения заголовка объединения в хранилище через версию K & R, можно ли будет использовать memcpy, чтобы вручную скопировать заголовок объединения в конец + 1 предыдущего блока и указать на него через prevblock-> next?

Вот пример реализации malloc в K & R:

static Header base; /* empty list to get started */
static Header *freep = NULL; /* ptr to last block used */

/* malloc: general-purpose storage allocator */
void *malloc(unsigned nbytes)
{
   Header *p, *prevp;
   Header *morecore(unsigned);
   unsigned nunits;

   nunits = (nbytes+sizeof(Header)-1)/sizeof(header) + 1;

   if ((prevp = freep) == NULL) { /* no free list yet */
      base.s.ptr = freeptr = prevptr = &base;
      base.s.size = 0;
   }

   for (p = prevp->s.ptr; ; prevp = p, p = p->s.ptr) {
      if (p->s.size >= nunits) { /* big enough */
        if (p->s.size == nunits) /* exactly */
           prevp->s.ptr = p->s.ptr;
        else { /* allocate tail end */
           p->s.size -= nunits;
           p += p->s.size;
           p->s.size = nunits
             }
        freep = prevp;
        return (void *)(p+1);
      }

      if (p == freep) /* wrapped around free list */
         if ((p = morecore(nunits)) == NULL)
             return NULL; /* none left */
      }
}

#define NALLOC 1024 /* minimum #units to request */
/* morecore: ask system for more memory */
static Header *morecore(unsigned nu)
{

  char *cp, *sbrk(int);
  Header *up;

  if (nu < NALLOC)
    nu = NALLOC;

  cp = sbrk(nu * sizeof(Header));

  if (cp == (char *) -1) /* no space at all */
    return NULL;

  up = (Header *) cp;
  up->s.size = nu;
  free((void *)(up+1));

  return freep;
}

/* free: put block ap in free list */
void free(void *ap) {
  Header *bp, *p;
  bp = (Header *)ap - 1; /* point to block header */
  for (p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
    if (p >= p->s.ptr && (bp > p || bp < p->s.ptr))
      break; /* freed block at start or end of arena */
  if (bp + bp->size == p->s.ptr) {
    bp->s.size += p->s.ptr->s.size;
    bp->s.ptr = p->s.ptr->s.ptr;
  } else
      bp->s.ptr = p->s.ptr;

  if (p + p->size == bp) {
    p->s.size += bp->s.size;
    p->s.ptr = bp->s.ptr;
  } else
    p->s.ptr = bp;
  freep = p;
}

Я понимаю, что функция free фактически помещает новые блоки в свободное хранилище, и что этого можно достичь таким образом,Однако вместо использования free для помещения новых блоков (новых блоков headers ) в свободное хранилище в нужных местах, возможно ли реализовать эту возможность в самом malloc через memcpy?Создание заголовка в malloc, использование memcpy для копирования заголовка в конец + 1 последнего блока или туда, куда умещается блок, а затем освобождение исходного заголовка?