Modèles C++: calculez des valeurs et prenez des décisions au moment de la compilation

Question

Supposons que vous ayez une classe de vecteur qui a une longueur et un type de modèle, c'est-à-dire vec<2,float>. Ceux-ci peuvent également être imbriqués - vec<2,vec<2,vec<2,float> > > ou vec<2,vec<2,float> >. Vous pouvez calculer à quel point emboîtés l'un de ces vecteurs est comme ceci:

template<typename T> 
inline int depth(const T& t) { return 0; } 
template<int N, typename T> 
inline int depth(const vec<N,T>& v) { return 1+depth(v[0]); } 

Le problème est que vous ne saurez pas si elle est profonde jusqu'à l'exécution, mais vous pouvez avoir besoin de connaître la profondeur à comile temps afin de faire quelque chose comme ceci:

// Do this one when depth(v1) > depth(v2) 
template<int N, typename T, int M, typename U> 
inline vec<N,T> operator +(const vec<N,T>& v1, const vec<M,U>& v2) { 
    return v1 + coerce(v2,v1); 
} 
// Do this one when depth(v1) < depth(v2) 
template<int N, typename T, int M, typename U> 
inline vec<M,U> operator +(const vec<N,T>& v1, const vec<M,U>& v2) { 
    return coerce(v1,v2) + v2; 
} 

Vous ne pouvez pas simplement jeter dans un « si » parce que (a) qui est plus profonde affecte le type de retour et (b) coerce() génère une erreur de construction si vous essayez de contraindre un vecteur imbriqué à un vecteur imbriqué.

Est-il possible de faire quelque chose comme ça ou suis-je poussé dans les limites des templates C++?

Answer 1

C'est tout à fait possible. Essayez par exemple

template<int N, typename T, int M, typename U> 
inline typename enable_if<is_deeper<T, U>::value, vec<N,T> >::type 
operator +(const vec<N,T>& v1, const vec<M,U>& v2) { 
    return v1 + coerce(v2,v1); 
} 

template<int N, typename T, int M, typename U> 
inline typename enable_if<is_deeper<U, T>::value, vec<M,U> >::type 
operator +(const vec<N,T>& v1, const vec<M,U>& v2) { 
    return coerce(v1,v2) + v2; 
} 

Où is_deeper est quelque chose comme

/* BTW what do you want to do if none is deeper? */ 
template<typename T, typename U> 
struct is_deeper { static bool const value = false; }; 

template<typename T, int N, typename U> 
struct is_deeper<vec<N, U>, T> { 
    static bool const value = true; 
}; 

template<typename T, int N, typename U> 
struct is_deeper<T, vec<N, U> > { 
    static bool const value = false; 
}; 

template<typename T, int N, int M, typename U> 
struct is_deeper<vec<M, T>, vec<N, U> > : is_deeper<T, U> 
{ }; 

Answer 2

Modèle metaprogramming vous libérera. Je fais cela au moment de l'exécution, mais il est évalué à la compilation:

#include <iostream> 
#include <boost\static_assert.hpp> 
using namespace std; 

template<size_t Depth> class Vec 
{ 
public: 
enum {MyDepth = Vec<Depth-1>::MyDepth + 1}; 
}; 

template<> class Vec<1> 
{ 
public: 
enum {MyDepth = 1}; 
}; 

    BOOST_STATIC_ASSERT(Vec<12>::MyDepth == 12); 
// Un-commenting the following line will generate a compile-time error 
// BOOST_STATIC_ASSERT(Vec<48>::MyDepth == 12); 

int main() 
{ 
cout << "v12 depth = " << Vec<12>::MyDepth; 
} 

EDIT: Inclus un coup de pouce assert statique pour montrer comment cela est évalué à la compilation.

Answer 3

La spécialisation partielle est très utile pour l'introspection. Habituellement, il vaut mieux éviter les fonctions inline avec des résultats constants à la compilation. (C++ 0x pourrait atténuer ce un peu, mais je ne sais pas à quel point.)

Tout d'abord, votre modèle vec ressemble beaucoup boost::array/std::tr1::array/std::array, donc je vais juste appeler array.

template< class ArrT > 
struct array_depth; // in the general case, array depth is undefined 

template< class ElemT, size_t N > // partial specialization 
struct array_depth< array< ElemT, N > > { // arrays do have depth 
    enum { value = 0 }; // in the general case, it is zero 
}; 

template< class ElemT, size_t N1, size_t N2 > // more specialized than previous 
struct array_depth< array< array< ElemT, N1 >, N2 > { 
    enum { value = 1 + array_depth< array< ElemT, N1 > >::value }; // recurse 
}; 

// define specializations for other nested datatypes, C-style arrays, etc. 
// C++0x std::rank<> already defines this for C-style arrays