ich hab folgendes problem (mit msvs2005+sp1): ich hab 'ne template methode in der klasse Logger

#ifndef __LOGCLIENT_H__
#define __LOGCLIENT_H__
class LogClient
{

	//...

	template<class T> 
	void LogClient::Log( T &t, LOGLEVEL logLevel )
	{
		if( logLevel > this->logLevel )
			return;

		if( !this->logger )
			this->logger = Logger::GetSingleton();

		this->logger->Log( t, this, logLevel );
	}

und davon 'ne spezialisierung für stringstreams:

template<>
	void LogClient::Log<std::stringstream>( std::stringstream &ss, LOGLEVEL logLevel )
	{
		this->Log( ss.str(), logLevel );
	}
};
#endif

das funktioniert soweit, nur wenn ich das file in mehreren .cpps includiere schreit der linker ab dem zweiten file:

Linker schrieb:

Error 1 error LNK2005: "public: void __thiscall psi::LogClient::Log<class std::basic_stringstream<char,struct std::char_traits<char>,class std::allocator<char> > >(class std::basic_stringstream<char,struct std::char_traits<char>,class std::allocator<char> > &,enum psi::LOGLEVEL)" (??$Log@V?$basic_stringstream@DU?$char\_traits@D@std@@V?$allocator@D@2@@std@@@LogClient@psi@@QAEXAAV?$basic\_stringstream@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@W4LOGLEVEL@1@@Z) already defined in Main.obj NetClient.obj

kann mir beim besten willen net erklären was ihm das nicht passt. HILFÄÄÄH!!

camper schrieb:

musst du sie allerdings trotzdem im Header deklarieren

hm. wie schreibt ma das syntaktisch an? oO

asoooh! das wusst' ich nicht, danke...

camper schrieb:

musst du sie allerdings trotzdem im Header deklarieren

hm. wie schreibt ma das syntaktisch an? oO

Wie jede andere Funktionsdeklaration. Du lässt einfach den Funktionsrumpf weg, und schreibst ein Semikolon dafür

template<>
void LogClient::Log<std::stringstream>( std::stringstream &ss, LOGLEVEL logLevel );

class LogClient
	{
		//...
		template<class T> 
		void Log( T &t, LOGLEVEL logLevel );

		template<>
		void Log<std::stringstream>( std::stringstream &ss, LOGLEVEL logLevel );
	};

und dann in der cpp implementiert:

template<>
void LogClient::Log<std::stringstream>( std::stringstream &ss, LOGLEVEL logLevel )
{
	this->Log( ss.str(), logLevel );
}

hast vielleicht da auch noch schnell a idee was daran falsch ist?

danke trotzdem, hast mir sehr geholfen!

Das "LogClient::" in der Definition von LogClient selbst ist allerdings unnötig und AFAIK auch falsch... der MSVC frisst das nur "trotzdem" (auch mit ausgeschalteten Extensions!?!).

okay, ich bin ein blödmann. was hier vorhin gestanden is ging nicht weil ich ein using namespace vergessen hab. ma muss ma aber zu gute halten: die fehlermeldungen vom compiler waren ja auch net ganz aufschlussreich...

jedoch hab i jetzt ein ganz anderes problem: i möcht eine template-klasse schreiben, von der der konstruktor und eine methode spezialisiert sind. diese spezialisierungen müssen in cpps ausgelagert werden, weils sonst linker-errors hagelt. soweit noch klar. weiters müssen die spezialisierungen im headerfile deklariert werden. auch logisch. nur gehts irgendwie nicht, jedenfalls krieg ichs nicht hin, die schreibweise hunzt. hab jetzt mehrere durchprobiert:

path.h

#ifndef __PATH_H__
#define __PATH_H__

#include <ogrequaternion.h>

namespace psi
{
	template <class T>
	class Path
	{
	public:
		virtual ~Path()	{}

		virtual T Calc( float progress )	=	0;
	};

