c ++ realloc та же самая гарантия указателя

Question

c ++ realloc та же самая гарантия указателя

0

Использование функции std :: realloc:

Если новый размер меньше, у него всегда есть гарантия, чтобы блок памяти находился в одном и том же положении и только уменьшал или мог иногда перемещать весь блок?

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

#include<cstdlib>
#include<iostream>
using namespace std;

int main(){
  //From 10,000,000 unsigned ints to 10 unsigned ints
  unsigned int * const array=new unsigned int[10000000];
  cout<<array<<endl;
  realloc(array,10*sizeof(unsigned int));
  cout<<array<<endl;
  delete array;
  return 0;
}

ncomputers 17 сен. 2014, в 22:06

Источник

5

Вы не должны смешивать new() и realloc() .
πάντα ῥεῖ 17 сен. 2014, в 19:44
3

Вы не можете перераспределить память, которая была выделена new .
AnT 17 сен. 2014, в 19:46
0

Какую библиотеку C вы используете? (realloc из библиотеки C)
Sam van Kampen 17 сен. 2014, в 19:54
0

Вы не можете смешивать new с realloc . Так что вместо этого вопроса и этого от вас: stackoverflow.com/questions/25898160/… , напишите свою собственную версию realloc которая учитывает оператор new . Тогда у вас не будет никаких вопросов, потому что вы будете точно контролировать, как ведет себя ваша домашняя функция realloc .
PaulMcKenzie 17 сен. 2014, в 19:59
0

realloc может перемещать выделенный кусок памяти, даже если он сокращается, чтобы улучшить распределение в будущем. Например, большие выделения могут быть получены из одной области памяти, а небольшие - из другой.
Keith Thompson 17 сен. 2014, в 20:34

Показать ещё 3 комментария

Теги:

c++

realloc

dynamic-memory-allocation

4 ответа

3

Нет !! Если realloc преуспевает, старый указатель (если он не был nullpointer) неопределен.

Кроме того, не смешивайте несовместимые функции управления памятью (предполагайте несовместимость, если не указано иное).

realloc только имеет гарантии, явно указанные в стандарте:

Если возвращаемое значение не равно 0: новый указатель указывает на size байт по меньшей мере, первый мин (oldsize, newsize) равен переданному блоку.
Иначе, если size равен 0, ничего не произошло с переданным блоком.
Возможно, старый блок был освобожден или нет.

Мораль: никогда не передавайте размер 0 для realloc и используйте старый указатель для чего-либо (включая сравнение с новым указателем), если realloc не удалось (или вы передали нулевой указатель).

7.22.3.5 Функция realloc
#include <stdlib.h>
void *realloc(void *ptr, size_t size);
2 Функция realloc освобождает старый объект, на который указывает ptr и возвращает указатель на новый объект, размер которого задан по size. Содержимое нового объекта должно быть таким же, как и у старого объекта до освобождения, вплоть до меньшего размера нового и старого. Любые байты нового объекта за пределами размера старого объекта имеют неопределенные значения.
3 Если ptr является нулевым указателем, функция realloc ведет себя как функция malloc для указанного размера. В противном случае, если ptr не соответствует указателю, ранее возвращенному функцией управления памятью, или если пространство было освобождено вызовом функции free или realloc, поведение не определено. Если память для нового объекта не может быть выделена, старый объект не освобождается и его значение не изменяется.

Возвращает
4 Функция realloc возвращает указатель на новый объект (который может иметь то же значение, что и указатель на старый объект), или нулевой указатель, если новый объект не может быть выделен.

Deduplicator 17 сен. 2014, в 18:09

0

ОП не передает 0 в realloc, поэтому большая часть вашего ответа совершенно излишня при ответе на его вопрос. Звучит знакомо?
Jonathan Potter 17 сен. 2014, в 20:11
0

Ну, теперь вы достигли. Я даю полную картину, которая несколько отличается от осуждения его примера для иллюстрации его вопроса.
Deduplicator 17 сен. 2014, в 20:17
0

Указывать на неблагоприятные последствия (утечка памяти, доступ к освобожденной памяти) неправильного использования функции - это не «осуждение его примера», а попытка показать, почему он не должен использовать метод, который пытается использовать. Получить контроль.
Jonathan Potter 17 сен. 2014, в 20:19
0

Ну, моя последняя попытка, чтобы вы поняли смысл (или, как вы выразились, чтобы дать вам «захват»): его пример иллюстрирует его вопрос, может ли он предположить, что новый указатель идентичен старому указателю, если предположить, что и вы не видите, что ответ «Нет» на вопрос идентичен тому, что предположение, на котором построен пример, не выполняется? Некоторые люди...
Deduplicator 17 сен. 2014, в 20:30
0

Моя последняя попытка для вас: он сказал: «Могу ли я сделать X?». Я ответил: «Нет, ты не можешь сделать X, потому что вот что пойдет не так, если ты это сделаешь». Вы ответили "нет, ты не можешь сделать Y". Как вы сказали, некоторые люди.
Jonathan Potter 17 сен. 2014, в 20:32

