Welche Sprache lernen ?

[Knuddlbaer]

Oh mann, da fällt einen doch nichts mehr ein.

So wie Du die Aufgabe interpretierst, erfüllst Du die Aufgabe nicht, weil Du die Originalkiste nicht vergrößerst sondern löschst und neu anlegst.

Aber machst ja eh was Du willst.....

Das was Du herausgefunden hast ist totaler humbuck. Du legst so zwei temporäre Kisten an und lässt den Zeiger auf die 2. Temporäre Kiste zeigen.

[Artchi]

Also die Aufgabe stellt sich aber einfacher, als du es umsetzen willst. Gehen wir mal davon aus, das du wirklich nur das umsetzen sollst, was du jetzt fett markiert hast, würde ich es so lösen:

class IntArray
{
    int feldAnzahl;
    int maxFelder;
    int *kiste;

public:
    IntArray(int felder)
    {
        kiste = new int[felder];
        feldAnzahl = 0;
        maxFelder = felder;
    }

    void add(int a)
    {
       if(feldAnzahl < maxFelder) {
           kiste[feldAnzahl] = a;
           feldAnzahl++;
       }
    }
};

So, ich hoffe ich habe keinen Fehler drin. In deiner Aufgabe steht nichts davon, das die Kiste sich in der Größe ändern soll.

Wenn du das machen willst (Kiste soll sich auch nachträglich ändern), hast du einen Denkfehler in deinem letzten Beispiel: du kopierst die Pointer einmal zu viel um und du legst dir eine temporäre Kiste unnötig an. Warum? Ich versuche es zu erklären: du hast ein originale Kiste, die zu klein ist. Aber "kiste" ist bei dir nur ein Zeiger! Ein Zettel, es ist nicht DIE physikalische Kiste. So, dann legst du eine temporäre Kiste an, die gleich die richtige Größe hat. Und legst die zwei alten Sachen (ints) in die neue Kiste rein. Gut. Für die zweite Kiste hast du einen neuen Zettel (Zeiger) namens TempKiste. Ok?

Warum legst du jetzt eine dritte Kiste an? Du bist doch bis jetzt fast fertig. Warum nimmst du nicht den zweiten Zettel, und schreibst den Inhalt (nur ein ZEIGER-Wert, nicht die physikalische zweite Kiste!!!) auf den Zettel der EHEMALIGEN ersten Kiste?

Mit diesem Schritt wäre alles fetig und du könntest deinen ersten Zettel weiter benutzen. Ohne dritte Kiste und ohne dritten Zettel.

Um den Inhalt des Zettels 2 auf Zettel 1 zu schreiben, sieht so aus:

Kiste = TempKiste;

Kommt dir bestimmt bekannt vor?

Versuch mal das, was ich dir jetzt erzählt habe, in C++ code umzusetzen. Und lasse das deleten auch erstmal weg. Das kannst du auch danach einbauen... aber nur aus Verständniszwecke später einbauen.

Übrigens würde ich auch zum besseren Verständnis, Kiste nicht Kiste nennen, sondern z.B. kiste_pointer oder zettel_kiste. Nur für dich als Einsteiger, damit du das visuell besser im Source siehst.

[STF-DIR]

Hallo,

danke für deine Antwort !!
Ich habe das Kapitel nochmals nachgeschlagen jedoch nichts anderes festgestellt als das was ich hier schon geschrieben habe.

So poste ich hier jetzt mal den ORIGINAL Quelltext der IntKlasse:

Die Klasse IntFeld :

class IntFeld {
  int *feld;
  int groesse;

public:
  IntFeld(int g): groesse(g) {
    feld = new int[groesse];
  }
  ~IntFeld() {
    delete[](feld);
  }

  void setWert(int pos, int wert) {
    feld[pos]=wert;
  }

  int getWert(int pos) const {
    return(feld[pos]);
  }
};

dazu die main.cpp :

