Консоль и неконсолидация шаблона

У меня есть шаблон класса, который я использую для получения размера переменной:

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 *, он переходит к неспециализированной версии. Мне было интересно, есть ли способ захватить как константную, так и неконстантную версии char * в специализации шаблона? Спасибо.

Ответ 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 */ }
};

EDIT: Пример того, как определять методы вне определения класса.

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

Ответ 2

Один из способов - использовать вспомогательную функцию, чтобы определить, является ли тип шаблона char * или char const *. Вы можете сделать это с помощью простой структуры. Затем вы можете использовать SFINAE, чтобы выбрать соответствующую специализацию своей структуры размера.

#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

Ответ 3

И вы также должны иметь возможность писать, конечно:

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 *>
{ };

Ответ 4

Самое простое решение - заменить специализацию char * на const char * one. Он будет работать и для char *.

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