Динамическое выделение памяти в цикле — c

Динамическое выделение памяти в цикле — c++

Каков наилучший способ динамического выделения памяти в цикле?

1.Free память каждого цикла?

2.Free память в конце концов?

6 ответов

• C/C++ динамическое или статическое распределение памяти?

Динамическое выделение памяти в C/C++ происходит через malloc , а статическое выделение памяти ex: int a[3]; выделяется после выполнения кода. Но этот код int x[y+1]; может произойти только после того, как значение приписано y, и это происходит во время выполнения, так что он статический.

Моя проблема требует преобразования фиксированного размера массива в динамическое выделение памяти. Я пробовал все виды операторов calloc, malloc и relloc, но ничего не получалось. Я думаю, что даже указатель void *data был бесполезен. Пожалуйста, преобразуйте этот код в динамическую память, чтобы.

Прежде всего, когда вы используете оператор new[] , вам нужно сопоставить его с оператором delete[] , поэтому вы должны сделать delete[] foo .

Во-вторых, если вы сделаете delete[] после цикла, вы освободите только последнюю выделенную память, что приведет к утечке памяти.

В-третьих, действительно ли вам нужно использовать необработанные указатели? Не можете ли вы вместо этого использовать, например, std::vector ?

Вариант 1: Многократное распределение / освобождение = плохая производительность

Вариант 2: Несколько выделений / одно освобождение = утечка памяти

Вариант 3: Одно выделение / одно освобождение = OK, если вам нужна динамическая память

Вариант 4: Избегайте динамического распределения / освобождения

В первом примере у вас неопределенное поведение, вам нужно использовать delete[] для удаления массива, выделенного new []

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

Решение:

• Лучший способ-использовать стандартный контейнер :

• Или вы все еще можете использовать интеллектуальный указатель :

• Или, если вы действительно не можете, убедитесь, что каждый вызов new[] совпадает с вызовом delete[]

Первый пример лучше, хотя вы должны позвонить:

Чтобы освободить весь квартал.

Ваш второй пример-утечка памяти. Вот почему:

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

Во-первых, нет хорошего решения с использованием new , точка. Аргументом будет новый std::vector каждый раз в цикле, по сравнению с одним вне цикла, с resize каждый раз в цикле:

Однако, если вы выполняете какую-либо реальную работу в цикле, разница , скорее всего, не будет существенной.

Вы можете улучшить первую версию, используя резерв:

Если rest цикла довольно тривиален, это может быть быстрее. Если на то пошло, если максимальный размер известен и не слишком велик, вы можете использовать:

Во многих случаях это вполне приемлемо, и это будет самым быстрым (хотя опять же, в большинстве случаев разница в производительности будет незначительной, и вы потеряете преимущества std::vector —which в большинстве случаев, включая проверку границ, когда оптимизация не активна).

• Динамическое выделение памяти и многоуровневые массивы в C

Q6: динамическое выделение памяти: рассмотрим следующее объявление для многоуровневого массива имен: char name_1[]= “John”; char name_2[]= “Paul”; char name_3[] = “Stephen”; char *names[3]=; Создайте эквивалентный многоуровневый массив: dynamic_names, содержащий все его.

Я изучаю процесс динамического выделения памяти в c++. 1.How объявить динамическое выделение памяти массива без предварительного знания его размера? 2.Suppose я использую переменную для динамического выделения памяти массиву, но позже в программе размер массива уменьшается. Будет ли происходить.

Лучше всего избегать того, что вы сейчас пытаетесь сделать, используя вектор. Однако, если это чисто учебное упражнение, я бы рекомендовал хранить каждый указатель (new int[]) в массиве. Причина этого, если на данный момент она не ясна, заключается в том, что вы продолжаете назначать новый массив, указывающий на массив в памяти, а затем теряете ссылку на него, назначая новую память тому же указателю без вызова delete[].

При немного лучшем дизайне вы могли бы, как я уже упоминал ранее, хранить массив таких указателей, например *foo-тогда вы можете очистить память в деструкторе

Foo(). Просто идея.

Похожие вопросы:

Я ясно представляю себе динамическое выделение памяти для struct в C++. struct Node < int item; struct Node *next; >; int main() < struct Node *head = new struct Node; return 0; >Вот такая картина.

