Surchargé une fonction template avec template

**SKone** · 11/10/2014, 23h16

Bonjour,

Je sais que ce problème a déjà été présenté dans ce forum mais les solutions proposées de fonctionne pas.
Dans mon cas j'ai un membre dans le fichier JSONSerializer.h:

Code Cpp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#pragma once
 
#include "Kernel/Kernel.h"
 
#include "Core/String/String.h"
#include "Core/String/StringTool.h"
#include "Core/Core/Errors.h"
 
#include "rapidjson/rapidjson.h"
#include "rapidjson/document.h"
#include "rapidjson/stringbuffer.h"
#include "rapidjson/writer.h"
 
namespace eMV
{
	typedef	rapidjson::UTF8<>														RJ_UTF8Trait;
	typedef rapidjson::GenericStringBuffer< rapidjson::UTF8<> >						StringBuffer;
	typedef	rapidjson::Writer< StringBuffer, rapidjson::UTF8<>, rapidjson::UTF8<> >	Writer;
	typedef	rapidjson::GenericReader< rapidjson::UTF8<>, rapidjson::UTF8<> >		Reader;
	typedef	rapidjson::GenericDocument< rapidjson::UTF8<> >							Document;
 
	namespace Core
	{
		class JSONSerializer
		{
		public:
			template < typename Type >
			static
			Type				GetObjectFromValue( rapidjson::Value const& oValue, Type const t = Type() );
		};
 
		#include "Core/Serializer/JSONSerializer.inl"
	}
}

Dans le fichier JSONSerializer.inl:

Code Cpp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
template < typename Type >
inline
Type			JSONSerializer::GetObjectFromValue( rapidjson::Value const& oValue, Type const )
{
	EMV_NOT_IMPL;
}
 
template <>
inline
UInt8			JSONSerializer::GetObjectFromValue( rapidjson::Value const& oValue, UInt8 const )
{
	return static_cast< UInt8 >( oValue.GetUint() );
}
 
template <>
inline
UInt16			JSONSerializer::GetObjectFromValue( rapidjson::Value const& oValue, UInt16 const )
{
	return static_cast< UInt16 >( oValue.GetUint() );
}
 
template <>
inline
UInt32			JSONSerializer::GetObjectFromValue( rapidjson::Value const& oValue, UInt32 const )
{
	return oValue.GetUint();
}
 
template <>
inline
UInt64			JSONSerializer::GetObjectFromValue( rapidjson::Value const& oValue, UInt64 const )
{
	return oValue.GetUint64();
}
 
template <>
inline
Int8			JSONSerializer::GetObjectFromValue( rapidjson::Value const& oValue, Int8 const )
{
	return static_cast< Int8 >( oValue.GetInt() );
}
 
template <>
inline
Int16			JSONSerializer::GetObjectFromValue( rapidjson::Value const& oValue, Int16 const )
{
	return static_cast< Int16 >( oValue.GetInt() );
}
 
template <>
inline
Int32			JSONSerializer::GetObjectFromValue( rapidjson::Value const& oValue, Int32 const )
{
	return oValue.GetInt();
}
 
template <>
inline
Int64			JSONSerializer::GetObjectFromValue( rapidjson::Value const& oValue, Int64 const )
{
	return oValue.GetInt64();
}
 
template <>
inline
f32			JSONSerializer::GetObjectFromValue( rapidjson::Value const& oValue, f32 const )
{
	return static_cast< f32 >( oValue.GetDouble() );
}
 
template <>
inline
f64			JSONSerializer::GetObjectFromValue( rapidjson::Value const& oValue, f64 const )
{
	return oValue.GetDouble();
}
 
template <>
inline
Core::ASCIIString	JSONSerializer::GetObjectFromValue( rapidjson::Value const& oValue, Core::ASCIIString const )
{
	return Core::StringTool::UTF8StringToASCIIStringCopy( Core::UTF8String( oValue.GetString() ) );
}
 
//template <>
//Core::UTF8String	JSONSerializer::GetObjectFromValue( rapidjson::Value const& oValue, Core::UTF8String const )
//{
//	//return Core::StringTool::UTF8StringToASCIIStringCopy( Core::UTF8String( oValue.GetString() ) );
//}
 
