Специализация шаблона для всех итераторов std::map

Question

У меня есть черты класса, говорящие:

template <class T>
struct KeyValueTraits
{
    typedef typename T::key_t key_t;
    typedef typename T::value_t value_t;
}

Теперь я хотел бы объявить специализацию этих черт для всех итераторов std::map

template < typename... Args >
struct KeyValueTraits<typename std::map<Args...>::iterator >
{
    typedef std::map<Args...> target_t;
    typedef typename target_t::key_type key_t;
    typedef typename target_t::mapped_type value_t;
};

Компилятор вызывает ошибку:

ошибка C2764: "Args": параметр шаблона не используется или выводится при частичной специализации

Итак, как объявить черты типа для всех возможных std::map<...>::iterator?

Answer 1

Вот одно из возможных решений (оно меняет сигнатуру шаблона KeyValueTraits, потому что иначе это не представляется возможным).

template <class T, class = void>
struct KeyValueTraits
{
    typedef typename T::key_t key_t;
    typedef typename T::value_t value_t;
};

template <class MapIter>
struct KeyValueTraits<MapIter, 
                      typename std::enable_if<
                         sizeof(std::declval<MapIter>()->first) && 
                         sizeof(std::declval<MapIter>()->second)
                      >::type>
{
    typedef decltype(std::declval<MapIter>()->first) key_t;
    typedef decltype(std::declval<MapIter>()->second) value_t;
};

Answer 2

Вы используете переменные параметры шаблона, поэтому я полагаю, что вы можете принять решение C++11.

Я предлагаю следующее (не очень хорошее) решение, основанное на специализации шаблонов.

Примите во внимание, что тип ключа, в std::map<>не key_t но key_type и что тип значения не value_t но mapped_type,

#include <map>

template <typename X>
struct with_kt
 { 
   template <typename Y = X>
   static constexpr bool getValue (int, typename Y::key_type * = nullptr)
    { return true; }

   static constexpr bool getValue (long)
    { return false; }

   static constexpr bool value { getValue(0) };
 };

template <typename T, bool = with_kt<T>::value>
struct KeyValueTraits;

template <typename T>
struct KeyValueTraits<T, true>
 {
   using key_t   = typename T::key_type;
   using value_t = typename T::mapped_type;
 };

template <typename T>
struct KeyValueTraits<T, false>
 {
   using pair_t  = decltype(* std::declval<T>());

   using key_t   = typename std::remove_const<
                      decltype(std::declval<pair_t>().first)>::type;
   using value_t = decltype(std::declval<pair_t>().second);
 };


using mil = std::map<int,long>;

int main()
 {
   static_assert(std::is_same<KeyValueTraits<mil>::key_t,
                              KeyValueTraits<mil::iterator>::key_t
                              >::value, "!");

   static_assert(std::is_same<KeyValueTraits<mil>::value_t,
                              KeyValueTraits<mil::iterator>::value_t
                              >::value, "!!");

   static_assert(std::is_same<KeyValueTraits<mil>::key_t,
                              KeyValueTraits<mil::const_iterator>::key_t
                              >::value, "!!!");

   static_assert(std::is_same<KeyValueTraits<mil>::key_t,
                              KeyValueTraits<mil::reverse_iterator>::key_t
                              >::value, "!!!!");

   static_assert(std::is_same<KeyValueTraits<mil>::key_t,
                              KeyValueTraits<mil::const_reverse_iterator>::key_t
                              >::value, "!!!!!");
 }