c++ - 有没有办法用模板替换这个预处理器宏，也许使用 Boost MPL？

Question

我有代码可以创建一个字符或字符串常量，该常量可以是 char 或 wchar_t 类型。这使得创建模板函数成为可能，这些函数可以使用字符类型，但可以使用字符或字符串常量。到目前为止，我提供的解决方案如下。

template<typename CharType>
CharType CharConstantOfType(const char c, const wchar_t w);
template<>
char CharConstantOfType<char>(const char c, const wchar_t /*w*/)
{
    return c;
}
template<>
wchar_t CharConstantOfType<wchar_t>(const char /*c*/, const wchar_t w)
{
    return w;
}

template<typename CharType>
const CharType* StringConstantOfType(const char* c, const wchar_t* w);
template<>
const char* StringConstantOfType<char>(const char* c, const wchar_t* /*w*/)
{
    return c;
}
template<>
const wchar_t* StringConstantOfType<wchar_t>(const char* /*c*/, const wchar_t* w)
{
    return w;
}

这些模板函数要求您通过提供常量的两个版本来复制常量。为了解决这些问题，我创建了以下宏。

#define _TOWSTRING(x) L##x
#define TOWSTRING(x) _TOWSTRING(x)
#define CHAR_CONSTANT(TYPE, STRING) CharConstantOfType<TYPE>(STRING, TOWSTRING(STRING))
#define STRING_CONSTANT(TYPE, STRING) StringConstantOfType<TYPE>(STRING, TOWSTRING(STRING))

我想删除宏。我想知道像 Boost MPL 库这样的东西是否可以使这成为可能。

这些宏的一种可能用途是编写一个模板函数来确定字符串是否包含制表符，如下所示。

template<typename CharType>
bool hasTab(const std::basic_string<CharType>& str)
{
    typedef std::basic_string<CharType> string_type;
    const CharType TabChar =  CHAR_CONSTANT(CharType, '\t');
    return (str.find(TabChar) != string_type::npos);
}

Answer 1

我想了想。我不认为存在从 wchar_t 到 char 的有效转换，但反过来也是合理的。

这里有一种方法可以让您只编写 char* 版本并允许程序根据需要创建 wchar_t 字符串:

#include <iostream>
#include <map>

// introduce the concept of a specialisable converter
template<class FromType, class ToType>
struct converter;

// use the concept
template<class To, class From>
To convert(From f) {
    return converter<From, To>::apply(f);
}

// specialise for non-conversion
template<class T>
struct converter<T, T>
{
    static constexpr T apply(T t) {
        return t;
    }
};

// specialise for converting char to wchar_t
template<>
struct converter<char, wchar_t>
{
    static constexpr wchar_t apply(char t) {
        // do whatever conversion you want here
        return wchar_t(t);
    }
};

// specialise for converting const char* to const wchar_t*
// note - this one is not thread-safe. a mutex will be needed to beef it up in a multi-
// threaded environment
template<>
struct converter<const char*, const wchar_t*>
{
    using string_map_type = std::map<const char*, std::wstring>;
    static string_map_type& string_map() {
        static string_map_type _;
        return _;
    }

    static std::wstring convert_to_wstring(const char*p ) {
        std::wstring result;
        while (*p) {
            result.push_back(convert<wchar_t>(*p++));
        }
        return result;
    }

    static const wchar_t* apply(const char* p) {
        auto& map = string_map();
        auto ifind = map.find(p);
        if (ifind == std::end(map)) {
            ifind = map.emplace(p, convert_to_wstring(p)).first;
        }
        return ifind->second.c_str();
    }
};


using namespace std;
auto main() -> int
{
    cout << "Hello, World" << endl;
    wcout << convert<const wchar_t*>("Hello, World") << endl;
    return 0;
}

预期输出:

Hello, World
Hello, World