template

[Tc++H]

Kleines Problem: Warum führ dieser Code zum ständigen Fehler:
: error C2955: "tpl::AutoPointer": Für die Verwendung der template-Klasse ist eine template-Argumentliste erforderlich.

//*************************************************************************//
// HEADER
//*************************************************************************//
#include "../core/StdTypes.h"

//*************************************************************************//

//*************************************************************************//
// NAMESPACE
//*************************************************************************//
namespace tpl
{

//*************************************************************************//
// CLASS
//*************************************************************************//
template<class T_>
class AutoPointer
{
private:
	T_* pointer_;

public:
		// Constructor
	AutoPointer(T_* pointer = 0);
	AutoPointer(const AutoPointer& autoPointer);
		// Destructor
	~AutoPointer(nhVoid);

		// Operators
	template<class X_>
	AutoPointer& operator =(const AutoPointer<X_>& autoPointer);
	template<class X_>
	operator AutoPointer<X_>();
	T_& operator *() const;
	T_* operator->() const;

		// Functions
	T_*		get		(nhVoid) const;
	T_*		release	(nhVoid);
	nhVoid	reset	(T_* pointer = 0);
};
//*************************************************************************//

//*************************************************************************//
// MEMBERS
//*************************************************************************//

//*************************************************************************//
// Constructor
//*************************************************************************//
AutoPointer::AutoPointer(T_* pointer /* = 0 */) : pointer_(pointer)
{

}

//*************************************************************************//
// Copy-Constructor
//*************************************************************************//
AutoPointer::AutoPointer(const AutoPointer& autoPointer) : 
						pointer_(const_cast<AutoPointer&>(autoPointer).release())
{

}

//*************************************************************************//
// Destructor
//*************************************************************************//
AutoPointer::~AutoPointer(nhVoid)
{
	delete(pointer_);
}

... ...

[camper]

AutoPointer::AutoPointer(T_* pointer /* = 0 */) : pointer_(pointer)
{

}

du mußt dem compiler hier schon sagen, dass du hier memberfunktionen einer templateklasse implementierst und wie die parameter heißen sollen. also

template<typename T_> AutoPointer<T_>::AutoPointer(T_* pointer /* = 0 */) : pointer_(pointer)
{

}

die namen, die du den parametern eines templates gibst, gehören nicht zu seiner signatur und sind austauschbar.

[Tc++H]

Habs gemacht und bekomme wieder folgenden Fehler(aber Fehleranzahl hat sich reduziert)

error C2955: "tpl::AutoPointer": Für die Verwendung der template-Klasse ist eine template-Argumentliste erforderlich.

[Tc++H]

+ error C2244: 'tpl::AutoPointer<T_>::{ctor}': Keine Übereinstimmung für Funktionsdefinition mit vorhandener Deklaration gefunden

[camper]

das template< .. > muss nat. in allen definitionen wiederholt werden (es sollte nicht notwendig sein, darauf hinzuweisen). und bitte auch die konkrete stelle zeigen, an der der fehler auftritt.

[Tc++H]

bei dem ersten Konstruktor tritt der Fehler wieder auf. (ich habe schon überall das Template... hingeschrieben)

[camper]

Tc++H schrieb:

bei dem ersten Konstruktor tritt der Fehler wieder auf. (ich habe schon überall das Template... hingeschrieben)

dann hast du einen schreibfehler drin. zeig doch mal den betreffenden code und die deklaration.

[Tc++H]

Da die Klasse recht klein ist, habe ich alles in die Header Datei geschrieben.

Klasse:

template<class T_>
class AutoPointer
{
private:
	T_* pointer_;

public:
		// Constructor
	AutoPointer(T_* pointer = 0);
	AutoPointer(const AutoPointer& autoPointer);
		// Destructor
	~AutoPointer(nhVoid);
...

Konstruktor:

template<class T_>
AutoPointer::AutoPointer(T_* pointer /* = 0 */) : pointer_(pointer)
{

}

[CStoll]

Da fehlt noch ein <T_> in der Definition des Konstruktor's:

template<class T_>
AutoPointer[b]<T_>[/b]::AutoPointer(T_* pointer /* = 0 */) : pointer_(pointer)
{

}

[GPC]

Tc++H schrieb:

Da die Klasse recht klein ist, habe ich alles in die Header Datei geschrieben.

Dir bleibt auch bei größeren, ja gigantischen Template-Klassen nichts anderes übrig, als alles in den Header zu schreiben. Hier ist nix mit Deklaration in den Header und Definition in die cpp Datei.

MfG

GPC

[Tc++H]

Gut, vielen Dank für die Hilfe, der Fehler hatte mich schonmal aufgehalten.

[Tc++H]

Es gibt aber noch paar Problemchen:

Klasse:

template<class X_>
	AutoPointer& operator =(const AutoPointer<X_>& autoPointer);

Definition:

template<class T_, class X_>
AutoPointer& AutoPointer<T_>::operator =(const AutoPointer<X_>& autoPointer)
{
	reset(const_cast<X_*>(autoPointer.release()));

	return(*this);
}

Fehler:

error C2955: "tpl::AutoPointer": Für die Verwendung der template-Klasse ist eine template-Argumentliste erforderlich.

[Tc++H]

Nein, hatt sich geklärt

AutoPointer<T_>::...

[Tc++H]

Den Fehler bekomme ich noch:

1>
error C2244: 'tpl::AutoPointer<T_>::operator =': Keine Übereinstimmung für Funktionsdefinition mit vorhandener Deklaration gefunden
1>        Definition
1>        'tpl::AutoPointer<T_> &tpl::AutoPointer<T_>::operator =(const tpl::AutoPointer<X_> &)'
1>        Vorhandene Deklarationen
1>        'tpl::AutoPointer<T_> &tpl::AutoPointer<T_>::operator =(const tpl::AutoPointer<X_> &)'

Klasse:

template<class X_>
	AutoPointer& operator =(const AutoPointer<X_>& autoPointer);

Definition:

template<class T_, class X_>
AutoPointer<T_>& AutoPointer<T_>::operator =(const AutoPointer<X_>& autoPointer)
{
	reset(const_cast<X_*>(autoPointer.release()));

	return(*this);
}

[GPC]

Tc++H schrieb:

Klasse:

template<class X_>
	AutoPointer& operator =(const AutoPointer<X_>& autoPointer);

Ein Template Parameter.

Definition:

template<class T_, class X_>
AutoPointer<T_>& AutoPointer<T_>::operator =(const AutoPointer<X_>& autoPointer)
{
	reset(const_cast<X_*>(autoPointer.release()));

	return(*this);
}

Zwei Template Parameter.

[Tc++H]

Hab jetzt auch in der Klasse:

template<class T_, class X_>
	AutoPointer& operator =(const AutoPointer<X_>& autoPointer);

ABER: der gleiche Fehler tritt wieder auf...

[GPC]

Die gesamte Klasse braucht diese zwei Template-Parameter, nicht nur diese einzelne op-Überladung. Also:

template <class T_, class X_>
class Autopointer {
  //... 
};

Ansonsten: kompletten Code herzeigen.

MfG

GPC

[Tc++H]

Ok, kompletten Code^^.

/*************************************************************************//
// INCLUDE GUARD
//*************************************************************************//
#if !defined(__tpl_AutoPointer_h__)
#define __tpl_AutoPointer_h__
//*************************************************************************//

//*************************************************************************//
// HEADER
//*************************************************************************//
#include "../core/StdTypes.h"

//*************************************************************************//

//*************************************************************************//
// NAMESPACE
//*************************************************************************//
namespace tpl
{

//*************************************************************************//
// CLASS
//*************************************************************************//
template<class T_>
class AutoPointer
{
private:
	T_* pointer_;

public:
		// Constructor
	AutoPointer(T_* pointer = 0);
	AutoPointer(const AutoPointer& autoPointer);
		// Destructor
	~AutoPointer(nhVoid);

