[template] petit probleme d'instanciation

Version imprimable

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

Une possibilité en utilisant SFINAE pour tester si la classe est abstraite pendant l'exécution (il me semble que c'était ce que tu demandais):

Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 template <class T> struct Test { typedef T type; Test(int) { create(); } void create() { new T(); } }; template <class T> void test_if_abstract( Test<T>::type ) {} template <class T> void test_if_abstract( ... ) { throw 1; } int main() { test_if_abstract<ConcreteBase>(10); test_if_abstract<AbstractBase>(10); };

ça compile sur un compilateur même pas C++98 (le borland gratuit, un ancêtre tout petit :)
et ça envoie une exception à l'exécution.

non, il y a une erreur dans mon code, dsl

10/09/2014, 15h11
ikeas

excuse moi mais je sais pas ce que c'est que l'ast de compilation lol
10/09/2014, 15h16
the Hound

~~Ce n'est pas ce qu'il demande, il veut un booléen constexpr pour l'utiliser avec un template, afin de faire des spécialisations.~~
Peu d'intérêt à déterminer si une classe est abstraite à l'exécution d'ailleurs, puisque si le code est correct (et utilisable concrètement) il n'est pas censé compiler ...
10/09/2014, 15h35
stendhal666

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

si, semble-t-il, ce serait une des questions posées...
10/09/2014, 15h43
the Hound
Ok j'avais pas vu, autant pour moi.

Bon sinon sous gcc il y a ça :
Code:

1 2 3 4 template <typename T> struct is_abstract { enum { value = __is_abstract(T) }; };
D'après la doc https://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html
M'enfin, c'est dégueu.

allez louya ca marche impec

merci encore

pour info je colle le code complet

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 is_abstract3 {
        enum {
                value = __is_abstract(T)
        };
};
 
// Factory to create T, lives in a struct to allow default template parameters
template<typename T, int ABSTRACT = is_abstract3<T>::value>
struct Create3 {
        static T* create() {
                std::cout << "Create Class : " << typeid(T).name() << "\n";
                return new T();
        }
};
 
// specialize Create for abstract base classes
template<typename T>
struct Create3<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;
        }
};

et en execution

Code:

1
2
3
 
 Create3<Alpha>::create();
 Create3<IBase>::create();

10/09/2014, 16h04
ternel

Par contre, maintenant, ton code ne compile plus qu'avec gcc, et dans certaines de ses versions seulement.

C'est peut-être dommage.
10/09/2014, 16h08
ikeas
je peux éventuellement mettre des directives de compilation avec std:is_abstract que j'ai essayé par ailleurs sur visual studio
et qui marche aussi en c++11
Code:

1 2 3 4 5 6 7 template<typename T> struct is_abstract3 { enum { value = std::is_abstract<T>::value }; };

juste une petite question connexe

je ne sais pas si c'est possible de passer du code suivant

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 is_abstract3 {
        enum {
                value = __is_abstract(T)
        };
};
 
// Factory to create T, lives in a struct to allow default template parameters
template<typename T, int ABSTRACT = is_abstract3<T>::value>
struct Create3 {
        static T* create() {
                std::cout << "Create Class : " << typeid(T).name() << "\n";
                return new T();
        }
};
 
// specialize Create for abstract base classes
template<typename T>
struct Create3<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 fait la sélection sur la classe

et faire un code qui ferrait la sélection sur un membre de la classe
un peut dans ce style

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
class Create5 {
public:
        template<typename T, int ABSTRACT = __is_abstract(T)>
        static T* create() {
                std::cout << "Create Class : " << typeid(T).name() << "\n";
                return new T();
        };
        template<typename 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";
                                eturn 0;
                };
 
 
};

évidement ce code ne passe pas

Tu ne peux pas spécialiser partiellement une fonction.
En revanche tu peux déplacer ta fonction create() dans une structure à part, que tu pourras spécialiser.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
template <typename T, bool = __is_abstract(T)>
struct create_helper {
  static T* create () { return new T(); }
};
 
template <typename T>
struct create_helper<T, 1> {
  static T* create () { /* ... */ }
};
 
