Héritage et opérateurs "externes"
Bonjour,
Je me suis inspiré de l'article de Laurent Gomila (Meta-Prog) pour essayer de produire mes propres structures mathématiques et arbres d'expressions.
Mes opérateurs sont donc d'abord déclarés de façon "globale" grâce aux template puis spécialisés, par exemple pour une structure Vector. Pour illustration :
Code:
1
2
3
4
5
6
|
template< typename T1, typename T2 >
inline BinaryExpression<T1, T2, Operator_Addition> operator+( const T1& t1, const T2& t2)
{
return BinaryExpression<T1, T2, Operator_Addition>(t1, t2);
} |
Et le prototype de la structure Vector (avec T le type à utiliser et Dim, la dimension), suivi du début de la spécialisation pour l'opérateur + :
Code:
1
2
3
4
5
6
7
8
|
template<typename T, unsigned int Dim> struct Vector;
template< typename T1, typename T2, unsigned int Dim> // V + V
inline
BinaryExpression< typename Vector<T1, Dim>::ConstIterator, typename Vector<T2, Dim>::ConstIterator, Operator_Addition>
operator+( const Vector<T1, Dim>& t1 , const Vector<T2, Dim>& t2)
//... |
Mais je voudrais maintenant créer des classes dérivant de Vector et pouvant réutiliser le code fournit pour l'opérateur +. Par exemple, je pensais à :
Code:
1
2
3
4
|
template<typename T, unsigned int Row, unsigned int Column>
struct Matrix : public Vector<T, Row*Column>
//... |
Comment puis-je faire? Pui-je le faire sans avoir à re-spécialiser l'opérateur + pour chaque type???
