Discussion :

[Lintel-oo]

Bonjour à tous

Je voulais savoir si dans le cas que je vais vous exposer brièvement il serait possible de faire une factorisation de code qui serait utilisé dans 2 classes quasiment identiques.

Je travaille sur 2 classes Matrix.
La première classe est template :

Code :

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

1
2
template<unsigned int Lines, unsigned int Columns, typename T>
class Matrix {...};

Cette classe utilise std::array et m'est utile pour pas mal de choses.

Cependant, j'ai eu besoin de faire une classe matrix sans paramètres template de taille, qui ne pouvaient être déterminés à la compilation. C'est pourquoi j'ai une seconde classe Matrix qui utilise non pas des std::array mais des std::vector.

Ma question est donc la suivante : est-ce possible de mettre en facteur la quasi totalité du code des 2 classes (ce sont exactement les mêmes algo et types d'accès aux données) sachant que l'une des classes contient des paramètres template définis à la compilation et l'autre peut être ajustée à l'exécution ?

Je précise que la deuxième classe pourrait être utilisée à la place de la première mais que la première apporte une sécurité d'utilisation

Merci d'avance

[oodini]

Tu peux templatiser en fonction du type de conteneur.

[Lintel-oo]

Oui en effet je ne sais pas pourquoi je n'y ai pas pensé ^^

Merci à toi je mets le sujet résolu dès que j'ai fini ce que je veux faire.

J'ai encore un petit problème : je n'arrive pas à voir comment faire pour avoir un template qui puisse prendre en compte à la fois le std::vector, qui serait quelque chose du type :

Code :

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

template <template <typename ... A> class Conteneur, typename ...Pack>

Ou plus simplement dans ce cas :

Code :

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

template <template <typename A> class Conteneur, typename A>

Et le type std::array, qui serait quelque chose comme cela :

Code :

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

template <template <typename A, unsigned int B> class Conteneur, typename A, unsigned int B>

Comment faire pour inclure des "template de valeurs" au milieu de "template de type" avec des template variadic (enfin pas forcément mais en tout cas sans avoir recours à une quelconque spécification qui serait synonyme de redondance dans le code)

[oodini]

Étant sur Visual 2010, je n'ai pas encore eu l'occasion de travailler avec les templates variables. Je ne pourrai donc t'aider sur ce point.

[Iradrille]

Hello,

Pas forcément besoin de templates variadiques ici.

Code C++ :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
template <class T>
class Mat {
	T data;
};
 
template <class T, unsigned int S>
using SmallMat = Mat<std::array<T, S>>;
 
template <class T>
using BigMat = Mat<std::vector<T>>;
 
SmallMat<int, 42> sm;
BigMat<float> bm;

edit : par contre, tu vas avoir un problème de constructeur.

Code :

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

1
2
3
4
5
6
template <class T>
class Mat {
	// ...
	Mat(unsigned int l, unsigned int c); // <- seulement dans le cas d'une matrice basée sur un vector
	// sans spécialiser Mat, c'est impossible de le supprimer/ajouter quand il faut.
};

On peut surement s'en sortir avec un static_assert, mais pas persuadé que ce soit une solution "propre".

[Trademark]

À propos du problème soulevé par Iradille, tu peux faire un trait :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
template <class T>
struct is_dynamic;
 
template<class T>
struct is_dynamic<std::vector<T>>
{
  static bool value = true;
};
 
template<class T, std::size_t c>
struct is_dynamic<std::array<T, c>>
{
  static bool value = false;
}

Ensuite tu actives le constructeurs seuleument pour les versions dynamiques :

Code :

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

1
2
3
4
5
6
7
template <class T>
class Mat {
	// ...
        template<typename U = T, class = typename std::enable_if<is_dynamic<T>::value>::type>
	Mat(unsigned int l, unsigned int c); // <- seulement dans le cas d'une matrice basée sur un vector
 
};

C'est une solution qui ne marche qu'en C++11 (voir la 2ème réponse ici).

Sinon tu peux faire la même chose en utilisant une classe de base et puis en spécialisant.