[C++] Realokacja pamięci a operator new

[Cabalerio 0]

Zastanawiam się w jaki sposób doalokować pamięć na przykład do obsługi stosu w momencie jak dodajemy nowy element. Jak sobie zrobię

int a = new int[10]

a później po dodaniu 10 elementów będę chciał wstawić 11 to mam lipę. Chodzi o to czy da się doalokować pamięć nie poprzez

int b = new int[20]
for(int i = 0; i < 10; i++)
   b[i] = a[i]
delete [] a

Da się takie coś zrobić ? Czy powyższy przykład jest jedynym rozwiązaniem(jeśli tak to czy może wydajniej będzie użyć malloc i realloc) ?

[209458 867]

Zamiast przepisywać w pętli możesz dać memcpy i różnicy względem realloca nie powinno być. No i najlepiej zwiększać tablicę o wielokrotności pewnej liczby (np. 10, 20, 40, 80), żeby za często tych danych nie kopiować

[revcorey 0]

a nie lepiej stl vector? I nie bawić się w tu jakieś przepisywanie itp. On się tu wewnętrznie zajmie alokacją pamięci z tego co pamiętam.

[Cabalerio 0]

Problem w tym ze mam użyć tablicy do przechowywania danych.

 

Mam kod i memcpy nie działa(kopiuje tylko 1 element), tylko muszę kopiować element po elemencie w konstruktorze kopiującym.

 

class stos
{
int nodesCount;
int *data;

public:
	stos()
	{
		nodesCount = 0;
		data = new int[10];
	};

	stos(const stos & s)
	{
		nodesCount = s.nodesCount;
		data = new int[s.nodesCount+10];

		memcpy(data, s.data, s.nodesCount+1);
		/*
		for(int i = 0; i < s.nodesCount; i++)
		{
			data[i] = s.data[i];
		}*/
	}

	~stos()
	{
		delete [] data;
	};

	// doklada
	void operator<< (int a)
	{
		if(nodesCount >= 0)
			data[nodesCount++] = a;	
		//else
	};

	//pobiera
	void operator>> (int & a)
	{
		if(nodesCount > 0)
			a = data[--nodesCount];

	};
};

 

Nie patrzcie na resztę bo pisze tylko do testów, a podałem cały kod żeby było wiadomo ocb. Może ja źle używam tego memcpy ?

[mejt 0]

Nudzi mi się, więc machnąłem W zasadzie 2 istotne rzeczy:

1. Sprawdzenie, czy trzeba zaalokować więcej pamięci powinno się robić przy próbie dodania nowego elementu, a więc w operatorze <<

2. memcpy kopiuje podaną ilość bajtów, a nie elementów, więc trzecim parametrem nie może być ilość elementów tablicy do przekopiowania(no chyba że element ma rozmiar 1B)

 

#include <cstring>
#include <iostream>

class stos
{
int allocated, used;
int *data;
static const int BLOCK = 10;

public:
		stos()
		{
			data = new int[bLOCK];
			used = 0;
			allocated = BLOCK;
			std::cerr << "Initial state: used=" << used << "; allocated=" << allocated << std::endl;
		};

		~stos()
		{
			delete [] data;
		};

		stos& operator<< (const int& a)
		{
			std::cerr << "Trying to add: " << a << std::endl;

			if(used < allocated) {
				data[used++] = a;
				std::cerr << "Elem added: " << a << "; used=" << used << "; allocated=" << allocated << std::endl;

				//warto zwracać stos& z tego operatora, przez co będzie mozna dodawać kilka elementów w jednej linii(zobacz main)
				return *this;
			} else {
				std::cerr << "Reallocation needed...";

				//alokacja nowej, wiekszej tablicy
				int* newData = new int[allocated + BLOCK];

				//memcpy operuje na bajtach, więc musimy kopiować ilość bajtów, a nie elementów
				memcpy(newData, data, used*sizeof(int));

				//usunięcie starej tablicy, żeby nie ciekło po nogawkach
				delete [] data;

				//ustawienie wskaźnika na nową, powiększoną tablicę
				data = newData;

				//zwiększenie zmiennej zawierającej informację jaką ilością miejsca aktualnie dysponujemy
				allocated += BLOCK;

				std::cerr << " Allocated " << BLOCK << " additional empty stack elements\n";

				//dodanie elementu przez rekurencyjne wywołanie operatora
				return operator<<(a);
			}
		};

		void out() const {
			for(int i=0;i<used;++i) {
				std::cout << data[i] << " ";
			}

			std::cout << std::endl;
		}
};

int main() {
stos s;
s << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11;
s.out();

s << 12 << 13 << 14 << 15 << 16 << 17 << 18 << 19 << 20 << 21 << 23 << 24 << 25;
s.out();

return 0;
}

 

I w zasadzie jeszcze jedna rzecz, przekazuj parametry jako stałe referencje. Zapobiegnie to tworzeniu niepotrzebnej kopii, jesli "int" zamieniłbyś na jakiś inny typ, którego kopiowanie jest kosztowne.

[Cabalerio 0]

Całkiem ciekawy jest ten pomysł z kilkoma operatorami w jednej linii. A memcpy to naprawdę głupi błąd zrobiłem, dzięki za naprostowanie .