Discussion :

[backlash]

Dans un souci de compréhension (à comprendre par là que je ne suis pas atteint de NIH), je suis en train d'implémenter une version de la classe is_array de Boost.

J'ai le code suivant :

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
#include <iostream>
 
using namespace std;
 
template<typename T>
struct is_array
{
    static const bool value = false;
};
 
template< typename T >
struct is_array< T[] >
{
    static const bool value = true;
};
 
int main()
{
    is_array< int[2] > :: value ? cout << "array" << endl : cout << "other type" << endl;
 
    return 0;
}

Cependant lorsque j'instancie la classe is_array pour un type tableau, ce n'est pas la classe spécialisée qui est instanciée mais la générique.
Cependant en spécialisant la classe is_array pour les tableaux de 2 éléments, j'ai bien le comportement voulu :

Code :

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

1
2
3
4
5
template< typename T >
struct is_array< T[2] >
{
    static const bool value = true;
};

Ma question est :
-est ce possible de "spécialiser génériquement" la classe is_array pour les différentes tailles de tableau c'est à dire est ce qu'il est possible de n'avoir qu'une spécialisation qui gérerait toutes les tailles ?

PS : j'ai été voir le code de Boost, j'ai l'impression que c'est le préprocesseur qui crée les bonnes spécialisations selon la taille du tableau et son type d'élément, mais j'aimerais tout de même savoir cela est réalisable sans utiliser le préprocesseur.

[PhilIvey]

Ma question est :
-est ce possible de "spécialiser génériquement" la classe is_array pour les différentes tailles de tableau c'est à dire est ce qu'il est possible de n'avoir qu'une spécialisation qui gérerait toutes les tailles ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
 
template <class T>
struct is_array{
  static const bool value = false;
};
 
template <class T, int N>
struct is_array < T[N] >
{
  static const bool value = true;
};

Tu avais la réponse dans ta question
Une specialisation partielle

[backlash]

Par contre, est ce que ta solution est bien de la spécialisation partielle?.
En effet, tu rajoutes un paramètre template à la classe générique, est ce bien un cas de spécialisation partielle?

[PhilIvey]

Par contre, est ce que ta solution est bien de la spécialisation partielle?.
En effet, tu rajoutes un paramètre template à la classe générique, est ce bien un cas de spécialisation partielle?

Oui ta template reste is_array<T> avec un paramètre template, et tu la spécialise pour une catégorie de
type,

Tu peux verifier avec

Code :

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

1
2
3
4
 
 
	typedef int tab[20];
	is_array< tab > :: value ? std::cout << "array" << std::endl : std::cout << "other type" << std::endl;

[3DArchi]

Salut,

Par contre, est ce que ta solution est bien de la spécialisation partielle?.
En effet, tu rajoutes un paramètre template à la classe générique, est ce bien un cas de spécialisation partielle?

template<class T> struct dummy{} : définition générique.

template<> struct dummy<int[42]>{} : spécialisation (non partielle) (1).

template<class T, int N> struct dummy<T[N]>{} : spécialisation partielle (2).

La spécialisation (2) est partielle tout simplement parce qu'il reste des paramètres génériques dans cette spécialisation alors que dans la spécialisation (1) il ne reste plus de paramètre générique. Le fait d'ajouter ou de fixer des paramètres est annexe, la spécialisation reste partielle dès lors qu'il reste des éléments génériques dans la spécialisation. On pourrait imaginer d'autres spécialisations partielles :


template<int N> struct dummy<int[N]>{} ;
template<class T, int N> struct dummy<T[N]>{} ;
template<class T> struct dummy<std::vector<T> >{} ;
template<class T, class... TypeValues> struct dummy<T[ boost::mpl::plus<TypeValues...>::type::value ] > {} ;