Правильное использование кучи

[rengen]

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

#include <iostream>
using namespace std;

int *mass; 
char answer;
int accum;
void main()
{
	mass= new int[1];
	accum++;
	do
	{
		cout<<"Create new int?:";
		cin>>answer;
		if(answer=='Y')
		{
			accum++;
			mass= new int[accum];
			cout<<"Was created."<<endl;
			cout<<"accum now:"<<accum;

		}
	}while(answer!='N');

	delete[] mass;
	mass=0;

	cout<<mass;
}

и чем отличается
delete mass;
от
delete[] mass;

Delete[2] mass; освободит память по этому адресу?

[sVasilich]

delete[] mass удалит весь массив mass
delete mass удалит начало массива (хотя я здесь могу ошибаться, желательно что бы кто-то более опытный уточнил).

[Пепел Феникса]

Delete[2] mass; освободит память по этому адресу?

нет.
delete это если был new object
delete это для new object[n];
в вашем случае происходят потери mass= new int[accum]; тут, так как старую память вы не освобождаете.

delete mass удалит начало массива (хотя я здесь могу ошибаться, желательно что бы кто-то более опытный уточнил).

это ошибка.
но нужно смотреть по стандарту плюсов.

[rengen]

А как тогда создавать множество динамических объектов? Через список? Но он же медленный! Что, да как делать?


И почему компилятор не устраивает код вроде этого?

#include <iostream>
using namespace std;

class Bigman
{
public:
	int x;
	int y;
	Bigman()
	{
		cout<<"Bigman was created.";
		x,y=0;
	}
};

int BigmanNumber=0;
Bigman *Bigmans[]; 
char answer;
void main()
{
        Bigmans[0]= new Bigman;
	BigmanNumber++;
	Bigmans[1]= new Bigman;
	BigmanNumber++;
	do
	{
		cout<<"Create new Bigman?(Y\N): ";
		cin>>answer;
		if(answer=='Y')
		{
			Bigmans[BigmanNumber]= new Bigman;
			BigmanNumber++;
		}
	}while(answer!='N');

	for(;BigmanNumber>=0;BigmanNumber--)
	{
		delete Bigmans[BigmanNumber];
	}
}

Объясню словами, не случай если кодом я это не правильно записал.
Создаем массив указателей какого-то класса, и по очереди присваиваем свежий адрес каждой ячейке. Конечно теперь количество объектов ограничено размером массива указателей, но всё же размещаться и удаляться указатели в памяти будут быстрее чем целые объекты.
Или кто-нибудь может предложить альтернативу получше?

[Пепел Феникса]

Но он же медленный!

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

вообще берите std::vector или std::list.

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

[Smitt&Wesson]

и чем отличается
delete mass;
от
delete[] mass;

Практически ничем. В С это имело значение. В С++, из-за возможности перегрузки функций, это утратило своё значение. И так и так правильно.

[Пепел Феникса]

В С это имело значение.

о да, в С были new и delete.

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

[Smitt&Wesson]

о да, в С были new и delete.

Пардон, погорячился. Глянул справочник по С и С++. Спутался. У ранних версий С++ это было существенно. Сейчас это не существенно. Где-то на форуме я уже раскрывал эту тему. Вот не помню где.

[_Bers]

Сообщение от Smitt&Wesson

Пардон, погорячился. Глянул справочник по С и С++. Спутался. У ранних версий С++ это было существенно. Сейчас это не существенно. Где-то на форуме я уже раскрывал эту тему. Вот не помню где.

Существенно. Как выделяли память, так и освобождаем. Иначе - UB.
По стандарту UB.

Все дело в том, что компиляторы обязаны различать метод создания блока (дин. массива), и метод создание отдельного объекта.

Однако сам принцип выделения памяти, и запоминания количества элементов стандартном не регламентирован, и это на усмотрение компиляторов.

Так например, многие компиляторы при выделении памяти под блок, выделяют чуть больше памяти. В начале выделенного блока записывают количество выделенных элементов. А указатель на блок возвращают со смещением (на нулевой элемент).

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

delete ptr; // здесь удаление массива, или элемента?

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

Поэтому, неизвестно точно, что произойдёт в этом случае:

int* ptr = new int[100];
delete ptr;

Утечка памяти, крэш, или что-то иное.

http://alenacpp.blogspot.com/2008/01/delete.html