Определить размер динамически выделяемой памяти в C

Список часто задаваемых вопросов comp.lang.c · Вопрос 7.27 -

В. Итак, могу ли я запросить пакет malloc, чтобы узнать, насколько велик выделенный блок?

A. К сожалению, стандартного или портативного способа не существует. (Некоторые компиляторы предоставляют нестандартные расширения.) Если вам нужно знать, вам придется следить за этим самостоятельно. (См. Также вопрос 7.28.)

Стандартного способа найти эту информацию не существует. Однако в некоторых реализациях для этого есть такие функции, как msize. Например:

• _msize в Windows
• malloc_size в MacOS
• malloc_usable_size в системах с glibc

Однако имейте в виду, что этот malloc будет выделять минимум запрошенного размера, поэтому вам следует проверить, действительно ли вариант msize для вашей реализации возвращает размер объекта или память, фактически выделенную в куче.

Менталитет C заключается в том, чтобы предоставить программисту инструменты, помогающие ему в работе, а не предоставлять абстракции, которые меняют характер его работы. C также пытается избежать упрощения / безопасности, если это происходит за счет ограничения производительности.

Некоторые вещи, которые вы могли бы сделать с областью памяти, требуют только местоположения начала области. Такие вещи включают в себя работу со строками с завершающим нулем, манипулирование первыми n байтами области (если известно, что область по крайней мере такая большая) и т. Д.

По сути, отслеживание длины региона - это дополнительная работа, и если бы C делал это автоматически, он иногда делал бы это без надобности.

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

Да, реализации malloc () обычно отслеживают размер области, но они могут делать это косвенно, или округлять до некоторого значения, или не сохранять его вообще. Даже если они это поддерживают, определение размера таким способом может быть медленным по сравнению с отслеживанием его самостоятельно.

Если вам нужна структура данных, которая знает, насколько велика каждая область, C может сделать это за вас. Просто используйте структуру, которая отслеживает размер региона, а также указатель на него.

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

Украдено с: https://stackoverflow.com/a/35326444/638848

Вы также можете реализовать оболочку для malloc и бесплатно добавлять теги (например, выделенный размер и другую метаинформацию) перед указателем, возвращаемым malloc. Фактически, это метод, которым компилятор C ++ помечает объекты ссылками на виртуальные классы. Вот один рабочий пример:

#include <stdlib.h>
#include <stdio.h>

void * my_malloc(size_t s) 
{
  size_t * ret = malloc(sizeof(size_t) + s);
  *ret = s;
  return &ret[1];
}

void my_free(void * ptr) 
{
  free( (size_t*)ptr - 1);
}

size_t allocated_size(void * ptr) 
{
  return ((size_t*)ptr)[-1];
}

int main(int argc, const char ** argv) {
  int * array = my_malloc(sizeof(int) * 3);
  printf("%u\n", allocated_size(array));
  my_free(array);
  return 0;
}

Преимущество этого метода перед структурой с размером и указателем

 struct pointer
 {
   size_t size;
   void *p;
 };

в том, что вам нужно только заменить malloc и бесплатные звонки. Все остальные операции с указателями не требуют рефакторинга.

Нет, библиотека времени выполнения C не предоставляет такой функции.

Некоторые библиотеки могут предоставлять специфичные для платформы или компилятора функции, которые могут получать эту информацию, но обычно способ отслеживать эту информацию находится в другой целочисленной переменной.

Все, кто говорит вам, что это невозможно, технически правильны (лучший вариант правильного).

По техническим причинам полагаться на подсистему malloc для точного определения размера выделенного блока - плохая идея. Чтобы убедиться в этом, представьте, что вы пишете большое приложение с несколькими разными распределителями памяти - возможно, вы используете необработанную libc malloc в одной части, но C ++ operator new в другой части, а затем какую-то конкретную Windows API в еще одной части. Итак, у вас есть все виды void* летающих. Написать функцию, которая может работать с любыми из этих void*, невозможно, если вы не сможете каким-то образом определить по значению указателя, из какой из ваших куч он пришел.

Таким образом, вы можете заключить каждый указатель в своей программе с некоторым соглашением, которое указывает, откуда он появился (и куда его нужно вернуть). Например, в C ++ мы называем это std::unique_ptr<void> (для указателей, которые должны быть operator delete'd) или std::unique_ptr<void, D> (для указателей, которые необходимо вернуть через какой-либо другой механизм D). Вы могли бы сделать то же самое в C, если бы захотели. И как только вы заключите указатели в более крупные и безопасные объекты в любом случае, это всего лишь небольшой шаг до struct SizedPtr { void *ptr; size_t size; }, и тогда вам больше не придется беспокоиться о размере выделения.

Однако.

Есть также веские причины, по которым вы можете законно захотеть узнать фактический базовый размер выделения. Например, возможно, вы пишете инструмент профилирования для своего приложения, который будет сообщать фактический объем памяти, используемый каждой подсистемой, а не только объем памяти, который подумал программист Он пользовался. Если каждое из ваших 10-байтовых распределений тайно использует 16 байтов под капотом, это полезно знать! (Конечно, будут и другие накладные расходы, которые вы не измеряете таким образом. Но есть и другие инструменты для этой работы.) Или, может быть, вы просто исследуете поведение realloc на ваша платформа. Или, может быть, вы хотите «округлить» емкость растущего выделения, чтобы избежать преждевременного перераспределения в будущем. Пример:

SizedPtr round_up(void *p) {
    size_t sz = portable_ish_malloced_size(p);
    void *q = realloc(p, sz);  // for sanitizer-cleanliness
    assert(q != NULL && portable_ish_malloced_size(q) == sz);
    return (SizedPtr){q, sz};
}
bool reserve(VectorOfChar *v, size_t newcap) {
    if (v->sizedptr.size >= newcap) return true;
    char *newdata = realloc(v->sizedptr.ptr, newcap);
    if (newdata == NULL) return false;
    v->sizedptr = round_up(newdata);
    return true;
}

#if defined(__linux__)
// https://linux.die.net/man/3/malloc_usable_size
#include <malloc.h>
size_t portable_ish_malloced_size(const void *p) {
    return malloc_usable_size((void*)p);
}
#elif defined(__APPLE__)
// https://www.unix.com/man-page/osx/3/malloc_size/
#include <malloc/malloc.h>
size_t portable_ish_malloced_size(const void *p) {
    return malloc_size(p);
}
#elif defined(_WIN32)
// https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/msize
#include <malloc.h>
size_t portable_ish_malloced_size(const void *p) {
    return _msize((void *)p);
}
#else
#error "oops, I don't know this system"
#endif

#include <stdio.h>
#include <stdlib.h>  // for malloc itself

int main() {
    void *p = malloc(42);
    size_t true_length = portable_ish_malloced_size(p);
    printf("%zu\n", true_length);
}