stack an einen anderen anhängen

floppy

ich hab eine stapel-datenstruktur geschrieben, und ich möchte eine funktion void append(stack &s); einbauen, die einen stack an einen anderen anhängt (quasi um ihn erweitert)

mein programm lässt sich kompilieren und auch starten... gibt auch die richtigen werte aus, stürzt dann aber ab. hier der code:

main.cpp

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

int main()
{
	Stack Stapel(3);
	Stapel.push(1);
	Stapel.push(2);
	Stapel.push(3);

	Stack second(2);
	second.push(4);
	second.push(5);

	Stapel.append(second);
	cout << Stapel.top();

	return 0;
}

stack.h

#ifndef stack_h
#define stack_h

class Stack
{
protected:
	int maximum;
	int hoehe;
	int *feld;					
public:
	Stack (int n);				
	Stack (const Stack &kopie);
	~Stack ();					
	void push (int x);			
	void pop();					
	void append (Stack &s);
	double top();				
	bool empty();				
};

#endif

stack.cpp

#include "stack.h"

Stack::Stack (int n)
{
	feld = new int[n];
	maximum = n;
	hoehe = 0;
}

Stack::Stack (const Stack &kopie)
{
	hoehe = kopie.hoehe;
	maximum = kopie.maximum;
	feld = new int[maximum];
	for (int i = 0; i < maximum; i++)
	{
		feld[i] = kopie.feld[i];
	}
}

void Stack::append (Stack &s)
{
	int *feld2;
	feld2 = new int[hoehe + s.hoehe];
	for (int i = 0; i < hoehe; i++)
		feld2[i] = feld[i];
	for (int j = hoehe; j < (hoehe + s.hoehe); j++)
		feld2[j] = s.feld[j - hoehe];
	hoehe += s.hoehe;
	maximum += s.maximum;
	for (int k = 0; k < maximum; k++)
		feld[k] = feld2[k];
	delete[] feld2;

}

Stack::~Stack ()
{
	delete[] feld;
}

void Stack::push (int x)
{
	if (maximum > hoehe)
	{
		feld[hoehe] = x;
		hoehe++;
	}
}

void Stack::pop ()
{
	if(hoehe != 0)
	{
		feld[hoehe] = 0;
		hoehe--;
	}
}

double Stack::top ()
{
	if(hoehe > 0)
		return feld[hoehe - 1];
	else
		return -1;
}

bool Stack::empty ()
{
	if(hoehe == 0)
		return true;
	else
		return false;
}

AUTSCH!!!

for (int k = 0; k < maximum; k++) 
        feld[k] = feld2[k];

floppy

hää? das ist schon so gedacht!?!? also ich will das neue feld2 wieder durch das feld überschreiben und es dann wieder löschen...

ist doch okay oder? wo ist der fehler!?!?

floppy

okay... hat was gedauert
AUA!!!! feld ist zu klein

danke

Jester

void Stack::append (Stack &s)
{
	int *feld2;
	feld2 = new int[hoehe + s.hoehe];
	for (int i = 0; i < hoehe; i++)
		feld2[i] = feld[i];
	for (int j = hoehe; j < (hoehe + s.hoehe); j++)
		feld2[j] = s.feld[j - hoehe];
	hoehe += s.hoehe;
	maximum += s.maximum;

         // bis hier ist die Funktion korrekt

         // aber jetzt kopierst Du diese große Anzahl an Elementen
         // in das viel zu kleine feld.
	/*for (int k = 0; k < maximum; k++)
		feld[k] = feld2[k];
	delete[] feld2;*/

         //korrekt wäre:
         delete [] feld; // altes Feld freigeben
         feld = feld2;   // neues Feld wird aktuelles Feld
}

MfG Jester

floppy

^^ ich hatte es ja schon gecheckt und korrigiert...

void Stack::append (Stack &s)
{
	int *feld2;
	feld2 = new int[hoehe + s.hoehe];
	for (int i = 0; i < hoehe; i++)
		feld2[i] = feld[i];
	for (int j = hoehe; j < (hoehe + s.hoehe); j++)
		feld2[j] = s.feld[j - hoehe];
	hoehe += s.hoehe;
	maximum += s.maximum;
	delete[] feld;
	int *feld;                //"feld" muss natürlich neu erstellt werden
	feld = new int[maximum];
	for (int k = 0; k < hoehe; k++)
		feld[k] = feld2[k];    //und alle elemente werden reinkopiert
	delete[] feld2;

}

floppy

aso... durch

feld = feld2;

wird einfach der zeiger geändert (nicht der inhalt)

sprich: es darf dann kein

delete[] feld2;

mehr kommen

floppy

ich hab noch ne frage... ich habe noch eine funktion geschrieben, die die größe der Stacks nach oben hin ändert...

die funktioniert auch... nur stürzt das programm wie bei dem oberen problem halt wieder ab...
kann mir jemand sagen, wo diesmal der dumme fehler ist? *g*

void Stack::enlarge(int m)
{
	int *feldtemp;
	feldtemp = new int[maximum];
	for (int i=0; i < hoehe; i++)
		feldtemp[i] = feld[i];
	delete[] feld;
	feld = feldtemp;
	maximum = m;
}

floppy

void Stack::enlarge(int m) 
{ 
    int *feldtemp; 
    feldtemp = new int[m]; 
    for (int i=0; i < hoehe; i++) 
        feldtemp[i] = feld[i]; 
    delete[] feld; 
    feld = feldtemp; 
    maximum = m; 
}

so gehts