Template: Spécialisation partielle

Bonsoir, j'ai une classe définie comme suit:

template <class _T, class _T_power> class operator_binary_pow;

et notamment une fonction membre:

template <class _T, class _T_power>
inline _T operator_binary_pow<class _T, class _T_power>::Op_Eval(const _T & _arg1, const _T_power & _arg2) {}

Donc elle ne fait rien pour le moment, mais je voulais la spécialiser mais tout en laissant un type quelconque, est ce possible ?
En gros, je voulais faire ca:

template <class _T>
inline _T operator_binary_pow<class _T, int>::Op_Eval(const _T & _arg1, const int & _arg2) {}

mais j'obtiens plusieurs messages d'erreurs:
_ invalid use of undefined type `class operator_binary_pow<_T, int>'
_ declaration of `class operator_binary_pow<_T, int>'
_ template definition of non-template `_T operator_binary_pow<_T, int>::Op_Eval(const _T&, const int&)'

tu ne peux pas specialiser une fonction membre seule, que des classes template

template <class _T, class _T_power> class operator_binary_pow;
template <class _T> class operator_binary_pow<_T, int>;

Pourtant, http://casteyde.christian.free.fr/online/cours_cpp/x4755.html
On peut spécialiser une méthode d'une classe template.

Il y cet exemple:

template <class T>
void Item<T>::print(void) const
{ cout << item << endl;  }

template <>
void Item<int *>::print(void) const
{ cout << *item << endl;  }

Mais je n'arrive pas à appliquer ca.
La spécialisation implique t-elle forcément la définition de tous les types.

j'avais oublié ca, par contre tu as bien une erreur de synthaxe

template <class _T>
inline _T operator_binary_pow<_T, int>::Op_Eval(const _T & _arg1, const int & _arg2) {}

tu fait quoi exactement avec ce code, tu t'essayes aux expressions templates ?

Oui exact, mais c'était une erreur de post :)
La déclaration suivante ne marche pas:
template <class _T>
inline _T operator_binary_pow<_T, int>::Op_Eval(const _T & _arg1, const int & _arg2) {}

Toujours les 3 memes messages d'erreurs.
Ce code est une partie de ma librairie sur les opérateurs. Librairie qui me sert pour gérer un peu de calcul formel.

En fait si ca peu éclaircir, voila la partie du code:

template <class _T, class _T_power>
class operator_binary_pow_int : public operator_binary<_T, _T_power, _T>
{
     public:
          ... // destructeur et constructeur
         
          virtual inline _T Op_Eval(const _T & _arg1, const _T_power & _arg2) { }
          ... // d'autres trucs
};

// la spécialisation suivante ne marche donc pas.
template <class _T>
inline _T operator_binary_pow_int<_T, int>::Op_Eval(const _T & _arg1, const int & _arg2)
{
     std::cout << "SPE" << std::endl;
    return 0.0f;
}

// par contre cela marche très bien
template <>
inline float operator_binary_pow_int<float, int>::Op_Eval(const float & _arg1, const int & _arg2)
{
     std::cout << "SPE" << std::endl;
    return 0.0f;
}

Donc le C++ ne permet peut etre pas ce que je souhaiterais.

c'est ce que je crois, faire une specialisation partielle de ta classe est une solution, il y a peut etre mieux.