В простом языке C существовали функции malloc для выделения динамической памяти, realloc для её перераспределения (например, когда увеличивается длина массива) и free для освобождения массива.

В C++ появились операторы new [] для выделения памяти для динамического массива и delete [] для её освобождения. А есть ли в C++ функции или операторы для перераспледеления динамической памяти?
Может быть, для этих целей мне следует использовать STL--стандартную библиотеку шаблонов? ( http://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B0%D0%BD%D0%B4%D0%B0%D1%80%D1%82%D0%BD%D0%B0%D1%8F_%D0%B1%D0%B8%D0%B1%D0%BB%D0%B8%D0%BE%D1%82%D0%B5%D0%BA%D0%B0_%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD%D0%BE%D0%B2 )
Какие контернейры и итераторы в этом случае мне придётся использовать?

У меня почти нет опыта работы с STL, поэтому я и спрашиваю об этом.

Здравствуйте, erslgoeirjh, Вы писали:

E>В простом языке C существовали функции malloc для выделения динамической памяти, realloc для её перераспределения (например, когда увеличивается длина массива) и free для освобождения массива.

E>В C++ появились операторы new [] для выделения памяти для динамического массива и delete [] для её освобождения. А есть ли в C++ функции или операторы для перераспледеления динамической памяти?
E>Может быть, для этих целей мне следует использовать STL--стандартную библиотеку шаблонов? ( http://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B0%D0%BD%D0%B4%D0%B0%D1%80%D1%82%D0%BD%D0%B0%D1%8F_%D0%B1%D0%B8%D0%B1%D0%BB%D0%B8%D0%BE%D1%82%D0%B5%D0%BA%D0%B0_%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD%D0%BE%D0%B2 )
E>Какие контернейры и итераторы в этом случае мне придётся использовать?

E>У меня почти нет опыта работы с STL, поэтому я и спрашиваю об этом.
С++ унаследовал от С все функции системы malloc/free.
Навскидку не вспомню средств перераспределения. Сильно подозреваю, что их и нет.

Можно перегрузить функции new/new[] так, чтобы они перераспределяли память. Хотя бы используя ту же realloc() в реализации.
Есть еще класс allocator в стандартной библиотеке — это стандартный распределитель памяти для контейнеров.
Можно написать свой, опять же с возможностью перераспределения.

Здравствуйте, erslgoeirjh, Вы писали:

E>В простом языке C существовали функции malloc для выделения динамической памяти, realloc для её перераспределения (например, когда увеличивается длина массива) и free для освобождения массива.

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

E>В C++ появились операторы new [] для выделения памяти для динамического массива и delete [] для её освобождения. А есть ли в C++ функции или операторы для перераспледеления динамической памяти?
E>Какие контернейры и итераторы в этом случае мне придётся использовать?

E>У меня почти нет опыта работы с STL, поэтому я и спрашиваю об этом.


Для замены массивов Си проще всего брать std::vector — у него есть resize.
Накладные расходы минимальны, есть дополнительные бонусы.

Используй std::vector. С ним можно работать как и с обычным сишным массивом

someFunc (&*vec.begin (), vec.size ());

И не надо париться на счет освобождения памяти.

Здравствуйте, panter_dsd, Вы писали:

_>Используй std::vector. С ним можно работать как и с обычным сишным массивом
_>

_>someFunc (&*vec.begin (), vec.size ());
_>

_>И не надо париться на счет освобождения памяти.

Тогда уж лучше

someFunc (&vec[0], vec.size ());

Здравствуйте, erslgoeirjh, Вы писали:

E>В простом языке C существовали функции malloc для выделения динамической памяти, realloc для её перераспределения (например, когда увеличивается длина массива) и free для освобождения массива.

E>В C++ появились операторы new [] для выделения памяти для динамического массива и delete [] для её освобождения. А есть ли в C++ функции или операторы для перераспледеления динамической памяти?

Пока нет классов, realloc имеет смысл, так как мы оперируем фактически просто блоками данных. При наличии классов возможность реаллокации в общем случае некорректна.

Здравствуйте, Pavel Dvorkin, Вы писали:

PD>Здравствуйте, erslgoeirjh, Вы писали:

E>>В простом языке C существовали функции malloc для выделения динамической памяти, realloc для её перераспределения (например, когда увеличивается длина массива) и free для освобождения массива.

E>>В C++ появились операторы new [] для выделения памяти для динамического массива и delete [] для её освобождения. А есть ли в C++ функции или операторы для перераспледеления динамической памяти?

PD>Пока нет классов, realloc имеет смысл, так как мы оперируем фактически просто блоками данных. При наличии классов возможность реаллокации в общем случае некорректна.

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

Здравствуйте, zaufi, Вы писали:

PD>>Пока нет классов, realloc имеет смысл, так как мы оперируем фактически просто блоками данных. При наличии классов возможность реаллокации в общем случае некорректна.

Z>небольшая поправочка: даже если у нас нет классов, с реаллокацией надо быть аккуратным, ибо где-то еще могут хранится указатели на эту реаллоцированную память (например в этой реаллоцированной памяти был утсроен связный список)

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

Здравствуйте, K13, Вы писали:

K13>Для замены массивов Си проще всего брать std::vector — у него есть resize.
K13>Накладные расходы минимальны, есть дополнительные бонусы.

Ваше предложение построено так, что можно понять:
накладные расходы resize минимальны.

Во-первых, одна величина не может быть минимальна! Относительно чего???
Во-вторых, не хототе же Вы сказать что накладные расходы resize несущественны?

I>realloc ни что иное, как выделение новой памяти и копирование туда информации за исключением некоторых ситуаций:
I>-- когда аллокатор выделяет с некоторым выравниванием, и новый размер находится в рамках границы выравнивания -- более вероятно.
I>-- когда особый аллокатор, выделеивший изначально большую память под себя, видя что на хвосте перевыделяемой памяти есть место, может удленить память -- это очень редкая вероятность
I>-- может забыл что-то

если аллокатор может использовать возможности Memory Mapping Unit: то есть сам настраивать таблицы так, что добавляемая память казалась непрерывной, несомтря на то что физически она прерывна.

Здравствуйте, dilmah, Вы писали:

D>если аллокатор может использовать возможности Memory Mapping Unit: то есть сам настраивать таблицы так, что добавляемая память казалась непрерывной, несомтря на то что физически она прерывна.

Это как? Точнее на каких платформах?

Здравствуйте, dilmah, Вы писали:

D>если аллокатор может использовать возможности Memory Mapping Unit: то есть сам настраивать таблицы так, что добавляемая память казалась непрерывной, несомтря на то что физически она прерывна.

в который раз придётся напомнить, что адресное пространство тоже фрагментируется

D>>если аллокатор может использовать возможности Memory Mapping Unit: то есть сам настраивать таблицы так, что добавляемая память казалась непрерывной, несомтря на то что физически она прерывна.

BZ>в который раз придётся напомнить, что адресное пространство тоже фрагментируется

в который раз появилась возможность указать на еще один плюс 64-битных архитектур

А на AS/400 указатели были 128-битными

E>В простом языке C существовали функции malloc для выделения динамической памяти, realloc для её перераспределения (например, когда увеличивается длина массива) и free для освобождения массива.

Когда-то пытался сделать шаблон простого динамического массива и на практике понял — realloc использовать неудобно по следующим причинам:

1) Ссылки на элементы массива могут хранится в сторонних указателях. Поэтому они должны иметь константные адресса. Если так, то realloc не подходит, так как он может перемещать блоки в памяти.

2) Операция realloc дорогая по производительности, если необходимо переносить блоки из одного места в другое.

