Schwierigkeiten mit Klasse und dynamischen Array

[Matthias Reitinger]

Wie muss ich da den Zuqweisungoperator umschreiben, oder muss ich noch mehr ändern?

Dein Problem ist ein konzeptuelles. Du meinst vermutlich, dass im Ausdruck a[3] = 5 erst operator [] und dann operator = auf deiner Klasse aufgerufen wird. Was tatsächlich passiert: operator [] wird auf deiner Klasse aufgerufen, auf dessen Rückgabe dann anschließend operator =. Damit sich dieser zweite Aufruf auf den in deiner Klasse gespeicherten Wert bezieht, musst du einfach nur eine Referenz zurückgeben.

Grüße, Matthias

PS: Du solltest einen Destruktor für deine Klasse definieren, in der reservierter Speicher wieder freigegeben wird.

 

[Meiki Jay]

Vielen dank für die Hilfe, ich habs jetzt hinbekommen.....

Wegen dem Destruktor, ich muss das dynamische Array so anlegen, dass immer 20 neue Elemente in einer Liste dazugehngt werden, deswegen hab ich noch keinen Destruktor gemacht.

lg Meiki

 

[Online-Skater]

Hallo, es wäre von Vorteil wenn du dein fertigen Code für die Nachwelt bereit stellen würdest. Somit hätte ein fragender User eventuell die Möglichkeit durch die Forumsuche an sein Ziel zu gelangen

mfg

 

[Meiki Jay]

Noch bin ich ja nicht fertig, ich muss ja noch das mit der Liste machen....

Dafür bräuchte ich auch hilfe, ich versth zwar wie man ein Liste macht, aber wie schaffe ich das jetzt mit meinem Programm, dass die jeweils neuen 20 Arrayelemente ans Ende der Liste anghängt werden?

Hier nochmal das fast fertige Programm

using namespace std;
#include<iostream>
#include<list>

class DynArray {
	
public:
	
	int *arr;
	int wert;
	list<int> array;
	
	DynArray () {
		arr = new int [20];
	}
	
	int& operator[](int str) {
		return arr[str]; 
	}
	
	int operator= (int x) {
		return x;
	}
	
	friend ostream& operator<< (ostream& o, DynArray const& x);
};

ostream& operator<< (ostream& o, DynArray const& x) {
	o << x.arr;
};

Also muss ich das Programm vollständig umschreiben oder kann ich das irgendwie mit der Liste hier implementieren?

 

[Online-Skater]

Hey es gibt mehrere Möglichkeiten, eine wäre das du eine Variable Index in der Klasse anlegst , die am Anfang 0 ist. Diese gilt als Array-UIndex und wird beim erfolgreichen eintragen hochgezählt. In der Einfüge-Operation überprüfst du ob der Index 19 ist. Wenn ja dann trägst du das aktuelle Array in die Liste ein (wird kopiert) dann setzt du den Index wieder auf 0 und überschreibst das aktuelle Array. Deine Liste speichert dann alle 20 Einträge diesen Block. Die Liste sieht dann so aus: std::list<int[20]>.
Gibt bestimmt noch viele andere Möglichkeiten.

mfg ;-)

 

[Meiki Jay]

ok, aber wie kopiere ich das array in die liste?

ich schaff das mit dem index im Zuweisungsoperator, aber wie schreib ich das array in die Liste und wie genau füge ich dann die neuen Elemente hinten dran?

 

[Online-Skater]

Am Anfang reserviert der Konstruktor der Klasse DynArray ein Integer Array mit 20 Plätzen. Beim befüllen dieses Arrays mit Werten (Zuweisungsoperator) stellst du fest wieviele Elemente besetzt sind und wenn es 20 sind (if abfrage) dann machst du:

....
if (Index == 20)
{
  int save[20];
  for (int i = 0; i < 20; i++)
  {
     save[i] = arr[i];
  }
  array.push_back(save);  // Hier wird das Array in die Liste kopiert.
  Index = 0;
  arr[Index] = wert;  // Array neu mit Werten füllen
}
else 
{
  arr[Index] = wert
}
Index++;  // Index erhöhen

Zeig mal deine aktuelle Klasse. Eventuell musst du dir noch etwas beim anzeigen der Elemente überlegen.