Показать ещё 3 комментария

2

C99 проект 7.20.3.4 гласит:

[# 4] Функция realloc возвращает указатель на новый объект (который может иметь то же значение, что и указатель на старый объект), или нулевой указатель, если новый объект не может быть выделен.

Вы не должны этого допускать.

А также: не смешивайте new и realloc поскольку πάντα уже писал в комментариях.

Marco A. 17 сен. 2014, в 18:27

0

Ничего не гарантировано в realloc. Это может уменьшить блок на месте, или он может выделить новый и скопировать данные. Это может также потерпеть неудачу.

Важный момент: realloc предназначен только для перераспределения памяти, ранее выделенной malloc. В вашем коде выше вы используете new которое не имеет эквивалента для перераспределения.

Также realloc фактически возвращает адрес нового блока памяти, поэтому в вашем коде выше вы будете: a) утечка этого и b) ссылка/освобождение потенциально уже выделенной памяти.

Jonathan Potter 17 сен. 2014, в 18:38

0

По его словам, он хочет знать, безопасно ли это (а это не так).
Deduplicator 17 сен. 2014, в 20:02
0

@Deduplicator: Ваша точка зрения?
Jonathan Potter 17 сен. 2014, в 20:04
0

Если бы была гарантия, что realloc всегда возвращает один и тот же указатель, если переданный блок имеет size не менее size байтах, не сохраняя возвращенный указатель, поскольку вы знаете, что в любом случае вы только уменьшаете блок, было бы правильным выбором. Таким образом, последний абзац совершенно лишен ответа на его вопрос.
Deduplicator 17 сен. 2014, в 20:07
0

@Deduplicator: самое первое, что я сказал, было «ничего не гарантировано о realloc». Возможно, вам нужно улучшить понимание прочитанного?
Jonathan Potter 17 сен. 2014, в 20:09
0

Хорошо, я попытаюсь перефразировать это для вас: он предоставляет код, чтобы проиллюстрировать свой вопрос: можно ли предположить, что возвращенный указатель realloc является указателем, который он передал, учитывая, что он просит уменьшить (или, по крайней мере, не увеличить) блок. Ваш ответ: нет, realloc не предоставляет такой гарантии, и между прочим, в вашем примере есть ошибка, поскольку realloc не гарантирует, что блок не будет перемещен. Теперь вы видите, как этот последний абзац в лучшем случае полностью избыточен?
Deduplicator 17 сен. 2014, в 20:14
0

@Deduplicator: Нет, потому что он использует функцию неправильно. Как это указывает на избыточность?
Jonathan Potter 17 сен. 2014, в 20:15

Показать ещё 4 комментария

Ещё вопросы

Вы не должны смешивать new() и realloc() .
Вы не можете перераспределить память, которая была выделена new .
Какую библиотеку C вы используете? (realloc из библиотеки C)
Вы не можете смешивать new с realloc . Так что вместо этого вопроса и этого от вас: stackoverflow.com/questions/25898160/… , напишите свою собственную версию realloc которая учитывает оператор new . Тогда у вас не будет никаких вопросов, потому что вы будете точно контролировать, как ведет себя ваша домашняя функция realloc .
realloc может перемещать выделенный кусок памяти, даже если он сокращается, чтобы улучшить распределение в будущем. Например, большие выделения могут быть получены из одной области памяти, а небольшие - из другой.
ОП не передает 0 в realloc, поэтому большая часть вашего ответа совершенно излишня при ответе на его вопрос. Звучит знакомо?
Ну, теперь вы достигли. Я даю полную картину, которая несколько отличается от осуждения его примера для иллюстрации его вопроса.
Указывать на неблагоприятные последствия (утечка памяти, доступ к освобожденной памяти) неправильного использования функции - это не «осуждение его примера», а попытка показать, почему он не должен использовать метод, который пытается использовать. Получить контроль.
Ну, моя последняя попытка, чтобы вы поняли смысл (или, как вы выразились, чтобы дать вам «захват»): его пример иллюстрирует его вопрос, может ли он предположить, что новый указатель идентичен старому указателю, если предположить, что и вы не видите, что ответ «Нет» на вопрос идентичен тому, что предположение, на котором построен пример, не выполняется? Некоторые люди...
Моя последняя попытка для вас: он сказал: «Могу ли я сделать X?». Я ответил: «Нет, ты не можешь сделать X, потому что вот что пойдет не так, если ты это сделаешь». Вы ответили "нет, ты не можешь сделать Y". Как вы сказали, некоторые люди.
По его словам, он хочет знать, безопасно ли это (а это не так).
Если бы была гарантия, что realloc всегда возвращает один и тот же указатель, если переданный блок имеет size не менее size байтах, не сохраняя возвращенный указатель, поскольку вы знаете, что в любом случае вы только уменьшаете блок, было бы правильным выбором. Таким образом, последний абзац совершенно лишен ответа на его вопрос.
@Deduplicator: самое первое, что я сказал, было «ничего не гарантировано о realloc». Возможно, вам нужно улучшить понимание прочитанного?
Хорошо, я попытаюсь перефразировать это для вас: он предоставляет код, чтобы проиллюстрировать свой вопрос: можно ли предположить, что возвращенный указатель realloc является указателем, который он передал, учитывая, что он просит уменьшить (или, по крайней мере, не увеличить) блок. Ваш ответ: нет, realloc не предоставляет такой гарантии, и между прочим, в вашем примере есть ошибка, поскольку realloc не гарантирует, что блок не будет перемещен. Теперь вы видите, как этот последний абзац в лучшем случае полностью избыточен?
@Deduplicator: Нет, потому что он использует функцию неправильно. Как это указывает на избыточность?

