méthodes C++ qui prennent des classes templated comme argument

Question

I ont une classe modélisée

Vector<class T, int N> 

Où T est le type des composants (deux par exemple) et n le nombre de composants (si N = 3 pour une 3D vecteur)

maintenant, je veux écrire une méthode comme

double findStepsize(Vector<double,2> v) 
{..} 

Je veux faire aussi pour trois et des vecteurs de dimension supérieure. Bien sûr, je pourrais juste introduire d'autres méthodes pour des dimensions plus élevées, mais les méthodes auraient beaucoup de code redondant, donc je veux une solution plus générique. Existe-t-il un moyen de créer une méthode qui prend une classe modèle sans la spécialiser davantage (dans ce cas sans spécifier T ou N)? Comme

double findStepsize(Vector<T,N> v) 

?

Answer 1

Oui, il est

template<typename T, int N> 
double findStepsize(Vector<T,N> v) 
{..} 

Si vous l'appelez avec un Vector<T, N> spécifique, le compilateur déduireT et N aux valeurs appropriées.

Vector<int, 2> v; 
// ... fill ... 
findStepsize(v); /* works */ 

La valeur paramètre correspond à votre exemple ci-dessus, mais il est préférable de passer les classes définies par l'utilisateur qui doivent travailler dans leurs constructeurs de copie par référence const (Vector<T, N> const& au lieu). Vous évitez ainsi les copies, mais vous ne pouvez toujours pas modifier l'argument de l'appelant.

Answer 2

Mettre en oeuvre cette façon:

template <typename A, int B> 
class Vector { 

}; 

template <typename T, int N> 
void foo(Vector<T, N>& v) { 

} 

template <> 
void foo(Vector<int, 3>& v) { 
    // your specialization 
} 

Answer 3

template <typename T, size_t N> 
T find_step_size(const Vector<T,N>& v) 
{ 
    return T(); // or something 
} 

Answer 4

Votre deuxième question réponse:

Vous ne pouvez pas avoir un pointeur basé sur un modèle à fonctionner, qui n'a aucun sens. Mais ce que vous pouvez faire est

#include <vector> 

template <typename T> 
void foo(const std::vector<T>& v) { 
    // do something 
} 

void (*ptr_foo)(const std::vector<int>&) = &foo<int>; 

(ici la fonction pointeurs fonction basé sur un modèle, quel argument de modèle est explicitement défini sur int)