c++ de la classe de modèle; fonction arbitraire type de conteneur, comment le définir?

Traits de solution.

Généraliser non plus que nécessaire, et pas moins.

Dans certains cas, cette solution pourrait ne pas être suffisante car elle correspond à un modèle, avec la signature (par exemple,shared_ptr), auquel cas vous pourriez faire usage de type_traits, très bien comme en tapant duck (modèles de canard tapé en général).

#include <type_traits>

//Helper to determine whether there's a const_iterator for T.
template<typename T>
struct has_const_iterator
{
private:
    template<typename C> static char test(typename C::const_iterator*);
    template<typename C> static int  test(...);
public:
    enum { value = sizeof(test<T>(0)) == sizeof(char) };
};


//bar() is defined for Containers that define const_iterator as well
//as value_type.
template <typename Container>
typename std::enable_if<has_const_iterator<Container>::value,
                        void>::type
bar(const Container &c, typename Container::value_type const & t)
{
  //Note: no extra check needed for value_type, the check comes for
  //      free in the function signature already.
}


template <typename T>
class DoesNotHaveConstIterator {};

#include <vector>
int main () {
    std::vector<float> c;
    bar (c, 1.2f);

    DoesNotHaveConstIterator<float> b;
    bar (b, 1.2f); //correctly fails to compile
}

Un bon modèle n'est généralement pas restreindre artificiellement le genre de types pour lesquels ils sont valides (pourquoi devraient-ils?). Mais imaginez que dans l'exemple ci-dessus, vous devez avoir accès à l'un des objets const_iterator, alors vous pouvez utiliser SFINAE et type_traits de mettre ces contraintes sur votre fonction.

Ou tout simplement pour que la bibliothèque standard ne

Généraliser non plus que nécessaire, et pas moins.

template <typename Iter>
void bar (Iter it, Iter end) {
    for (; it!=end; ++it) { /*...*/ }
}

#include <vector>
int main () {
    std::vector<float> c;
    bar (c.begin(), c.end());
}

Pour plus de tels exemples, regarder dans <algorithm>.

Cette approche de la force, c'est sa simplicité et est basé sur des concepts comme ForwardIterator. Il va même jusqu'à travailler pour les tableaux. Si vous souhaitez signaler des erreurs de droit dans la signature, vous pouvez les combiner avec des traits.

std conteneurs avec signature comme std::vector (pas recommandé)

La solution la plus simple est approximée par Kerrek SB déjà, si elle n'est pas valide en C++. Le corrigé variante va comme suit:

#include <memory> //for std::allocator
template <template <typename, typename> class Container, 
          typename Value,
          typename Allocator=std::allocator<Value> >
void bar(const Container<Value, Allocator> & c, const Value & t)
{
  //
}

Cependant: cela ne fonctionne que pour les conteneurs qui ont exactement deux type de modèle arguments, donc échouent lamentablement pour std::map (merci Luc Danton).

Tout type de secondaire arguments de modèle (pas recommandé)

La version corrigée secondaire nombre de paramètre est comme suit:

#include <memory> //for std::allocator<>

template <template <typename, typename...> class Container, 
          typename Value,
          typename... AddParams >
void bar(const Container<Value, AddParams...> & c, const Value & t)
{
  //
}

template <typename T>
class OneParameterVector {};

#include <vector>
int main () {
    OneParameterVector<float> b;
    bar (b, 1.2f);
    std::vector<float> c;
    bar (c, 1.2f);
}

Cependant: ce sera toujours pas pour les non-template des conteneurs (merci Luc Danton).

OriginalL'auteur Sebastian Mach

Voici la dernière version de cette réponse et une amélioration considérable de réponse par Sabastian.

L'idée est de définir tous les traits de conteneurs STL. Malheureusement, ce qui est difficile, très rapide, et heureusement, beaucoup de personnes ont travaillé sur le réglage du présent code. Ces traits sont réutilisables, il suffit donc de copier et passé de code ci-dessous dans le fichier appelé type_utils.hpp (n'hésitez pas à changer ces noms):

//put this in type_utils.hpp 
#ifndef commn_utils_type_utils_hpp
#define commn_utils_type_utils_hpp
#include <type_traits>
#include <valarray>
namespace common_utils { namespace type_utils {
//from: https://raw.githubusercontent.com/louisdx/cxx-prettyprint/master/prettyprint.hpp
//also see https://gist.github.com/louisdx/1076849
namespace detail
{
//SFINAE type trait to detect whether T::const_iterator exists.
struct sfinae_base
{
using yes = char;
using no  = yes[2];
};
template <typename T>
struct has_const_iterator : private sfinae_base
{
private:
template <typename C> static yes & test(typename C::const_iterator*);
template <typename C> static no  & test(...);
public:
static const bool value = sizeof(test<T>(nullptr)) == sizeof(yes);
using type =  T;
void dummy(); //for GCC to supress -Wctor-dtor-privacy
};
template <typename T>
struct has_begin_end : private sfinae_base
{
private:
template <typename C>
static yes & f(typename std::enable_if<
std::is_same<decltype(static_cast<typename C::const_iterator(C::*)() const>(&C::begin)),
typename C::const_iterator(C::*)() const>::value>::type *);
template <typename C> static no & f(...);
template <typename C>
static yes & g(typename std::enable_if<
std::is_same<decltype(static_cast<typename C::const_iterator(C::*)() const>(&C::end)),
typename C::const_iterator(C::*)() const>::value, void>::type*);
template <typename C> static no & g(...);
public:
static bool const beg_value = sizeof(f<T>(nullptr)) == sizeof(yes);
static bool const end_value = sizeof(g<T>(nullptr)) == sizeof(yes);
void dummy(); //for GCC to supress -Wctor-dtor-privacy
};
}  //namespace detail
//Basic is_container template; specialize to derive from std::true_type for all desired container types
template <typename T>
struct is_container : public std::integral_constant<bool,
detail::has_const_iterator<T>::value &&
detail::has_begin_end<T>::beg_value  &&
detail::has_begin_end<T>::end_value> { };
template <typename T, std::size_t N>
struct is_container<T[N]> : std::true_type { };
template <std::size_t N>
struct is_container<char[N]> : std::false_type { };
template <typename T>
struct is_container<std::valarray<T>> : std::true_type { };
template <typename T1, typename T2>
struct is_container<std::pair<T1, T2>> : std::true_type { };
template <typename ...Args>
struct is_container<std::tuple<Args...>> : std::true_type { };
}}  //namespace
#endif

Maintenant vous pouvez utiliser ces traits de faire en sorte que notre code accepte uniquement les types de conteneurs. Par exemple, vous pouvez mettre en œuvre ajout de la fonction qui ajoute un vecteur à l'autre comme ceci:

#include "type_utils.hpp"
template<typename Container>
static typename std::enable_if<type_utils::is_container<Container>::value, void>::type
append(Container& to, const Container& from)
{
using std::begin;
using std::end;
to.insert(end(to), begin(from), end(from));
}

Avis que je suis en utilisant begin() et end() de l'espace de noms std juste pour être sûr que nous avons itérateur comportement. Pour plus d'explication voir mon blog.

OriginalL'auteur ShitalShah