ich habe da folgendes Problem. Ich habe eine Klasse erstellt, die zwei Membervariablen enthält.

long AB_Number_class_Profiles;
AB_classified_Laserprofil *AB_P_class_Profiles;

Und zwar handelt es sich um eine Variable vom Typ long, die mir angibt, wieviele Querprofile in der Klasse enthalten sein sollen und dann zusätzlich einen Pointer auf ein später im Construktor dynamisch generiertes 1D-Array der einzelnen Profile. z.B. der Standardkonstruktor

AB_classified_Laserprofil_Array::AB_classified_Laserprofil_Array(void)
{
AB_Number_class_Profiles = 1;
AB_P_class_Profiles = new AB_classified_Laserprofil[1];
}

Bisher wußte ich immer, wie viele Profile verarbeitet werden sollen und konnte dann über entsprechende Memberfunktionen die Anzahl der Profile ändern, das Feld neu anlegen und anschließend die Profile einfügen (siehe Funktion)

void AB_classified_Laserprofil_Array::Set_Number_of_Profiles(long Number_Profiles)
{
AB_Number_class_Profiles = Number_Profiles;

delete []AB_P_class_Profiles;
AB_P_class_Profiles = new AB_classified_Laserprofil[Number_Profiles];
}

Jetzt möchte ich aber das Feld um neue Profile erweitern, ohne die alten zeitaufwendig aus dem alten Array herauszulesen und in dem neuen erweiterten abzulegen. Gibt es da Möglichkeiten? Vielen Dank!

Ich habe mal was realisiert, was mit Tags arbeitet (weil das ganze sowieso eine Tagbasierte Beschreibung war). War der Speicher knapp schrieb ich ein Tag rein, dass auf den nächsten Speicherblock verwies und dort schrieb ich weiter.
Das ist allerdings etwas spezialisiert.

Wenn Du es etwas universeller wünschst, kannst Du Dir auch die Idee der Linux INodes mal ansehen und daraus was basteln:
Wenn Du üblicherweise 16 Einträge hast, schreibst Du sie in ein Array in Deiner Klasse. Hast Du mehr als 16, aber weniger als 255, erweiterst Du ein Array von Arrays.

class DynamicArray
{
  int      Items;
  Type    Direct[16];     // Einträge 0-15
  Type  * Indirect1[15];  // Einträge 16-255 ( mit 15 Arrays je 16 Einträge )
  Type ** Indirect2[15];  // Einträge 255-65535 ( 15 Arrays je 15 Arrays je 16 Einträge )
};

Die Verwaltung braucht also ein int, ein Array von 16 entsprechend Deines Types und 2 Zeiger. Wo Du zugreifen musst, verrät Dir der Index, das geht bei der hier gewählten Basis recht fix mittels der Und-Funktion und den Schiebeoperatoren.
Für die Einträge 0 bis 16 ist alles easy.
Wenn Du den 16. Eintrag machst, erkennst Du, dass Indirekt2 noch nicht existiert, also legst Du das Array an. Dann erkennst Du, dass Indirekt2[0] noch nicht existiert und legst dafür das Array an, wo Du anschließend den ersten Eintrag plazierst.

So kannst Du auch Array[5] und Array[4711] beschriften, obwohl das Array selber nur 32 Einträge groß ist (plus 2 Zeigerarrays + 1 int + 2 Zeiger = 140 Bytes Verwaltungsoverhead auf 32Bit Rechnern)

Der Zugriff ist entsprechend des Indexes aufwendiger. Dafür ist die Verwaltung bei kleinen Arrays sparsam und das Erweitern kostet nicht viel.

@Xin Sobald ich also das 16. Element setzen will, weise ich dann also dem Pointer Indirect1[0] ein Array mit 16 Elementen meines Typs zu und fülle das 0.Element des 0.Arrays von Indirect1 Richtig? Das heißt dann aber auch, dass ich in der Regel bzw. je nach Wahl meiner Basis (in dem Falle 16) damit rechnen muss, mehr Arrays angelegt zu haben, als ich wirklich nutze.

Also gibt es in meinem konkreten Fall keine Möglichkeit unter Beibehaltung der bisherigen Programmierung (also diese beiden Membervariablen) das Array zu erweitern?

@CStoll Ich werde mir das Ganze gleich mal anschauen. Habe auch von einem Kollegen diesen Tip bekommen.