C++ in Klasse größeren Array erstellen und alten löschen

[whasabi]

Hallo

Also ich habe einen Klasse in der ich einen Array erstelle und in diesem Array sind Listen und in diesen Listen wiederum wieder Arrays

aber ich will nun in einer Methode meinen derzeitigen Array[zahl] {zB size_t zahl=2} ersetzen durch einen neuen erstellen Array -> Array[zahl von anderem Array+1]
zusäzlich will ich noch andere Werte von dem alten Array übernehmen zB
size_t h=1
size_t g=5 usw...

wie kann ich es machen, wenn ich den alten Array löschen will und dem Programm sagen will: nimm jetzt den neuen Array als eigentlichen Array für alle anderen Methoden


hier ein kleiner Ausschnitt aus meinem Programm (die Listen und die Arrays in den Listen hab ich jetzt weggelassen, da sie für meine Fragen daweil unwichtig sind, und auch die anderen Methoden )

Class Test{
    size_t zahl;   
    size_t h;
    size_t g;
   public:
	// hier stehen meine structs mit den Listen und dem Array in der Liste

   Liste *test;
   };

   Test() {
       h=0;
       g=0;
       zahl = 1;
       test = new Liste[zahl];
    }

 

[dominic.e]

Wenn man Arrays nicht unbedingt braucht, sollte man sie auch nicht verwenden. C++ bietet da schon schöne dynamische Möglichkeiten =)