Я только изучаю динамическое распределение памяти, но есть одна вещь, которую я хотел бы объяснить. Одно из применений динамического распределения — это массивы динамического размера, и мне это.

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

Динамическое выделение памяти в C/C++ происходит через malloc , а статическое выделение памяти ex: int a[3]; выделяется после выполнения кода. Но этот код int x[y+1]; может произойти только после.

Моя проблема требует преобразования фиксированного размера массива в динамическое выделение памяти. Я пробовал все виды операторов calloc, malloc и relloc, но ничего не получалось. Я думаю, что даже.

Q6: динамическое выделение памяти: рассмотрим следующее объявление для многоуровневого массива имен: char name_1[]= “John”; char name_2[]= “Paul”; char name_3[] = “Stephen”; char *names[3]=

Я изучаю процесс динамического выделения памяти в c++. 1.How объявить динамическое выделение памяти массива без предварительного знания его размера? 2.Suppose я использую переменную для.

Возможно ли иметь динамическое выделение памяти в строке, которая читается с помощью scanf, без предварительного объявления ее как массива?

int a[10]; Приведенный выше код создаст массив из четырех переменных размера int &, таким образом, программа сможет хранить только 4 целых числа. Теперь рассмотрим следующие команды int.

Я пытаюсь полностью отключить динамическое выделение памяти в приложении с низким ресурсом. Я никогда не использую malloc / free и т. д., и, насколько я могу судить, ни одна из моих зависимостей не.

Динамическое распределение памяти в си

В качестве входного параметра функция принимает размер памяти, которую требуется выделить. Возвращаемым значением является указатель на выделенный в куче участок памяти.
Для выделения памяти под 1 000 000 int`ов необходимо выполнить следующий код:

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

В языке С++ потребуется небольшая модификация данной кода (из-за того, что в С++ нет неявного приведения указателей):

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

Если ОС не смогла выделить память (например, памяти не хватило), то malloc возвращает 0.

После окончания работы с выделенной динамически памятью нужно освободить ее. Для этой цели используется функция free, которая возвращает память под управление ОС.

void free(void *ptr);

В качестве входного параметра в free нужно передать указатель, значение которого полученно из функции malloc. Вызов free на указателях полученных не из malloc (например, free(p+10)) приведет к неопределенному поведению. Это связанно с тем, что при выделении памяти при помощи malloc в ячейки перед той, на которую указывает возвращаемый функцией указатель операционная система записывает служебную информацию (см. рис.). При вызове free(p+10) информация находящаяся перед ячейкой (p+10) будет трактоваться как служебная.

void *calloc(size_t nmemb, size_t size);

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

int * q = (int *) calloc(1000000, sizeof(int))

q будет указывать на начало массива из миллиона int`ов инициализированных нулями.

void *realloc(void *ptr, size_t size);

Функция изменяет размер выделенной памяти (на которую указывает ptr, полученный из вызова malloc, calloc или realloc). Если размер указанный в параметре size больше, чем тот, который был выделен под указатель ptr, то проверяется, есть ли возможность выделить недостающие ячейки памяти подряд с уже выделенными. Если места недостаточно, то выделяется новый участок памяти размером size и данные по указателю ptr копируются в начало нового участка.

Какие бывают ошибки:

1. Потеря памяти

int * p = (int *) malloc(100);
p = (int *) malloc(200); // потерян указатель на первые 100 int`ов, которые теперь нельзя отдать обратно ОС

2.Повторное освобождение выделенной памяти

free(p); … free(p); // неопределенное поведение

free(p);
p = 0;
…
free(p); // отработает без ошибок

Работа с динамической памятью в С++

В С++ есть свой механизм выделения и освобождения памяти — это функции new и delete.

Пример использования new:

int * p = new int[1000000]; // выделение памяти под 1000000 int`ов

Т.е. при использовании функции new не нужно приводить указатель и не нужно использовать sizeof().
Освобождение выделенной при помощи new памяти осуществляется посредством следующего вызова:

Если требуется выделить память под один элемент, то можно использовать

int * q = new int;

int * q = new int(10); // выделенный int проинциализируется значением 10

в этом случае удаление будет выглядеть следующим образом:

