dynamische Arrays? geht das?

[Poldi]

Hallo,

ich will ein Array haben:

int *meinArray[];

ich weiß aber noch nicht, wie groß das wird, kann man die Dinger dynamisch gestalten? Das Array wird in einer Unterfunktion gefüllt werden, zu dem Zeitpunkt kann ich die Größe aber noch nicht abschätzen.

hoffe ihr versteht was mein problem ist und könnt mir helfen ...

thx,

Poldi

[Hasi]

Hi Poldi,

ich hab so was schon mal gemacht,

aber ich find das Program nicht mehr... Altzheimer laesst gruessen

ich hab das irgendwie mit der funktion malloc() realisiert

vielleicht hilft die ja die Funktion weiter

Liebe Gruesse

Hasi

[CaPPoCCinO]

Hi Poldi,

ich denke schon, das ich Dein Problem verstanden habe, probiere es hiermit:

int const maxarray=100;

int a[maxarray];

und später in der Schleife:

for(int i=0; i<=maxarray; i++) {

cout << "gib eine Zahl in das Array " << i << " ein:";

cin >> a;

}

ich denke, damit müsste es hinhauen.

Gruß

[maddin]

ich denke dynamischer sollte das mit malloc und realloc zu lösen sein.

beispiel:

// erstes anlegen

int* parray = malloc ( /*größe*/ sizeof(int[10]) );

// vergrößern

parray = realloc ( /*alter zeiger*/ parray, /*neue größe*/ sizeof(int[20]) );

beim malloc wird speicher dynamisch angelegt. und zwar in der übergebenen größe in diesem fall sizeof(int[10]) also eine integer feld mit 10 elemente.

beim realloc wird zusätzlich noch ein zeiger mit übergeben. dessen inhalt wird dann in den neu angelegten speicher kopiert.

[Hasi]

Post ueberfluessig maddin war schneller

<FONT COLOR="#a62a2a" SIZE="1">[ 13. September 2001 18:06: Beitrag 1 mal editiert, zuletzt von Hasi ]</font>

[Crush]

Warum macht Ihr das denn nicht mit CArrays? Die sind doch von vornherein dynamisch. Außerdem könnte man auch von der STL eine List oder einen Vektor nehmen, da kann man sogar typgenaue Iteratoren generieren (Templates). Man kann mit Insert und SetAtGrow oder Append was ranknallen ohne sich weitere Gedanken machen zu müssen! Wenn man mit Linked-Lists arbeitet kann man auch Array-artige Strukturen erstellen und ein Sortieren, Verschieben ist relativ einfach mit *prev & *next Einklinken erledigt.

<FONT COLOR="#a62a2a" SIZE="1">[ 13. September 2001 20:57: Beitrag 1 mal editiert, zuletzt von Crush ]</font>

[maddin]

ich denke das es nicht immmer angebracht ist eine klasse aus der stl zu nehmen. für ein einfaches programm, das nur ein array dynamisch anlegen soll und mit daten füllen, brauche ich keine STL. da reichen mir malloc, calloc und realloc.

wenn es dann aber irgendwann möglich sein soll mit diesem array auch noch komplexere aufgaben zu lösen, sei es die daten zu sortieren ... , dann würde ich erst zur STL raten. beim einfachen daten in ein array speichern ist mir das zu viel.

<FONT COLOR="#a62a2a" SIZE="1">[ 14. September 2001 07:26: Beitrag 2 mal editiert, zuletzt von maddin ]</font>

[gugelhupf]

also ich nehm (nur in c++ !) dafür immer new ! warum sich mit malloc und konsorten ärgern ?

int mySize=irgendwas;

char* myArryay=new char[mySize];

....

delete myArryay;

[maddin]

@gugelhupf

vergleich mal beide und sag mir was schwerer ist.

int* pn = new int[20];

delete pn;

// oder

int* pn2 = malloc (sizeof(int[20]));

free (pn2);

also ich weiß ja nicht, ob was leichter ist.

ps: kannst ja mal einen ähnlichen vergleich mit realloc und new aufstellen.

[Poldi]

danke für eure antworten

das mit dem reralloc werd ich mir mal anschauen, ich raff das nämlich nicht ganz.

aber mit den maxwerten definieren will ich nicht, da ich auf den speicher achten muß und vorher nicht weiß, ob das array 10 oder 1000 elemente groß wird.

mich tät nur interessieren, ob ich das so definieren könnte: int *meinArray[10] und dann nachher nachträglich noch ein elftes, zwölftes ... element dranhängen kann ...

kann auch ruhig c++ sein, sollten nur keine windows klassen sein, da ich hier auf digital unix programmiere. nur: ich hab kaum ahnung von c++ ... lol

