Como posso evitar que o C ++ adivinhe um segundo argumento de modelo?

Estou usando uma biblioteca C ++ ( strf ) que, em algum lugar dentro dela, tem o seguinte código:

namespace strf {
template <typename ForwardIt>
inline auto range(ForwardIt begin, ForwardIt end) { /* ... */ }

template <typename Range, typename CharT>
inline auto range(const Range& range, const CharT* sep) { /* ... */ }
}

Agora, quero usar strf::range<const char*>(some_char_ptr, some_char_ptr + some_length)no meu código. Mas, se o fizer, obtenho o seguinte erro (com o NVCC da CUDA 10.1):

error: more than one instance of overloaded function "strf::range" matches the argument list:
            function template "auto strf::range(ForwardIt, ForwardIt)"
            function template "auto strf::range(const Range &, const CharT *)"
            argument types are: (util::constexpr_string::const_iterator, util::constexpr_string::const_iterator)

O código da biblioteca provavelmente pode ser alterado para evitar isso (por exemplo, usando:

inline auto range(const typename std::enable_if<not std::is_pointer<typename std::remove_cv<Range>::type>::value, Range &>::type range, const CharT* sep)

garantir que Rangenão seja um ponteiro); mas não posso fazer essa alteração agora. Em vez disso, quero de alguma forma indicar ao compilador que realmente pretendo ter apenas um argumento de modelo, não um especificado e outro deduzido.

Posso fazer isso?

Gostaria de receber respostas para C ++ 11 e C ++ 14; As respostas C ++ 17 que envolvem guias de dedução são menos relevantes, mas se você tiver uma, publique-a (para versões futuras do NVCC ...)

_{Atualização: A própria biblioteca strf foi atualizada para contornar essa situação, mas a pergunta permanece conforme a pergunta.}

template<typename T>
inline constexpr auto range1_ptr = strf::range<T>;

template<typename T>
inline decltype(auto) range1(T begin, T end) {
    return range1_ptr<T>(begin, end);
}

Em seguida, ligue em range1vez de strf::range.

range1_ptr<T>(...)sempre pode ser usado para chamar explicitamente o modelo usando um argumento de modelo, mas não deduz os argumentos. range1replica a dedução do strf::rangemodelo original .

Isso funciona, porque [temp.deduct.funcaddr] / 1 diz que a dedução de argumento do modelo ao obter o endereço de uma função sem o tipo de destino da conversão é feita em cada modelo de função candidato como se o parâmetro e a lista de argumentos de uma chamada hipotética fossem esvaziar. Portanto, o segundo argumento do modelo não pode ser deduzido para a segunda sobrecarga com dois parâmetros de modelo. O único candidato que resta é a primeira sobrecarga, que será escolhida como o alvo do ponteiro da função.

Desde que não haja um segundo modelo de função candidato para o qual um ID de modelo válido com apenas um argumento possa ser formado, range1_ptrsempre pode ser usado para chamar o modelo de função usando um argumento sem ambiguidade. Caso contrário, a instanciação de range1_ptrdará um erro por causa da ambiguidade.

Que tal passar por um using?

using tfp = void(*)(char const *, char const *);

tfp x = &strf::range;

char const * a = "abcd";

(*x)(a, a+2);

Uma solução é

1) primeiro, você deve especificar o tipo para o segundo argumento, por exemplo (char *)(some_char_ptr + some_length)

2) não use constpara os dois, isso funciona bem:

strf::range((char *)some_char_ptr, (char *)(some_char_ptr + some_length));

Você pode tentar substituir (char *)por (const char *)à esquerda OU à direita, ainda funciona.