1. При динамическом выделении памяти в ней помимо значения указанного типа будет храниться служебная информация ОС и С/С++. Таким образом потребуется гораздо больше памяти, чем при хранении необходимых данных на стеке.
2. Если в памяти хранить большое количество маленьких кусочков, то она будет сильно фрагментирована и большой массив данных может не поместиться.

Многомерные массивы.

1ый способ

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

int ** a = new int*[n];
for (int i = 0; i != n; ++i)
a[i] = new int[m];

Однако, этот способ плох тем, что в нём требуется n+1 выделение памяти, а это достаточно дорогая по времени операция.

2ой способ

На первом шаге выделение массива указателей и массива чисел размером n на m. На втором шаге каждому указателю из массива ставится в соответствие строка в массиве чисел.

int ** a = new int*[n];
a[0] = new int[n*m];
for (int i = 1; i != n; ++i)
a[i] = a[0] + i*m;

В данном случае требуется всего 2 выделения памяти.

Для освобождения памяти требуется выполнить:

for (int i = 0; i != n; ++i)
delete [] a[i];
delete [] a;

delete [] a[0];
delete [] a;

Таким образом, второй способ опять же требует гораздо меньше вызовов функции delete [], чем первый.

Русские Блоги

Есть два способа открыть пространство памяти в C:
1. Статически открыть память: например:

Характеристики этого открытого пространства памяти
Открытая память Откройте в стеке из Фиксированный размер Да, если a равно 4 байта, массив b равен 40 байтов, и длина массива должна быть указана при объявлении, поскольку память массива выделяется во время компиляции. Если мы хотим определить массив во время выполнения программы Размер, метод статического открытия пространства памяти не работает, например:

Запись таким образом вызовет ошибку во время компиляции. Компилятор напомнит, что [] должно быть константным выражением. При определении массивов в C, например, могут использоваться следующие типы:

Следует отметить, что const int n = 10 в C; n не может определить массив как длину массива, но в C ++,
Но наша потребность в разработке пространства часто этим не ограничивается. Наиболее распространенное определение массива — это когда размер массива известен во время работы программы. Статическая разработка уже бессильна. Конечно, есть статическая разработка. Должно быть динамическое развитие, далее мы рассмотрим динамическое развитие пространства памяти.

2. Динамически открывать память:
Для динамического открытия пространства в C необходимы три функции:
malloc(), calloc(), realloc() , Эти три функции Применить к куче Пространство памяти.
Пространство памяти, применяемое в куче, не будет таким же, как локальные переменные, хранящиеся в стеке. Вызов функции автоматически освободит память после вызова функции. Если нам нужно освободить ее вручную, нам нужно free() Функция для завершения.
Давайте посмотрим на соответствующие функции, способы использования, различия и связи этих функций.

1.malloc()

void * malloc（size_t size）

1). malloc() Функция будет отвал Подать заявку на ломтик непрерывный из имеющийся Пространство памяти
2). Если приложение успешно, возвращается указатель на это пространство памяти. Если приложение не удается, оно возвращается. NULL, Итак, мы используем malloc() После того, как функция открывает динамическую память, Обязательно определите, является ли возвращаемое значение функции NULL.
3). Тип возврата void* Введите, malloc() Функция не знает непрерывного развития size Какой тип данных хранится в каждом байте, поэтому мы должны решить для себя, метод malloc() Перед усилением системы она преобразуется в нужный нам тип, такой как: (int*)malloc(sizeof(int)*n).
4). если size 0, это поведение не определено и могут возникнуть неизвестные ошибки, в зависимости от компилятора

Как это использовать, например.

В настоящее время это эквивалентно созданию массива p (n). Это значение n вводится пользователем во время работы программы.

2.free()

void free(void* ptr)
Объем памяти, запрошенный в куче, не будет таким же, как у локальных переменных, хранящихся в стеке. Память будет автоматически освобождена после вызова функции. Если мы не освободим ее вручную, она не будет освобождена до конца программы. , Это может привести к Утечка памяти, То есть данные в этой части памяти в куче больше не используются, но они занимают это пространство (в общепринятых терминах это занимает яму, а не дерьмо), поэтому, когда динамическая память, к которой мы обращались, больше не используется, она должна быть Выпуск вовремя.

