ist das sinnvoll?

leo aka qsch

sry wegen dem titel aber ich wusste wirklich nicht wie ich es sonst nennen sollte

naja also ist das fuer euch sinnvoll?

template<class T>
	class Formulastack : public stack<T, deque<T> >
	{
	public:
		Formulastack() : stack<T>()
		{
			_t = new char[sizeof(T)];
		}
		~Formulastack() { delete _t; }

		T get()
		{
			_t = &top();
			pop();

			return *_t;
		}
	private:
		T *_t;
	};

CStoll

nein, das ist nicht sinnvoll - der stl::stack speichert seine eigenen Daten in einer internen Datenstruktur (deque), da brauchst du nicht noch Daten parallel dazu festzuhalten (davon abgesehen, daß new char[sizeof(T)] grauenhaft ist).

Wenn es dir nur darum geht, für pop() einen Rückgabewert zu erhalten, empfehle ich eher so was:

template<typename T>
T get_pop(stack<T>& s)
{
  T ret = s.top();
  s.pop();
  return ret;
}

leo aka qsch

ok stimmt danke, naja war mal wieder nicht so eine geistreiche idee von mir..

7H3 N4C3R

Die meisten STL-Klassen (speziell die Container) sind nicht dafür designt, von ihnen abzuleiten!

Was Du willst, kannst Du alles mit Komposition erreichen.

spjoe

Jaaa nieder mit den Verbungen, nur noch Kompositionen

Konfusius

es ist icht nur wenig sinvoll sondern auch fehlerhaft
da du _t mit new char[sizeof(T)] initialisierst anstatt mit new T zeigt _t nicht auf ein objekt vom typ T sondern auf uninitialisierten speicher. wenn du nun delete _t aufrufst, dann wird es, wenn du pech hast, krachen. auch eine zuweisung an _t funktioniert dann nicht. solange du für T nur einfache datentypen wie int etc verwendest, deren konstruktoren und destruktoren nichts tun, fällt der fehler aber nicht auf.

und wenn du jetzt denkst "ach, da der fehler nicht auffällt, ist es ja nicht schlimm", dann hast du weit gefehlt. dann ist er nämlich eine tickende zeitbombe und damit besonders schlimm. du verwendest irgendwann einmal nichts ahnend dein selbstgeschriebenes template mit einem datentyp, der im konstruktor/destruktor tatsächlich mal was tut, und peng! anschließend kannst du dich beim debugging verzweifelt durch megabytes von quelltext quälen

CStoll

Ja, das Problem der Speicherverwaltung kommt auch noch dazu. Und außerdem würde _t nach dem ersten Aufruf von get() schon nicht mehr auf den im Konstruktor angelegten Speicher zeigen (der damit heimatlos im Heap zurückbleibt), sondern auf einen Datenbereich, der gerade vom untendrunterliegenden Stack als "unbelegt" gekennzeichnet wurde (wenn du Glück hast, sind die Daten noch gültig, wenn du Pech hast, wurde der Speicherbereich auch physikalisch freigegeben).
Und spätestens am Programmende wendest du zweimal delete auf den selben Speicherbereich an (einmal im std::stack-Destruktor, der seine Daten aufräumt, einmal in deinem Destruktor, der inzwischen irgendwo in die stack-Daten zielt) - und dann crasht es gewaltig.

@spjoe: Verrerbungen sind mitunter nützlich. Nur sollte man wissen, wo man sie einsetzen kann. Und die STL-Klassen sind wie oben gesagt nicht dafür entwickelt, daß man etwas davon ableiten kann (Stichwort: virtueller Destruktor).

Konfusius

stimmt. &top() ist natürlich auch noch murks

@leo aka qsch
aber nur nicht entmutigen lassen! bis weihnachten wird das bestimmt noch was. da mußt du als anfänger durch :D:D:D