passant std :: vecteur pour tout type à une fonction

Question

Vu:

template<typename T> class A { 
    B b; 
    std::vector<T> vec1; 
    std::vector<T> vec2; 
} 

Je voudrais B d'avoir une fonction de membre qui remplissent() qui prend une référence à ceux des vecteurs et remplit vec2 avec des valeurs de T en fonction de certaines informations contenues dans b.
Une façon de le faire est de remplir la surcharge() pour chaque argument possible T:

fill(const std::vector<float>& a, std::vector<float>& b) 

et ainsi de suite, mais cela signifie beaucoup de duplication inutile que les opérations sont les mêmes pour tous les possibles T. A l'intérieur de fill() Je pourrais utiliser vector :: value_type pour les calculs mais je ne sais pas comment le déclarer de telle sorte qu'il prenne tout type de std :: vector. La manière évidente serait d'utiliser une fonction gratuite avec des modèles. Y a-t-il une manière plus simple de faire ceci?

Answer 1

B. créer des modèles à

template<typename T> class B { 
    void fill(const std::vector<T>& a, std::vector<T>& b) { } 
}; 

template<typename T> class A { 
    B<T> b; 
    std::vector<T> vec1; 
    std::vector<T> vec2; 
} 

Si vous ne voulez pas B créer des modèles à, puis la fonction créer des modèles à remplissage:

class B { 
    template<typename T> 
    void fill(const std::vector<T>& a, std::vector<T>& b) {} 
}; 

Answer 2

fill créer des modèles à:

class B { 
public: 
    template<typename T> 
    void fill(const std::vector<T>& a, std::vector<T>& b) 
    { /*...*/ } 
    //... 
}; 

(A partir de votre description il voit que b devrait être un const std::vector<T>&.)

Answer 3

Vous pouvez définir B en tant que classe de modèle, remplir en fonction du modèle (dans une classe non-modèle B) ou, mon préféré, utilisez la norme std::transform/std::copy/std::fill, qui sont déjà fonction modèle, pour remplir votre vecteur.
(Tous situés à l'intérieur <algorithm> en-tête).

Answer 4

Vous avez obtenu un certain nombre de réponses, mais je ne suis pas d'accord avec elles, au moins dans une certaine mesure. Ma réaction immédiate est que vous ne devriez pas passer un vecteur à b::fill du tout. Au contraire, vous devriez passer un itérateur (ou peut-être une paire d'itérateurs). Le reste est la plupart du temps juste: cela signifie toujours fill devrait être une fonction de membre de modèle. Lorsque vous l'appelez, vous voudrez probablement passer un std::back_insert_iterator, généralement obtenu avec std::back_inserter.

Une partie de ce que vous avez dit semble contradictoire que: si b::fill et modifie vec1vec2, ils devraient probablement pas être passés comme des références à Const. Certes, const n'a pas exactement sa signification habituelle lorsqu'il est appliqué à un conteneur, mais il reste que passer une référence à const à une fonction dont la seule intention est apparemment de modifier ce qui est passé semble faux.