1). если ptr Не указание на пространство памяти, выделенное с помощью функции динамического выделения памяти, приводит к неопределенному поведению.
2). если ptr Нулевой указатель, функция ничего не делает.
3). Эта функция не меняется ptr Значение само по себе, поэтому оно по-прежнему указывает на то же (теперь недопустимое) местоположение (память)
4). в free() После того, как функция должна снова очистить ptr, то есть ptr = NULL; Если нет ptr Если оставить пустым, если последующие процедуры пройдут снова ptr Получит доступ к памяти, которая была освобождена как недействительная или была переработана. Чтобы обеспечить надежность программы, мы обычно пишем ptr = NULL; .

Примечание: free() Не удается повторно освободить часть памяти, например:

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

free() Конкретное использование, например:

3.calloc()

void * calloc（size_t num，size_t size）
и malloc() Разница между функциями заключается в том, что calloc() Функция будет в До обратного адреса Запрашиваемая память Каждый байт инициализируется в 0 .

1). calloc() Функции функции распределяются динамически num Размер (длина байта) size Пространство памяти.
2). Если приложение успешно, возвращается указатель на это пространство памяти. Если приложение не удается, оно возвращается. NULL, Итак, мы используем calloc() После того, как функция открывает динамическую память, Обязательно определите, является ли возвращаемое значение функции NULL.
3). Тип возврата void* Введите, calloc() Функция хоть назначена num более size Размер памяти, но до сих пор не знаю, какой тип данных хранится, поэтому нам нужно решить для себя, метод calloc() Перед усилением системы она преобразуется в нужный нам тип, такой как: (int*)calloc(num, sizeof(int) ).
4). если size и num Один или оба равны 0, это поведение не определено, будут возникать неизвестные ошибки, в зависимости от компилятора

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

4.realloc()

void * realloc（void * ptr，size_t size）

realloc() Функции делают динамическое управление памятью более гибким. Динамическое выделение объема памяти во время выполнения программы. Если выделение слишком велико, это приведет к потере места. Если оно слишком мало, его может все еще быть недостаточно. Для разумного использования памяти мы будем Сделайте гибкие настройки размера памяти. что realloc() Функция может регулировать размер динамически открытой памяти (большой или небольшой).

1). ptr Для адресов памяти, которые должны быть скорректированы
2) . size Чтобы настроить размер (в байтах)
3). Если корректировка прошла успешно, возвращаемое значение — это начальная позиция измененной памяти (то есть указатель на скорректированную память), ptr Если произойдет сбой (когда нет памяти для выделения, он обычно не появляется), затем верните NULL , Так что все равно придется очистить возвращаемое значение
4). если ptr Нулевой указатель, то malloc() Функции работают одинаково

Примечание: есть два случая, когда функция realloc () расширяет пространство памяти
1). ptr За указанной памятью достаточно места для расширения, как показано на рисунке:

2). ptr Недостаточно места за указанной памятью для расширения, как показано на рисунке:

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

5. Резюме

1). malloc() и calloc() Использование функции такое же, разница только calloc() Инициализируйте каждый байт запрошенной памяти на 0

2). malloc() , calloc(), realloc() Когда запрошенная память больше не используется, она должна использоваться free() Отпустите, иначе это приведет к утечке памяти

3). p = realloc(ptr, size) Когда возвращаемое значение функции не пустое, нет необходимости писать при освобождении памяти free(ptr) И просто напиши free(p)

Динамическое выделение памяти

В предыдущей главе уже обсуждалось, что локальные переменные кладутся на стек и существую до тех пор, пока мы не вышли из функции. С одной стороны, это позволяет автоматически очищать память, с другой стороны, существует необходимость в переменных, время жизни которых мы можем контролировать самостоятельно. Кроме того, нам необходимо динамическое выделение памяти, когда размер используемого пространства заранее не известен. Для этого используется выделение памяти на куче. Недостатков у такого подхода два: во-первых, память необходимо вручную очищать, во-вторых, выдеение памяти – достаточно дорогостоящая операция.

Для выделения памяти на куче в си используется функция malloc (memory allocation) из библиотеки stdlib.h

Функция выделяет size байтов памяти и возвращает указатель на неё. Если память выделить не удалось, то функция возвращает NULL. Так как malloc возвращает указатель типа void, то его необходимо явно приводить к нужному нам типу. Например, создадим указатель, после этого выделим память размером в 100 байт.

