passant la fonction de modèle à std :: for_each

Question

J'essaye d'écrire une fonction modèle simple qui imprime chaque élément d'un conteneur, sans utiliser pour les boucles. Jusqu'à présent, j'ai

#include <iostream> 
#include <vector> 
#include <algorithm> 

template <typename T> void print_with_space(T x){ 
    std::cout << x << ' '; 
} 

template <typename T> void print_all(T beg, T end){ 
    std::for_each(beg, end, print_with_space<int>); 
    std::cout << '\n'; 
} 

int main(){ 
    int a[] = {1, 2, 3}; 
    std::vector<int> v(a, a+3); 
    print_all(v.begin(), v.end()); 
    return 0; 
} 

Le code compile et fonctionne, mais seulement parce que je mis print_with_space<int> dans la mise en œuvre de print_all. Je voudrais simplement avoir print_with_space là pour des raisons évidentes, mais le code ne compile pas. Comment puis-je faire cela?

Answer 1

Vous pouvez utiliser:

std::for_each(beg, end, [](const typename T::value_type& value) { 
    print_with_space(value); 
}); 

T est de type std::vector<>::iterator, qui est un RandomAccessIterator. Chaque RandomAcessIterator a un type sous-jacent, qui est exposé par value_type. Par conséquent, si vous transmettez std::vector<int>::iterator, std::vector<int>::iterator::value_type sera int.

Maintenant que vous avez le type, vous pouvez créer un lambda, qui sera exécuté à chaque itération.

---

En C++ 14, vous pouvez même le faire:

//'auto' automatically deduces the type for you 
std::for_each(beg, end, [](const auto& value) { 
    print_with_space(value); 
}); 

Answer 2

Alternative pour 03 C++:

#include <iterator> 

template <typename T> void print_all(T beg, T end) 
{ 
    typedef typename std::iterator_traits<T>::value_type val_t; 
    std::for_each(beg, end, print_with_space<val_t>); 
    std::cout << '\n'; 
} 

Answer 3

Une autre option:

template <typename T> void print_all(T beg, T end) { 
    std::for_each(beg, end, print_with_space<decltype(*beg)>); 
    std::cout << '\n'; 
} 

Answer 4

Le solution la plus flexible, qui fonctionnera avec toutes les versions de C++, est de faire print_with_space un objet fonction.

Cela confère un certain nombre d'avantages:

1. pas besoin de spécifier le type de modèle sur le site d'appel.
2. pas besoin de bidouiller avec la déduction manuelle.
3. une spécialisation partielle peut être obtenue en faisant en sorte que le foncteur soit déféré à une fonction libre modélisée.

Tels que:

#include <iostream> 
#include <iomanip> 
#include <vector> 
#include <algorithm> 

// basic implementation 
template<class T> void impl_print_with_space(const T& x) 
{ 
    std::cout << x << ' '; 
} 

// what about special handling for strings? 

template<class C, class Ch, class Alloc> 
void impl_print_with_space(const std::basic_string<C, Ch, Alloc>& x) 
{ 
    std::cout << std::quoted(x) << ' '; 
} 

// functor 

struct print_with_space 
{ 
    template<class T> void operator()(const T& x) const 
    { 
    impl_print_with_space(x); 
    } 
}; 


template <typename Iter> void print_all(Iter beg, Iter end) 
{ 
    std::for_each(beg, end, print_with_space()); 
    std::cout << '\n'; 
} 

int main(){ 
    int a[] = {1, 2, 3}; 
    std::vector<int> v(a, a+3); 
    print_all(v.begin(), v.end()); 

    auto b = std::vector<std::string> { "hello", "world" }; 
    print_all(b.begin(), b.end()); 

    return 0; 
}