Почему вы указываете размер при использовании malloc в C?

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

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

По таким вопросам, как этот, полезной ссылкой на проконсультируйтесь. См. 7.3b.

По теме (юмористической) см. Также список bloopers от ART.

C любезно позвольте вам выстрелить себе в голову. Вы только что использовали случайную память в куче. С непредвиденными последствиями.

Отказ от ответственности: мое последнее настоящее программирование на C было выполнено около 15 лет назад.

Приведу аналогию, почему это «работает».

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

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

Когда закончите, вы делаете шаг назад и смотрите на свой рисунок, и он выглядит хорошо, именно так, как вы хотели, и именно так, как вы его нарисовали.

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

Теперь отсутствует часть рисунка. Фрагмент, который вы нарисовали на бумаге другого человека.

Вдобавок у этого человека теперь есть кусочки вашего рисунка на бумаге, и он, вероятно, возится с тем, что хотел вместо этого на бумаге.

Таким образом, хотя может показаться, что использование памяти работает, это происходит только потому, что ваша программа завершается. Оставьте такую ​​ошибку в программе, которая работает на некоторое время, и я могу гарантировать вам, что вы получите странные результаты, сбои и тому подобное.

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

Тебе (не) повезло. Доступ к p [3] не определен, поскольку вы не выделили эту память для себя. Чтение / списание конца массива - один из способов загадочного сбоя программ на языке C.

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

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

Фактически, malloc не выделяет достаточно места для вашего третьего целого числа, но вам «повезло», и ваша программа не аварийно завершилась. Вы можете быть уверены только в том, что malloc выделил именно то, что вы просили, не более того. Другими словами, ваша программа записала в часть памяти, которая не была выделена для нее.

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

Все это восходит к тому, что C позволил вам выстрелить себе в ногу. То, что вы можете это сделать, не означает, что вы должны это делать. Определенно не гарантируется, что значение p + 3 будет тем, что вы поместили туда, если вы специально не распределили его с помощью malloc.

Попробуй это:

int main ( int argc, char *argv[] ) {
  int *p = malloc(2 * sizeof *p);
  int *q = malloc(sizeof *q);
  *q = 100;

  p[0] = 10;    p[1] = 20;    p[2] = 30;    p[3] = 40;
  p[4] = 50;    p[5] = 60;    p[6] = 70;


  printf("%d\n", *q);

  return 0;
}

На моей машине он печатает:

50

Это потому, что вы перезаписали память, выделенную для p, и наступили на q.

Обратите внимание, что malloc может не помещать p и q в непрерывную память из-за ограничений выравнивания.

Память представлена ​​в виде перечисляемой непрерывной линии слотов, в которых могут храниться числа. Функция malloc использует некоторые из этих слотов для своей собственной информации отслеживания, а также иногда возвращает слоты большего размера, чем вам нужно, так что когда вы вернете их позже он не застрял в непривычно маленьком куске памяти. Ваш третий int либо приземляется на собственные данные mallocs, либо на оставшееся пустое пространство в возвращаемом фрагменте, либо в области ожидающей памяти, которую malloc запросил у ОС, но еще не распределен для вас.

В зависимости от платформы p [500], вероятно, тоже будет "работать".

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

В этот момент вы запросили то, что в стандарте называется «Неопределенное поведение», и компилятору и библиотеке разрешено делать что угодно в ответ. Допускается даже внешний вид работающего «правильно».

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

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

Изменить: OP исправил побочную проблему с *(p+2), противоречащим p[1], поэтому я отредактировал свой ответ, чтобы убрать эту точку.

Вы просите место для двух целых чисел. p [3] предполагает, что у вас есть место для 4 целых чисел!

===================

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

malloc может делать все, что захочет, если он возвращает по крайней мере объем памяти, который вы запрашиваете.

Это как просить место в ресторане. Вам могут дать стол побольше, чем вам нужно. Или вам могут предоставить место за столом с другими людьми. Или вам могут предоставить стол на одно место. Маллок волен делать все, что захочет, пока вы получаете свое единственное место.

В рамках «контракта» на использование malloc вы обязаны никогда не ссылаться на память сверх того, что вы запросили, потому что вы гарантированно получите только запрошенную сумму.

Поскольку malloc () выделяется в БАЙТАХ. Итак, если вы хотите выделить (например) 2 целых числа, вы должны указать размер в байтах 2 целых чисел. Размер целого числа можно найти с помощью sizeof (int), поэтому размер в байтах 2 целых чисел равен 2 * sizeof (int). Сложите все это вместе, и вы получите:

int * p = malloc(2 * sizeof(int));

Примечание: учитывая, что вышеупомянутое выделяет место только для ДВУХ целых чисел, вы очень непослушны, назначая третье. Тебе повезло, что он не падает. :)

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

Когда вы используете * (p + 3), вы обращаетесь за пределы даже с использованием 2 * sizeof (* p), следовательно, вы получаете доступ к недопустимому блоку памяти, идеально подходящему для ошибок seg.

Вы указываете размер b / c, иначе функция не знает, какой размер блока из кучи памяти выделить вашей программе для этого указателя.

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

Во-вторых, c позволяет писать в любую часть оперативной памяти в любое время. Ядро может препятствовать записи в определенные разделы, вызывая сбои в защите, но ничто не мешает программисту попытаться это сделать.

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

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

int *p = malloc(2 * sizeof(int));
p[0] = 10; p[1] = 20; p[2] = 30;
int *q = malloc(2 * sizeof(int));
q[0] = 0; // This may or may not get written to p[2], overwriting your 30.

printf("%d", p[0]); // Correctly prints 10
printf("%d", p[1]); // Correctly prints 20
printf("%d", p[2]); // May print 30, or 0, or possibly something else entirely.

Невозможно гарантировать, что ваша программа выделит место для q в точке p [2]. На самом деле он может выбрать совершенно другое место. Но для такой простой программы это кажется вероятным, и если она действительно выделяет q в том месте, где будет p [2], это ясно продемонстрирует ошибку вне допустимого диапазона.