3. template

template

  • T

    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)
{

}
    0
  • C

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

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

}
    0
  • G

    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

    0
  • T

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

    0
  • T

    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.
    0
  • T

    Nein, hatt sich geklärt

    AutoPointer<T_>::...
    0
  • T

    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);
}
    0
  • G

    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.

    ⚠

    0
  • T

    Hab jetzt auch in der Klasse:

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

    ABER: der gleiche Fehler tritt wieder auf...

    0
  • G

    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

    0
  • T

    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
//*************************************************************************//
    0
  • G

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

    0
  • T

    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

//*************************************************************************//
    0
  • G

    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

    0
  • ?
     

    template< class T >
struct Foo
{
  template< class X >
  X bar();
};

template< class T >
 template< class X >
  X Foo< T >::bar()
  { 
     return X();
  }
    0
  • C
    Mod

    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.

    0
Anmelden zum Antworten