int main() {
  cout << "Wie viele Werte:";
  int x;
  cin >> x;
  IntFeld f(x);
  for(int i=0; i<x; ++i) {
    cout << "Wert " << i+1 << ":";
    int w;
    cin >> w;
    f.setWert(i,w);
  }
}

Das hier ist mir eigentlich klar.
Also setWert und getWert und das Erstellen des Feldes mit IntFeld f(x);

So, jetzt kommt die Klasse DynIntFeld :

class DynIntFeld {
  int *feld;
  int groesse;
  int kapazitaet;

public:
  DynIntFeld(): feld(new int[2]), groesse(0), kapazitaet(2)
  {}

  DynIntFeld(int g): groesse(g), kapazitaet(g) {
    feld = new int[groesse];
  }
  ~DynIntFeld() {
    delete[](feld);
  }

  void setWert(int pos, int wert) {
    feld[pos]=wert;
  }

  int getWert(int pos) const {
    return(feld[pos]);
  }

  int size() const {
    return(groesse);
  }

  int capacity() const {
    return(kapazitaet);
  }

  void add(int wert) {
    if(groesse>=kapazitaet) {
      int* nf=new int[kapazitaet*2];
      for(int i=0; i<groesse; ++i)
        nf=feld[i];
      delete[](feld);
      feld=nf;
      kapazitaet*=2;
    }
    feld[groesse++]=wert;
  }
};

Hierbei ist mir schonmal unklar was es mit der kapazitaet auf sich hat
und wie genau der Konstruktor funktioniert ?
DynIntFeld(): feld(new int[2]), groesse(0), kapazitaet(2)
{}
Wieso denn new int[2] ??? und wieso kapazitaet(2) ?????

dann hier :
int* nf=new int[kapazitaet2];
ein neuer Zeiger nf mit der kapazitaet2 ???
Wieso ?
dann hier:
delete[](feld); // Zeiger feld löschen ???
feld=nf; // und hier plötzlich dem eben gelöschten Zeiger etwas zuweisen ?
Wieso geht das ?

Hier noch die Aufgabe aus dem Buch abgeschrieben :

Kapitel 12.6

Schreiben Sie eine Klasse [i]DynIntFeld

*, die wie in der Klasse IntFeld aus dem Kapitel ein int-Feld verwaltet. Sie soll zusätzlich zu den Methoden getWert und setWert, die sich auf bereits bestehende Feldelemente beziehen, eine neue Methode Add besitzen, mit der ein neue Element an die bestehenden Elemente angehängt wird. Technisch könnte das so aussehen, das Sie ein neue, größeres Array dynamisch reservieren, die Werte des alten Arrays in das neue kopieren und das alte Array löschen. Sie könnten natürlich auch intern ein vector-Objekt verwenden, davon sollten Sie jedoch wegen des Übungscharakters absehen.

So, das ist GENAU der Text aus dem Buch.
Da Ihr alle etwas anderes schreibt denke ich mittlerweile das ich hier irgendwas doch nicht richtig verstanden habe und auf dem Holzweg bin.
Deswegen habe ich hier mal die komplette Aufgabe gestellt.

Was ich nicht verstehe habe ich ja geschrieben.
Noch eins...gehe ich erstmal richtig das

int * kiste_pointer = new int[2];

Kiste_pointer ist nur der Zettel auf dem steht WO die Kiste ( im SPeicher ) zu finden ist.
Das "new int[2]" wäre dann eigentlich die physiche Kiste ??

Matthias

[MFK]

STF-DIR schrieb:

Wieso denn new int[2] ???

Weil die anfängliche Kapazität 2 ist,

und wieso kapazitaet(2) ?????

Willkür seitens des Entwicklers. Die Klasse hat eine Kapazität, die größer ist als die Menge der Daten. Das hat den Zweck, dass das Datenarray nicht bei jedem Anfügevorgang vergrößert werden muss. Das spart Zeit, verschwendet aber dafür ein wenig Speicher.

