wenn klassenspezifische Memberfunktion hat

Question

ich die folgende Template-Funktion geschrieben, die ein willkürlicher Behälter überprüft, ob ein bestimmtes Element enthält:

template<template<class, class...> class container_t, class item_t, class... rest_t> 
bool contains(const container_t<item_t, rest_t...> &_container, const item_t &_item) { 
    for(const item_t &otherItem : _container) { 
     if(otherItem == _item) { return true; } 
    } 
    return false; 
} 

Das funktioniert gut für die meisten Container. Doch für alle Arten von Sätzen (und Karten) ist suboptimal, da könnten wir verwenden:

template<template<class, class...> class set_t, class item_t, class... rest_t> 
bool contains(const set_t<item_t, rest_t...> &_set, const item_t &_item) { 
    return _set.count(_item) > 0; 
} 

Natürlich sind wir nicht beide Vorlagen gleichzeitig wegen Mehrdeutigkeit verwenden können. Jetzt suche ich nach einer Möglichkeit, std::enable_if zu verwenden, um die erste Vorlage zu aktivieren, wenn container_t keine count Mitgliedsfunktion und die zweite Vorlage, wenn dies der Fall ist. Ich kann jedoch nicht herausfinden, wie Sie nach einer bestimmten Elementfunktion suchen (mit C++ 11).

Answer 1

C++ 14-Funktion neu implementiert:

template<class...>struct voider{using type=void;}; 
template<class...Ts>using void_t=typename voider<Ts...>::type; 

A mini metaprogramming Bibliothek:

template<class...>struct types{using type=types;}; 
namespace details { 
    template<template<class...>class Z, class types, class=void> 
    struct can_apply : std::false_type {}; 
    template<template<class...>class Z, class...Ts> 
    struct can_apply< Z, types<Ts...>, void_t< Z<Ts...> > >: 
    std::true_type 
    {}; 
} 
template<template<class...>class Z, class...Ts> 
using can_apply = details::can_apply<Z,types<Ts...>>; 

can_apply< some_template, args... > erbt von true_type iff some_template<args...> ein gültiger Ausdruck (in dem unmittelbaren Kontext).

Jetzt für Ihr Problem:

template<class T, class I> 
using dot_count_type = decltype(std::declval<T>().count(std::declval<I>())); 

template<class T, class I> 
using has_dot_count = can_apply<dot_count_type, T, I>; 

und has_dot_count ist eine Klasse, die Züge von true_type iff T.count(I) erbt ein gültiger Ausdruck ist.

namespace details { 
    template<class C, class I> 
    bool contains(std::false_type, C const& c, I const& i) { 
    for(auto&& x:c) { 
     if(x == i) { return true; } 
    } 
    return false; 
    } 
    template<class C, class I> 
    bool contains(std::true_type, C const& c, I const& i) { 
    return c.count(i) != 0; 
    } 
} 
template<class C, class I> 
bool contains(C const& c, I const& i) { 
    return details::contains(has_dot_count<C const&,I const&>{}, c, i); 
} 

, die Tag-Dispatching anstelle von SFINAE verwendet.

Verwenden find scheint wie eine bessere Idee als .count als beiseite. In der Tat sollten Sie in einem Fall .find den anderen find verwenden. In beiden Fällen sollten Sie using std::end; auto e = end(c); verwenden.

Nebenbei, MSVC 2013 (ich weiß nicht über 2015) nicht mit dieser Art von SFINAE oben verwendet. Sie nennen es "Ausdruck SFINAE". Sie verfügen über benutzerdefinierte Erweiterungen, um das Vorhandensein einer Elementfunktion zu erkennen. Aber das liegt daran, dass sie weit entfernt von C++ 11 Standard sind.