Инициализация до нуля после malloc или вызова calloc

Question

У меня небольшая путаница в использовании calloc вместо malloc. Я помню где-то, что я прочитал, что calloc медленнее, чем malloc, потому что calloc выполняет инициализацию на ноль после выполнения выделения памяти.

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

str* strptr = (str*)malloc(sizeof(str));
memset(strptr,0,sizeof(str));

Здесь str является структурой.

Это похоже на

str* strptr =(str*)calloc(1,sizeof(str));

Я хочу знать, имеет ли использование malloc над calloc какие-либо преимущества и какой метод предпочтительнее.

Answer 1

Я хочу знать, имеет ли использование malloc над calloc какие-либо преимущества

Различия между ними просто

• calloc также принимает количество объектов в отличие от malloc который принимает только количество байтов
• calloc нули памяти; malloc оставляет память неинициализированной

Так что никаких исключительных преимуществ нет, кроме нуля.

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

Почему бы не использовать malloc как он используется в кодовой базе вы смотрите? Избежать дублирования работы и кода; когда API уже делает это, зачем изобретать велосипед? Вы могли видеть кодовые базы с утилитой, которая делает именно это: выделяет и обнуляет память. Это показывает, что фрагмент будет использоваться много раз, и, следовательно, они заключают его в макрос / функцию для вызова из разных мест. Однако зачем это делать, когда calloc уже это делает?

Лучший код - это вообще не код. Чем меньше код, тем лучше, и поэтому вы должны предпочесть calloc над malloc Вот. Может быть, оптимизатор будет делать то же самое под ним, но зачем рисковать? По-видимому, оптимизатор может быть не таким умным, что является причиной этого вопроса: почему malloc + memset медленнее, чем calloc?

Так же calloc Маршрут требует меньших нажатий клавиш.

Answer 2

calloc выравнивает объекты на "подходящей границе", а malloc - нет. Например, если у вас есть

typedef struct {
    char cc[2];
} t_test myVar;
myVar= calloc(32, sizeof(t_test));

он выделит 32 элемента по 4 байта каждый (32-битный компьютер), поэтому каждый элемент t_test "соответствующим образом выровнен". С malloc:

myVar= malloc(32*sizeof(t_test));

такого выравнивания быть не могло. (Могут быть другие причины для выравнивания или не выравнивания компилятором; это только пример.) Выравнивание может ускорить программу / машину / память, так как он может просто извлекать слова и не должен принимать выравнивание в учетную запись.

Примечание: посмотрите на предметы, перечисленные справа, с подробным обсуждением malloc против calloc. На самом деле никто не упоминает мой аргумент как важный аспект.