[template] petit probleme d'instanciation

Version imprimable

Voir 40 message(s) de cette discussion en une page

09/09/2014, 15h08
ikeas

[template] petit probleme d'instanciation
bonjour

pour des raison perso (j'utilise une bibliotheque de templates) j'aimerais faire ceci
Code:

1 2 3 4 template<typename T> void function(){ new T(); }
avec Alpha qui est une classe concrete et IBase qui est un interface
soit
Code:

1 2 3 4 5 6 7 8 9 10 11 class Alpha { public: Alpha() {}; virtual ~Alpha() {}; }; class IBeta { public: virtual void canDecode() = 0; };
evidement function<Alpha>(); fonctionne
et function<IBeta>(); plante a la compile

y'a t'il une solution pour tester si le type T est abstrait dans la definition du template ?

merci
09/09/2014, 15h20
ternel

Tu sais que function<IBeta>();, c'est {return new IBeta();}?

Parce comme IBeta::decode() est virtuelle pure, ça ne peut pas fonctionner.
09/09/2014, 15h28
ikeas
oui j'avais compris

j'utilise un bibliotheque de reflexion http://www.extreme.indiana.edu/reflcpp/ et manifestement il ne l'on pas reflechi assez ;)
Code:

1 2 3 4 5 6 template <typename Obj_TP> PtrHolder_smptr_t ClassType_body_tmpl<Obj_TP>::createInstance() const { return PtrHolder_smptr_t(new SmartPtrHolder_tmpl<Obj_TP>(new Obj_TP)); }
manifestement tu peux utiliser des classes abstraite (pour faire des interfaces), mais ca ne passe pas....

ceci etant j'aimerais savoir si je peux faire un distinguo entre les Type abstrait et les type concret, forcement a la compilation
disons un code pour les concrets et un autre pour les non concret

c'est possible ca en c++ ?
09/09/2014, 15h48
ternel

Oui, mais tu ne veux pas appeler createInstance sur une classe abstraite.
Par contre, il doit y avoir une conversion possible entre les types de pointeurs.
09/09/2014, 22h22
ikeas

attend je reformule
j'utilise une bibliothèque que je n'ai pas fait moi même (merci le net)
je tente sans être obligé de tout deconstruire de trouver une solution pour éviter qu'il possède les méthodes createinstance (y'en a plusieurs) quand le type d’objet défini dans le Template se trouve être un type abstrait

je sais très bien qu'on ne peut pas construire un objet abstrait :roll:

ce que j'aimerais juste savoir c'est si on peut faire une compilation conditionnelle sur un Template en fonction du type
ou autoriser quand même la compilation et résoudre le problème au runtime avec un try/catch par exemple

enfin une solution pour que je n'ai pas a me refaire la librairie complète pour mettre une classe de base (templaté) avec des createinstance vide
puis une classe dérivée avec le code et de revoir la compilation de gccxml et du compilateur natif pour utiliser soit l'une soit l'autre des classes
mais la c un taf compiqué
10/09/2014, 09h25
ternel

Il y a bien les spécialisations de template, mais je n'en fais tellement peu que je t'envoie dans notre faq.

Cela dit, pour moi, c'est la manière d'utiliser la bibliothèque qui est peut-être erronnée.

