==========================
Note admin codes-sources:
==========================
ATTENTI ON:
Ce code est un exemple de ce qu'il est possible de faire avec des templates. Néanmoins, ce code NE doit PAS être utilisé. En effet, tous les effets que ce code émule sont disponibles dans le langage. "dynamic_cast" et "typeid" se charge déjà de le faire, et le font bien mieux.
En C++ propre, tout ce code tiendrait en 3 lignes (voir même en un mot "dynamic_cast"):
#include <iostream>
template <typename CastType, typename ObjType>
bool isInstanceOf(ObjType obj)
{
return dynamic_cast<CastType>(obj);
}
struct A {};
struct B : public A {};
struct C {};
int main()
{
A a;
B b;
C c;
C* null = 0;
std::cout << std::boolalpha
<< isInstanceOf<A*>(&a) << std::endl // true
<< isInstanceOf<A*>(&b) << std::endl // true
<< isInstanceOf<B*>(&b) << std::endl // true
<< isInstanceOf<C*>(&c) << std::endl // true
<< isInstanceOf<C*>(null) << std::endl; // false
isInstanceOf<A*>(&c); // Ne compilera pas ! Et heureusement :)
return 0;
}
==========================
Ce code permet de créer une mécanique qui imite le dynamic_cast. Le seul but est de montrer ce que l'on peut faire avec des templates.
Exemple : 'MyObject' est un objet générique, Les autres objets que l'on créera hériteront de cet objet.
MyClass1 heritera de MyObject
MyClass2 heritera de MyObject
etc, etc
Ainsi on peu générer automatiquement l'arborescence d'un objet, verifier s'il est bien une instance d'un objet parent etc etc.
Par exempl :
class MyClass1 : public MyObject
{
/* ... */
};
class MyClass2 : public MyObject
{
/* ... */
};
MyObject* obj1 = new MyClass1();
MyObject* obj2 = new MyClass2();
cout << (obj1.instanceOf<MyClass1>() ? "true" : "false") << endl; //true
cout << (obj1.instanceOf<MyClass2>() ? "true" : "false") << endl; //false
cout << (obj2.instanceOf<MyClass1>() ? "true" : "false") << endl; //true
cout << (obj2.instanceOf<MyClass2>() ? "true" : "false") << endl; //false
On peut imaginer encore plus complex
class MyClass3 : public MyClass1
{
/* ... */
};
class Myclass4 : public MyClass2
{
/* ... */
};
MyObject* obj3 = new MyClass3();
MyObject* obj4 = new MyClass4();
cout << (obj3.instanceOf<MyClass1>() ? "true" : "false") << endl; //true
cout << (obj3.instanceOf<MyClass2>() ? "true" : "false") << endl; //false
cout << (obj3.instanceOf<MyClass3>() ? "true" : "false") << endl; //true
cout << (obj3.instanceOf<MyClass4>() ? "true" : "false") << endl; //false
cout << (obj4.instanceOf<MyClass1>() ? "true" : "false") << endl; //false
cout << (obj4.instanceOf<MyClass2>() ? "true" : "false") << endl; //true
cout << (obj4.instanceOf<MyClass3>() ? "true" : "false") << endl; //false
cout << (obj4.instanceOf<MyClass4>() ? "true" : "false") << endl; //true
Voila, voir le code pour comprendre comment cela fonctionne.