habe da nen kleines problemchen.

Ich habe eine template Klasse Programmiert. Soweit so gut, wenn die baer funktionieren würde. Das Problem ist folgendes:

Sobald ich ein objekt erzeuge , bringt mir der Compiler den Fehler:

Kein geeigneter Standardkonstruktor verfügbar

Ich weis net was des sein soll, keine ahnung. Wenn mir einer weiterhelfen kann, wäre ich sehr verbunden.

Hier noch mein gesamter code:

#include <iostream>
#include "Liste.h"
#include "Listenelement.h"
#include "SmartPointer.h"

using namespace std;

void main ()
{

	SmartPointer<Liste> L;
}

#include "Listenelement.h"

class Liste
{
	private:

		Listenelement *anfang;
		Listenelement *ende;

	public:

		Liste(void);
		~Liste(void);
		void einfuegen(int);
		void ausgeben(void);
};

class Listenelement
{
	private:

		int wert;

	public:

		Listenelement(void);
		~Listenelement(void);

		void setWert(int);
		int getWert(void);
};

template<class T>
class SmartPointer
{
	private:

		T *Zeiger;

	public:

		SmartPointer(T*);
		~SmartPointer(void);

		SmartPointer<T>& operator = (T*);
		T* operator -> ();
};

#include ".\liste.h"

Liste::Liste(void)
{
	anfang = 0;
	ende = 0;
}

Liste::~Liste(void)
{
}

void Liste::einfuegen(int x)
{
}

void Liste::ausgeben(void)
{
}

#include ".\listenelement.h"

Listenelement::Listenelement(void)
{
	wert = 0;
}

Listenelement::~Listenelement(void)
{
}

void Listenelement::setWert(int x)
{
	wert = x;
}

int Listenelement::getWert(void)
{
	return wert;
}

#include ".\smartpointer.h"

template<class T>
SmartPointer<T>::SmartPointer(T* p = 0)
{
	Zeiger = p;
}

template<class T>
SmartPointer<T>::~SmartPointer(void)
{
}

template<class T>
SmartPointer<T>& SmartPointer<T>::operator = (T* p)
{
	Zeiger = p;
	return *this;
}

template<class T>
T* SmartPointer<T>::operator ->()
{
	return Zeiger;
}

public:
        SmartPointer(T*);

Du möchtest einen SmartPointer<Liste> mit dem Standardkonstruktor (einem, der null Parameter erwartet) erstellen, hast aber nur einen Konstruktor mit einem Parameter, der ein Liste* erwartet, zur Verfügung.

Entweder Du konstruierst dem Smartpointer eine zu verwaltende Instanz dazu

SmartPointer<Liste> L( new Liste() );

Oder Du spendierst Deinem Smartpointer einen weiteren Konstruktor (wobei das wenig Sinn machen würde).

(seh ich da schon wieder void main? )

Ohje hätte ich das nicht übersehen hätte ich garnicht geantwortet

also:

template<class T>
class SmartPointer
{
    private:

        T *Zeiger;

    public:

        SmartPointer(T*=0); // hier muss die 0 hin
        ~SmartPointer(void);

        SmartPointer<T>& operator = (T*);
        T* operator -> ();
};

template<class T>
SmartPointer<T>::SmartPointer(T* p) // und hier muss sie weg
{
    Zeiger = p;
}

Ah, die Impl hab ich mir garnicht mehr angeschaut nachdem ich den Konstruktor ohne Default-Parameter angeschaut habe

dito. ein guter schiri muss das auch abpfeifen. err...

erstmal danke für eure Hilfe!

Eure Ratschläge habe ich mir mal zu herzen genommen und diese dann auch mal umgesetzt.
Leider funktioniert das so alles nicht. Wobei dies mit dem "void main()" habe ich net so ganz verstanden was gemeint war, aber es muss auch mit "void main ()" funktionieren. Habe auch nen anderen Code ( sehr ähnlich ) wo es auch funktioniert.

Mich würde mal interessiern, ob ihr das auch mal ausgetestet habt?

Z.B. das von "DOMMEL" funktioniert mal garnet. Ich bekomme da nen Fehler, auch ohne ein Objekt zu erstellen. Da könnte ich nen Hals bekommen!!!

Also Jungs ( vielleicht auch Mädels ), bitte bitte bitte, wenn es denn für EUCH machbart ist, dann schriebt was hin, was auch definitiv funktioniert und net irgendwelchen Code, wo ihr der Meinung seit, das es funktionieren müsste allein vom drauf gucken.
Ich unterstellen euch allen mal, das ihr HELFEN wollt. Dann seit so nett und schreibt auch mal das hin was funktioniert.

Gruß

Musterschüler

template<class T> 
class SmartPointer 
{ 
    private: 

        T *Zeiger; 

    public: 

        SmartPointer(T* p=0); 
        ~SmartPointer(void); 

        SmartPointer<T>& operator = (T*); 
        T* operator -> (); 
};

das "=0" musst du dann in der Konstruktor-Definitaion natürlich wieder weg nehmen...

Ich hab deinen Code mal in eine Datei kopiert und die Klassen-Deklarationen so vertauscht, dass sie in der richtigen Reihenfolge stehen und es wird fehlerfrei kompiliert

(denk mal darüber nach: Woher soll der Compiler denn wissen, ob er einen SmartPointer<Liste> oder SmartPointer<int> benötigt, wenn er nur die Pointer.cpp sieht?)

PS@"void main()": mag sein, daß das dein Compiler schluckt, aber laut Standard ist es nicht erlaubt - da heißt das "int main()".