Разница между {0} и calloc?

Question

Как this answer on another question обложки, используя агрегатную инициализацию

struct foo { 
    size_t a; 
    size_t b; 
}; 

struct foo bar = {0}; 

результаты в встроенных типов инициализируются в ноль.

Есть ли разница между использованием выше и с использованием

struct foo * bar2 = calloc(1, sizeof(struct foo)); 

оставляя в стороне тот факт, что одна переменная является указателем.
Глядя на отладчик, мы можем видеть, что оба значения a и b действительно равны нулю для обоих приведенных выше примеров.

В чем разница между двумя приведенными выше примерами, есть ли какие-либо проблемы или скрытые проблемы?

Answer 1

Да, есть существенная разница (помимо хранения класса вашего объекта типа struct foo):

struct foo bar = {0}; 
struct foo * bar2 = calloc(1, sizeof *bar2); 

Каждый член bar равен нулю инициализирован (и заполнение обнуляется для суб- объект без инициализатора, или если bar имеет static или thread_local хранения класса),
в то время как все *bar2 обнуляется, которые могут иметь совершенно разные результаты:

Нейт er null-pointers (T*)0, а числа с плавающей запятой со значением 0 гарантируют, что будут все-бит-0.
(На самом деле, только для char, unsigned char и signed char (а также некоторые из дополнительных точных-размера-типов из <stdint.h>) гарантируется, что все-бит-0 соответствует значению-0 до некоторого времени после C99. Позже технический исправления гарантировали его для всех интегральных типов.)

Формат с плавающей запятой может быть не IEEE754.

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

Cite от c-faq (Спасибо Jim Балтер for linking it):

Серия Prime 50 используется сегмент 07777, смещение 0 для нулевой указатель, по крайней мере, для PL/I.

Answer 2

calloc дает вам кучу dynamically allocated нулевую зону памяти (в ваш bar2). Но автоматическая переменная (например, bar, при условии, что ее объявление находится внутри функции) назначается на call stack. См. Также calloc(3)

В C вам необходимо явно указать free выделенную памятью. Но данные, выделенные стекем, выворачиваются, когда возвращается функция.

Rerad также wikipage на C dynamic memory allocation, а также на garbage collection. Reference counting - широко используемый метод в C и C++, и его можно рассматривать как форму GC. Подумайте о circular references, с ними сложно справиться.

Boehm conservative GC может использоваться в программах на C.

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

При кодировании функции, возвращающей указатель на кучу (т. Е. Некоторый указатель на динамическое хранилище), вы должны документировать этот факт и решать, кто его освобождает.

Об инициализации: calloc указатель обнуляется (когда calloc успешно). Автоматическая переменная, инициализированная как {0}, также обнуляется. На практике некоторые реализации могут calloc по-разному большие объекты (путем запроса целых нулевых страниц из ядра для них, например, с mmap(2)) и небольших объектов (путем повторного использования, если доступно, ранее free-d зоны и обнуления). нулевая зона использует быстрый эквивалент memset(3)

^{PS. Я игнорирую странные машины, на которых вся нулевая бит-зона памяти не является очищенными данными для стандарта C, то есть {0}. Я не знаю таких машин на практике, даже если я знаю, что они в принципе возможны (и теоретически указатель NULL может не быть полностью нулевым битом)}

BTW, компилятор может оптимизировать все -zero локальная структура (и, возможно, не выделяет ее вообще в стеке, поскольку она будет вписываться в регистры).

Answer 3

struct foo bar = {0}; 

Это определяет объект типа struct foo имени bar, и инициализирует его к нулю.

«Нуль» определяется рекурсивно. Все целые субобъекты инициализируются на 0, все подобъекты с плавающей запятой на 0.0 и все указатели на NULL.

struct foo * bar2 = calloc(1, sizeof(struct foo)); 

ИМХО это лучше (но то же самое), как написано:

struct foo *bar2 = calloc(1, sizeof *bar2); 

К не повторяя имя типа, мы избегаем риск несоответствия при изменении кода в дальнейшем.

Это динамически выделяет объект типа struct foo (в куче), инициализирует этот объект для всех бит-ноль и инициализирует bar2, чтобы указать на него.

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

И весь-бит-ноль не гарантированно быть таким же, как «нулевым ». Для целых типов (включая size_t), это почти гарантировано.Для типов с плавающей запятой и указателями для 0.0 или NULL вполне допустимо иметь внутреннее представление, отличное от всех бит-ноль. Вы вряд ли столкнетесь с этим, и поскольку все члены вашей структуры целы, вам, вероятно, не нужно беспокоиться об этом.

Answer 4

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

Что касается инициализации, то у компилятора есть возможности для оптимизации с автоматическими переменными (например, если не очистить, если это необходимо); это невозможно с вызовом calloc.

Если вам нравится стиль calloc, у вас также есть возможность выполнить memset в автоматической переменной.

memset(&bar, 0, sizeof bar); 

ОБНОВЛЕНИЕ: выделение автоматических переменных выполняется квазикомандой во время компиляции.

Answer 5

(Этот ответ фокусируется на различиях в инициализации, в случае struct содержащих только целочисленных типов)

Обе формы установить a и b в 0. Это связано с тем, что Стандарт определяет, что для каждого целочисленного типа все бит-ноль должен представлять значение 0.

Если есть прокладка структуры, тогда версия calloc устанавливает это, но нулевая инициализация может и не быть. Например:

struct foo a = { 0 }, b = { 0 }; 
struct foo c, d; memset(&c, 0, sizeof c); memset(&d, 0, sizeof d); 

if (memcmp(&a, &b, sizeof a)) 
    printf("This line may appear.\n"); 

if (memcmp(&c, &d, sizeof c)) 
    printf("This line must not appear.\n"); 

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

Программист не хотел сравнивать элементы структуры индивидуально, поскольку это слишком большой размер кода, поэтому вместо этого он будет копировать структуры с использованием memcpy, инициализировать их с помощью memset; чтобы сохранить возможность использовать memcmp для проверки равенства.

---

В современном программировании я настоятельно рекомендую не делать этого; и всегда использовать форму инициализации { 0 }. Другое преимущество последнего заключается в том, что нет возможности ошибиться с аргументом размера и случайно установить слишком много памяти или слишком мало памяти.