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

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

      Хоть б через using написал
      Ответить
    • А почему так? Чем это отличается от специализации?
      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);
      Ответить
      • тем что если типа в мапе нет, то остается тот же тип что и на входе
        Ответить
        • > тем что если типа в мапе нет, то остается тот же тип что и на входе
          А, так ради этого... Ну, оставил:
          template <typename T> struct convert_primitive_type_to_class { typedef T type; };
          Ответить
        • как будто если там будет присутствующий тип, то на выходе окажется какой-то другой...

          Если что, typedef/using это всего лишь алиасы типов. Скажем, std::is_same_v<unsigned char, uint8_t> будет true везде кроме экзотерики. По факту, вся это простыня только и делает, что кастит тип сам в себя
          Ответить
          • А почему ты так уверен, что там не class SByte { int8_t m_value; /* methods */ }?
            Ответить
      • > Чем это отличается от специализации?

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

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