Jak uniknąć próchnicy z parametrem szablonu odliczenia

Question

uproszczonej:

// CHAR_TYPE == char, wchar_t, ... 
template <typename CHAR_TYPE, unsigned CHAR_COUNT> 
void Foo(CHAR_TYPE const (&value)[CHAR_COUNT]) noexcept 
{ 
    TRACE("const ref array"); 
    // perform a bit of logic and forward... 
} 

template <typename CHAR_TYPE> 
void Foo(CHAR_TYPE const* value) noexcept 
{ 
    TRACE("const ptr"); 
    // perform a bit of logic and forward... 
} 

// [ several other overloads ] 

Callsite:

char const* ptr = ... 
wchar_t const* wptr = ... 

Foo(ptr);  // <-- good: "const ptr" 
Foo(wptr); // <-- good: "const ptr" 

constexpr char const buffer[] { "blah blah blah" }; 
constexpr wchar_t const wbuffer[] { L"blah blah blah" }; 

Foo(buffer); // <-- ambiguous 
Foo(wbuffer); // <-- ambiguous 

Oczywiście, mogę usunąć const przeciążenie tablicy ref. Jednak chciałbym obsługiwać te typy w różny sposób. Próbowałem warunkowo włączyć poprawne przeciążenie, ale nie byłem w stanie określić koniecznego stanu.

template <typename CHAR_TYPE, unsigned COUNT> 
typename std::enable_if</* std::is_?? */, void>::type 
    Foo(CHAR_TYPE const (&value)[COUNT]) noexcept 
{ 
    TRACE("by ref array"); 
    // perform a bit of logic and forward... 
} 

template <typename CHAR_TYPE> 
typename std::enable_if</* std::is_?? */, void>::type 
    Foo(CHAR_TYPE const* value) noexcept 
{ 
    TRACE("ptr"); 
    // perform a bit of logic and forward... 
} 

Jaki jest najlepszy sposób na rozróżnienie tych przeciążeń?
(wolałbym nie używać opakowania array)

Answer 1

Biorąc argument rozpadu (const) blokuje odniesienia tablica-to-wskaźnik w odjęciu szablon argumentów. Zobacz [temp.deduct.call]/2. A więc:

template <typename CHAR_TYPE> 
void Foo(CHAR_TYPE const* const & value) noexcept 
{ 
    TRACE("const ptr"); 
    // perform a bit of logic and forward... 
} 

Answer 2

jeden pomysł, który działa jest usunięcie wskaźnika, a po prostu mieć T zamiast z std::enable_if_t<std::is_pointer<T>::value> straży. Przykład uproszczone następująco:

#include <iostream> 
#include <type_traits> 

template<class T, size_t N> 
void f(T const (&) [N]) 
{ 
    std::cout << __PRETTY_FUNCTION__ << std::endl; 
} 

template<class T, std::enable_if_t<std::is_pointer<T>::value>* = nullptr > 
void f(T) 
{ 
    std::cout << __PRETTY_FUNCTION__ << std::endl; 
} 

int main() 
{ 
    const char* str = "test"; 
    char str2[]{"test2"}; 

    f(str); 
    f(str2); 
} 

Live on Coliru