	template <class T>
	class LinearPath : public Path<T>
	{
	private:
		T	t0;
		T	t1;

	public:
		LinearPath( T start, T end ) : t0( start ), t1( end - start )	{}

		T Calc( float progress );

		template <>
		LinearPath( Ogre::Quaternion start, Ogre::Quaternion end );
		template <>
		Ogre::Quaternion Calc( float progress );
	};

	template <class T>
	T LinearPath<T>::Calc( float progress )
	{
		return ( this->t0 + this->t1 * progress );
	}

}
#endif

path.cpp

#include "Path.h"

using namespace psi;

template <>
LinearPath<Ogre::Quaternion>::LinearPath( Ogre::Quaternion start, Ogre::Quaternion end ) : t0( start ), t1( end )	{}

template <>
Ogre::Quaternion LinearPath<Ogre::Quaternion>::Calc( float progress )
{
	return Ogre::Quaternion::Slerp( progress, this->t0, this->t1, true );
}

wenn ich path.h in zwei files includiere krieg ich nen linker error.

Error 1 error LNK2005: "public: virtual class Ogre::Quaternion __thiscall psi::LinearPath<class Ogre::Quaternion>::Calc(float)" (?Calc@?$LinearPath@VQuaternion@Ogre@@@psi@@UAE?AVQuaternion@Ogre@@M@Z) already defined in mainTest.obj Path.obj

kann ma wer sagen wie die syntax ausschauen muss dass sowas klappt?

Der 2. Konstruktor ist eine normale Überladung:

LinearPath( Ogre::Quaternion start, Ogre::Quaternion end );

Und du kannst keine 2 gleichen Funktionen mit unterschiedlichen Rückgabewerten deklarieren:

T Calc( float progress );

Ogre::Quaternion Calc( float progress );

Welche soll er dann bei "t.Calc(0.0f)" aufrufen?

template <class T>
	class LinearPath : public Path<T>
	{
	private:
		T	t0;
		T	t1;

	public:
		LinearPath()					{	this->t0 = 0; this->t1 = 0;		}
		LinearPath( T start, T end )	{	this->Set( start, end );		}

		T Calc( float progress );

		void Set( T start, T end )		{	this->t0 = start;	this->t1 = end - start;			}

		T GetStart()					{	return ( this->t0 );				}
		T GetEnd()						{	return ( this->t0 + this->t1 );		}
	};

	template <class T>
	T LinearPath<T>::Calc( float progress )
	{
		return ( this->t0 + this->t1 * progress );
	}

	template <>
	class LinearPath<Ogre::Quaternion> : public Path<Ogre::Quaternion>
	{
	private:
		Ogre::Quaternion	t0;
		Ogre::Quaternion	t1;

	public:
		LinearPath( Ogre::Quaternion start, Ogre::Quaternion end )	{	this->Set( start, end );	}
		Ogre::Quaternion Calc( float progress );

		void Set( Ogre::Quaternion start, Ogre::Quaternion end )	{	this->t0 = start;	this->t1 = end;	}
		Ogre::Quaternion GetStart()									{	return this->t0;					}
		Ogre::Quaternion GetEnd()									{	return this->t1;					}
	};

#include "Path.h"

using namespace psi;

Ogre::Quaternion LinearPath<Ogre::Quaternion>::Calc( float progress )
{
	return Ogre::Quaternion::Slerp( progress, this->t0, this->t1, true );
}

Th schrieb:

Welche soll er dann bei "t.Calc(0.0f)" aufrufen?

das is ja ka überladung sondern a spezialisierung. er soll natürlich die methode verwenden, die für die aktuell verwendete klasse kompiliert worden ist -> also in dem fall

LinearPath<Ogre::Quaternion> path( q1, q2 );
q = path.Calc( 0.75f );

eben die spezialisierte, in dem fall

LinearPath<int> path( 10, 120 );
i = path.Calc( 0.75f );

eine für int kompilierte version.