Почему malloc инициализирует значения в 0 в gcc?

ОС обычно очищает свежие страницы памяти, которые она отправляет в ваш процесс, поэтому она не может смотреть на данные более старого процесса. Это означает, что в первый раз, когда вы инициализируете переменную (или что-то malloc), она часто будет равна нулю, но если вы когда-либо повторно используете эту память (например, освобождая ее и malloc-ing снова), тогда все ставки выключены.

эта несогласованность именно поэтому неинициализированные переменные так трудно найти ошибку.

---

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

почему вы предполагаете, что malloc() инициализируются к нулю? Так уж получилось, что первый звонок malloc() приводит к вызову sbrk или mmap системные вызовы, которые выделяют страницу памяти из ОС. ОС обязана предоставлять память с нулевой инициализацией по соображениям безопасности (в противном случае данные из других процессов становятся видимыми!). Так что вы можете подумать там-ОС тратит время на обнуление страницы. Но нет! В Linux существует специальная общесистемная одноэлементная страница под названием ' zero page ' и эта страница будет отображаться как Copy-On-Write, что означает, что только когда вы действительно пишете на этой странице, ОС выделит другую страницу и инициализирует ее. Поэтому я надеюсь, что это ответ на ваш вопрос относительно производительности. Модель подкачки памяти позволяет использовать память как бы лениво, поддерживая возможность многократного отображения одной и той же страницы плюс способность обрабатывать случай, когда происходит первая запись.

если вы называете free() на glibc распределитель верните регион в его свободные списки, и когда malloc() вызывается снова, вы можете получить тот же регион, но грязный с предыдущими данными. В конце концов, free() может вернуть память в ОС, вызвав системные вызовы снова.

заметил, что glibcна странице on malloc() строго говорит, что память не очищается, поэтому по "контракту" на API вы не можете предположить, что она очищается. Вот оригинальный отрывок:

malloc() выделяет size байт и возвращает указатель на выделенную память.
Память не очищается. Если размер равен 0, то malloc () возвращает либо NULL, или уникальное значение указателя, которое позже может быть успешно передано в free ().

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

Я изменил ваш пример, чтобы содержать 2 одинаковых распределений. Теперь это легко увидеть malloc не ноль инициализирует память.

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

int main(void)
{
    {
      double *a = malloc(sizeof(double)*100);
      *a = 100;
      printf("%f\n", *a);
      free(a);
    }
    {
      double *a = malloc(sizeof(double)*100);
      printf("%f\n", *a);
      free(a);
    }

    return 0;
}

выход с gcc 4.3.4

100.000000
100.000000

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

ваш код не демонстрирует этого malloc инициализирует память до 0. Это может быть сделано операционной системой до запуска программы. Чтобы увидеть, что это так, напишите другое значение в память, освободите его и снова вызовите malloc. Вы, вероятно, получите тот же адрес, но вам придется проверить это. Если это так, вы можете посмотреть, что он содержит. Дайте нам знать!

от gnu.org:

очень большие блоки (намного больше страницы) выделяются с помощью mmap (anonymous или через /dev / zero) этой реализацией.

вы знаете, что он определенно инициализируется? Возможно ли, что зона, возвращаемый malloc() просто часто имеет 0 в начале?

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

если содержимое памяти является критическим, инициализируйте его самостоятельно.