Wie schreibe ich ein Typmerkmal `is_container` oder `is_vector`?

Ist es möglich, ein Typmerkmal zu schreiben, dessen Wert für alle gängigen STL-Strukturen wahr ist (z. B. vector, set, map…)?

Zu Beginn möchte ich ein Typmerkmal schreiben, das für a gilt vector und falsch sonst. Ich habe es versucht, aber es lässt sich nicht kompilieren:

template<class T, typename Enable = void>
struct is_vector {
  static bool const value = false;
};

template<class T, class U>
struct is_vector<T, typename boost::enable_if<boost::is_same<T, std::vector<U> > >::type> {
  static bool const value = true;
};

Die Fehlermeldung ist template parameters not used in partial specialization: U.

Schauen Sie, eine weitere SFINAE-basierte Lösung zum Erkennen von STL-ähnlichen Containern:

template<typename T, typename _ = void>
struct is_container : std::false_type {};

template<typename... Ts>
struct is_container_helper {};

template<typename T>
struct is_container<
        T,
        std::conditional_t<
            false,
            is_container_helper<
                typename T::value_type,
                typename T::size_type,
                typename T::allocator_type,
                typename T::iterator,
                typename T::const_iterator,
                decltype(std::declval<T>().size()),
                decltype(std::declval<T>().begin()),
                decltype(std::declval<T>().end()),
                decltype(std::declval<T>().cbegin()),
                decltype(std::declval<T>().cend())
                >,
            void
            >
        > : public std::true_type {};

Natürlich können Sie die zu überprüfenden Methoden und Typen ändern.

Wenn Sie nur STL-Container erkennen möchten (dh std::vector, std::listusw.) sollten Sie so etwas tun.

AKTUALISIEREN. Wie @Deduplicator feststellte, erfüllt der Container möglicherweise nicht die AllocatorAwareContainer-Anforderungen (z. B.: std::array<T, N>). Deshalb check on T::allocator_type ist nicht notwendig. Aber Sie können alle/alle ankreuzen Container Anforderungen in ähnlicher Weise.

Eigentlich habe ich nach einigem Ausprobieren festgestellt, dass es ganz einfach ist:

template<class T>
struct is_vector<std::vector<T> > {
  static bool const value = true;
};

Ich würde immer noch gerne wissen, wie man eine allgemeinere schreibt is_container. Muss ich alle Typen von Hand auflisten?

Sie würden sagen, es sollte einfacher sein als das …

template <typename T, typename _ = void>
struct is_vector { 
    static const bool value = false;
};
template <typename T>
struct is_vector< T,
                  typename enable_if<
                      is_same<T,
                              std::vector< typename T::value_type,
                                           typename T::allocator_type >
                             >::value
                  >::type
                >
{
    static const bool value = true;
};

… Aber ich bin mir nicht sicher, ob das so ist einfacher oder nicht.

In C ++ 11 können Sie Typaliase verwenden (glaube ich, ungetestet):

template <typename T>
using is_vector = is_same<T, std::vector< typename T::value_type,
                                          typename T::allocator_type > >;

Das Problem mit Ihrem Ansatz ist, dass der Typ U ist in dem Kontext, in dem es verwendet wird, nicht ableitbar.

Während die anderen Antworten hier, die versuchen zu erraten, ob eine Klasse ein Container ist oder nicht, für Sie funktionieren könnten, möchte ich Ihnen die Alternative vorstellen, den Typ zu benennen, für den Sie true zurückgeben möchten. Sie können dies verwenden, um beliebige zu erstellen is_(something) Eigenschaften Typen.

template<class T> struct is_container : public std::false_type {};

template<class T, class Alloc> 
struct is_container<std::vector<T, Alloc>> : public std::true_type {};

template<class K, class T, class Comp, class Alloc> 
struct is_container<std::map<K, T, Comp, Alloc>> : public std::true_type {};

Und so weiter.

Sie müssen einbeziehen <type_traits> und welche Klassen Sie Ihren Regeln hinzufügen.

Warum nicht so etwas für is_container?

template <typename Container>
struct is_container : std::false_type { };

template <typename... Ts> struct is_container<std::list<Ts...> > : std::true_type { };
template <typename... Ts> struct is_container<std::vector<Ts...> > : std::true_type { };
// ...

Auf diese Weise können Benutzer ihre eigenen Container hinzufügen, indem sie sich teilweise spezialisieren. Verwenden Sie für is_vector et al. nur eine teilweise Spezialisierung wie oben, aber beschränken Sie sie auf nur einen Containertyp, nicht viele.

template <typename T>
struct is_container {

    template <
       typename U,
       typename I = typename U::const_iterator
    >   
    static int8_t      test(U* u); 

    template <typename U>
    static int16_t     test(...);

    enum { value  =  sizeof test <typename std::remove_cv<T>::type> (0) == 1 };
};


template<typename T, size_t N>  
struct  is_container <std::array<T,N>>    : std::true_type { };

Die Art und Weise, wie ich feststellen möchte, ob etwas ein Container ist, ist zu suchen data() und size() Mitgliedsfunktionen. So was:

template <typename T, typename = void>
struct is_container : std::false_type {};

template <typename T>
struct is_container<T
   , std::void_t<decltype(std::declval<T>().data())
      , decltype(std::declval<T>().size())>> : std::true_type {};