Wie wäre es mit Listen oder Vectoren? (#include <vector>)

​LG

 

[whasabi]

leider muss ich in diesem Programm einen Array bestehend aus Listen erstellen :/
außerdem darf ich nichts verwenden - nichtmal cout..

 

[Fortatus]

Dann sag deinem Lehrer oder Chef, dass er keine Ahnung hat. Warum C++ nutzen, wenn man die guten Seiten (die _jeder_ C++-Compiler mitbringt) nicht nutzen darf.. Die beste Lösung in deinem Fall wäre halt vector<>

 

[whasabi]

aber trotzdem muss ich das Problem leider lösen ^^

Weiß keiner wie man in einer Methode die Werte des alten Array übernehmen kann, diesen dann löschen und den neuen dann für das restliche Programm verwenden kann?

 

[Fortatus]

Da du bisher nichts über die genutze Version gesagt hast:
Nimm C++11 und einen shared_pointer (wenn du kannst einen unique_pointer). Dann kannst du mit http://www.cplusplus.com/reference/memory/shared_ptr/reset/ das Objekt im Zeiger löschen und das neue array dem alten Zeiger zuweisen.

 

[antred]

Da du bisher nichts über die genutze Version gesagt hast:
Nimm C++11 und einen shared_pointer (wenn du kannst einen unique_pointer). Dann kannst du mit http://www.cplusplus.com/reference/memory/shared_ptr/reset/ das Objekt im Zeiger löschen und das neue array dem alten Zeiger zuweisen.

Dann aber dazu sagen, daß shared_ptr (anders als unique_ptr, welches eine Spezialisierung für Array-Typen hat) per default in seinem Destruktor nicht delete [] sondern einfach nur delete aufruft. Um shared_ptr für Arrays tauglich zu machen, muß man einen custom-Deleter angeben, der eben doch das für Arrays nötige delete [] aufruft:

#include <memory>
#include <iostream>

class Test
{
public:
	Test()
	{
		std::cout << "Default-Konstruktor aufgerufen für Test-Instanz 0x" << std::hex << this << std::dec << ".\n";
	}
	
	~Test()
	{
		std::cout << "Destruktor aufgerufen für Test-Instanz 0x" << std::hex << this << std::dec << ".\n";
	}

};

int main()
{
	std::shared_ptr<int> ptr( new Test[3], std::default_delete<Test[]>() );
}

WARNUNG: Nicht getestest, kann Syntax-Fehler enthalten.

 

[Hancock]

Was macht ihr hier für STL-Lösungen, ich glaub es geht darum, erst du Logik dahinter zum Laufen zu bekommen.

Also Arrays in Listen in einem Array...
Und du willst das alleroberste Array vergrößern:

struct ArrayType{
List *liste;
~ArrayType(){
delete list;
}
};
void move_ArrayType(ArrayType& dest,ArrayType& src){
dest.liste=src.liste;
src.liste=nullptr;//Sonst wird die Liste gelöscht, wenn src gelöscht wird
}
auto newArray=new ArrayType[newSize];
for(size_t i=0;i<oldSize;++i)
move_ArrayType(newArray[i],oldArray[i];
delete[]oldArray;

Dadurch ersparst du dir das Kopieren aller Listen (sofern du sorgfältig arbeitest) und kannst sogar Zeiger in die Elemente der Liste erzeugen, ohne Angst zu haben, dass diese gelöscht werden.

Der Code ist natürlich nur Pseudocode, aber vielleicht ist er ein hilfreicher Lösungsansatz.

 

[antred]

Was macht ihr hier für STL-Lösungen, ich glaub es geht darum, erst du Logik dahinter zum Laufen zu bekommen. [...]

Sorry, dass ich wieder klug rumscheiße , aber in der von dir vorgeschlagenen Lösung solltest du noch anmerken, daß ArrayType-Instanzen nicht kopiert werden dürfen. Was passiert nämlich, wenn du von einer ArrayType-Instanz, deren liste-Pointer auf ein List-Objekt zeigt, eine Kopie erzeugst und sowohl die Kopie als auch das Original später gelöscht werden? Sie versuchen beide, das List-Objekt, auf das liste zeigt, zu löschen. Das kann natürlich nicht gut gehen. Deshalb einfach Kopierkonstruktor und Kopier-Zuweisungsoperator von ArrayType als private deklarieren und nicht implementieren. Wird dann im Code irgendwo versehentlich versucht, eine Instanz von ArrayType-Instanz zu kopieren, meckert der Compiler das gleich an (spätestens aber der Linker).

Ein Konstruktor, der liste zumindest auf null setzt, damit es nicht irgend wo in den Wald zeigt, wäre wahrscheinlich auch nicht schlecht.

struct ArrayType
{
	List *liste;
	
	ArrayType() : liste( nullptr ) {}

	~ArrayType()
	{
		delete list;
	}
	
private:
	// Sowohl Kopierkonstruktor als auch Kopier-Zuweisungsoperator als private deklarieren und
	// __NICHT__ implementieren. Damit wird versehentliches Kopieren von ArrayType
	// unterbunden.
	ArrayType( const ArrayType& );
	ArrayType& operator = ( const ArrayType& );
};

P.S. Ich verstehe, daß das keine vollständige Lösung sein sollte sondern nur ein Denkansatz, aber auf solche fiesen Stolperfallen sollte man einen Neuling trotzdem hinweisen.

 

[Hancock]

Du hast natürlich vollkommen recht, darauf hätte man hinweisen müssen, allerdings kann man da gleich den C++11-Weg wählen:

struct ArrayType{
List *liste;
ArrayType(const ArrayType&)=delete;
ArrayType& Operator=(const ArrayType&)=delete;
};

 

[antred]

Stimmt. War mir allerdings nicht sicher, ob alle Compiler das schon können. Einer der gebräuchlisten Compiler, das Visual Studio, hinkt auch in der 2013-Variante immer noch ein bißcher hinterher, was den C++11-Standard angeht.

 

[Sculletto]

Ich schätze mal, es wird eher so etwas "traditionelles" wie das hier gemeint sein:

class Test{
   private:
    size_t zahl;   
    size_t h;
    size_t g;
   public:
	// hier stehen meine structs mit den Listen und dem Array in der Liste

    Liste *test;
    
    Test();
    void ResizeArray(size_t neueZahl);
   };

Test::Test() {
       h=0;
       g=0;
       zahl = 1;
       test = new Liste[zahl];
}

void Test::ResizeArray(size_t neueZahl) {
      // neues Array mit neuer Größe erzeugen
      Liste *temp = new Liste[neueZahl];  
      // altes Array in neues kopieren
      for (int i = 0; i < zahl; i++) {
           temp[i] = test[i];   // hierzu muss für Liste der Zuweisungsoperator = definiert sein
      }
      // altes Array löschen
      delete [] test;
      // Pointer auf neues Array setzen
      test = temp;
      // neue Größe speichern
      zahl = neueZahl;
}

Wozu g und h gut sein sollen, kann ich mir allerdings auch nicht erklären.

 

[Fonce]

Dann sag deinem Lehrer oder Chef, dass er keine Ahnung hat. Warum C++ nutzen, wenn man die guten Seiten (die _jeder_ C++-Compiler mitbringt) nicht nutzen darf.. Die beste Lösung in deinem Fall wäre halt vector<>

Genau wo kämen wir den hin wenn man Leuten etwas für Datenstrukturen beibringt, damit sie verstehen wie Datentypen wie vector oder list intern arbeiten.
OMG, wie kann man nur so einen blödsinn schreiben?