В моей ситуации помогла структура примерно такого вида

template <class T>
struct CElement
{
   int Count;
   T   Data[8000/sizeof(T)];
   CElement<T*> Next;
};

где Count это текущее число элементов в массиве, Data — сам массив, а Next — это указатель на следующую такую структуру, если количество элементов привысит максимальный размер Data[]. При этом если удаляется весь массив — удаляются и все подчиненные структуры. Иначе память только выделяется.

При таком подходе нужны только операторы new и delete/

On 17.08.2011 11:33, LaptevVV wrote:

> С++ унаследовал от С все функции системы malloc/free.
> Навскидку не вспомню средств перераспределения. Сильно подозреваю, что их и нет.

Да нет их, нет.

> Можно перегрузить функции new/new[] так, чтобы они перераспределяли память. Хотя
> бы используя ту же realloc() в реализации.

> Есть еще класс allocator в стандартной библиотеке — это стандартный
> распределитель памяти для контейнеров.

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

Здравствуйте, MasterZiv, Вы писали:

MZ>On 17.08.2011 11:33, LaptevVV wrote:

>> С++ унаследовал от С все функции системы malloc/free.
>> Навскидку не вспомню средств перераспределения. Сильно подозреваю, что их и нет.

MZ>Да нет их, нет.

>> Можно перегрузить функции new/new[] так, чтобы они перераспределяли память. Хотя
>> бы используя ту же realloc() в реализации.

>> Есть еще класс allocator в стандартной библиотеке — это стандартный
>> распределитель памяти для контейнеров.

MZ>Про allocator в стандартной бибилиотеке лучше забыть и не вспоминать
MZ>никогда.
Ну почему. Стенли Липпман неплохо про него написал. Может служить в качестве примера реализации своего.
У Александреску — тоже неплохо написано, но там не для новичков.
Еще у Скотта Мейерса можно почитать про идеи управления памятью.
Ну, и на закуску — смотреть Элджера...