Die Klasse Neuron sieht in Auszügen so aus:

class Neuron
{
public:
	double *weight;
	bool initialized;
	bool stored;
	Link **input;
	int nInput;

	Neuron()
	{
		initialized=false;
		stored=false;
		input=NULL;
		weight=NULL;
		nInput=0;
	}
	Neuron(int size, Link **links, bool store)
	{
		nInput=size;
		if (store)
		{
			stored=true;
			input=new Link*[SIZE];
			memcpy(input, links, sizeof(Link *)*SIZE);
		}
		else
		{
			stored=false;
			input=links;
		}		
		weight=new double[nInput];
		printf("    Neuron(parameters)\n        weight address %d allocated\n", weight);
		initialized=true;
	}
	Neuron operator=(const Neuron &other)
	{
		destroy();
		if (other.initialized)
		{
			nInput=other.nInput;
			if (other.stored)
			{
				stored=true;
				input=new Link*[SIZE];
				memcpy(input, other.input, sizeof(Link *)*SIZE);
			}
			else
			{
				stored=false;
				input=other.input;
			}
			weight=new double[nInput];
			printf("    operator=\n        weight address %d allocated\n", weight);
			memcpy(weight, other.weight, sizeof(double)*nInput);

			initialized=true;
		}
		return *this;
	}
	void destroy()
	{
		if (initialized)
		{
			if (weight!=NULL)
				delete[] weight;
			if (stored)
				delete[] input;
		}
		initialized=false;
		weight=NULL;
		stored=false;
		input=NULL;
		nInput=0;
	}
	~Neuron()
	{
		printf("    destructor\n        weight adress: %d\n", weight);
		destroy();
	}

};

Und hier wird sie benutzt:

// global definiert:
Neuron neurons[SIZE][SIZE];

// ... blah blah ...

// später dann irgendwo im Programm:
	for (int i=0; i<SIZE; i++)
		for (int j=0; j<SIZE; j++)
		{
		// ... blah ...
			printf("blah\n");
			neurons[i][j]=Neuron(SIZE*SIZE, links, false);
			printf("blub\n");
		// ... blah ...
		}

Das Problem ist jetzt, dass direkt nach "neurons[i][j]=..." offenbar der Destruktor für neurons[i][j] aufgerufen wird. Also nicht nur für den rechten Operanden, bei dem das ja klar ist.

Die Ausgabe an der Stelle ist:

blah
    Neuron(parameters)
        weight address -2063630320 allocated
    operator=
         weight address -2063495152 allocated
    destructor
        weight adress: -2063495152
    destructor
        weight adress: -2063630320
    blub

Ich hab echt keine Ahnung, warum der Destruktor da gleich aufgerufen wird. Das macht doch keinen Sinn??
Sorry für den langen Code-Abschnitt mit der Neuron-Klasse. Aber da muss ja wohl irgendwo der Fehler drin stecken und ich hab keine Ahnung, wo.

Grüße
Krecik

...nach jahrelanger dilletantischer Gelegenheits-C++-Programmiererei...

Ohne böse sein zu wollen, genau so sieht dein Code auch aus. Was willst du mit dieser Klasse eigenlich erreichen? Zudem scheinst du eine absolute Vorliebe für Zeigerarithmetik zu haben (womit du dir das Leben nur unnötig schwer machst).

Vielleicht kann man dir helfen in dem du mal beschreibst was du mit dieser Klasse erreichen willst (und Bitte: printf, public Membervariablen, memcpy [mit Ausnahme von Absoluten Sonderfällen] gehören nicht in sauberes C++). Zudem sollte ein Konstruktor immer einen sauberen Initialzustand haben (und warum verwendest du eine Methode destroy obwohl es in den Destruktor gehört?).

Ganz davon abgesehen: Der Destruktor wird am Ende der Lebenszeit aufgerufen (Sprich: falls du das Element lokal angelegt hast am Ende des Scopes und bei dynamischen beim delete). Die Membervariablen (sofern sie nicht statisch sind) werden dadurch ungültig, so das du diese auch nicht auf Initialwerte setzen musst. Zudem hat delete eine Automatische Prüfung gegen NULL, sofern du nicht anschließend mit dem Zeiger noch was anstellst kannst du dir somit sowohl das if, als auch das = NULL sparen.

cu André

class Neuron
{
public:
    typedef std::pair< double, Link* > link_type;
    typedef std::vector< link_type > links_type;
    links_type links;
    Neuron() : links() {}
    explicit Neuron(const links_type& links)
        : links( links )
    {}
};

Hier passiert also nicht viel - kein Grund dafür 100 Zeilen fehlerhaften Code zu verschwenden.
initialized und stored sind sowieso überflüssig, nInput korrespondier mit links.size()
ich bin einfach mal davon ausgegangen, dass korrespondierende weight und Links-Elemente zusammengehören.

bool initialized;

Nicht destruktoren sind dein Problem, sondern generell Initialisierungen.
Der Konstruktor sollte initialisieren, naemlich das was dein operator= und dein nicht Default-Konstruktor macht.

Indem du diese initialized-Variable wegwirfst, reduzierst du die Komplexitaet enorm.

Im Prinzip ist dein destroy() genau das was ein Destruktor macht - nur dass du eben mit dem initialized komplett gegen diese Mechanik arbeitest. Der Fehler in deinem Code liegt aber in der Verletzung der Regel der grossen 3.

Kleiner Tip:
achte mal auf den Rueckgabetyp vom operator==

Im Prinzip ist dein destroy() genau das was ein Destruktor macht - nur dass du eben mit dem initialized komplett gegen diese Mechanik arbeitest.

Deswegen wohl auch destruktive Destruktoren im Topic

hab auch mal versucht die struktur bis auf die einzelnen neuronen runterzubrechen, und glaub mir, das macht nur ärger ...

Viele Grüße
Unkraut