Discussion :

[SKone]

Bonjour,

Je dois implémenter mes propres fonction de RTTI pour avoir le nom d'un type.
Pour ce faire c'est assez simple théoriquement:

Code cpp :

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

1
2
3
4
5
6
7
8
9
10
11
class RTTI
{
public:
	template < typename Type >
	static
	Core::String	GetTypeName( Type const& tInstance );
 
	template < typename Type >
	static
	Core::String	GetName();
};

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
template < typename Type >
inline
Core::String	RTTI::GetName()
{
	return RTTI::GetTypeName( Type() );
}
 
template < typename Type >
inline
Core::String	RTTI::GetTypeName( Type const& tInstance )
{
	return tInstance.GetRTTIType().Name();
}
 
// Après c'est les spécialisations...
template <>
inline
Core::String	RTTI::GetTypeName< u8 >( u8 const& /*tInstance*/ )
{
	return _T( "u8" );
}
 
template <>
inline
Core::String	RTTI::GetTypeName( u16 const& /*tInstance*/ )
{
	return _T( "u16" );
}
 
template <>
inline
Core::String	RTTI::GetTypeName( u32 const& /*tInstance*/ )
{
	return _T( "u32" );
}
 
// ...

J'ai besoin de gérer les versions avec pointeurs.
Et là ça se complique, voilà ce que j'ai essayé:

Code cpp :

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

1
2
3
4
5
6
7
8
9
10
template < typename TheType >
inline
Core::String	RTTI::GetName()
{
	typedef typename std::conditional<	std::is_pointer< TheType >::value,
										std::remove_pointer< TheType >::type,
										TheType >::type	UsedType;
 
	return RTTI::GetTypeNamePtr( UsedType() ); // Retourne le nom du type + _T( '*' )
}

Là j'ai un "error : incomplete type is not allowed"

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
template < typename Type >
inline
typename std::enable_if< std::is_pointer< Type >::value, Core::String >::type
	RTTI::GetTypeName( Type const& tInstance )
{
	return tInstance.GetRTTIType().Name();
}
 
template < typename Type >
inline
typename std::disable_if< std::is_pointer< Type >::value, Core::String >::type
	RTTI::GetTypeName( Type const& tInstance )
{
	return tInstance.GetRTTIType().Name();
}

Là par contre c'est les spécialisations qui fail.
Mes autres méthodes spécialisés ne peuvent plus être utilisés.
"error : no instance of overloaded function "RTTI::GetTypeName" matches the specified type".

Information complémentaire j'utilise Intel C++ 14

Si vous avez une idée je suis preneur.

Merci

[map programmer]

Bonjour, je pense que tu n'a pas utilisé la bonne méthode pour faire de la RTTI, l'utilisation des fonctions virtuels me semble plus appropriée.

Code :

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
 
#include <iostream>
class Type {
    public:
        virtual const char* typeName(){
            return "type";
        }
 
        virtual ~Type(){
        }
};
 
class Type2 : public Type {
    public:
        virtual const char* typeName(){
            return "type2";
        }
 
        virtual ~Type2(){
        }
};
 
int main()
{
    Type* t = new Type;
    std::cout << t->typeName() << std::endl;
    delete t;
    t = new Type2;
    std::cout << t->typeName() << std::endl;
    return 0;
}