Größe eines Arrays während der Laufzeit festlegen

[The Incredible Fufialk]

Hallo, ich möchte mit meinem Programm Daten aus einer Datei in ein Array einlesen. Da meine Dateien jedoch unterschiedlich viele Werte enthalten suche ich nach einer Möglichkeit, die Größe des Arrays während der Laufzeit korrekt anzupassen.

Ich stelle mir das ungefähr so vor:

void main()

{

ofstream ofl; // Ausgabestrom

char fileread[64]; // Dateiname der einzulesenden Datei

char filewrite[64]; // Dateiname der Auszugebenden Datei

double c; // Eingabezeichen

char rep; // Kontrollvariable

int y; // Array zum einlesen der Daten

int i = sizeof(fileread);

cout << "\n\n Geben Sie den Dateinamen der zu bearbeitenden Datei ein: ";

cin.getline(fileread, 64);

ifstream ifl(fileread, ios::in|ios::binary); //öffnen der Datei zur Eingabe im Binärmodus

ifl.read((char*)y, sizeof(y)); // Dateiinhalt in Array y einlesen

ifl.close();

.....

Bei dieser Vorgehensweise bleibt die Größe meines Arrays jedoch immer konstant. Vielleicht kennt ja jemand den Trick. Danke

[carstenj]

Hallo,

da du offensichtlich C++ benutzt, würde ich dir empfehlen, std::vector zu benutzen. Damit brauchst du dich nicht um solche Dinge zu kümmern, das wird automatisch erledigt.

BTW: Es heisst int main(), void main() ist falsch.

[sissy66]

BTW: Es heisst int main(), void main() ist falsch.

;-)

Kommt auf den Compiler drauf an. Bei meinem gcc-2.bla.bla kommt da nur ne warning. Vom Stil her ist es aber besser int zu schreiben.

[Guybrush Threepwood]

;-)

Kommt auf den Compiler drauf an. Bei meinem gcc-2.bla.bla kommt da nur ne warning. Vom Stil her ist es aber besser int zu schreiben.

Nein laut standard heißt es int main(), alles andere wird zwar von manchen Kompilern akzeptiert, ist aber falsch.

[Orffi]

;-)

Kommt auf den Compiler drauf an. Bei meinem gcc-2.bla.bla kommt da nur ne warning. Vom Stil her ist es aber besser int zu schreiben.

Es ist nicht entscheidend, was der gcc oder sonst ein Compiler dazu sagt, es ist entscheidend, was (wenn man denn Standard C++ programmiert) das Dokument ISO/IEC 14882 sagt. Das ist zur Zeit der gültige Standard und lässt keinen Zweifel, dass void main (void) nicht dem Standard entspricht.

Wenn man sich nach dem gcc richten würde, wäre auch folgendes erlaubt, was aber ebenso nicht dem Standard entspricht:

void test (void)

{

  int x = 7;

  int y[x];

  //...

}

HTH

Jan

[edit]

Guybrush war schneller...

Dafür liefer ich dann noch die Seitenzahl nach S.43 in dem oben genannent Dokument

[/edit]

[The Incredible Fufialk]

Ich wollte hier keine Diskussion über Standards auslösen. Bei mir hat es keine Fehlermeldung verursacht, aber ich werde mich trotzdem von nun an an die Standards halten. Hat denn nun noch jemand einen Tipp zum eigentlichen Thema?

[carstenj]

Hi,

was spricht gegen std::vector?

[tzeh]

Also ich hab das nicht getestet seh nur Deinen Queltext und da erstellst Du das Array bevor i deklariert wurde und einen Wert bekommt. Vielleicht hilft Dir das.

Gruß

[Biese]

Ein Array lässt sich nicht wirklich dynamisch vergrößern. Arrays werden - sofern sie 'ganz normal' angelegt werden - im Stack abgelegt, ein Vector (oder eine verkettete Liste) wird im Heap abgelegt. Der Heap ist dazu da, den speicher selbst und dynamisch zu verwalten.

die C Funktion malloc macht ja bekanntlich speicher im Heap frei. Du könntest Dir - vorausgesetzt Du hast die nötige Langeweile - selbst eine verkettete Liste programmieren. Dazu brauchst Du nur ein paar kleine Zutaten:

Eine Tüte void-Pointer

einen Startpointer

einen null-Pointer

ein Struct, das aus einem Pointer auf ein eben solches struct und wahlweise aus einem Void-Pointer oder einem anderen Wert besteht.

Man mache nun initial Speicher von der größe <struct> frei. Die zurückgelieferte Adresse wird im start-pointer untergebracht. Der im neuen <struct> befindliche Pointer auf ein weiteres <struct> wird nun auf null gesetzt. Kräftig ümrühren und eine halbe Stunde gehen lassen.

Nun macht man erneut speicher von der Größe <struct> frei. Die Adresse aus dem Start-Pointer wird kurz bei seite gelegt. Stattdessen wird die neu gelieferte Adresse in den Startpointer geschrieben. Der nun 'alte' startpointer wird in unserem neuen <struct> in den pointer geschrieben, der auf andere <struct>s zeigt.

Das ganze kommt für 20 Minuten in den Ofen.

Nachdem das ganze gar ist haben wir folgendes: eine LiFo-Pipe. Last in First out. Denn der Startpointer zeigt auf das zuletzt frei gemachte <struct>. Dieses wiederum zeigt auf das zuvor freigemachte <struct>. Diese Liste lässt sich nun solange weiter verfolgen, bis man auf einen null-Pointer stößt. Wir erinnern uns: das erste Element wurde mit einem solchen Nullpointer versehen. Wir sind also am offiziellen Ende unserer Liste.

Zum Desert können wir nun diesem Null-Pointer den Wert des Startpointers zuweisen. Das ganze kommt in den Kühlschrank, und wir haben einen perfekt geschlossenen Kreis.

:-)

So liebe Kinder. Jetzt husch husch ins Bett.

Bis zum nächsten mal,

euer Onkel Biese