mfg

 

[Meiki Jay]

Meine Aktuelle Klasse sieht so aus...

using namespace std;
#include<iostream>
#include<list>

class DynArray {
	
public:
	
	int Index;
	int* arr;	
	
	DynArray () {
		arr = new int [20];
	}
	
	int& operator[](int str) {
		return arr[str]; 
	}
	
	void operator= (int wert) {
               	list<int> array; 
		if (Index == 20) {
			int save[20];
			for (int i = 0; i < 20; i++)  {
				save[i] = arr[i];
			}
			array.push_back(save);  // Hier wird das Array in die Liste kopiert.
			Index = 0;
			arr[Index] = wert;  // Array neu mit Werten füllen
		}
		else  {
			arr[Index] = wert;
		}
		Index++;  // Index erhöhen
	}
	
	friend ostream& operator<< (ostream& o, DynArray const& x); 
};


ostream& operator<< (ostream& o, DynArray const& x) {
	o << x.arr;
}

Und ich hab noch eine neue Frage: Wo muss die Variable Index mit 0 initialisieren? In der Klasse selbst kann ich das ja nicht machen, weil die sonst const sein müsste...
Und hier ist Index ja in der if schleife, also wird es theoretisch nie 20 sein, weil das Programm ja nicht von 0 zu zählen anfängt...

Ich bekomme ausserdem den Fehler error: request for member 'push_back' in ... which is of non-class type '__gnu_debug_def::list<int, std::allocator <int> > *'

 

[Meiki Jay]

Ich hab das mit dem push_back fehler gelöst, indem ich einfach eine Schleife geschrieben hab, die jedes einzelne Element aus save kopiert.

Nur das mit dem Index brauch ich noch, wo muss ich die Variale initialisieren, deklariert hab ich sie ja ganz am Anfang der Klasse...

 

[Online-Skater]

Hey ich hab mich nicht an deine Variablen gehalten. Da musst du schon gucken.
Ich habe es mal eben versucht zu implementieren, leider weis ich bei der ausgabe gerade nicht weiter. Vielleicht findet sich ja noch wer der das Problem kennt.

Header:

#ifndef DYNARRAY_H
#define DYNARRAY_H

#include<iostream>
#include<list>

class DynArray {

  public:

    DynArray ();    // Konstruktor
    ~DynArray();    // Destruktor

    int& operator[](int str);
    void insertElem(const int x);

    friend std::ostream& operator<< (std::ostream& o, const DynArray& x);
  private:
        int index;
        int* arr;
        std::list<int*> liste;

};

#endif

Source:

#include "test.h"

DynArray::DynArray()
: index(0)
{
   arr = new int [20];  // Speicher reservieren bei der Initialisierung
}

DynArray::~DynArray()
{
    delete arr; // Am Ende des Programms wird der Speicher freigegeben
}

int& DynArray::operator[](int str)
{
    // Zugriff nur auf das aktuelle Array
    if (str < 20)
    {
        return arr[str];
    }
}

void DynArray::insertElem(const int x)
{
    if (index == 20)
    {
        int save[20];
        for (int i = 0; i < 20; i++)
        {
            save[i] = arr[i];
        }
        liste.push_back(save);  // Hier wird das Array in die Liste kopiert.
        index = 0;
        arr[index] = x;  // Array neu mit Werten füllen
    }
    else
    {
        arr[index] = x;
    }
    index++;  // Index erhöhen
}

std::ostream& operator<< (std::ostream& o, const DynArray& x)
{
    // erst die liste ausgeben
    if (!x.liste.empty())
    {
        o << "Listeneinträge:\n";
        std::list<int*>::iterator it;
        for (it = x.liste.begin(); it != x.liste.end(); ++it) // Warum geht das hier nicht ?
        {

            o << "\n-----------------------------------------\n";
            for (int i = 0; i < 20; i++)
            {
               // o << it[i];   // Zugriff auf ein Element
            }
            o << "\n-----------------------------------------\n";
        }
    }
    // aktuelle Ausgabe
    o << "\naktuelle Elemente:\n";
    for (int i = 0; i < x.index; i++)
    {
        o << arr[i];
    }
}

Vielleicht gibt dir das Anregung. Der Index muss im Konstruktor initialisiert werden.

mfg