帮助模板专业化

Question

我正在使用/学习模板函数专业化规则。我从这个函数开始

template<typename T>
std::string toString(const T& t)
{
    ostringstream out;
    out << t;
    return out.str();
}

现在我想将它专门用于 const char*

typedef const char* ccharPtr;

template<>
std::string toString(const ccharPtr& s)
{
    cout << "in specialization" << endl; // just to let me know
    return std::string(s);
}

我想在没有 typedef 的情况下这样做，但到目前为止我无法弄清楚。

该特化适用于 const char*，但不适用于 char*。

const char* s1 = "Hi"
cout << toString(s1); // works
char s2[] = "There";
cout << toString(s2); // doesn't work, since s2 isn't const char*
cout << toString(", Bob"); // doesn't work. Why not?

我想要一个专长来处理每个案例，但很难搞清楚。

Answer 1

为什么要专业化？只是重载函数。通常不需要完全专业化的函数模板。

template <typename T>
std::string toString(const T& in)
{
    ostringstream out;
    out << in;
    return out.str();
}

std::string toString(char const* in)
{
    return in;
}

---

好的，如果你真的想要这样做，那么你必须考虑字符串文字的类型——尽管它们隐式地转换到char const*——是@ 987654324@.

template <typename T>
std::string toString(T const & t) {
    ostringstream out;
    out << t;
    return out.str();
}

template <>
std::string toString(char const* const & s) {
    cout << "(S1)";
    return std::string(s);
}

template <size_t N>
std::string toString(char (&s)[N]) {
    cout << "(S2)";
    return std::string(s);
}

template <size_t N>
std::string toString(char const (&s)[N]) {
    cout << "(S3)";
    return std::string(s);
}

int main() {
    const char* s1 = "Hi";
    cout << toString(s1) << endl;
    char s2[] = "There";
    cout << toString(s2) << endl;
    cout << toString(", Bob") << endl;
}

// Output:
// (S1)Hi
// (S2)There
// (S3), Bob

Live demo.

您可以省略专门化S2，然后"There" 和", Bob" 都将使用S3。

请注意，实际上，这根本不是专业化。我宁愿通过创建 new 函数模板来作弊。但我必须得到size_t 参数；如果您为 N 选择 one 值并将其作为具体类型的一部分写入函数签名中，或者您可以 >部分专门化函数模板。

Answer 2

它不起作用的原因是它实际上不是正确的类型。字符串文字不是const char* 类型，它们是const char[N] 类型。当你传递一个字符串字面量时，T 被推断为char[N]。这是完全匹配的，而专业化不是。您不能专门化字符串文字，因为这需要部分规范，而 C++ 不支持部分函数专门化。

Answer 3

我认为这应该可行：

template <typename T>
    std::string to_string(const T &)
{
    ...
}

// non templated
std::string to_string(const char* x)
{
    ...
}

Answer 4

我在使用 Sun Studio C++ 编译器时遇到了类似的问题。

起初，我使用了两个数组重载（char (&)[N] 有和没有const）和两个指针重载（char* 和const char*）。

令我惊讶的是，像toString("quoted literal") 这样的调用使用了const char*，而且似乎不可能强制编译器选择数组重载。更有趣的是——对于像char lit[] = "literal" 这样的参数，toString(lit) 选择了数组重载！

经过一番思考，我找到了一种方法来编写一个表现为偏函数特化的代码。诀窍是利用 SFINAE

首先，定义一个模板来区分(const) char*和(const) char[N]

template<typename T>
    struct is_literal {
};

template<size_t N>
struct is_literal<const char[N]> {
    typedef std::string type;
    static const size_t len = N - 1;  // subtract terminating null char from N
};

template<size_t N>
struct is_literal<char[N]> {
    typedef std::string type;
    static const size_t len = N - 1;
};

template<>
struct is_literal<const char*> {
    typedef std::string ptr_type;
};

template<>
struct is_literal<char*> {
    typedef std::string ptr_type;
};

内部 typedef type 作用类似于 enable_if 和 ptr_type 类似于 disable_if

我们可以使用is_literal来实现功能：

template<typename T>
typename is_literal<T>::type
toString(T& arg)
{
    std::cout << "(literal)";
    // note the second argument which means length
    // this can be a performance gain because no strlen call is needed
    return std::string(arg, is_literal<T>::len); 
}

template<typename T>
typename is_literal<T>::ptr_type
toString(T& arg)
{
    std::cout << "(raw pointer)";
    return std::string(arg);
}

一些编译器可能会遇到const 的问题——因为可能需要const T& arg 重载。

当我经常调用函数并想保存strlen 调用或将strcpy 替换为简单的memcpy 时，我主要出于性能原因使用此解决方案