Wer schreibt da in meinen Speicher?

Hallo,

ich habe in meiner main-Methode eine endlose while-Schleife, die mit jedem Durchgang ein Menue anzeigt, in dem ausgewählt werden kann, ob der Inhalt eines Arrays aufgelistet werden soll. Das Array wurde zuvor mit z.B. 0 initialisiert.

Wenn ich das Programm starte, passiert ganz was komisches:

Bei den ersten 3 Auflistungen steht überall die 0 drinnen, wie es auch sein soll. Aber ab dem 4. steht in der ersten Position eine komische Zahl und zwar immer dieselbe: 48694032. Bei jedem weiteren 2-3. Durchgang werden auch die nachfolgenden Positionen mit dieser Zahl belegt. Ich hab keine Anhnung, wie die dort hin kommen, zumal ich nur bei der Initialisierung in das Array schreibe und später nur lese.

Der Code ist etwas umfangreicher, weshalb ich ihn hier nicht auflisten und euch zumuten möchte Vielleicht weiß jemand ja auf anhieb, wo der Fehler liegt. Ansonsten werd ich den Code vereinfachen und hier posten, falls gewünscht.

Vielen Dank!

hi

Poste uns mal den Code der Initalisierung und des Auslesends.
Kann so noch nichts zu deinem Problem sagen.

gruß
de_Bert

Hi,

ich glaube, ich habe das Problem eingrenzen können. Und zwar verwende ich einen Basisinitialisierer, durch den eine zweite Klasse initialisiert wird. Diese gewrappte Klasse hole ich durch getHeap() aus der zugrundeliegenden Klasse. Wenn ich den Heap direkt initialisiere, funktioniert alles. Wenn ich mir jedoch das Objekt aus der Klasse hole, crasht es im Beispiel sogar schon beim Initialisieren in der Main.cpp in deren main-Methpde:

Definitions.h:

class Heap {

private:
	int *heap;
	int size;

public:
	Heap(int size);
	~Heap();

	void SetVal(int index, int value);
	int GetVal(int index);
	int getSize(void);
};

class HeapWrapper {

private:
	Heap heap;

public:
	HeapWrapper(int size);
	Heap getHeap();
};

Heap.cpp:

#include "Definitions.h"
#include <iostream>
using namespace std;

Heap::Heap(int size) {

	this->size = size;
	this->heap = new int[size];
}

Heap::~Heap() {

	delete[] heap;
}

int Heap::GetVal(int index) {

	cout << "GetVal " << index << "\n";

	return this->heap[index];
}

void Heap::SetVal(int index, int value) {

	cout << "SetVal " << index << ", " << value << "\n";

	this->heap[index] = value;
}

int Heap::getSize() {

	cout << "getSize\n";

	return this->size;
}

HeapWrapper.cpp:

#include "Definitions.h"

HeapWrapper::HeapWrapper(int size) : heap(size) {

	// Do nothing here
}

Heap HeapWrapper::getHeap() {

	return this->heap;
}

Main.cpp:

#include <iostream>
#include "Definitions.h"
using namespace std;

void showHeapLong(Heap &heap) {

	for(int a=0; a<heap.getSize(); a++) {

		cout << a;
		cout << ":";
		cout << heap.GetVal(a);
		cout << " | ";
	}

	cout << "\n";
}

int main() {

	HeapWrapper heapWrapper = HeapWrapper(100);

	// Initialisieren mit der 0
         // Hier crasht es schon nach dem 2. Durchlauf, warum ?????
	for(int a=0; a<heapWrapper.getHeap().getSize(); a++) {

		heapWrapper.getHeap().SetVal(a, 0);
	}

	char action;

	// Schleife, stark vereinfacht...
	while(true) {

		cout << "Eingabe: ";
		cin >> action;

		if(action == '0')
			showHeapLong(heapWrapper.getHeap());

	}
}

Bekomme ich da etwa Probleme mit dem Speicher, wenn ich auf ein Objekt im Objekt zugreife? Wie gesagt, wenn ich direkt Heap erzeuge und damit arbeite, funktioniert es.

Knuddlbaer

Ersetze mal

HeapWrapper heapWrapper = HeapWrapper(100);

durch

HeapWrapper heapWrapper(100);

Problem:

Es ist kein op= definiert.

HeapWrapper(100) wird als temporäres Objekt erzeugt. Das aloziiert den Speicher der nach der Zuweisung freigegeben wird. Der op= kopiert aber nur (!) die Adresse des vom temporär Erzeugten Objekts.

Zu dem Zeitpunkt wo Du heapWrapper verwendest gibt es den Speicher nicht mehr.

(Sobald Zeiger im Spiel sind prüfen ob ein eigener op= und Kopierkonstruktor notwendig ist. Bei Dir wäre das der Fall, und wenn es nur ne deklaration als private ist.)

Mis2com

Hallo,

da lässt dir den Heap als Kopie zurückgeben, du solltest hier eine Referenz oder einen Zeiger verwenden, damit sich die Änderungen auch wirklich auswirken.
Also:

Heap& HeapWrapper::getHeap() {

    return this->heap;
}

statt

Heap HeapWrapper::getHeap() {

    return this->heap;
}

Solltest du korrigieren, auch wenn das Problem wo anders lag.

MfG MAV

Knuddlbaer

Eventuell würde aber auch schon ein std::vectot<int> mit operator[] die gleiche Aufgabe erledigen, wenn die Heapklasse nicht vorgeschrieben wurde.

ChrisM

Hi,

wollte ich auch gerade sagen, die Klasse ist irgendwie überflüssig

Achja,

HeapWrapper heapWrapper = HeapWrapper(100);

erzeugt ein temporäres Objekt und ruft dann den Copyctor auf und nicht operator=()!

ChrisM

ne, den ganz normalen Ctor.

Knuddlbaer

Keine zuweisung ?
Hmmm... An der Stelle fall ich jedesmal auf die Nase weil da ein = steht