SFINAE function that returns proper character encoding depending on template type?

Question

I'm creating a class that's writing code strings, The difference between the string and the wring is only what to put in the basic_string, so I'm going to write it as a template class.

The problem is that the literal strings used internally also have to change depending on the Type, so I combined macro and SFINAE to create a function that returns different literal strings depending on the Type.

But my code had a "no instance of function template matches the argument list" error.

this is my code:

#include <filesystem>
#include <string>
#include <type_traits>
#include <fstream>
#include "windows.h"

namespace stdfs = std::filesystem;

template <typename T>
class CCodeWriter
{
public:
    CCodeWriter() {};
    ~CCodeWriter() {};

private:
    template <typename U = T, typename std::enable_if_t<std::is_same_v<U, wchar_t>, wchar_t>>
    const std::basic_string_view<U> ConvString(const std::string_view _AstrView, const std::wstring_view _WstrView)
    {
        return _WstrView;
    }

    template <typename U = T, typename std::enable_if_t<std::is_same_v<U, char>, char>>
    const std::basic_string_view<U> ConvString(const std::string_view _AstrView, const std::wstring_view _WstrView)
    {
        return _AstrView;
    }



#define CONV_STRING(str) ConvString(str, L##str)


private:
    int m_iIndentation;
    std::basic_ofstream<T> m_ofs;

public:
    HRESULT Open(stdfs::path const& _path) { return S_OK; }
    bool IsOpen() const { return m_ofs.is_open(); }

    void WriteCode(const std::basic_string_view<T> _strCode)
    {

        ...

        //Error
        m_ofs << CONV_STRING("\t");

        //Error
        m_ofs << ConvString("\t", L"\t");

        ...
    }
};


int main()
{
    CCodeWriter<char> writer;

    writer.WriteCode("HI");

    return 0;
}

Isn't there any other way but write each literal strings by hand?

I tried to change the parameter type, but I'm not familiar with SFINAE, so everything I've tried has an error.

What I expect is that due to the attibutes of SFINAE, the literal "\t" is returned when the type is entered in , and the literal L"\t" is returned when the <wchar_t> type is entered.

Will it be possible?

Looks like [XY problem](https://mywiki.wooledge.org/XyProblem). Here is explanation how to handle encoding in MSVC: https://stackoverflow.com/a/67819605/1387438 — Marek R, Jun 30 '23 at 14:17
@MarekR That's not an encoding issue, that's how to change character literal type based on a template parameter. It's a pretty common issue when you have a template class that format string-like and use standard characters (typically tabs or newlines) and you need to use the proper version of the character to format. — Holt, Jun 30 '23 at 14:20
`L##str` is wrong (`##` is to create **identifier**) (gcc rejects it). Using `L"" str` (let concatenate C-string literal) works. — Jarod42, Jun 30 '23 at 14:36

Holt · Accepted Answer · 2023-06-30T14:26:05.463

Your enable_if usage is incorrect, one possible usage would be

template <typename U = T, std::enable_if_t<std::is_same_v<U, wchar_t>, int> = 0>

Currently, when T is char, your SFINAE overloads looks like this

template <typename U = char, char>

So obviously that second char non-type template parameter cannot be deduced.

In C++17 and above, you can simply use if constexpr

const std::basic_string_view<T> 
ConvString(const std::string_view _AstrView, const std::wstring_view _WstrView)
{
    if constexpr (std::is_same_v<T, char>) { return _AstrView; }
    else { return _WstrView; }
}

You can also use std::char_traits<T>::to_char_type('\n') to convert '\n' to the appropriate character type. This should work for basic characters (\n and \t in particular).

SFINAE function that returns proper character encoding depending on template type?

1 Answers1