Ich habe ein Array auf dem Heap wie z.B. das hier:

char *meinArray = new char[10];

Dann brauch ich ein elftes Element. Wie soll ich das Problem am effizientisten lösen (ohne std)?

Aber gibt es einen Grund, die STL nicht zu verwenden?

Nexus schrieb:

Aber gibt es einen Grund, die STL nicht zu verwenden?

Jop, muss auf komplett eigener Basis sein (ausser Schlüsselwörter)...

EDIT: Geht das?

char *array1 = new char[10];
char *temparray = new char[10];
for(int c = 0; c < 10; c++)
{
  temparray[c] = array1[c];
}
delete[] array1;
array1 = new char[11];
for(int c = 0; c < 10; c++)
{
  array1[c] = temparray[c];
}
array1[10] = '!';

Gruß,
Stephan.

Nun müsste zweitesArray den Namen von erstesArray haben...

EDIT: Geht das?

char *array1 = new char[10];
char *temparray = new char[10];
for(int c = 0; c < 10; c++)
{
  temparray[c] = array1[c];
}
delete[] array1;
array1 = new char[11];
for(int c = 0; c < 10; c++)
{
  array1[c] = temparray[c];
}
array1[10] = '!';

Ja, aber das geht auch einfacher:

int main()
{
	char *array1 = new char[10];

	char *array2 = new char[11];
	for (int i = 0; i < 10; ++i)
	{
		array2[i] = array1[i];
	}

	delete[] array1;

	array1 = array2;

	array1[10] = '!';

	delete[] array1;

	return 0;
}

Ohne jemanden angreifen zu wollen: Die hier gezeigten Codes sind grauenhaftes C++ (unübersichtlich, mühsam in der Handhabung, sehr fehleranfällig). Am ehesten geht noch kljkljk's Version, aber auch das kann man noch einfacher lösen.

EOutOfResources schrieb:

Dann brauch ich ein elftes Element. Wie soll ich das Problem am effizientisten lösen (ohne std)?

Wenn es effizient sein soll, spricht etwas dagegen, es gleich wie std::vector zu lösen? Also vorallokieren und bei Bedarf vergrössern? Dann hat man nämlich nicht bei jedem Einfügen ein Umkopieren der ganzen Sequenz.

Dann hat man drei Variablen: Zeiger auf dynamisches Array, Kapazität (totale Anzahl Array-Elemente) und Grösse (Anzahl momentan benutzter Array-Elemente). Die kann man mindestens in einem struct zusammenfassen.

template <class T>
class SmartArray {
	public:
		SmartArray(size_t len = 100) : size_(len) {
			buf_  = new T[len];
		}
		~SmartArray(void){ delete [] buf_; }
		size_t size(void) const { return size_;}
		T& operator[](size_t i){
			if(in_range(i)) return buf_[i];	}
	private:
		size_t size_;
		T* buf_;
		bool in_range(size_t i) const {
			return (i>=0 && i<size());};		
};

Anbei als Hilfestellung
...

Ein Code-Beispiel, welches die Dreierregel verletzt, finde ich wahrscheinlich nicht so hilfreich wie Du. Außerdem sollte der Konstruktor explicit sein.

... Dreierregel ... sollte der Konstruktor explicit sein.

Selbstverständlich! Ist natürlich richtig. Der Range-Check hat auch kein else usw.