fork download
copy 
  1. //---------------------------------------------------------------------------------------
  2.  
  3. using   i8                      = char;
  4. using   u8                      = unsigned char;
  5. using   i16                     = short;
  6. using   u16                     = unsigned short;
  7. using   i32                     = int;
  8. using   u32                     = unsigned int;
  9. using   i64                     = long long;
  10. using   u64                     = unsigned long long;
  11.  
  12. using   f32                     = float;
  13. using   f64                     = double;
  14.  
  15. #define rigid                   constexpr
  16.  
  17. //---------------------------------------------------------------------------------------
  18.  
  19. rigid   u32 CHAR_BITS           = 8;
  20.  
  21. // 특정 타입의 most significant bit의 위치를 리턴
  22. // ex ) 32bit type -> 31
  23. template< typename T >
  24. inline  rigid   auto    msb()
  25. {
  26.     return  sizeof( T ) * CHAR_BITS - 1;
  27. }
  28.  
  29. // 특정 타입의 most significant bit를 1로 둔 값을 리턴
  30. // ex ) 32bit type -> 0x80000000
  31. template< typename T >
  32. inline  rigid   auto    msb_value()
  33. {
  34.     return  (T)1 << msb< T >();
  35. }
  36.  
  37. // 특정 타입의 most significant bit를 제외시키는 마스크를 리턴
  38. // ex ) 32bit type -> 0x7FFFFFFF
  39. template< typename T >
  40. inline  rigid   auto    msb_mask()
  41. {
  42.     return  (T)~msb_value< T >();
  43. }
  44.  
  45. // 편하게 쓰자
  46. #define msb_pos( var ) msb< decltype( var ) >()
  47. #define msb_val( var ) msb_value< decltype( var ) >()
  48.  
  49. // dst 의 가장 큰값 위치에 bits 값을 얹는다
  50. template< typename T0, typename T1 >
  51. inline  void    set_msbs( T0& dst, const T1 bits )
  52. {
  53.     *( (T1*)&dst + ( sizeof dst / sizeof bits - 1 ) ) |= bits;
  54. }
  55. //---------------------------------------------------------------------------------------
  56.  
  57. // 문자열로부터 부호없는 연속한 숫자를 리턴
  58. // 포인터를 숫자의 끝 다음으로 이동시킴
  59. inline  u32     atou32( char*& s )
  60. {
  61.     u32 value;
  62.     for( value = 0; *s <= '9' && *s >= '0'; ++s )
  63.         value = value * 10 + ( *s - '0' );
  64.     return  value;
  65. }
  66.  
  67. // 문자열로부터 부호있는 연속한 숫자를 리턴
  68. // 포인터를 숫자의 끝 다음으로 이동시킴
  69. inline  i32     atoi32( char*& s )
  70. {
  71.     if( *s == '-' )
  72.         return  -(i32)atou32( ++s );
  73.     return  (i32)atou32( s );
  74. }
  75.  
  76. #include <cmath>
  77. // 문자열로부터 부호처리된 부동소수 및 지수값을 리턴
  78. // 포인터를 숫자의 끝 다음으로 이동시킴
  79. template< typename T = f64 >
  80. inline  T       atof( char*& s )
  81. {
  82.     char* p     = s;
  83.     u32 sign    = 0;
  84.     T   digit   = 0.;
  85.     T   base    = 1.;
  86.     T   step    = 1.;
  87.  
  88.     for( i8 token; token = *p++; )
  89.     {
  90.         switch( token )
  91.         {
  92.         case '-':
  93.             sign = msb_val( sign );
  94.             break;
  95.         case '.':
  96.             step = 10;
  97.             break;
  98.         case 'E':
  99.         case 'e':
  100.             digit *= std::pow( 10., (f64)atof< T >( s = p ) );
  101.             goto exit;
  102.         default:
  103.             if( token <= '9' && token >= '0' )
  104.             {
  105.                 digit = digit * (T)10. + ( token & 0xF );
  106.                 base *= step;
  107.                 continue;
  108.             }
  109.             goto exit;
  110.         }
  111.     }
  112.     exit:
  113.     if( s < p - 1 ) s = p - 1;
  114.     set_msbs( digit, sign );
  115.     return  T( digit / base );
  116. }
  117.  
  118. // 편하게 쓰자
  119. inline  auto    atof32( char*& s )
  120. {
  121.     return  atof< f32 >( s );
  122. }
  123.  
  124. inline  auto    atof64( char*& s )
  125. {
  126.     return  atof< f64 >( s );
  127. }
  128. //---------------------------------------------------------------------------------------
  129.  
  130. #include <type_traits>
  131. // 타입에 맞게 문자열의 숫자를 해독해서 param 에 넣음
  132. template< typename T >
  133. inline  char*   parse_number( const char* string, T& param )
  134. {
  135.     char* s = (char*)string;
  136.     while( *s == ' ' || *s == '\t' || *s == '\n' ) s++;
  137.  
  138.     if( std::is_same< T, i32 >::value )
  139.         param = (T)atoi32( s );
  140.     if( std::is_same< T, u32 >::value )
  141.         param = (T)atou32( s );
  142.     if( std::is_same< T, f32 >::value )
  143.         param = (T)atof32( s );
  144.     if( std::is_same< T, f64 >::value )
  145.         param = (T)atof64( s );
  146.  
  147.     return  s;
  148. }
  149.  
  150. // 복수 params
  151. template< typename T, typename... Ts >
  152. inline  char*   parse_number( const char* string, T& param1, Ts&... rest )
  153. {
  154.     return  parse_number( parse_number( string, param1 ), rest... );
  155. }
  156. //---------------------------------------------------------------------------------------
  157.  
  158. #include <iostream>
  159. using namespace std;
  160.  
  161. int main()
  162. {
  163.     i32 a, b;
  164.     u32 c, d;
  165.     f64 e;
  166.     f32 f;
  167.  
  168.     parse_number( "-1 0 1 2 1.23e2 1.23456", a, b, c, d, e, f );
  169.     cout << a << " " << b << " " << c << " " << d << " " << e << " " << f << endl;
  170.  
  171.     return 0;
  172. }
Success #stdin #stdout 0s 3420KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
-1 0 1 2 123 1.23456
https://ideone.com/tJxarB
atou, atoi, atof
language:
C++14 (gcc 8.3)
created:
10 years ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!