Sam van Kampen · Accepted Answer · 2014-09-17T18-53-00.000Z

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

EDIT: использование realloc в памяти, выделенное new, действительно запрещено, как упомянуто в других ответах.

Память, выделенная без внутреннего использования `mmap`

Если блок памяти не выделен с помощью mmap, __libc_realloc вызывает функцию _int_realloc, которая содержит следующий фрагмент кода:

if ((unsigned long) (oldsize) >= (unsigned long) (nb))
 {
   /* already big enough; split below */
   newp = oldp;
   newsize = oldsize;
 }

Это делает указатель на новую память равным указателю на старую память и соответственно устанавливает размер. Обратите внимание на split below комментария; старый блок памяти может быть изменен до требуемого размера, но не будет перемещен.

Память, выделенная внутренне с помощью `mmap`

Если память была внутренне распределена с помощью mmap, существует два способа изменения размера области памяти; mremap_chunk или серию вызовов в malloc, memcpy и free. Если функция mremap_chunk доступна, она используется вместо последней опции.

Память перераспределяется с использованием `mremap_chunk`

Функция mremap_chunk содержит этот фрагмент кода

/* No need to remap if the number of pages does not change.  */
if (size + offset == new_size)
    return p;

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

Память перераспределяется с использованием `malloc`, `memcpy` и `free`

Если mremap_chunk недоступен, источник __libc_realloc продолжается следующим образом:

/* Note the extra SIZE_SZ overhead. */
if (oldsize - SIZE_SZ >= nb)
    return oldmem;                         /* do nothing */

Если переменная oldsize минус размер блока больше или равна новому размеру, просто верните старую память.

Хорошо, тогда мы здесь. Во всех случаях glibc возвращает указатель на старую память, не перемещая ее (но, возможно, изменяя ее размер). Если вы используете glibc (и можете как-то гарантировать, что единственная библиотека C, с которой вы его используете, - glibc, и может гарантировать, что она не изменится в какой-то момент в будущем), вы можете полагаться на поведение, которое realloc не перемещает блок памяти, если запрашиваемый размер равен или меньше старого.

Очень зависящая от реализации и изменчивая информация. Имейте в виду, что даже если возвращенный указатель фактически совпадает с переданным указателем, все переменные, до сих пор хранящие старый указатель, впоследствии не определены. Это не теоретический момент, но он был продемонстрирован в дикой природе с использованием clang в блоге, который я недавно читал на UB. Мне просто жаль, что я потерял ссылку ...
Это кажется странным - позор, что вы потеряли ссылку, кажется интересным чтением. Но да, я согласен с вами; это больше интересовало то, как glibc справился с этим, чем с очень переносимой или практической информацией.
Ваш ответ очень хорош. Большое спасибо. Я не очень хорошо понял это предложение: «РЕДАКТИРОВАТЬ: использование realloc для памяти, выделенной new, действительно запрещено, как уже упоминалось в других ответах». Вы просите других пользователей редактировать то, что они написали? Потому что можно использовать realloc с new и delete?
Редактировать означает, что я отредактировал пост позже, чтобы включить эту информацию; Я повторяю, что использование realloc с new и delete запрещено.
Тем не менее, если вы хотите погрузиться во внутренности g ++, вы можете обнаружить, что смешивание new[] и realloc как это, «работает» так же, как то, о чем вы уже говорили выше, работает. То есть это не гарантируется, но, возможно, это происходит в одной или нескольких конкретных реализациях только из-за «очевидного» способа реализации new[] для типов POD.

c ++ realloc та же самая гарантия указателя

4 ответа

Память, выделенная без внутреннего использования mmap

Память, выделенная внутренне с помощью mmap

Память перераспределяется с использованием mremap_chunk

Память перераспределяется с использованием malloc, memcpy и free

7.22.3.5 Функция realloc

Ещё вопросы

Память, выделенная без внутреннего использования `mmap`

Память, выделенная внутренне с помощью `mmap`

Память перераспределяется с использованием `mremap_chunk`

Память перераспределяется с использованием `malloc`, `memcpy` и `free`