template <>
inline
Core::UTF16String	JSONSerializer::GetObjectFromValue( rapidjson::Value const& oValue, Core::UTF16String const )
{
	return Core::StringTool::UTF8StringToUTF16StringCopy( Core::UTF8String( oValue.GetString() ) );
}
 
template <>
inline
Core::UTF32String	JSONSerializer::GetObjectFromValue( rapidjson::Value const& oValue, Core::UTF32String const )
{
	return Core::StringTool::UTF8StringToUTF32StringCopy( Core::UTF8String( oValue.GetString() ) );
}
 
template <>
inline
Core::WideString	JSONSerializer::GetObjectFromValue( rapidjson::Value const& oValue, Core::WideString const )
{
	return Core::StringTool::UTF8StringToWideStringCopy( Core::UTF8String( oValue.GetString() ) );
}

Je voudrais surchargé GetObjectFromValue pour template < typename ScalarType > Math::tVector4< ScalarType >;
Donc je vais dans Vector4.h et je procède de la manière suivante dans Math/Vector4.h:

Code Cpp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#pragma once
 
#include "Math/MathConfig.h"
#include "Math/MathAPI.h"
#include "Math/Consts.h"
#include "Math/Vectorial.h"
 
#include "Core/Core/TypeTraits.h"
#include "Core/Stream/Stream.h"
#include "Core/Serializer/JSONSerializer.h"
#include "Core/Core/CRC32.h"
 
namespace eMV
{
	namespace Math
	{
		template < typename ScalarType = Scalar >
		class tVector4
		{
		public:
			// Implementation blabla
		};
 
// #if USE_VECTOR4_SIMD == 1 && Core::IsSame< f80, Scalar >::Value
// #	error	Vector4 Vectorial & Scalar f80 is not usable
// #endif
 
// #if Core::IsSame< f80, Scalar >::Value
// #	include "Math/Vector4.hpp"
// #elif	USE_VECTOR4_SIMD
// 	// TODO AVX & SSE f64 version with double f64 SSE Instruction OR AVX instruction
// 	//		=> TODO Only the Dot
// #	include "Math/Vector4Vectorial.hpp"
// #else
// #	include "Math/Vector4.hpp"
// #endif
#if Core::IsSame< f80, Scalar >::Value
#	include "Math/Vector4.hpp"
#elif	USE_VECTOR4_SIMD
	// TODO AVX & SSE f64 version with double f64 SSE Instruction OR AVX instruction
	//		=> TODO Only the Dot
#	include "Math/Vector4Vectorial.hpp"
#else
#	include "Math/Vector4.hpp"
#endif
	}
 
	namespace Core
	{
		template < typename ScalarType >
		inline
		Math::tVector4< ScalarType >	JSONSerializer::GetObjectFromValue( rapidjson::Value const& oValue, Math::tVector4< ScalarType > const )
		{
			EMV_ASSERT( oValue.Size() == 4 );
 
			Math::tVector4< ScalarType >	vVector;
 
			vVector.Set(	static_cast< ScalarType >( oValue[ 0 ].GetDouble() ),
							static_cast< ScalarType >( oValue[ 1 ].GetDouble() ),
							static_cast< ScalarType >( oValue[ 2 ].GetDouble() ),
							static_cast< ScalarType >( oValue[ 3 ].GetDouble() ) );
 
			return vVector;
		}
	}
}

Auriez-vous une idée de ce que j'ai mal fait ?

Merci

PS: Compilateur Intel C++ 14

**Flob90** · 12/10/2014, 14h23

Ça ne marche pas parce que ta fonction est membre, donc tu ne peux pas surcharger la fonction à l'extérieur. Je vois que cette fonction est statique, tu ne peux pas la passer en fonction libre ? Ce qui te permettra de la surcharger.

**SKone** · 12/10/2014, 20h00

En effet, je connaissais pas cette contrainte.
Comme ma classe contient que des fonctions static je transforme le tout en Namespace et ça fix mon problème de cette manière je me garde le droit de faire Core::JSONSerializer::GetObjectFromValue...

Merci => Resolu

Surchargé une fonction template avec template

Langage C++

Discussions similaires

Partager

Partager