[template] petit probleme d'instanciation

**ikeas** · 09/09/2014, 15h08

bonjour

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

Code :

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

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 :

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

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

**ternel** · 09/09/2014, 15h20

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

Parce comme IBeta::decode() est virtuelle pure, ça ne peut pas fonctionner.

**ikeas** · 09/09/2014, 15h28

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 :

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

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++ ?

**ternel** · 09/09/2014, 15h48

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.

**ikeas** · 09/09/2014, 22h22

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

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é

**ternel** · 10/09/2014, 09h25

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?

**ikeas** · 10/09/2014, 09h52

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 :

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

1
2
3
4
5
6
class IBase {
 
public:
        virtual bool canDecode() = 0;
        virtual ~IBase();
};

j'ai apres compilation une autre classe

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
 
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 :

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
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 ....

**the Hound** · 10/09/2014, 10h27

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

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
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.

**ikeas** · 10/09/2014, 10h57

j'ai tenté cela

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
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 :

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

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

**the Hound** · 10/09/2014, 11h15

auto ... -> ... c'est du C++11. Tu utilises quel compilateur ? Tu compiles en C++11 ?
Quel est le message d'erreur ?

**ikeas** · 10/09/2014, 11h44

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

**ternel** · 10/09/2014, 11h54

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

**the Hound** · 10/09/2014, 12h07

Et comme ça ?

Code :

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

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

**ikeas** · 10/09/2014, 13h04

la ca passe

en renomant is_abstract2
par contre si je fais

Code :

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

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

**the Hound** · 10/09/2014, 14h04

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

Code :

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

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) };
	};

**ikeas** · 10/09/2014, 14h08

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

Code :

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

enum { value = sizeof(_f(static_cast<T*>(0))) == sizeof(X) };

**the Hound** · 10/09/2014, 14h10

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

**stendhal666** · 10/09/2014, 14h15

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 :

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

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...