Как да огранича параметър на шаблон да отговаря на ключ в std::map?

Зависи какво имате предвид под „съответства“. Ако искате да проверите дали K има оператор <, можете да опитате Boost Concept Checking Library.

#include "boost/concept_check.hpp"

template< typename K >
class Foo
{
  BOOST_CONCEPT_ASSERT((boost::LessThanComparable< K >));

  // lots of other code here...

  private:
    std::map< K, size_t > m_map;
};

Ако обаче искате да проверите дали < дефинира StrictWeakOrdering на K, това ще изисква тестване на поведението по време на изпълнение при всички възможни входове.

C++11 версия:

#include <type_traits>

template<class T>
struct satisfies_key_req{
  struct nat{};

  template<class K> static auto test(K* k) -> decltype(*k < *k);
  template<class K> static nat  test(...);

  static bool const value = !std::is_same<decltype(test<T>(0)), nat>::value;
};

#include <iostream>

struct foo{};

int main(){
    static bool const b = satisfies_key_req<int>::value;
    std::cout << b << '\n';
    static bool const b2 = satisfies_key_req<foo>::value;
    std::cout << b2 << '\n';
}

Изход:

1
0

Ключовият момент, който използвах тук, е изразът SFINAE: auto test(K* k) -> decltype(*k < *k). Ако изразът в trailing-return-type не е валиден, тогава това конкретно претоварване на test се премахва от набора за претоварване. С други думи, това е SFINAE'd.

§14.8.2 [temp.deduct]

p6 В определени моменти от процеса на дедукция на аргументите на шаблона е необходимо да се вземе тип функция, който използва параметри на шаблона и да се заменят тези параметри на шаблона със съответните аргументи на шаблона. Това се прави в началото на шаблона изваждане на аргументи, когато изрично посочените аргументи на шаблона се заместват в типа на функцията и отново в края на изваждането на аргументи на шаблона, когато се заместват всички аргументи на шаблон, които са били изведени или получени от аргументи по подразбиране.

p7 Заместването се случва във всички типове и изрази, които се използват във функционалния тип и в декларациите на параметрите на шаблона. Изразите включват не само постоянни изрази като тези, които се появяват в границите на масива или като аргументи на шаблон без тип но също и общи изрази (т.е. непостоянни изрази) вътре sizeof, decltype и други контексти, които позволяват неконстантни изрази.

p8 Ако заместването води до невалиден тип или израз, дедукцията на типа е неуспешна. Невалиден тип или израз е този, който би бил неправилно оформен, ако е написан с помощта на заместените аргументи. [...]

Можете да го използвате в три варианта за вашия Foo клас, за да задействате грешка.

// static_assert, arguably the best choice
template< typename K >
class Foo
{
  static_assert<satisfies_key_req<K>::value, "K does not satisfy key requirements");
  // lots of other code here...

  private:
    std::map< K, size_t > m_map;
};

// new-style SFINAE'd, maybe not really clear
template<
  typename K,
  typename = typename std::enable_if<
               satisfies_key_req<K>::value
             >::type
>
class Foo
{
  // lots of other code here...

  private:
    std::map< K, size_t > m_map;
};

// partial specialization, clarity similar to SFINAE approach
template< 
  typename K,
  bool = satisfies_key_req<K>::value
>
class Foo
{
  // lots of other code here...

  private:
    std::map< K, size_t > m_map;
};

template<typename K>
class Foo<K, false>;

Пълното решение на вашия проблем вероятно е невъзможно. Но мога да ви предложа решение, ако искате да ограничите K до конкретен тип, можете да дефинирате вашия клас, както следва

template <class K, bool = std::is_same<K,int>::value>
class Foo { ... };

template <class K>
class Foo<K,false> { Foo(); };

Така че, ако K е int вашият клас работи според очакванията. В противен случай не можете да конструирате обект от тип Foo<K>. Очевидно можете да прецизирате условието.

За да проверите дали K има operator<, можете да използвате boost::has_less, но тъй като можете да проверите в документация тази характеристика не винаги работи правилно.

От въпроса ви предполагам, че искате една подходяща грешка вместо купища грешки.

Следният код намира дали типът има валиден operator < или не:

namespace OperatorExist
{
  typedef char no[3]; // '3' can be any awkward number
  template<typename T> no& operator < (const T&, const T&);

  template<typename T>
  struct LessThan {
    static const bool value = (sizeof(*(T*)(0) < *(T*)(0)) != sizeof(no));
  };
}

Сега можете да специализирате class Foo, като използвате горната конструкция:

template<typename K, bool = OperatorExist::LessThan<K>::value>
class Foo 
{
  // lots of other code here...
  private:
    std::map<K, size_t> m_map;
};

template<typename K>
class Foo<K, false>; // unimplemented for types not suitable for 'std::map'

Веднага щом използвате някакъв тип A, който няма съвместимост с std::map, компилаторът ще се оплаче с една грешка:

error: aggregate ‘Foo<A> oa’ has incomplete type and cannot be defined

Демо