А так вы ничего не проверяете.
Нужно выделить новый блок и только после этого удалять старый. Как это делается в разных строках и векторах.

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

Если вы пишете не связный поток слов, то о деле говорить сложно.

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

C++ (Qt)
#include <iostream>
#include <iomanip>
#include <QVector>
 
using namespace std;
 
int main()
{
	{
		cerr << "Allocate 1Gb" << endl;
		QVector<char> tst( 1024 * 1024 * 1024 );
	}
	{
		cerr << "Allocate..." << endl;
		size_t it = 0;
 
		QVector<char> vec;
		QVector<char> chunk( 1024 * 1024 );
		for(;;)
		{
			vec += chunk;
			cerr << dec << it++ << " Mb" << "   addr = " << hex << reinterpret_cast<const void*>( vec.constData() ) << "   size = " << dec << vec.capacity() << endl;
		}
	}
}
 

Переделал демонстрашку. QVector захватывает память с запасом, поэтому что бы никого не путать решил переделать все на new/delete.

C++ (Qt)
#include <iostream>
#include <iomanip>
 
using namespace std;
 
int main()
{
	{
		cerr << "Allocate..." << endl;
		size_t it = 1;
 
		char *oldPtr = new char[ it * 1024 * 1024 ];
		for(;;)
		{
			size_t sz = ++it * 1024 * 1024;
 
			char *newPtr = new char[ sz ];
			delete[] oldPtr;
			oldPtr = newPtr;
 
			cerr << dec << it << " Mb" << "   addr = " << hex << reinterpret_cast<const void*>( oldPtr ) << "   " << sz << endl;
		}
	}
}
 

Этот пример хорошо показывает, где в адресном пространстве выделяется буфер и если внимательно посмотреть, то можно заметить когда уже освободившиеся блоки объединяются в один и в нем происходит выделение памяти.

Но фрагментация свое дело знает и более 500 с копейками мегабайт мы получить не сможем. Хотя свободной памяти у нас еще чуть меньше полутора гигабайтов.

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

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

По поводу 2 Гб - это ограничение венды, она отдается 2 Гб из 4 пользовательскому процессу, а 2 оставляет для ядра. У linux соотношение другое - 3 пользовательскому коду, 1 ядру. Это все для 32 битных процессов, которые не умеют адресовать более 4 Гб.

Это особенности всех процессоров совместно с flat-mode - особенности непрерывного адресного пространства. Я показывал этот эффект на диаграммах для машины с памятью в 64 байта, он будет аналогичным и для любых других объемов. Только время полной фрагментации адресного пространства придется ждать дольше.

Так с 90-х особо ничего не изменилось. Разработчики вцепились в flat-mode и мы потеряли возможность использовать сегменты, а так бы даже на 32 битных платформах можно было использовать кучу сегментов, размером до 4 Гб, большие буферы легко бы расширялись и никаких проблем с фрагментацией адресного пространства просто не было.

Да я-то еще много лет назад разобрался А разговаривать с "поучающим" больше не хочу

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

Когда наступит этот момент, то выходить из положения будет поздно. Такие моменты не стоит допускать.
Проблема возникает если нужны большие непрерывные блоки памяти, которым еще хочется расширять (т.е. выделять больший блок и копировать туда данные из старого блока).
Если в вашей программе нужны такие блоки, то стоит заранее продумать как их выделять. Например, можно сразу выделить большой блок в памяти и постепенно его заполнять, вместо постоянных переаллокаций все больших блоков.
С небольшими блоками таких проблем не случается, если конечно нет утечек.

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