Come posso impedire a C ++ di indovinare un secondo argomento modello?

Sto usando una libreria C ++ ( strf ) che, da qualche parte al suo interno, ha il seguente codice:

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) { /* ... */ }
}

Ora voglio usare strf::range<const char*>(some_char_ptr, some_char_ptr + some_length)nel mio codice. Ma se lo faccio, ottengo il seguente errore (con NVCC di 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)

Il codice della libreria può probabilmente essere modificato per evitarlo (ad es. 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)

assicurarsi che Rangenon sia un puntatore); ma non posso apportare quel cambiamento in questo momento. Invece, voglio in qualche modo indicare al compilatore che intendo davvero avere solo un argomento template, non uno specificato e un altro dedotto.

Posso farlo?

Gradirei le risposte per C ++ 11 e C ++ 14; Le risposte C ++ 17 che coinvolgono le guide alla detrazione sono meno rilevanti, ma se ne hai una, per favore pubblicala (per future versioni NVCC ...)

_{Aggiornamento: la stessa libreria strf è stata aggiornata per aggirare questa situazione, ma la domanda si pone come posta.}

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);
}

Quindi chiama range1invece di strf::range.

range1_ptr<T>(...)può sempre essere usato per chiamare esplicitamente il modello prendendo un argomento template, ma non fa alcuna deduzione dagli argomenti. range1replica la detrazione dal strf::rangemodello originale .

Questo funziona perché [temp.deduct.funcaddr] / 1 afferma che la deduzione dell'argomento modello quando si prende l'indirizzo di una funzione senza tipo di destinazione della conversione viene eseguita su ciascun modello di funzione candidato come se gli elenchi di parametri e argomenti di una chiamata ipotetica fossero vuoto. Pertanto, il secondo argomento del modello non può essere dedotto per il secondo sovraccarico con due parametri del modello. L'unico candidato rimasto è il primo sovraccarico, che verrà scelto come target del puntatore alla funzione.

Finché non esiste un secondo modello di funzione candidato per il quale può essere formato un ID modello valido con un solo argomento, range1_ptrpuò sempre essere utilizzato per chiamare il modello di funzione prendendo un argomento in modo inequivocabile. Altrimenti, l'istanza di range1_ptrdarà un errore a causa dell'ambiguità.

Che ne dici di passare attraverso un using?

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

tfp x = &strf::range;

char const * a = "abcd";

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

Una soluzione è

1) prima di tutto, dovresti specificare il tipo per il secondo argomento, ad es (char *)(some_char_ptr + some_length)

2) non usare constper entrambi, funziona bene:

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

Puoi provare a sostituirlo (char *)con (const char *)a sinistra O a destra, funziona ancora.