[maddin]

ein int* ArrayOfInt[10] kannst du später wieder vergrößern. entsprechened mit realloc

beispiel:

int array[10];

array = realloc (array, sizeof(int[20]));

ps: willst du wirklich ein feld von zeigern auf int (int* a[]) oder eine feld mit int werten (int a[]) ?

<FONT COLOR="#a62a2a" SIZE="1">[ 14. September 2001 09:41: Beitrag 1 mal editiert, zuletzt von maddin ]</font>

[Poldi]

ich will ein array von zeigern; diese zeiger zeigen dann auf irgendwelche strings im speicher. im grunde will ich eine Liste simulieren. struct ist nur unpassend dafür.

das realloc, pappt mir das dann noch mal 10 felder hintendran? das, was schon in dem array gespeichert ist, geht mir dann aber nicht verloren, oder? kann ich dann in der realloc klammer auch ne variable benutzen? so in etwa:

  

int array[10];

int i = 50;



array = realloc (array, sizeof(int[i]));

tut es das?

ich kann da halt wirklich nichts hart codieren.

[maddin]

da bin ich mir zu 99% sicher das das funktioniert. ansonsten must du einfach einmal statt sizeof(int), sizeof(int) * i verwenden, dann klappt das zu 100%.

[Crush]

Also das mit dem NEW von oben ist doch eigentlich schwachsinn, weil NEW eh nur malloc() verwendet und halt noch nebenbei die Speicher-Anforderungen in einem Array vermerkt, welches bei Aufruf des obersten Destruktors aufgeräumt wird, damit keine Speicherlücken entstehen. Das CArray ist eine Standard C++ Library und wird überall auf jedem C++-System unterstützt. Dasselbe sollte auch für STL gelten, das wurde nämlich nicht von Microsoft sondern von einem IBM-Anhänger für HP glaub entwickelt und ist heute auch nunmehr Standard auf allen Systemen. Jeder Compiler, der Templates unterstützt sollte auch in der Lage sein die STL einzubinden. Die STL ist im großen und ganzen nämlich nix anderes als eine Container-Library. Container heißt: Es sind mehrere Strukturen von Feldern, Listen und assoziativen Containern vorgefertigt(Maps, Multimaps = Hash-Table-Arrays), welche Daten aller Art (Templates) aufnehmen können und vorgefertigte Standard-Funktionen darauf anwenden können, gerade wie sortieren, invertieren, suchen, automatisches Durchlaufen (for_each()), etc.. Also es ist bestimmt kein Fehler sich wenigstens mal die STL im Groben anzuschauen. In vielen Firmen ist STL übrigens PFLICHT! Gerade ein dynamisch wachsendes Array SCHREIT doch danach, als Template definiert zu werden! Templates sind ja auch ein Hauptbestandteil von C++.

<FONT COLOR="#a62a2a" SIZE="1">[ 14. September 2001 12:10: Beitrag 1 mal editiert, zuletzt von Crush ]</font>

[Poldi]

Ich hab mit dir STL mal grob angeschaut, das sieht eigentlich ganz gut aus. Mein Problem sollte eigentlich mit nem Vektor oder einer Liste zu realisieren sein.

Hat jemand mal n Beispiel für mich zu dem Thema? Ich programmier ja eigentlich nur C und komm mit der C++ Syntax noch nicht klar. Ein Beispiel würde mir sicher sehr weiterhelfen.

Danke!!

[Crush]

Hello Poldi!

Vielleicht hilft Dir das Beispiel zum Verständnis. Wichtig ist es zu checken, was der Iterator soll. Der Iterator ist ein Pointer auf die Inhalte, muß vom Templatetyp mit richtigem Inhaltstyp abgeleitet werden und wird intern bei Zugriffen wie begin() und end() vom Template verwendet. Die Funktionen sind meist Inline, d.h. Geschwindigkeit ist gewährleistet. Die Einträge sind alles verkettete Listen. Ein li. (also mit Punktoperator) zeigt wunderbar alle Variablen des Templates. Der Allokator wird zum anwachsen des Templates verwendet. Es gibt auch die Möglichkeit den Allokator selbst zu definieren. Das bedeutet, nach sagen wir 10 Array-Einträgen muß das Array um weitere 10 anwachsen, usw.. Eigentlich ganz einfach, doch mit den Maps habe ich mir diesmal komischerweise schwer getan. Aber irgendwo habe ich mal damit rumhantiert - muß mir das halt nochmal genauer anschauen. Es sieht komplizierter aus als es ist - schau es Dir einfach mal an - man kann sich schnell daran gewöhnen, vor allem an die Vectors=Array. Wichtig zu wissen: .end() zeigt immer auf letzte Position+1. Den Iterator kann man bequem mit ++ und -- hoch und runter zählen.

