1. C++ / Говнокод #22747

    −141

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    template <typename T> struct convert_primitive_type_to_class
{
	typedef
		typename std::conditional< std::is_same< T, void >::value, Void, 
		typename std::conditional< std::is_same< T, int8_t >::value, SByte, 
		typename std::conditional< std::is_same< T, uint8_t >::value, Byte, 
		typename std::conditional< std::is_same< T, int16_t >::value, Int16, 
		typename std::conditional< std::is_same< T, uint16_t >::value, UInt16, 
		typename std::conditional< std::is_same< T, char16_t >::value, Char, 
		typename std::conditional< std::is_same< T, int32_t >::value, Int32, 
		typename std::conditional< std::is_same< T, uint32_t >::value, UInt32, 
		typename std::conditional< std::is_same< T, int64_t >::value, Int64, 
		typename std::conditional< std::is_same< T, uint64_t >::value, UInt64, 
		typename std::conditional< std::is_same< T, float >::value, Single, 
		typename std::conditional< std::is_same< T, double >::value, Double, 
		T 
		>::type>::type>::type>::type>::type>::type>::type>::type>::type>::type>::type>::type type;
};

template <typename T> struct convert_class_to_primitive_type
{
	typedef
		typename std::conditional< std::is_same< T, Void >::value, void, 
		typename std::conditional< std::is_same< T, SByte >::value, int8_t, 
		typename std::conditional< std::is_same< T, Byte >::value, uint8_t, 
		typename std::conditional< std::is_same< T, Int16 >::value, int16_t, 
		typename std::conditional< std::is_same< T, UInt16 >::value, uint16_t, 
		typename std::conditional< std::is_same< T, Char >::value, char16_t, 
		typename std::conditional< std::is_same< T, Int32 >::value, int32_t, 
		typename std::conditional< std::is_same< T, UInt32 >::value, uint32_t, 
		typename std::conditional< std::is_same< T, Int64 >::value, int64_t, 
		typename std::conditional< std::is_same< T, UInt64 >::value, uint64_t, 
		typename std::conditional< std::is_same< T, Single >::value, float, 
		typename std::conditional< std::is_same< T, Double >::value, double, 
		T 
		>::type>::type>::type>::type>::type>::type>::type>::type>::type>::type>::type>::type type;
};

    мапирование типов в C++ через шаблоны.

    пример юза:

    convert_primitive_type_to_class<uint16_t >::type - вернет "UInt16" type

    Запостил: ASD_77, 06 Апреля 2017

    Комментарии (17) RSS

    • ava Antervis 06.04.2017 17:27 # +2

      у нас есть стандартные целочисленные типы? Нет, это неок. Надо натайпдефать своих и захуярить тонну метушни по конверсии типов сами в себя. гуд жоп комрадэ.

      Хоть б через using написал
      Ответить

    • ava 1024-- 06.04.2017 17:50 # +3

      А почему так? Чем это отличается от специализации?
      template <typename T> struct convert_primitive_type_to_class {};
template <> struct convert_primitive_type_to_class<void>    { typedef Void  type; };
template <> struct convert_primitive_type_to_class<int8_t>  { typedef SByte type; };
template <> struct convert_primitive_type_to_class<uint8_t> { typedef Byte  type; };

template <typename T> struct convert_class_to_primitive_type {};
template <> struct convert_class_to_primitive_type<Void>    { typedef void   type;  };
template <> struct convert_class_to_primitive_type<SByte>   { typedef int8_t type;  };
template <> struct convert_class_to_primitive_type<Byte>    { typedef uint8_t type; };


      Тем более, что специализация расширяема:
      template <typename T> struct convert_primitive_type_to_class {};
template <typename T> struct convert_class_to_primitive_type {};

#define UNARY_VALUE_METAFUNCTION(func, in, out) \
template <> struct func<in> { typedef out type; }

#define MAP_TYPE(type, class) \
UNARY_VALUE_METAFUNCTION(convert_primitive_type_to_class, type, class); \
UNARY_VALUE_METAFUNCTION(convert_class_to_primitive_type, class, type)

MAP_TYPE(void,   Void);
MAP_TYPE(int8_t, SByte);
MAP_TYPE(uint8_t, Byte);
      Ответить

      • ava ASD_77 06.04.2017 17:55 # −2

        тем что если типа в мапе нет, то остается тот же тип что и на входе
        Ответить

        • ava 1024-- 06.04.2017 18:00 # +4

          > тем что если типа в мапе нет, то остается тот же тип что и на входе
          А, так ради этого... Ну, оставил:
          template <typename T> struct convert_primitive_type_to_class { typedef T type; };
          Ответить

        • ava Antervis 06.04.2017 19:26 # +1

          как будто если там будет присутствующий тип, то на выходе окажется какой-то другой...

          Если что, typedef/using это всего лишь алиасы типов. Скажем, std::is_same_v<unsigned char, uint8_t> будет true везде кроме экзотерики. По факту, вся это простыня только и делает, что кастит тип сам в себя
          Ответить

          • ava bormand 06.04.2017 19:27 # +1

            А почему ты так уверен, что там не class SByte { int8_t m_value; /* methods */ }?
            Ответить

      • ava roman-kashitsyn 06.04.2017 18:41 # +3

        > Чем это отличается от специализации?

        У тебя не клин код
        ...     >::type
      >::type
    >::type
  >::type
>::type
        Ответить

    Добавить комментарий