После того, как мы поработали с памятью, необходимо освободить память функцией free.
Используя указатель, можно работать с выделенной памятью как с массивом. Пример: пользователь вводит число – размер массива, создаём массив этого размера и заполняем его квадратами чисел по порядку. После этого выводим и удаляем массив.

Здесь (int *) – приведение типов. Пишем такой же тип, как и у указателя.
size * sizeof(int) – сколько байт выделить. sizeof(int) – размер одного элемента массива.
После этого работаем с указателем точно также, как и с массивом. В конце не забываем удалять выделенную память.

Теперь представим на рисунке, что у нас происходило. Пусть мы ввели число 5.

Функция malloc выделила память на куче по определённому адресу, после чего вернула его. Теперь указатель p хранит этот адрес и может им пользоваться для работы. В принципе, он может пользоваться и любым другим адресом.
Когда функция malloc «выделяет память», то она резервирует место на куче и возвращает адрес этого участка. У нас будет гарантия, что компьютер не отдаст нашу память кому-то ещё. Когда мы вызываем функцию free, то мы освобождаем память, то есть говорим компьютеру, что эта память может быть использована кем-то другим. Он может использовать нашу память, а может и нет, но теперь у нас уже нет гарантии, что эта память наша. При этом сама переменная не зануляется, она продолжает хранить адрес, которым ранее пользовалась.

Это очень похоже на съём номера в отеле. Мы получаем дубликат ключа от номера, живём в нём, а потом сдаём комнату обратно. Но дубликат ключа у нас остаётся. Всегда можно зайти в этот номер, но в нём уже кто-то может жить. Так что наша обязанность – удалить дубликат.

Иногда думают, что происходит «создание» или «удаление» памяти. На самом деле происходит только перераспределение ресурсов.

Освобождение памяти с помощью free

Т еперь рассмотри, как происходит освобождение памяти. Переменная указатель хранит адрес области памяти, начиная с которого она может им пользоваться. Однако, она не хранит размера этой области. Откуда тогда функция free знает, сколько памяти необходимо освободить?

• 1. Можно создать карту, в которой будет храниться размер выделенного участка. Каждый раз при освобождении памяти компьютер будет обращаться к этим данным и получать нужную информацию.
• 2. Второе решение более распространено. Информация о размере хранится на куче до самих данных. Таким образом, при выделении памяти резервируется места больше и туда записывается информация о выделенном участке. При освобождении памяти функция free «подсматривает», сколько памяти необходимо удалить.

Работа с двумерными и многомерными массивами

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

• 1. Создавать массивы «неправильной формы», то есть массив строк, каждая из которых имеет свой размер.
• 2. Работать по отдельности с каждой строкой массива: освобождать память или изменять размер строки.

Создадим «треугольный» массив и заполним его значениями

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

calloc

Ф ункция calloc выделяет n объектов размером m и заполняет их нулями. Обычно она используется для выделения памяти под массивы. Синтаксис

realloc

Е щё одна важная функция – realloc (re-allocation). Она позволяет изменить размер ранее выделенной памяти и получает в качестве аргументов старый указатель и новый размер памяти в байтах:

Функция realloc может как использовать ранее выделенный участок памяти, так и новый. При этом не важно, меньше или больше новый размер – менеджер памяти сам решает, где выделять память.
Пример – пользователь вводит слова. Для начала выделяем под слова массив размером 10. Если пользователь ввёл больше слов, то изменяем его размер, чтобы хватило места. Когда пользователь вводит слово end, прекращаем ввод и выводим на печать все слова.

Хочу обратить внимание, что мы при выделении памяти пишем sizeof(char*), потому что размер указателя на char не равен одному байту, как размер переменной типа char.

Ошибки при выделении памяти

1. Бывает ситуация, при которой память не может быть выделена. В этом случае функция malloc (и calloc) возвращает NULL. Поэтому, перед выделением памяти необходимо обнулить указатель, а после выделения проверить, не равен ли он NULL. Так же ведёт себя и realloc. Когда мы используем функцию free проверять на NULL нет необходимости, так как согласно документации free(NULL) не производит никаких действий. Применительно к последнему примеру:

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

2. Изменение указателя, который хранит адрес выделенной области памяти. Как уже упоминалось выше, в выделенной области хранятся данные об объекте — его размер. При удалении free получает эту информацию. Однако, если мы изменили указатель, то удаление приведёт к ошибке, например

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