ein neuer Zeiger nf mit der kapazitaet*2 ???
Wieso ?

Wiederum Willkür. Wenn das Array schließlich vergrößert werden muss, wird gleich Platz für doppelt soviele Elemente angelegt. Grund siehe oben.

feld=nf; // und hier plötzlich dem eben gelöschten Zeiger etwas zuweisen ?
Wieso geht das ?

Wieso geht das nicht? Delete löscht nicht den Zeiger, sondern das, auf das der Zeiger zeigt. Delete macht die Kiste kaputt, nicht den Zettel. Den Zettel kannst du dann neu beschriften, das macht die Zuweisung an den Zeiger.

Technisch könnte das so aussehen, das Sie ein neue, größeres Array dynamisch reservieren, die Werte des alten Arrays in das neue kopieren und das alte Array löschen.
...
So, das ist GENAU der Text aus dem Buch.

Und das ist genau das, was in diesem Code passiert.

int * kiste_pointer = new int[2];

Kiste_pointer ist nur der Zettel auf dem steht WO die Kiste ( im SPeicher ) zu finden ist.
Das "new int[2]" wäre dann eigentlich die physiche Kiste ??

Fast, new int[2] erzeugt die Kiste und liefert dir einen Zettel.

[Simon2]

STF-DIR schrieb:

...Hierbei ist mir schonmal unklar was es mit der kapazitaet auf sich hat...

Ich will mich nicht groß einmischen (Du hast hier schon deutlich bessere Ratgeber als mich :D) und vielleicht ist es auch nicht neu, aber Vieles wird leichter, wenn man weiß, dass

http://de.wikipedia.org/wiki/Kapazität schrieb:

... Kapazität (v. lat. capacitas „Fassungsvermögen“ ...

ist.
Wenn Du überall mal "Fassungsvermögen" liest, wo "Kapazität" steht, wird vielleicht einiges klarer.
Wenn Du das schon wusstest: Vergiss mein Post und entschuldige Deine vergeudete Lebenszeit...

Gruß,

Simon2.

[STF-DIR]

Hallo,

erst mal dank an MFK und Simon2 für die Antworten.
MFK ganz besonders für die große Mühe die sich aber wirklich gelohnt hat, denn
da haben wir den Fehler :

Wieso geht das nicht? Delete löscht nicht den Zeiger, sondern das, auf das der Zeiger zeigt. Delete macht die Kiste kaputt, nicht den Zettel. Den Zettel kannst du dann neu beschriften, das macht die Zuweisung an den Zeiger.

Das ist es, ich hatte das so verstanden das ein delete[]() den Zeiger samt der Kiste löscht und danach gar nix mehr da ist.

Ok,dann hab ich das jetzt auch endlich kapiert wieso
feld = tempFeld; geht und das TempFeld dann icht gelöscht werden kann...klar.
Danke...endlich...

Das mit der kapazität .. naja, warum er das gemacht hat und einen so durcheinander bringt wird wohl sein Geheimnis bleiben

Ok, dann danke ich euch allen nochmals !!

Matthias

[Simon2]

STF-DIR schrieb:

..
Das mit der kapazität .. naja, warum er das gemacht hat und einen so durcheinander bringt wird wohl sein Geheimnis bleiben :-)...

Nicht ganz. Immerhin muß man einmal festlegen, wie groß die Kiste am Anfang sein soll .... und um wieviel sie jeweils vergrößert werden soll.

Gruß,

Simon2.

[STF-DIR]

Hallo,

laut diesem Konstruktor :

public: 
  DynIntFeld(): feld(new int[2]), groesse(0), kapazitaet(2) 
  {}

welcher mit

DynIntFeld f;

ausferufen wird erstellt er einen IntArray mit 2 Elementen, IntArray[0] und IntArray[1] ja.

Aber warum am Anfang gleich 2 ?

Matthias

[Knuddlbaer]

Du liest schon was hier geschrieben wird oder müssen es einfach 5 Leute stehts wiederholen ?!

