void WideToUTF8(wchar_t const *input, size_t size, std::string &out); //спрятана в .cpp файле.

inline void WideToUTF8(const std::wstring &str, std::string &out) 
{
    WideToUTF8(str.data(), str.size(), out);
}

template <int N>
inline void WideToUTF8(wchar_t const (&string_literal)[N], std::string &out)
{
    WideToUTF8(string_literal, N-1, out);
}

inline void WideToUTF8(wchar_t const *input, std::string &out) 
{
    WideToUTF8(input, wcslen(input), out);
}

__>>В VC 8.0 тоже он есть

void f(const char (&a)[2]){}
void f(const char* a){}

f("a"); // error C2668: 'f' : ambiguous call to overloaded function  :maniac:

template<size_t N>
void f(const char (&a)[N]){}

void f(const char* a){}

void f(const char (&a)[2]){}

template<typename T>
void f(const T* a){}

template<size_t N>
void f(const char (&a)[N]){}

template<typename T>
void f(const T* a){}

f("a"); // error C2668: 'f' : ambiguous call to overloaded function

#include "boost/range.hpp"

void WideToUTF8(wchar_t const *input, size_t size, std::string &out);

template<class Range>
inline 
void WideToUTF8( const Range& c, std::string &out)
{
    return WideToUTF8(boost::begin(c), boost::size(c), out);
}

int main()
{
    std::string s;
    WideToUTF8(L"hello", s);
}

__>void f(const char (&a)[2]){}
__>void f(const char* a){}

__>f("a"); // error C2668: 'f' : ambiguous call to overloaded function  :maniac: 
__>

__>template<size_t N>
__>void f(const char (&a)[N]){}

__>void f(const char* a){}
__>

__>void f(const char (&a)[2]){}

__>template<typename T>
__>void f(const T* a){}
__>

__>Переписать функции как шаблон не получится, т.к. тогда тоже у VC возникает неоднозначность.

__>template<size_t N>
__>void f(const char (&a)[N]){}

__>template<typename T>
__>void f(const T* a){}

__>f("a"); // error C2668: 'f' : ambiguous call to overloaded function
__>

template <int N>
inline void func(wchar_t const (&string_literal)[N])
{
    std::cout << "literal\n";
}

template <int>
inline void func(wchar_t const *input)
{
    std::cout << "ptr\n";
}

int main()
{
    func(L"hello");
}

__>Я неправильно понял вашу идею сначала

inline void func(wchar_t const (&string_literal)[6])
{
    std::cout << "literal\n";
}


inline void func(wchar_t const *input)
{
    std::cout << "ptr\n";
}

int main()
{
    func(L"hello");//неоднозначность
}

void WideToUTF8(wchar_t const *input, size_t size, std::string &out);

template<typename> struct WideToUTF8Helper;

template<> 
struct WideToUTF8Helper<const wchar_t*>
{
  static void process(wchar_t const *input, std::string &out) 
  {
    WideToUTF8(input, wcslen(input), out);
  }
};

template<int N> 
struct WideToUTF8Helper<const wchar_t[N]>
{
  static void process(const wchar_t (&string_literal)[N], std::string &out)
  {
    WideToUTF8(string_literal, N-1, out);
  }
};

template<typename T>
void WideToUTF8(const T& input, std::string &out) 
{
  WideToUTF8Helper<T>::process(input, out);
}

int main()
{
  std::string out;
  
  WideToUTF8(L"Hello", out);
  WideToUTF8((const wchar_t*)L"Hello", out);

}

__>>Я неправильно понял вашу идею сначала

S>А теперь я ее не понял

S>inline void func(wchar_t const (&string_literal)[6])
S>{
S>    std::cout << "literal\n";
S>}


S>inline void func(wchar_t const *input)
S>{
S>    std::cout << "ptr\n";
S>}

S>int main()
S>{
S>    func(L"hello");//неоднозначность
S>}
S>

S>Ведь логика та же...

f(static_cast<const wchar_t (&)[6]>("hello")); // Ambiguity

f(static_cast<const wchar_t*>("hello")); // OK

S>template <int N>
S>inline void func(wchar_t const (&string_literal)[N])
S>{
S>    std::cout << "literal\n";
S>}

S>template <int>
S>inline void func(wchar_t const *input)
S>{
S>    std::cout << "ptr\n";
S>}

S>int main()
S>{
S>    func(L"hello");
S>}
S>

func<6>(L"hello");

WideToUTF8<>(L"hello", s);

  WideToUTF8(L"Hello", out);

wchar_t buf[4096] = {0};
...
someFuncThatFillsBuffer(buf, 1024, ...);

std::string s;
WideToUTF8(buf, s);

std::string s = "...";
wchar_t buf[4096] = {0};
WideToUTF8(s, buf);