本demo实现了字符串转各种位宽的函数，代码简单效率高，非常适合单片机嵌入式应用。需要注意的是字符串需要按照严格的输入要求输入才行，比如“-127”，“255”等，除了第一个字符可以是负号‘-’外，其他字符必须是数字，对应位宽的数字字符，必须选择对应的函数。demo如下，可以直接拷贝到C语言编译器，编译允许即可获得结果。
  1. #include <stdio.h>
  2. #include <string.h>

  4.     /* exact-width signed integer types */
  5. typedef   signed          char int8_t;
  6. typedef   signed short     int int16_t;
  7. typedef   signed           int int32_t;
  8. typedef   signed       long long int64_t;

  10.     /* exact-width unsigned integer types */
  11. typedef unsigned          char uint8_t;
  12. typedef unsigned short     int uint16_t;
  13. typedef unsigned           int uint32_t;
  14. typedef unsigned       long long uint64_t;
  15. int8_t cAto8(const char * pcString,uint8_t ucLength){
  16.     int8_t cInt8 = 0;
  17.     uint8_t ucI = 0;
  18.     if(pcString[ucI] == '-'){//
  19.         ucI++;
  20.     }
  21.     for(;ucI<ucLength;ucI++){
  22.         cInt8 = cInt8*10 + pcString[ucI]-'0';
  23.     }
  24.     if(pcString[0] == '-'){//
  25.         cInt8 = ~cInt8 + 1;
  26.     }
  27.     return cInt8;
  28. }

  30. uint8_t ucAtou8(const char * pcString,uint8_t ucLength){
  31.     uint8_t ucInt8 = 0;
  32.     uint8_t ucI = 0;
  33.     for(;ucI<ucLength;ucI++){
  34.         ucInt8 = ucInt8*10 + pcString[ucI]-'0';
  35.     }
  36.     return ucInt8;
  37. }
  38. int16_t sAto16(const char * pcString,uint8_t ucLength){
  39.     int16_t sInt16 = 0;
  40.     uint8_t ucI = 0;
  41.     if(pcString[ucI] == '-'){//
  42.         ucI++;
  43.     }
  44.     for(;ucI<ucLength;ucI++){
  45.         sInt16 = sInt16*10 + pcString[ucI]-'0';
  46.     }
  47.     if(pcString[0] == '-'){//
  48.         sInt16 = ~sInt16 + 1;
  49.     }
  50.     return sInt16;
  51. }
  52. uint16_t usAtou16(const char * pcString,uint8_t ucLength){
  53.     uint16_t usInt16 = 0;
  54.     uint8_t ucI = 0;
  55.     for(;ucI<ucLength;ucI++){
  56.         usInt16 = usInt16*10 + pcString[ucI]-'0';
  57.     }
  58.     return usInt16;
  59. }
  60. int32_t iAto32(const char * pcString,uint8_t ucLength){
  61.     int32_t iInt32 = 0;
  62.     uint8_t ucI = 0;
  63.     if(pcString[ucI] == '-'){//
  64.         ucI++;
  65.     }
  66.     for(;ucI<ucLength;ucI++){
  67.         iInt32 = iInt32*10 + pcString[ucI]-'0';
  68.     }
  69.     if(pcString[0] == '-'){//
  70.         iInt32 = ~iInt32 + 1;
  71.     }
  72.     return iInt32;
  73. }
  74. uint32_t uiAtou32(const char * pcString,uint8_t ucLength){
  75.     uint32_t uiInt32 = 0;
  76.     uint8_t ucI = 0;
  77.     for(;ucI<ucLength;ucI++){
  78.         uiInt32 = uiInt32*10 + pcString[ucI]-'0';
  79.     }
  80.     return uiInt32;
  81. }
  82. int64_t lAto64(const char * pcString,uint8_t ucLength){
  83.     int64_t lInt64 = 0;
  84.     uint8_t ucI = 0;
  85.     if(pcString[ucI] == '-'){//
  86.         ucI++;
  87.     }
  88.     for(;ucI<ucLength;ucI++){
  89.         lInt64 = lInt64*10 + pcString[ucI]-'0';
  90.     }
  91.     if(pcString[0] == '-'){//
  92.         lInt64 = ~lInt64 + 1;
  93.     }
  94.     return lInt64;
  95. }
  96. uint64_t ulAtou64(const char * pcString,uint8_t ucLength){
  97.     uint64_t ulInt64 = 0;
  98.     uint8_t ucI = 0;
  99.     for(;ucI<ucLength;ucI++){
  100.         ulInt64 = ulInt64*10 + pcString[ucI]-'0';
  101.     }
  102.     return ulInt64;
  103. }
  104. main(int argc, char *argv[])
  105. {
  106.     int8_t a1;
  107.     uint8_t a2;
  108.     int16_t b1;
  109.     uint16_t b2;
  110.     int32_t c1;
  111.     uint32_t c2;
  112.     int64_t d1;
  113.     uint64_t d2;
  114.     a1 = cAto8("-128",strlen("-128"));
  115.     printf("a1=%d\r\n",a1);
  116.     a2 = ucAtou8("255",strlen("255"));
  117.     printf("a2=%d\r\n",a2);
  118.     b1 = sAto16("-32768",strlen("-32768"));
  119.     printf("b1=%d\r\n",b1);
  120.     b2 = usAtou16("65535",strlen("65535"));
  121.     printf("b2=%d\r\n",b2);
  122.     c1 = iAto32("-2147483648",strlen("-2147483648"));
  123.     printf("c1=%ld\r\n",c1);
  124.     c2 = uiAtou32("4294967295",strlen("4294967295"));
  125.     printf("c2=%u\r\n",c2);
  126.     d1 = lAto64("-9223372036854775808",strlen("-9223372036854775808"));
  127.     printf("d1=%ld\r\n",d1);
  128.     d2 = ulAtou64("18446744073709551615",strlen("18446744073709551615"));
  129.     printf("d2=%lu\r\n",d2);
  130.     return 0;
  131. }

  133. /*-------------------(C) COPYRIGHT 2020 头条@单片机嵌入式爱好者 ----------------*/

  135. 运行结果如下：

  137. a1=-128
  138. a2=255
  139. b1=-32768
  140. b2=65535
  141. c1=2147483648
  142. c2=4294967295
  143. d1=-9223372036854775808
  144. d2=18446744073709551615


来源：单片机嵌入式爱好者