As-tu essayé de modifier ton code appelant (qu'il faudrait nous montrer) pour fournir un std::nullptr, plutot que laisser la bibliothèque instancier?

tu peux telecharger l'ensemble du code
http://www.extreme.indiana.edu/reflcpp/

en gros ca compile des .hpp pour faire référence a des classes internes (templaté) et donner accès a de la réflection (au sens java ou c#) en c++
Code:

1 2 3 4 5 6 class IBase { public: virtual bool canDecode() = 0; virtual ~IBase(); };
j'ai apres compilation une autre classe
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 namespace reflcpp { template <typename Bottom_TP, typename Der_TP, int N> class Bases<Bottom_TP, Der_TP, IBase, N> : public BaseList<Bottom_TP, IBase > {}; struct IBase_strings { static const char name[]; static const char m_canDecode[]; }; template <> class Members <IBase> : public MemberList< IBase, IBase_strings::name ,MemberFunctionDcl000<IBase, FundamentalType_tmpl<bool>, &IBase::canDecode, IBase_strings::m_canDecode> > {}; }
le probleme c'est qu'il utilise le meme template que ce soit une classe abstraite ou pas, or comme dans le template il y'a le create instance en profondeur ... ca coince

je viens de trouver un truc sympa sur un autre fofo
Code:

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 template<typename T> struct isAbstractBaseClass { enum { VALUE = 0 }; }; // Factory to create T, lives in a struct to allow default template parameters template<typename T, int ABSTRACT = isAbstractBaseClass<T>::VALUE > struct Create { static T* create() { return new T(); } }; // specialize Create for abstract base classes template<typename T> struct Create<T, 1> { static T* create() { std::cout << "Cannot create and Abstract Base Class!\n"; std::cout << "Create failed on type_info::name() = " << typeid(T).name() << "\n"; return 0; } };
qui marche pas mal quand tu change la VALUE, il me faudrait juste que je puisse distinguer le type a ce moment pour changer la value ....

Ce traits détermine si on peut instancier une classe ou pas :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
template <typename T>
	class is_abstract {
		typedef struct { char c[1]; } A;
		typedef struct { char c[2]; } B;
		template <typename U>
			static auto _f (U) -> A;
		static auto _f (...) -> B;
	public:
		enum { value = sizeof(_f(*static_cast<T*>(0))) == sizeof(B) };
	};
 
struct A {};
struct B { virtual void toto() = 0; };
 
is_abstract<A>::value; // 0 (false)
is_abstract<B>::value; // 1 (true)

Fait à l'arrache, j'ai pas cherché à me conformer à la norme.

j'ai tenté cela

Code:

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
 
// version 2
template <typename T>
        class is_abstract {
                typedef struct { char c[1]; } A;
                typedef struct { char c[2]; } B;
                template <typename U>
                        static auto _f (U) -> A;
                        static auto _f (...) -> B;
        public:
                enum { value = sizeof(_f(*static_cast<T*>(0))) == sizeof(B) };
        };
 
// Factory to create T, lives in a struct to allow default template parameters
template<typename T, int ABSTRACT = is_abstract<T>::value >
struct Create2
{
  static T* create()
  {
        std::cout << "Create Class : " << typeid(T).name() << "\n";
    return new T();
  }
};
 
// specialize Create for abstract base classes
template<typename T>
struct Create2<T, 1>
{
  static T* create()
  {
    std::cout << "Cannot create and Abstract Base Class!\n";
    std::cout << " Create failed on type_info::name() = " << typeid(T).name() << "\n";
    return 0;
  }
};

avec comme code

Code:

1
2
3
4
 
 // try to using create2
        Create2<Alpha>::create();
        Create2<IBase>::create(); // IBeta est mon interface donc abstrait

et j'ai une erreur de compil sur static auto_f avec un conflit

10/09/2014, 11h15
the Hound

auto ... -> ... c'est du C++11. Tu utilises quel compilateur ? Tu compiles en C++11 ?
Quel est le message d'erreur ?
10/09/2014, 11h44
ikeas

non justement je suis pas en c++ 11 sinon j'aurais acces a std::is_abstract directement ;)

le message que j'ai c'est :
sur la ligne static auto _f(U) -> A;

j'ai :
auto will change meaning in c++0x please remove it
conflicting specifiers in declaration of _f
10/09/2014, 11h54
ternel

Sans nous donner l'erreur elle même, c'est difficile de t'aider.
Surtout que les erreurs de template sont assez subtiles à deviner

Et comme ça ?

Code:

1
2
3
template <typename U>
	static A _f (U);
static B _f (...);

la ca passe

en renomant is_abstract2
par contre si je fais

Code:

1
2
3
 
 cout << is_abstract2<Alpha>::value << endl; // ca passe 
 cout << is_abstract2<IBase>::value << endl; // ca passe pas : cannot allocate an object of abstract type IBase sur la ligne enum

Avec une approche légèrement différente ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
template <typename T>
	class is_abstract {
		// On veut que sizeof(X) > sizeof(T) quel que soit T
		// En considérant un alignement de 4 octets
		typedef struct { char c[sizeof(T) + 4]; } X;
 
		template <typename U>
			static U _f (U*);
		static X _f (...);
 
	public:
		enum { value = sizeof(_f(static_cast<T*>(0))) == sizeof(X) };
	};

10/09/2014, 14h08
ikeas

même erreur au même endroit c'est a dire sur l'enum

Code:

enum { value = sizeof(_f(static_cast<T*>(0))) == sizeof(X) };
10/09/2014, 14h10
the Hound

C'est bizarre, pourtant sur cette ligne il n'y a pas d’instanciation de T.
Tu utilises quel compilateur ?

Bonjour,

Si les classes abstraites que tu as à gérer ne sont pas trop nombreuses, tu pourrais procéder par spécialisation, par ex:
Code:

1 2 3 4 5 6 7 8 9 10 template <class T> struct is_abstract { static const bool value = false; }; template<> struct is_abstract<IBase> { // à répéter pour chaque classe abstraite utilisée static const bool value = true; };
Evidemment ce n'est pas très propre et ça ne peut pas fonctionner dans un contexte librairie, où tu ne sais pas à l'avance quelle classe va être employée...

10/09/2014, 14h16
ikeas

g++ en version 4.4.6 20120305 (redhat 4.4.6-4)

Citation:

Envoyé par stendhal666

Si les classes abstraites que tu as à gérer ne sont pas trop nombreuses, tu pourrais procéder par spécialisation ....

c'est surtout tres long et compliqué ;)

le but ultime c'etait de faire de la reflection avec un pre compilateur ...
10/09/2014, 14h23
ternel

Au passage, passer par un plugin de g++ pour utiliser l'AST de compilation, ça ne marcherai pas?

(Ca doit aussi exister avec LLVM)

Voir 40 message(s) de cette discussion en une page