const 和非 const 模板特化答案

【问题标题】：Const and non const template specializationconst 和非 const 模板特化
【发布时间】：2013-02-17 21:49:50
【问题描述】：

我有一个类模板，我用它来获取变量的大小：

template <class T>
class Size
{
   unsigned int operator() (T) {return sizeof(T);}
};

这很好用，但对于字符串我想使用 strlen 而不是 sizeof：

template <>
class Size<char *>
{
   unsigned int operator() (char *str) {return strlen(str);}
};

问题是当我使用 const char * 创建一个 size 实例时，它会转到非专业版本。我想知道是否有办法在模板专业化中同时捕获 char * 的 const 和非 const 版本？谢谢。

【问题讨论】：

我不相信这是个好主意。如果(const) char * 不指向字符串，情况会怎样？
只专门化const 版本是否有效？
不，那么当你传递一个非 const char * 时，它不使用专业化。

标签： c++ templates

【解决方案1】：

使用这种技术：

#include <type_traits>

template< typename T, typename = void >
class Size
{
  unsigned int operator() (T) {return sizeof(T);}
};

template< typename T >
class Size< T, typename std::enable_if<
                 std::is_same< T, char* >::value ||
                 std::is_same< T, const char* >::value
               >::type >
{
  unsigned int operator() ( T str ) { /* your code here */ }
};

编辑：如何在类定义之外定义方法的示例。

EDIT2：添加了帮助以避免重复可能冗长而复杂的情况。

EDIT3：简化的助手。

#include <type_traits>
#include <iostream>

template< typename T >
struct my_condition
  : std::enable_if< std::is_same< T, char* >::value ||
                    std::is_same< T, const char* >::value >
{};

template< typename T, typename = void >
struct Size
{
  unsigned int operator() (T);
};

template< typename T >
struct Size< T, typename my_condition< T >::type >
{
  unsigned int operator() (T);
};

template< typename T, typename Dummy >
unsigned int Size< T, Dummy >::operator() (T)
{
  return 1;
}

template< typename T >
unsigned int Size< T, typename my_condition< T >::type >::operator() (T)
{
  return 2;
}

int main()
{
  std::cout << Size< int >()(0) << std::endl;
  std::cout << Size< char* >()(0) << std::endl;
  std::cout << Size< const char* >()(0) << std::endl;
}

打印出来的

1
2
2

【讨论】：

谢谢，我不熟悉 'typename = void' 语法，如果我想在类之外编写函数体而不是内联，我该如何定义 operator()？
它只是typename Dummy = void 的缩写，其中Dummy 从未使用过。我将检查并增强答案如何在课堂外定义operator()...
谢谢，对于特殊情况，我是否需要在函数定义中写出这么长的东西？
基本上是的，你必须写它。请参阅我关于如何使用帮助程序以避免手动重复条件的第二次编辑。

【解决方案2】：

当然你也应该会写：

template <>
class Size<const char *>
{
   unsigned int operator() (const char *str) {return strlen(str);}
};

template <>
class Size<char *> : public Size<const char *>
{ };

...并且，如果您需要：

template <size_t size>
class Size<char[size]> : public Size<const char *>
{ };

template <size_t size>
class Size<const char[size]> : public Size<const char *>
{ };

【讨论】：

这是迄今为止最干净的解决方案 IMO。重复使用代码，不要让它过于冗长，以供其他任何使用您的代码的人使用。

【解决方案3】：

一种方法是使用辅助函数来确定模板类型是char * 还是char const *。你可以用一个简单的结构来做到这一点。然后，您可以使用 SFINAE 来选择您的 Size 结构的适当专业化。

#include <cstring>
#include <iostream>

#include <boost/utility/enable_if.hpp>

template<typename T>
struct is_cstring {
  enum { value = false };
};

template<>
struct is_cstring<char *> {
  enum { value = true };
};

template<>
struct is_cstring<char const *> {
  enum { value = true };
};

template<typename T, typename = void>
struct Size;

template<typename T>
struct Size<T, typename boost::disable_if<is_cstring<T> >::type> {
  unsigned int operator ()(T const &) const {
    return sizeof(T);
  }
};

template<typename T>
struct Size<T, typename boost::enable_if<is_cstring<T> >::type> {
  unsigned int operator ()(T const &str) const {
    return strlen(str);
  }
};

int main() {
  std::string blah = "afafasa";
  char *x = "asdfsadsad";

  std::cout << Size<int>()(4) << std::endl;
  std::cout << Size<char const *>()("blahblah") << std::endl;
  std::cout << Size<char *>()(x) << std::endl;
}

打印出来的结果是：

4
8
10

【讨论】：