<![CDATA[template]]>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_);
}

... ...

]]>https://www.c-plusplus.net/forum/topic/150632/templateRSS for NodeSat, 05 Sep 2026 20:34:46 GMTSun, 18 Jun 2006 20:56:43 GMT60<![CDATA[Reply to template on Sun, 18 Jun 2006 20:58:35 GMT]]>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_);
}

... ...

]]>https://www.c-plusplus.net/forum/post/1080270https://www.c-plusplus.net/forum/post/1080270Sun, 18 Jun 2006 20:58:35 GMT<![CDATA[Reply to template on Sun, 18 Jun 2006 21:12:39 GMT]]> 
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.

]]>https://www.c-plusplus.net/forum/post/1080277https://www.c-plusplus.net/forum/post/1080277Sun, 18 Jun 2006 21:12:39 GMT<![CDATA[Reply to template on Sun, 18 Jun 2006 21:22:17 GMT]]>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.

]]>https://www.c-plusplus.net/forum/post/1080283https://www.c-plusplus.net/forum/post/1080283Sun, 18 Jun 2006 21:22:17 GMT<![CDATA[Reply to template on Sun, 18 Jun 2006 21:23:47 GMT]]>+ error C2244: 'tpl::AutoPointer<T_>::{ctor}': Keine Übereinstimmung für Funktionsdefinition mit vorhandener Deklaration gefunden

]]>https://www.c-plusplus.net/forum/post/1080284https://www.c-plusplus.net/forum/post/1080284Sun, 18 Jun 2006 21:23:47 GMT<![CDATA[Reply to template on Sun, 18 Jun 2006 21:27:22 GMT]]>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.

]]>https://www.c-plusplus.net/forum/post/1080286https://www.c-plusplus.net/forum/post/1080286Sun, 18 Jun 2006 21:27:22 GMT<![CDATA[Reply to template on Sun, 18 Jun 2006 21:29:12 GMT]]>bei dem ersten Konstruktor tritt der Fehler wieder auf. (ich habe schon überall das Template... hingeschrieben)

]]>https://www.c-plusplus.net/forum/post/1080289https://www.c-plusplus.net/forum/post/1080289Sun, 18 Jun 2006 21:29:12 GMT<![CDATA[Reply to template on Sun, 18 Jun 2006 21:48:42 GMT]]>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.

]]>https://www.c-plusplus.net/forum/post/1080299https://www.c-plusplus.net/forum/post/1080299Sun, 18 Jun 2006 21:48:42 GMT<![CDATA[Reply to template on Mon, 19 Jun 2006 08:22:23 GMT]]>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)
{

}
]]>https://www.c-plusplus.net/forum/post/1080421https://www.c-plusplus.net/forum/post/1080421Mon, 19 Jun 2006 08:22:23 GMT<![CDATA[Reply to template on Mon, 19 Jun 2006 08:28:50 GMT]]>Da fehlt noch ein <T_> in der Definition des Konstruktor's:

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

}
]]>https://www.c-plusplus.net/forum/post/1080427https://www.c-plusplus.net/forum/post/1080427Mon, 19 Jun 2006 08:28:50 GMT<![CDATA[Reply to template on Mon, 19 Jun 2006 08:32:43 GMT]]>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

]]>https://www.c-plusplus.net/forum/post/1080428https://www.c-plusplus.net/forum/post/1080428Mon, 19 Jun 2006 08:32:43 GMT<![CDATA[Reply to template on Mon, 19 Jun 2006 08:47:57 GMT]]>Gut, vielen Dank für die Hilfe, der Fehler hatte mich schonmal aufgehalten.

]]>https://www.c-plusplus.net/forum/post/1080435https://www.c-plusplus.net/forum/post/1080435Mon, 19 Jun 2006 08:47:57 GMT<![CDATA[Reply to template on Mon, 19 Jun 2006 08:50:41 GMT]]>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.
]]>https://www.c-plusplus.net/forum/post/1080440https://www.c-plusplus.net/forum/post/1080440Mon, 19 Jun 2006 08:50:41 GMT<![CDATA[Reply to template on Mon, 19 Jun 2006 08:51:55 GMT]]>Nein, hatt sich geklärt

