Лучше ли инициализировать переменную с помощью malloc?

Question

Если у меня есть указатель на функцию, и я знаю, какой размер это, было бы лучше использовать malloc при инициализации указателя? Например, , если у меня есть функция, было бы лучше сделать это

int * func(int size){ 
    int * ptr = (int *) malloc(size); 
    //some code 
    return ptr; 
} 

или это

int * func(int size){ 
    int * ptr; 
    ptr = (int *) malloc(size); 
    //some code 
    return ptr; 
} 

Answer 1

Они в основном то же самое. Я хочу просто дать вам совет, всегда инициализировать указатель с помощью NULL (вы не во втором фрагменте). Кроме того, не забудьте освободить() память для динамически назначенной переменной внутри функции.

Answer 2

«Насколько это более эффективно?»

Небольшая или незначительная разница в эффективности во время работы. @Jens Gustedt

Лучше ли инициализировать переменную с помощью malloc?

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

int *func(int size) { 
    int *ptr = malloc(size); 
    //some code 
    return ptr; 
} 

Пока неясно, если size относится к числу элементов в массиве int или предполагаемого размера одного int. Рекомендовать:

int *func(size_t array_n) { 
    int *ptr = malloc(sizeof *ptr * array_n); 
    //some code 
    return ptr; 
} 

Answer 3

Первая форма лучше в том смысле, что ваш код более безопасен; вы знаете, что ptr будет либо содержать действительное значение адреса, либо NULL перед его первым использованием.

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

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

Вы должны всегда инициализировать переменные-указатели на время объявления и ИМО следует отложить их заявление пока вы на самом деле необходимость им.IOW, вместо того, чтобы писать что-то вроде этого:

void foo(void) 
{ 
    int *ptr = NULL; 
    /** 
    * several dozen lines of code 
    */ 
    ptr = malloc(sizeof *ptr * number_of_elements); 
    /** 
    * do stuff with ptr 
    */ 
} 

это лучше написать так:

void foo(void) 
{ 
    /** 
    * several dozen lines of code 
    */ 
    int *ptr = malloc(sizeof *ptr * number_of_elements); 
    /** 
    * do stuff with ptr 
    */ 
} 

Конечно, это возможно только с C99 на; если вы используете компилятор C89 или более ранний, все объявления должны перед любыми исполняемыми операциями в блоке.

Обычные нит:

• Не отвергни результат malloc; с C89 это не нужно, и в C89 компиляторы могут маскировать ошибку. Это все еще требуется для C++, но если вы пишете C++, вы все равно не должны использовать malloc. Если вы пишете код, который должен быть создан как C и C++, скройте свой код выделения памяти за интерфейсом и реализуйте его по-разному для каждого. Я не шучу.
• Использование sizeof *ptr вместо sizeof (type) в malloc вызова, такие как

  int *ptr = malloc(sizeof *ptr * number_of_elements);

  Это уменьшит головную боль технического обслуживания, если вы когда-либо изменить тип ptr (скажем, от int * к unsigned * или long *).