		// Operators
	template<class T_, class X_>
	AutoPointer& operator =(const AutoPointer<X_>& autoPointer);
	template<class T_, class X_>
	operator AutoPointer<X_>();
	T_& operator *() const;
	T_* operator->() const;

		// Functions
	T_*		get		(nhVoid) const;
	T_*		release	(nhVoid);
	nhVoid	reset	(T_* pointer = 0);
};
//*************************************************************************//

//*************************************************************************//
// MEMBERS
//*************************************************************************//

//*************************************************************************//
// Constructor
//*************************************************************************//
template<class T_>
AutoPointer<T_>::AutoPointer(T_* pointer /* = 0 */) : pointer_(pointer)
{

}

//*************************************************************************//
// Copy-Constructor
//*************************************************************************//
template<class T_>
AutoPointer<T_>::AutoPointer(const AutoPointer& autoPointer) : 
						pointer_(const_cast<AutoPointer&>(autoPointer).release())
{

}

//*************************************************************************//
// Destructor
//*************************************************************************//
template<class T_>
AutoPointer<T_>::~AutoPointer(nhVoid)
{
	delete(pointer_);
}

//*************************************************************************//
// Operator =
//*************************************************************************//
template<class T_, class X_>
AutoPointer<T_>& AutoPointer<T_>::operator =(const AutoPointer<X_>& autoPointer)
{
	reset(const_cast<X_*>(autoPointer.release()));

	return(*this);
}

//*************************************************************************//
// Operator
//*************************************************************************//
/*template<class T_, class X_>
AutoPointer<T_>::operator AutoPointer<X_>()
{
	return(AutoPointer<X_>.release());
}
*/
//*************************************************************************//
// Operator *
//*************************************************************************//
template<class T_>
T_& AutoPointer<T_>::operator *() const
{
	return(*pointer_);
}

//*************************************************************************//
// Operator->
//*************************************************************************//
template<class T_>
T_* AutoPointer<T_>::operator ->() const
{
	return(pointer_);
}

//*************************************************************************//
// get
//*************************************************************************//
template<class T_>
T_* AutoPointer<T_>::get(nhVoid) const
{
	return(pointer_);
}

//*************************************************************************//
// release
//*************************************************************************//
template<class T_>
T_* AutoPointer<T_>::release(nhVoid)
{
	T_* tmp  = pointer_;
	pointer_ = 0;

	return(tmp);
}

//*************************************************************************//
// reset
//*************************************************************************//
template<class T_>
nhVoid AutoPointer<T_>::reset(T_* pointer /* = 0 */)
{
	if(pointer_ != pointer)
	{
		delete(pointer_);

		pointer_ = pointer;
	}
}

//*************************************************************************//
}
//*************************************************************************//

//*************************************************************************//
// INCLUDE GUARD
//*************************************************************************//
#endif
//*************************************************************************//

[GPC]

ja, wie ich sagte: Die gesamte AutoPointer Klasse braucht zwei Template-Parameter, wenn du der op= Methode zwei spendieren willst. C'ést la vie.

[Tc++H]

Den Spaß hatte ich früher mal geproggt und der ließ sich auch anstandslos kompilieren...

/*************************************************************************//
// INCLUDE GUARD
//*************************************************************************//
#if !defined(__autoPtr_h__)
#define __autoPtr_h__

//*************************************************************************//

//*************************************************************************//
// HEADER
//*************************************************************************//

//*************************************************************************//
// NAMESPACE
//*************************************************************************//
namespace uty
{

//*************************************************************************//
// CLASSES
//*************************************************************************//
template<class T_>
class autoPtr
{
private:
	T_* ptr_;

public:
	autoPtr(T_* ptr = 0) : ptr_(ptr)
	{

	}

	autoPtr(const autoPtr& aptr) : ptr_(const_cast<autoPtr&>(aptr).release())
	{

	}

	~autoPtr(void)
	{
		delete(ptr_);
	}

	template<class X_>
	autoPtr& operator= (const autoPtr<X_>& aptr)
	{
		reset(const_cast<X_*>(aptr.release()));

		return(*this);
	}

	template<class X_>
	operator autoPtr<X_>()
	{
		return(autoPtr<X_>(release()));
	}

	T_& operator* () const
	{
		return(*ptr_);
	}

	T_* operator->() const
	{
		return(ptr_);
	}

	T_* get(void) const
	{
		return(ptr_);
	}

	T_* release(void)
	{
		T_* tmp = ptr_;
		ptr_ = 0;
		return(tmp);
	}

	void reset(T_* ptr = 0)
	{
		if(ptr_ != ptr)
		{
			delete(ptr);
			ptr_ = ptr;
		}
	}

};

}

//*************************************************************************//
// INCLUDE GUARD
//*************************************************************************//
#endif

//*************************************************************************//