Ошибка при кодировании моей собственной реализации realloc()

Вы предполагаете, что данные в чанке представляют собой правильно завершенную строку C, и используете my_strlen_unsigned() для вычисления старого размера. Вы не можете этого сделать, так как не можете знать, какие данные хранятся в чанке. Единственное реальное решение - также каким-то образом запомнить размер фрагмента и передать его в качестве параметра вашей функции.

Если вы не можете этого сделать, могут быть другие способы обойти проблему. Например, функция malloc_usable_size() — это расширение GNU, доступное в glibc (GNU libc), которое можно использовать для запроса размера существующего фрагмента, поэтому вы можете использовать его вместо своего my_strlen_unsigned(). Однако обратите внимание, что если вы используете динамическую компоновку (по умолчанию при компиляции), это сделает вашу программу непереносимой и будет работать только в системах, использующих glibc. В этом случае вы можете связать свою программу статически.

Предполагая, что другие функции в вашем коде (например, my_memcpy()) реализованы правильно, правильная реализация my_realloc() будет выглядеть следующим образом:

void *my_realloc(void *ptr, size_t size)
{
    void *new_ptr;
    size_t old_size;

    if (!ptr)
        return malloc(size);

    if (size == 0) {
        free(ptr);
        return NULL;
    }

    new_ptr  = ptr;
    old_size = malloc_usable_size(ptr);
    
    if (size != old_size) {
        new_ptr = malloc(size);
        if (!new_ptr)
            return NULL;

        my_memcpy(new_ptr, ptr, old_size < size ? old_size : size);
        free(ptr);
    }

    return new_ptr;
}

Неверное предположение:

void *my_realloc(void *ptr, size_t size)
{
    unsigned char *old_ptr = (unsigned char *)ptr;

Вы нарушаете спецификацию realloc() здесь. realloc() не предполагает, что ptr всегда будет указывать на строку. Он не зависит от типа.

И актерский состав лишний. Существует неявное преобразование из void * в любой другой тип указателя.

Неопределенное поведение:

old_size = my_strlen_unsigned(old_ptr) + 1;

Стандарт или ваша my_strlen_unsigned версия работает со строками, то есть предполагается, что указатель указывает на массив char, оканчивающийся нулевым байтом. Массив ints не будет заканчиваться нулевым байтом. Таким образом, ваш my_realloc() вызывает неопределенное поведение.

Возможное исправление:

Вы не можете определить старый размер блока, на который указывает ptr, и повторно реализовать realloc(), по крайней мере, не переопределив свои собственные malloc() и free(), переносимым образом. Но в качестве третьего аргумента можно взять старый размер. (Но стандарт realloc() принимает только два. Будет ли это соответствующей реализацией?)

Вот реализация glibc: malloc().c

Вот его реализация на C: malloc().c

А вот мой игрушечный пример, который в некоторой степени пытается подражать стандарту realloc():

/** 
*    @brief The my_realloc() function shall deallocate the old object pointed to
*           by ptr and return a pointer to a new object that has the size specified by new_size.
*
*    @param ptr - A pointer to a block of memory to resize.
*    @param old_size - The size of the block pointed to by ptr.
*    @param new_size - The size to resize by.
*
*    If ptr is a null pointer, my_realloc() shall be equivalent to
*    malloc() for the specified new_size.
*
*    If ptr does not match a pointer returned earlier by calloc(),
*    malloc(), or realloc() or if the space has previously been
*    deallocated by a call to free() or realloc(), the behavior is undefined.
*    
*    @return Upon successful completion, my_realloc() shall return a pointer to the moved allocated space.  
*            If size and ptr both evaluate to 0, my_realloc() shall return a 
*            NULL pointer with errno set to [EINVAL].
*            If there is not enough available memory, my_realloc() shall return a
*            NULL pointer and set errno to [ENOMEM].
*            
*            If my_realloc() returns a NULL pointer, the memory referenced by ptr shall not be changed.
*
*    @warning my_realloc() may return NULL to indicate an error. For that reason, a different pointer variable 
*             must be used to hold it's return value. Otherwise, you risk overwriting the original ptr with NULL and 
*             losing your only reference to the original block of memory.
*/ 
              
void *my_realloc (void *ptr, size_t new_size, size_t old size) 
{
    if (!ptr) {
        return malloc (new_size);
    }
    
    if (!new_size) {
        errno = EINVAL;
        return 0;
    }
    
    if (new_size <= old_size) {
        return ptr;
    }

   /* As a last resort, allocate a new chunk and copy to it. 
    */
    void *new = 0;
    if (new_size > old_size) {
        new = malloc (new_size);
        if (!new) {
            return 0;
        }
        memcpy (new, ptr, old_size);
        free (ptr);
    }
    return new;
}

Дополнительные примечания:

char *new_str = malloc(1);
new_str = my_realloc(..);

Вы рискуете потерять доступ к исходной памяти, выделенной через malloc() здесь. Если my_realloc() вернет NULL, new_str будет присвоен его результат, и вы вызовете утечку памяти в вашей программе.

Кроме того, память, возвращаемая malloc(), не инициализирована. И ваш код вызывает неопределенное поведение, вызывая my_strlen() под my_realloc() для неинициализированного указателя. Отсюда и предупреждения.