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