A proper function declaration for conversion from ANSI string to std::basic_string

Question

I tried to declare a function that converts const char * to std::basic_string in the following way:

#include <string>
#include <cstring>

#ifdef _MSC_VER
#include <tchar.h>
#else
#define TCHAR char
#endif

typedef TCHAR Char;

typedef std::basic_string<Char> String;

template <typename = typename std::enable_if< !std::is_same<Char, char>::value >::type >
inline String FromACString(const char * p_src)
{
    String dest(std::strlen(p_src), ' ');

    auto p_cur = p_src;

    for (auto & ch : dest)
    {
        ch = *p_cur++;
    }

    return dest;
}

template <typename = typename std::enable_if< std::is_same<Char, char>::value >::type >
inline String FromACString(const char * p_src)
{
    return p_src;
}

but got compiler errors. My idea was to have two overloads and enable one of them depending on TCHAR type. What is the proper way to do this?

The error with VC2017 is:

error C2995: 'String FromACString(const char *)': function template has already been defined

What is `C` in `std::is_same`? What compilation error did you get? — François Andrieux, Aug 27 '18 at 13:37
@FrançoisAndrieux C is Char, I corrected the code. The error with VC2017 is: error C2995: 'String FromACString(const char *)': function template has already been defined — Alexey Starinsky, Aug 27 '18 at 13:53
@AlexeyStarinsky add the error message to the question as well. — eerorika, Aug 27 '18 at 14:10
This is probably a duplicate of [this question](https://stackoverflow.com/questions/6972368/stdenable-if-to-conditionally-compile-a-member-function). `std::enable_if` only works if it depends on a function template's template arguments. — François Andrieux, Aug 27 '18 at 14:17

eerorika · Answer 1 · 2018-08-27T14:30:54.770

3

Miles' answered what's wrong with your enable_if. However, you can avoid the nuances of enable_if by using if constexpr:

inline std::basic_string<TCHAR>
FromACString(const char * p_src)
{
    if constexpr (std::is_same_v<TCHAR, char>) {
        // logic for case where TCHAR is char
    } else {
        // logic for case where TCHAR isn't char
    }
}

PS. Your TCHAR conversion to wchar_t (which I assume is the only other possible type besides char) should probably take character encoding into consideration. You might use mbsrtowcs.

edited Aug 27 '18 at 14:30

answered Aug 27 '18 at 14:23

eerorika

232,697
12
197
326

my function is for "abc", but not for u8"z\u00df\u6c34\U0001f34c" – Alexey Starinsky Aug 27 '18 at 14:34

score 2 · Accepted Answer · answered Aug 27 '18 at 14:19

Your code has two issues:

SFINAE only works in dependent contexts. Since nothing in typename std::enable_if<!std::is_same<Char, char>::value>::type is dependent on any template parameters, SFINAE does not apply, and you get a hard error since std::enable_if<false>::type is invalid.
When determining the "uniqueness" of templates, only the parameter types themselves are considered, not their default values. You have two definitions of the function template template <typename> String FromACString(const char*), and that is an error.

To fix the first problem, you can introduce another template parameter with a default value of Char. The usual fix to the second problem is to use the enable_if expression itself as the template parameter type, instead of a default. That leaves you with something like this:

template <typename C = Char,
          std::enable_if_t<!std::is_same<C, char>::value>* = nullptr>
String FromACString(const char* p_src) {
    //...
}

template <typename C = Char,
          std::enable_if_t<std::is_same<C, char>::value>* = nullptr>
String FromACString(const char* p_src) {
    //...
}

Live Demo

Now, depending on how Char is defined, you end up with one template with the signature

template <typename, void*>
String FromACString(const char*);

and another that is ill-formed and therefore disabled by SFINAE.

A proper function declaration for conversion from ANSI string to std::basic_string

2 Answers2