c++ - 如何避免 C 字符串的许多类似重载

Question

代码如下:

template <typename L, typename R> bool eq (const L& lhs, const R& rhs) { return lhs == rhs; }

template<int N> bool eq(char* lhs,           const char(&rhs)[N]) { return String(lhs).compare(rhs) == 0; }
template<int N> bool eq(const char(&lhs)[N], char* rhs)           { return String(lhs).compare(rhs) == 0; }
inline          bool eq(char* lhs,           char* rhs)           { return String(lhs).compare(rhs) == 0; }
inline          bool eq(const char* lhs,     const char* rhs)     { return String(lhs).compare(rhs) == 0; }
inline          bool eq(char* lhs,           const char* rhs)     { return String(lhs).compare(rhs) == 0; }
inline          bool eq(const char* lhs,     char*  rhs)          { return String(lhs).compare(rhs) == 0; }

我必须为 neq/lt/gt/lte/gte 这样做，而不仅仅是为了平等。也许我已经错过了什么。

有没有办法不列出所有可能的 C 字符串类型组合？

还有 C++98。

编辑:>> here << 是有问题的在线演示

Answer 1

将数组类型衰减为指针:

template<class T>
struct decay_array { typedef T type; };
template<class T, size_t N>
struct decay_array<T[N]> { typedef T* type; };
template<class T>
struct decay_array<T[]> { typedef T* type; };

检查类型是否不是指向(可能是 const)char 的指针:

template<class T>
struct not_char_pointer { enum { value = true }; };
template<>
struct not_char_pointer<char*> { enum { value = false }; };
template<>
struct not_char_pointer<const char*> { enum { value = false }; };

现在检查类型不是指向(可能是 const)char 的指针或数组:

template<class T>
struct can_use_op : not_char_pointer<typename decay_array<T>::type> {};

重新实现std::enable_if:

template<bool, class = void>
struct enable_if {};
template<class T>
struct enable_if<true, T> { typedef T type; };

并用它来约束你的模板:

template <typename L, typename R> 
typename enable_if<can_use_op<L>::value || can_use_op<R>::value, bool>::type 
eq (const L& lhs, const R& rhs) { return lhs == rhs; }

然后只需一个重载就足够了:

inline bool eq(const char* lhs, const char* rhs) { return String(lhs).compare(rhs) == 0; }