und wieso kapazitaet(2) ?????

Willkür seitens des Entwicklers. Die Klasse hat eine Kapazität, die größer ist als die Menge der Daten. Das hat den Zweck, dass das Datenarray nicht bei jedem Anfügevorgang vergrößert werden muss. Das spart Zeit, verschwendet aber dafür ein wenig Speicher.

[Simon2]

STF-DIR schrieb:

...
Aber warum am Anfang gleich 2 ?

Matthias

Simon2 schrieb:

...Immerhin muß man einmal festlegen, wie groß die Kiste am Anfang sein soll ...

... und da er sich vermutlich gedacht hat "naja, 2 kommen meistens sowieso irgendwann rein", hat er wohl "auf Vorrat" geplant.
So kann er sich beim ersten Add diesen Teil (also das Neuanlegen, Kopieren und Löschen) sparen:

if(groesse>=kapazitaet) {
      int* nf=new int[kapazitaet*2];
      for(int i=0; i<groesse; ++i)
        nf[i]=feld[i];
      delete[](feld);
      feld=nf;
      kapazitaet*=2;
    }

Im letzten Statement kommt die Strategie zum Ausdruck: "Je öfter ich vergrößern muß, umso mehr hole ich mir jedesmal auf Vorrat !" (beim ersten Mal 4, dann 8, dann 16 ....)
Ist halt der Versuch,

• weder einen Haufen überflüssigen Speichers zu reservieren (zu hohe Kapazität)
• noch zu oft neu reservieren zu müssen (zu kleine Kapazität)

Gruß,

Simon2.

[STF-DIR]

Simon2 schrieb:

STF-DIR schrieb:

...
Aber warum am Anfang gleich 2 ?

Matthias

Simon2 schrieb:

...Immerhin muß man einmal festlegen, wie groß die Kiste am Anfang sein soll ...

... und da er sich vermutlich gedacht hat "naja, 2 kommen meistens sowieso irgendwann rein", hat er wohl "auf Vorrat" geplant.
So kann er sich beim ersten Add diesen Teil (also das Neuanlegen, Kopieren und Löschen) sparen:

if(groesse>=kapazitaet) {
      int* nf=new int[kapazitaet*2];
      for(int i=0; i<groesse; ++i)
        nf[i]=feld[i];
      delete[](feld);
      feld=nf;
      kapazitaet*=2;
    }

Im letzten Statement kommt die Strategie zum Ausdruck: "Je öfter ich vergrößern muß, umso mehr hole ich mir jedesmal auf Vorrat !" (beim ersten Mal 4, dann 8, dann 16 ....)
Ist halt der Versuch,

• weder einen Haufen überflüssigen Speichers zu reservieren (zu hohe Kapazität)
• noch zu oft neu reservieren zu müssen (zu kleine Kapazität)

Gruß,

Simon2.

Hallo,

ja siehste, so schnell kanns gehen und man bekommt einfach mal ne erschöpfende Antwort...danke Simon2 !

Anscheinend gibts hier ja doch Leute die verstehen das hier auch mal jemand schreibt der nicht alles gleich auf Anhieb versteht und mit anchen Sachen eben seine Probleme hat.

Wenn ich die mal mit in meinen Flieger nehme dann verstehen sie sicher auch nicht alles auf Anhieb.

Also danke nochmals !!

Matthias

[Simon2]

STF-DIR schrieb:

...danke Simon2 !...

Gern geschehen.

Gruß,

Simon2.

[MFK]

STF-DIR schrieb:

Anscheinend gibts hier ja doch Leute die verstehen das hier auch mal jemand schreibt der nicht alles gleich auf Anhieb versteht und mit anchen Sachen eben seine Probleme hat.

Wenn das der Fall ist, dann sollte der Fragende aber schon sagen, was er an der Erklärung nicht verstanden hat, und nicht immer wieder dieselbe Frage stellen, als ob er die Antwort gar nicht mitbekommen hätte.