Сбой при выводе типа с указателем на метод-член

Компилятор не может определить тип A, поскольку он имеет контрастную информацию. Из типа функции-члена было бы выведено A быть std::string const&в то время как из типа второго аргумента, он будет выводить std::string,

Измените шаблон вашей функции на тот, который допускает разные типы для параметра функции-члена и фактически предоставленного аргумента, а затем SFINAE-ограничивает последний для преобразования в первый:

template <typename A, typename B,
typename std::enable_if<std::is_convertible<B, A>::value>::type* = nullptr>
void call(void (T::*f)(A), B a)
{
(o_.*f)(a);
}

Если вам интересно, почему из этого вызова функции:

std::string const s = "For kids, you know.";
// ...
p.call(&Hudsucker::g, s);

Компилятор выведет std::stringэто из-за пункта 14.8.2.1/2 стандарта C ++ 11:

Если P не является ссылочным типом:

— Если A тип массива, тип указателя, полученный стандартным преобразованием массива в указатель (4.2)
используется вместо A для вычета типа; иначе,

— Если A тип функции, тип указателя, получаемый стандартным преобразованием функции в указатель (4.3)
используется вместо A для вычета типа; иначе,

— Если A является cv-квалифицированным типом, cv-квалификаторы верхнего уровня AТип игнорируется для вывода типа.

В цитируемом пункте P твой A (из шаблона вашей функции) и A является std::string const, Это означает, что const в std::string const игнорируется для вывода типа. Чтобы увидеть это лучше, рассмотрим этот более простой пример:

#include <type_traits>

template<typename T>
void foo(T t)
{
// Does NOT fire!
static_assert(std::is_same<T, int>::value, "!");
}

int main()
{
int const x = 42;
foo(x);
}

Учитывая второй вызов функции:

std::string const &r = s;
// ...
p.call(&Hudsucker::g, r);

Причина в том, что тип ID-выражение r является std::string const, Ссылка исключена из-за пункта 5/5:

Если выражение изначально имеет тип «ссылка на T»(8.3.2, 8.5.3), тип корректируется на T до
любой дальнейший анализ. Выражение обозначает объект или функцию, обозначенную ссылкой, и
Выражение является lvalue или xvalue, в зависимости от выражения.

И теперь мы вернулись к той же ситуации, что и для первого вызова функции.

Как отметил Майк Вайн в комментариях, вы можете захотеть совершенно вперед Ваш второй аргумент при вводе его в качестве аргумента first (функция-член) во время вызова функции:

#include <utility> // For std::forward<>()

template <typename A, typename B,
typename std::enable_if<std::is_convertible<B, A>::value>::type* = nullptr>
void call(void (T::*f)(A), B&& a)
{
(o_.*f)(std::forward<B>(a));
}

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

template <typename A, typename B>
typename enable_if<is_convertible<B, A>::value>::type
//       ^^^^^^^^^ ^^^^^^^^^^^^^^
//       But how about these traits?
call(void (T::*f)(A), B a)
{
(o_.*f)(a);
}

Заметить, что std::enable_if а также std::is_convertible не являются частью стандартной библиотеки C ++ 03. К счастью, Boost имеет свою версию enable_if а также is_convertible, так:

#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_convertible.hpp>

template <typename T> class Proxy
{
public:
Proxy(T &o): o_(o) {}

template <typename A, typename B>
typename boost::enable_if<boost::is_convertible<B, A>>::type
call(void (T::*f)(A), B a)
{
(o_.*f)(a);
}

private:
T &o_;
};

Заметить, что boost::enable_if принимает в качестве первого аргумента шаблона тип который определяет value логический член, тогда как std::enable_if принимает логическое значение. Эквивалент std::enable_if в Boost есть boost::enable_if_c,