Ich habe eine Basisklasse:

template<class T>
class LContainer
{
protected:
	class Element
	{
	public:
		T data;
		Element* next;
		Element(const T& v):data(v),next(NULL) {} //Copy C-tor von Element
	};
	class EmptyLContainerException: public std::exception
	{
		virtual const char* what() throw() {return "LContainer is empty";}
	};
	Element *first;
	unsigned int anz_elem;
public:
	LContainer();
	~LContainer();
	unsigned int getAnzahlElement();
	bool is_empty();
	void clear();
};

Dies ist die basisklasse von Stack, Queue, und Deque

nun habe ich aber das problem, dass Stack ja nicht first, sondern top benutzt, nur weiß ich nicht wie ich machen kann, dass ich top und nicht first benutzen kann?

Trotzdem zu Referenzen: Diese müssen immer im Konstruktor initialisiert werden. Das gilt auch für Referenzen auf Zeiger.

Generell sind Funktionen besser, weil sie die Schnittstellen der Klassen repräsentieren. Dann kannst du die Zeiger auch privat haben. Und wenn du plötzlich noch eine weitere Funktionalität einbauen willst, kannst du die entsprechende Funktion ändern.

template<class T>
class LContainer
{
protected:
	class Element
	{
	public:
		T data;
		Element* next;
		Element(const T& v):data(v),next(NULL) {} //Copy C-tor von Element
	};
	class EmptyLContainerException: public std::exception
	{
		virtual const char* what() throw() {return "LContainer is empty";}
	};
	Element *ptrtofirst;
	unsigned int anz_elem;
public:
	LContainer();
	~LContainer();
	unsigned int getAnzahlElement();
	bool is_empty();
	void clear();
};

template<class T>
class LStack :public LContainer<T>
{
public:
	LStack();
	LStack(const LStack& other);
	~LStack();
	void push(const T& v);
	T pop();
	T& top();
	void swap(LStack& other);
	LStack<T>& operator=(const LStack& other);
};

Dann kannst du ja genauer beschreiben was besser wäre^^

Dann kannst du ja genauer beschreiben was besser wäre^^

Ja, oder du könntest selber überlegen.

Ich hab ja alles schon gesagt: Schreib eine Funktion, die eine Referenz auf den Wert an der ersten Stelle zurückgibt.

T& top();

oder wie meinst du das?

ich schreib mal jetzt die 2 klassen, aber ohne funktionen

Ups, da hab ich wohl nach deiner Mitteilung zu wenig genau hingeschaut. Dennoch hast du die Funktion nur deklariert, was dir noch gar nichts bringt

Definier die Funktion top() und versuch doch einfach mal, eine Referenz auf den ersten Wert zurückzugeben. Wenn ich dir den Code poste, bringt das uns beiden nichts. Bei konkreten Problemen kannst du ja wieder nachfragen.

hier ist mal die ganze klasse:

#ifndef LSTACK_H
#define LSTACK_H

#include "lcontainer.h"

template<class T>
class LStack :public LContainer<T>
{
public:
	LStack();
	LStack(const LStack& other);
	~LStack();
	void push(const T& v);
	T pop();
	T& top();
	void swap(LStack& other);
	LStack<T>& operator=(const LStack& other);
};

template<class T>LStack<T>::LStack()
:LContainer<T>::LContainer()
{
}

template<class T>LStack<T>::LStack(const LStack &other)
:LContainer<T>::LContainer()
{
	if(!other.ptrtofirst) //leerer Stack, nichts zu kopieren
		return;
	this->ptrtofirst = new Element(other.ptrtofirst->data); //wenn hier was fliegt räumt C++ selber auf
	Element *rigth = other.ptrtofirst;
	Element *left = ptrtofirst;
	while(rigth->next)
	{
		try
		{
			left->next = new Element(rigth->next->data); //sollte hier was fliegen...
			rigth = rigth->next;
			left = left->next;
		}
		catch(...)
		{
			clear();   //müssen wir selber aufräumen
			throw;
		}
	}
}

template<class T>LStack<T>::~LStack()
{
	LContainer::~LContainer();
}

template<class T>void LStack<T>::push(const T& v)
{
	Element* temp = new Element(v);
	temp->next = this->ptrtofirst;
	this->ptrtofirst = temp;
	++anz_elem;
}

template<class T>T LStack<T>::pop()
{
	if(!this->ptrtofirst)
		throw EmptyLContainerException();
	T result(this->ptrtofirst->data);
	Element *temp = this->ptrtofirst;
	this->ptrtofirst = this->ptrtofirst->next;
	delete(temp);
	--anz_elem;
	return result;
}

template<class T>T& LStack<T>::top()
{
	if(!this->ptrtofirst)
		throw EmptyLContainerException();
	return this->ptrtofirst->data;
}

template<class T> void LStack<T>::swap(LStack &other)
{
	std::swap(this->anz_elem, other.anz_elem);
	std::swap(this->ptrtofirst,other.ptrtofirst);
}

template<class T> LStack<T>& LStack<T>::operator=(const LStack& other)
{
	LStack<T> temp = other;
	this->swap(temp);
	return *this;
}
#endif

gibt es irgenteinen Sinn manche funktionen als konstantwährend zu deklarieren?

Für mich gibt es keinen Sinn zB: einen const Stack zu erstellen, oder was meint ihr?

Noch ein Detail: Es ist zwar Geschmackssache, aber du brauchst die this-> eigentlich nicht. Wenn sie dir bei der Übersichtlichkeit helfen, lass sie drin. Mich würden sie stören

uhsuhz schrieb:

gibt es irgenteinen Sinn manche funktionen als konstantwährend zu deklarieren?