class Create {
public:
  template <typename T>
    static T* create() {
      return create_helper<T>::create();
    }
};

et si je veux définir le corps des fonction en dehors des structures ?

j'ai tenté cela mais ça passe pas

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
 
template<typename T, bool = __is_abstract(T)>
struct create_helper2 {
        static T* create();
};
 
template<typename T, bool = __is_abstract(T)>
T* create_helper2<T,bool>::create(){
        std::cout << "Create Class : " << typeid(T).name() << "\n";
                        return new T();
}
 
template<typename T>
struct create_helper2<T, 1> {
        static T* create();
};
 
template<typename T>
T* create_helper2<T, 1>::create(); {
        std::cout << "Cannot create and Abstract Base Class!\n";
                        std::cout << " Create failed on type_info::name() = "
                                        << typeid(T).name() << "\n";
        return 0;
}
 
 
class Create6 {
public:
        template<typename T>
        static T* create() {
                return create_helper2<T>::create();
        }
};

11/09/2014, 09h40
the Hound

C'est normal. Ton code est incorrect. Relis-le, il ne veut rien dire.
Renseigne-toi sur la définition d'un membre de classe template.
11/09/2014, 09h55
ikeas

oui je tente mais c'est la spécialisation qui me pose problème
je sais pas trop comment exprimer le bool pour la version instanciable et pour exprimer le 1 dans la version abstraite

sur les versions simple j'y arrive :?
11/09/2014, 10h04
the Hound

Le bool = __is_abstract(T) ça déclare un paramètre sans nom. Pour dire, en gros, "j'ai un deuxième paramètre, booléen, qui vaut par défaut __is_abstract(T), mais pour ce cas d'usage, je me fiche de savoir comment s'appelle ce paramètre, vraiment. Ce qui m'importe c'est la valeur".
Maintenant si tu as besoin d'utiliser ce booléen il n'y a qu'à lui donner un nom.

non non j'en ai pas vraiment besoin du bool
je vois juste pas comment écrire les deux formats
et quand j'utilise le refactoring d'eclipse il se plante aussi

voila ce a quoi j'arrive

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
 
template <typename T, bool U = __is_abstract(T)>
struct create_helper4 {
  static T* create ();
};
 
template <typename T, bool U>
T* create_helper4<T, U>::create(){
        std::cout << "create on create_helper4 \n";
        return new T();
}
 
template<typename T>
struct create_helper4<T, 1> {
        static T* create();
};
 
template<typename T>
T* create_helper4<T, 1>::create() {
        std::cout << "Cannot create and Abstract Base Class!\n";
                        std::cout << " Create failed on type_info::name() = "
                                        << typeid(T).name() << "\n";
        return 0;
}

la ca passe
par contre je sais pas comment supprimer le U de la premiere struct

11/09/2014, 10h25
the Hound

Donc ça fonctionne maintenant ?
11/09/2014, 10h28
ikeas

oui ça marche mais
tu aurais pas une solution pour passer de

Code:

template <typename T, bool U = __is_abstract(T)>

à

Code:

template <typename T, bool = __is_abstract(T)>

car si j’enlève le U
je n'arrive plus à faire la définition pour (enfin ça ne compile plus)

Code:

T* create_helper4<T, U>::create()
11/09/2014, 10h34
ternel

mais pourquoi veux-tu enlever le U.
Tu peux le renommer en abstractness, isAbstract, bidule ou ce que tu veux, mais en supprimant le nom, tu ne pourras pas le donner à create_helper4.
11/09/2014, 10h37
the Hound

Si tu enlèves le U, tu mets quoi entre les chevrons <> pour la spécialisation ?
Tu n'as pas d'autre choix ici que donner un nom à ta variable pour passer sa valeur.
11/09/2014, 10h43
ikeas

en fait je n'ai pas vraiment besoin de récupérer la valeur
je trouvais que la syntaxe

Code:

template <typename T, bool = __is_abstract(T)>

était plus "sexy"

j'ai la solution mais je pensais que ça serait plus simple de spécialiser le template sans définir le nom de la variable
après c'est peut être pas possible

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