Ytukyg

I have following two functions:

void bar(const std::string &s)

{

    someCFunctionU(s.c_str());

}



void bar(const std::wstring &s)

{

    someCFunctionW(s.c_str());

}

Both of these call some C function which accepts const char * or const wchar_t * and have U or W suffixes respectively. I would like to create a template function to handle both of these cases. I tried following attempt:

template <typename T>

void foo(const std::basic_string<T> &s)

{

    if constexpr (std::is_same_v<T, char>)

        someCFunctionU(s.c_str());

    else

        someCFunctionW(s.c_str());

}

But this does not seem to work correctly. If I call:

foo("abc");

this will not compile. Why is that? why a compiler is not able to deduce the proper type T to char? Is it possible to create one function which would handle both std::string and std::wstring?

this will not compile. Why is that? why a compiler is not able to deduce the proper type T to char?

As better explained by others, "abc" is a char[4], so is convertible to a std::basic_string<char> but isn't a std::basic_string<char>, so can't be deduced the T type as char for a template function that accept a std::basic_string<T>.

Is it possible to create one function which would handle both std::string and std::wstring?

Yes, it's possible; but what's wrong with your two-function-in-overloading solution?

Anyway, if you really want a single function and if you accept to write a lot of casuistry, I suppose you can write something as follows

template <typename T>

void foo (T const & s)

{

    if constexpr ( std::is_same_v<T, std::string> )

        someCFunctionU(s.c_str());                       

    else if constexpr ( std::is_convertible_v<T, char const *>)

        someCFunctionU(s);

    else if constexpr ( std::is_same_v<T, std::wstring> )

        someCFunctionW(s.c_str());

    else if constexpr ( std::is_convertible_v<T, wchar_t const *> )

        someCFunctionW(s);

    // else exception ?

}

or, a little more synthetic but less efficient

template <typename T>

void foo (T const & s)

{

    if constexpr ( std::is_convertible_v<T, std::string> )

        someCFunctionU(std::string{s}.c_str());

    else if constexpr (std::is_convertible_v<T, std::wstring> )

        someCFunctionW(std::wstring{s}.c_str());

    // else exception ?

}

So you should be able to call foo() with std::string, std::wstring, char *, wchar_t *, char or wchar_t.

The issue here is that in foo("abc");, "abc" is not a std::string or a std::wstring, it is a const char[N]. Since it isn't a std::string or a std::wstring the compiler cannot deduce what T should be and it fails to compile. The easiest solution is to use what you already have. The overloads will be considered and it is a better match to convert "abc" to a std::string so it will call that version of the function.

If you want you could use a std::string_view/std::wstring_view instead of std::string/std::wstring so you don't actually allocate any memory if you pass the function a string literal. That would change the overloads to

void bar(std::string_view s)

{

    someCFunctionU(s.data());

}



void bar(std::wstring_view s)

{

    someCFunctionW(s.data());

}

Do note that std::basic_string_view can be constructed without having a null terminator so it is possible to pass a std::basic_string_view that won't fulfill the null terminated c-string requirement that your C function has. In that case the code has undefined behavior.

A workaround in C++17 is:

template <typename T>

void foo(const T &s)

{

    std::basic_string_view sv{s}; // Class template argument deduction



    if constexpr (std::is_same_v<typename decltype(sv)::value_type, char>)

        someCFunctionU(sv.data());

    else

        someCFunctionW(sv.data());

}

And to avoid issue mentioned by Justin about non-null-terminated string

template <typename T> struct is_basic_string_view : std::false_type {};



template <typename T> struct is_basic_string_view<basic_string_view<T>> : std::true_type

{};



template <typename T>

std::enable_if_t<!is_basic_string_view<T>::value> foo(const T &s)

{

    std::basic_string_view sv{s}; // Class template argument deduction



    if constexpr (std::is_same_v<typename decltype(sv)::value_type, char>)

        someCFunctionU(sv.data());

    else

        someCFunctionW(sv.data());

}

Yes, there exist a type, i.e. std::basic_string<char>, which can be copy initialized from expression "abc". So you can call a function like void foo(std::basic_string<char>) with argument "abc".

And no, you can't call a function template template <class T> void foo(const std::basic_string<T> &s) with argument "abc". Because in order to figure out whether the parameter can be initialized by the argument, the compiler need to determine the template parameter T first. It will try to match const std::basic_string<T> & against const char [4]. And it will fail.

The reason why it will fail is because of the template argument deduction rule. The actual rule is very complicated. But in this case, for std::basic_string<char> to be examined during the deduction, compiler will need to look for a proper "converting constructor", i.e. the constructor which can be called implicitly with argument "abc", and such lookup isn't allowed by the standard during deduction.

Yes, it is possible to handle std::string and std::wstring in one function template:

void foo_impl(const std::string &) {}

void foo_impl(const std::wstring &) {}



template <class T>

auto foo(T &&t) {

    return foo_impl(std::forward<T>(t));

}