Grundsätzlich schon. Erstens sieht man dann gerade (und stellt auch sicher), dass die Funktion die Klasse nicht verändert. Zweitens können wie gesagt auch konstante Instanzen diese Funktion benutzen.

Zu dem gerade:

uhsuhz schrieb:

Für mich gibt es keinen Sinn zB: einen const Stack zu erstellen, oder was meint ihr?

Nein, einen erstellen wohl kaum. Eher, wenn du bereits einen Stack hast, und von diesem eine konstante Kopie anfertigst. Oder wenn du eine konstante Referenz an eine Funktion übergibst.

zum dem this. Ich weiß dass man es nicht braucht, aber ich mag es irgentwie lieber wenn ich this-> davor schreibe.

nun habe ich noch ein frage, ich habe den == und den != operator in der basisklasse implementiert.

template<class T>
class LContainer
{
protected:
	class Element
	{
	public:
		T data;
		Element* next;
		Element(const T& v):data(v),next(NULL) {} //Copy C-tor von Element
	};
	class EmptyLContainerException: public std::exception
	{
		virtual const char* what() throw() {return "LContainer is empty";}
	};
	Element *ptrtofirst;
	unsigned int anz_elem;
public:
	LContainer();
	~LContainer();
	unsigned int getAnzahlElement();
	bool is_empty();
	void clear();
	bool operator==(LContainer& other);
	bool operator!=(LContainer& other);
};

template<class T>bool LContainer<T>::operator ==(LContainer& other)
{
	if(this->anz_elem != other.anz_elem)
		return false;
	Element* rigth = other.ptrtofirst;
	Element* left = this->ptrtofirst;
	while(rigth)
	{
		if(rigth->data == left->data)
		{
			rigth = rigth->next;
			left = left->next;
		}
		else
			return false;
	}
	return true;
}

template<class T>bool LContainer<T>::operator!=(LContainer& other)
{
	if(*this == other)
		return false;
	return true;
}

ich dachte dass ich die funktionen überladen müsste in der LStack klasse, und dann per static_cast<LContainer<T>>(...) aufrufen müsste, aber irgenwie klappt es auch wenn ich den operator nicht überladen habe für die LStack-klasse, kann ich das so lassen, oder ist es sicherer wenn ich per static_cast gehe?

ich dachte dass ich die funktionen überladen müsste in der LStack klasse, und dann per static_cast<LContainer<T>>(...) aufrufen müsste, aber irgenwie klappt es auch wenn ich den operator nicht überladen habe für die LStack-klasse, kann ich das so lassen, oder ist es sicherer wenn ich per static_cast gehe?

Ich würde die Operatoren global machen und in den Klassen als Friend deklarieren. Ich würde dann aber für jeden Containertypen, der in der Praxis vorkommt, eine überladene Funktion definieren. Nach Möglichkeit lässt du die Implementierung für die Basisklasse weg, damit es nicht zu ungewollten Vergleichen (implizite Umwandlung) kommt. Oder du machst das ganze in der Klasse (evtl. polymorph). Aber lass op== für die Basisklasse weg, wenn er nicht gebraucht wird.

Und den !=-Operator kannst du einfacher implementieren:

template<class T>bool LContainer<T>::operator!=(LContainer& other)
{
    return !(*this == other);
}

Und right schreibt man so

Und right schreibt man so

lol hab da wohl nicht aufgepasst^^ na lieber mal schnell ändern^^

//Edit
hmm irgentwie verstehe ich nicht genau was ich da machen soll...:-( also aus der basisklasse rausnehmen ist ja klar, aber dann haben die ja keinen zugriff mehr auf element?? und auch nicht mehr auf ptrtofirst, ich müsste die funktion höchstens als friend deklarieren,hmm da bräuchte ich vielleicht wenn es geht genauere beschreibungen

// Deklaration und Definition der Funktion (genauer: des überladenen Operators)
bool operator==(const MyClass& Left, const MyClass& Right)
{
    // ...
}

class MyClass
{
    // Friend-Deklaration innerhalb der Klasse; operator== kann jetzt
    // auf private Member von MyClass zugreifen
    friend bool operator==(const MyClass& Left, const MyClass& Right);
};

öhm vielleicht weil das L für Linked steht?
aber dieser post war jetzt wirklick überflüssig, ich hätte die klasse ja auch
HaltDieFresseStack nennen können, ist ja meine entscheidung

loooooooool

hmm ich merke gerade, dass ich deque gar nicht von basis ableiten kann, da next ja kein prev kennt... gibt es da eventuell eine möglichkeit, dass next aus der basisklasse prev kennt?

Ehm.. Du speicherst dir auch einen Verweise auf prev?!

template<class T>
class MyContainer
{
	template<class T>friend bool operator==(const MyContainer& leftContainer,const MyContainer& rightContainer);
.
.
.
};

und dann in der stack klasse noch mal:

template<class T> bool operator==(const MyStack<T>& left,const MyStack<T>& right)
{
	return (static_cast<MyContainer<T>>(left) == static_cast<MyContainer<T>>(left));
}

template<class T> bool operator!=(const MyStack<T>& left,const MyStack<T>& right)
{
	return !(left == right);
}

diese funktionen sind aber nicht freunde der klasse, brauchen sie auch nicht. funktionieren tut es schon mal^^

Stack und Deque sind zwar Container, aber bei Vererbung das Liskov Substitution Principle beachten.

Ableitung macht hier wenig Sinn. Was du willst ist Komposition.
Damit loesen sich uebrigens auch alle Namensprobleme in Luft auf.

Stack und Deque sind zwar Container, aber bei Vererbung das Liskov Substitution Principle beachten.

io ich werde mir das morgen mal anschauen, für heute habe ich genug^^