#include <list> // Template-Includes

#include <vector>

using namespace std; // unter Umständen wahrscheinlich notwendig

void funktion()

{

list<CString> l1; // Das hier ist die Liste

list<CString>::iterator li=l1.begin(); // Hier wird ein Iterator generiert kompatibel zu li mit Offset .begin()

// Es gibt auch Reverse Iteratoren (laufen rückwärts)

CString x1; // dieser String wird immer mit Inhalten gefüllt

x1="1:Hallo"; // sieht man alles gut im Debugger

l1.insert(l1.end(),x1); // Am Ende der Liste einfügen= normale Reihenfolge

x1="2: Das ist"; // Inhalte werden "kopiert" = call by value

l1.insert(l1.end(),x1);

x1="3:eine Liste";

l1.insert(l1.end(),x1);

li=l1.begin(); // Iterator durch einfügen auf letzte Position, deshalb zurücksetzen

x1=*li++; // Per Dereferenzieren des Iterators wird auf das Listenelement

x1=*li++; // direkt zugegriffen.

x1=*li++;

vector<CString> v1; // entspricht einem Array ungefähr

x1="1:Und nun"; // sieht man alles gut im Debugger

v1.insert(v1.end(),x1);

x1="2:Mal ein";

v1.insert(v1.end(),x1);

x1="3:Vektor";

v1.insert(v1.end(),x1);

x1=v1[0]; // einfach, nicht? wie ein Array halt

x1=v1[1];

x1=v1[2];

}

<FONT COLOR="#a62a2a" SIZE="1">[ 14. September 2001 23:07: Beitrag 1 mal editiert, zuletzt von Crush ]</font>

[Poldi]

danke für dein beispiel ... !! in der theorie hab ich es begriffen *freu*, mal sehen ob ich es auch in die praxis umsetzen kann. werd ich direkt testen!

Danke Dir!!!

[Crush]

Wenn man einen Zeiger auf den Vektor hat, dann klappt das mit den x=vektor[position]; nicht mehr. Dann muß man über:

x=Zeiger_auf_vektor->at(position); auf die Elemente zugreifen. (Nur zur Ergänzung des Threads)

<FONT COLOR="#a62a2a" SIZE="1">[ 23. September 2001 01:18: Beitrag 4 mal editiert, zuletzt von Crush ]</font>

[gajUli]

<BLOCKQUOTE><font size="1" face="Verdana, Arial, Helvetica, sans-serif">Zitat:</font><HR>Original erstellt von Crush:

<STRONG>Wenn man einen Zeiger auf den Vektor hat, dann klappt das mit den x=vektor[position]; nicht mehr. Dann muß man über:

x=Zeiger_auf_vektor->at(position); auf die Elemente zugreifen. </STRONG>

[Crush]

x=(*vektor)[position];

Aaaahaaaa! Das heißt, daß Operatoren noch vor der Dereferenzierung abgearbeitet werden, gell! Das erklärt natürlich alles! Danke!

[gajUli]

<BLOCKQUOTE><font size="1" face="Verdana, Arial, Helvetica, sans-serif">Zitat:</font><HR>Original erstellt von Crush:

<STRONG>x=(*vektor)[position];

Aaaahaaaa! Das heißt, daß Operatoren noch vor der Dereferenzierung abgearbeitet werden, gell! </STRONG>

[Crush]

Ich hab´s probiert. Das mag bei normalen Arrays stimmen, aber bei den STL-Containern funktioniert das Austauschen der Operanden nicht mehr.

Ich frage mich, warum der Stroutrup schrieb, daß der []-Operator keine Typprüfung vornimmt. Er hat auch empfohlen, den Operator mit at() abzusichern.

Hat M$ vielleicht aufgrund dieser Aussage das ganze verändert? Wenn es noch mehr solche Änderungen gibt, dann enthalten einige Abschnitte aus den gängigen Büchern jetzt nicht mehr korrekte Aussagen - und das könnte zu ziemlichen Anwendungsproblemen führen wie z.B.: ("warum klappt denn das schon wieder nicht - hier steht´s doch ganz genauso!!!").

[gajUli]

<BLOCKQUOTE><font size="1" face="Verdana, Arial, Helvetica, sans-serif">Zitat:</font><HR>Original erstellt von Crush:

<STRONG>Ich hab´s probiert. Das mag bei normalen Arrays stimmen, aber bei den STL-Containern funktioniert das Austauschen der Operanden nicht mehr.

</STRONG>