AutoPointer<T_>::...
]]>https://www.c-plusplus.net/forum/post/1080443https://www.c-plusplus.net/forum/post/1080443Mon, 19 Jun 2006 08:51:55 GMT<![CDATA[Reply to template on Mon, 19 Jun 2006 09:42:32 GMT]]>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);
}
]]>https://www.c-plusplus.net/forum/post/1080484https://www.c-plusplus.net/forum/post/1080484Mon, 19 Jun 2006 09:42:32 GMT<![CDATA[Reply to template on Mon, 19 Jun 2006 09:46:50 GMT]]>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.

⚠

]]>https://www.c-plusplus.net/forum/post/1080486https://www.c-plusplus.net/forum/post/1080486Mon, 19 Jun 2006 09:46:50 GMT<![CDATA[Reply to template on Mon, 19 Jun 2006 09:49:35 GMT]]>Hab jetzt auch in der Klasse:

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

ABER: der gleiche Fehler tritt wieder auf...

]]>https://www.c-plusplus.net/forum/post/1080490https://www.c-plusplus.net/forum/post/1080490Mon, 19 Jun 2006 09:49:35 GMT<![CDATA[Reply to template on Mon, 19 Jun 2006 09:52:53 GMT]]>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

]]>https://www.c-plusplus.net/forum/post/1080492https://www.c-plusplus.net/forum/post/1080492Mon, 19 Jun 2006 09:52:53 GMT<![CDATA[Reply to template on Mon, 19 Jun 2006 09:53:44 GMT]]>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
//*************************************************************************//
]]>https://www.c-plusplus.net/forum/post/1080496https://www.c-plusplus.net/forum/post/1080496Mon, 19 Jun 2006 09:53:44 GMT<![CDATA[Reply to template on Mon, 19 Jun 2006 09:56:05 GMT]]>ja, wie ich sagte: Die gesamte AutoPointer Klasse braucht zwei Template-Parameter, wenn du der op= Methode zwei spendieren willst. C'ést la vie.

]]>https://www.c-plusplus.net/forum/post/1080499https://www.c-plusplus.net/forum/post/1080499Mon, 19 Jun 2006 09:56:05 GMT<![CDATA[Reply to template on Mon, 19 Jun 2006 09:58:36 GMT]]>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

//*************************************************************************//
]]>https://www.c-plusplus.net/forum/post/1080504https://www.c-plusplus.net/forum/post/1080504Mon, 19 Jun 2006 09:58:36 GMT<![CDATA[Reply to template on Mon, 19 Jun 2006 11:16:36 GMT]]>ach menno, der Punkt ist folgender: Dein zweiter Code, der schon mal anstandslos kompilierte, hat auch nur einen Template Parameter im op=, es ist zwar ein anderer als T, aber es ist nur einer. Es ist kein Problem dem Template einen anderen zu geben, solange es nicht mehr sind, als das Template aufnehmen kann.

Du hingegen willst laut op= eine Klasse AutoPointer<T,X> haben, die gibt's aber nicht. Es gibt nur einen AutoPointer<T>. Wohin sollen zwei Parameter gepackt werden, wenn nur einer angegeben ist?

MfG

GPC

]]>https://www.c-plusplus.net/forum/post/1080541https://www.c-plusplus.net/forum/post/1080541Mon, 19 Jun 2006 11:16:36 GMT<![CDATA[Reply to template on Mon, 19 Jun 2006 11:17:54 GMT]]>template< class T > struct Foo { template< class X > X bar(); }; template< class T > template< class X > X Foo< T >::bar() { return X(); } ]]>https://www.c-plusplus.net/forum/post/1080543https://www.c-plusplus.net/forum/post/1080543Mon, 19 Jun 2006 11:17:54 GMT<![CDATA[Reply to template on Mon, 19 Jun 2006 14:18:28 GMT]]>wie dr. prof gezeigt hat. du hast hier ein template innerhalb eines templates.
der zwang, stets alle parameter wiederholen zu müssen, führt leicht zu einer menge deklarativen 'lärms', wenn auf 1 zeile richtigen code 10 zeilen deklaration kommen. hier sollte man die definition der member direkt in der klassendefinition in betracht ziehen. im übrigen will noch darauf hinweise, dass - abgesehen von den syntaktischen problemen, die bis jetzt diskutiert wurden - diese smartpointer klasse (ebenso wie die vorlage) mehrere fehler enthält.

]]>https://www.c-plusplus.net/forum/post/1080669https://www.c-plusplus.net/forum/post/1080669Mon, 19 Jun 2006 14:18:28 GMT