3. Использование освобождённой области. Почему это работает в си, описано выше. Эта ошибка выливается в другую – так называемые висячие указатели (dangling pointers или wild pointers). Вы удаляете объект, но при этом забываете изменить значение указателя на NULL. В итоге, он хранит адрес области памяти, которой уже нельзя воспользоваться, при этом проверить, валидная эта область или нет, у нас нет возможности.

Эта программа отработает и выведет мусор, или не мусор, или не выведет. Поведение не определено.

Если же мы напишем

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

4. Освобождение освобождённой памяти. Пример

Здесь дважды вызывается free для переменной a. При этом, переменная a продолжает хранить адрес, который может далее быть передан кому-нибудь для использования. Решение здесь такое же как и раньше — обнулить указатель явно после удаления:

5. Одновременная работа с двумя указателями на одну область памяти. Пусть, например, у нас два указателя p1 и p2. Если под первый указатель была выделена память, то второй указатель может запросто скомпрометировать эту область:

Рассмотрим код ещё раз.

Теперь оба указателя хранят один адрес.

А вот здесь происходит непредвиденное. Мы решили выделить под p2 новый участок памяти. realloc гарантирует сохранение контента, но вот сам указатель p1 может перестать быть валидным. Есть разные ситуации. Во-первых, вызов malloc мог выделить много памяти, часть которой не используется. После вызова ничего не поменяется и p1 продолжит оставаться валидным. Если же потребовалось перемещение объекта, то p1 может указывать на невалидный адрес (именно это с большой вероятностью и произойдёт в нашем случае). Тогда p1 выведет мусор (или же произойдёт ошибка, если p1 полезет в недоступную память), в то время как p2 выведет старое содержимое p1. В этом случае поведение не определено.

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

Различные аргументы realloc и malloc.

При вызове функции malloc, realloc и calloc с нулевым размером поведение не определено. Это значит, что может быть возвращён как NULL, так и реальный адрес. Им можно пользоваться, но к нему нельзя применять операцию разадресации.
Вызов realloc(NULL, size_t) эквиваленте вызову malloc(size_t).
Однако, вызов realloc(NULL, 0) не эквивалентен вызову malloc(0) 🙂 Понимайте это, как хотите.

Примеры

1. Простое скользящее среднее равно среднему арифметическому функции за период n. Пусть у нас имеется ряд измерений значения функции. Часто эти измерения из-за погрешности «плавают» или на них присутствуют высокочастотные колебания. Мы хотим сгладить ряд, для того, чтобы избавиться от этих помех, или для того, чтобы выявить общий тренд. Самый простой способ: взять n элементов ряда и получить их среднее арифметическое. n в данном случае — это период простого скользящего среднего. Так как мы берём n элементов для нахождения среднего, то в результирующем массиве будет на n чисел меньше.

Пусть есть ряд
1, 4, 4, 6, 7, 8, 9, 11, 12, 11, 15
Тогда если период среднего будет 3, то мы получим ряд
(1+4+4)/3, (4+4+6)/3, (4+6+7)/3, (6+7+8)/3, (7+8+9)/3, (8+9+11)/3, (9+11+12)/3, (11+12+11)/3, (12+11+15)/3
Видно, что сумма находится в «окне», которое скользит по ряду. Вместо того, чтобы каждый раз в цикле находить сумму, можно найти её для первого периода, а затем вычитать из суммы крайнее левое значение предыдущего периода и прибавлять крайнее правое значение следующего.
Будем запрашивать у пользователя числа и период, а затем создадим новый массив и заполним его средними значениями.

Это простой пример. Большая его часть связана со считыванием данных, вычисление среднего всего в девяти строчках.

2. Сортировка двумерного массива. Самый простой способ сортировки — перевести двумерный массив MxN в одномерный размером M*N, после чего отсортировать одномерный массив, а затем заполнить двумерный массив отсортированными данными. Чтобы не тратить место под новый массив, мы поступим по-другому: если проходить по всем элементам массива k от 0 до M*N, то индексы текущего элемента можно найти следующим образом:
j = k / N;
i = k — j*M;
Заполним массив случайными числами и отсортируем

3. Бином Ньютона. Создадим треугольную матрицу и заполним биномиальными коэффициентами

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

Всё ещё не понятно? – пиши вопросы на ящик