C/C++ 字符串与数字相互转换

1. C字符串转换为数字

• 包含头文件 （）

• 转换为 int 类型

  int atoi (const char * str);
  

  将C字符串 str 解释为一个int类型的整数。

  该函数首先丢弃尽可能多的空白字符，直到找到第一个非空白字符。 然后，从该字符开始，接受可选的正负号，后跟尽可能多的基数为10的数字，并将它们解释为数值。

  字符串可以包含在形成整数之后的其他字符，这些字符将被忽略并且对此函数的行为没有影响。

  如果 str 中的第一个非空白字符序列不是有效的整数，或者由于str是空的或者只包含空格字符而不存在这样的序列，则不执行转换并返回零。

  例子

  /* atoi example */
  #include       /* printf, fgets */
  #include      /* atoi */
  
  int main () {
  	  int i;
  	  char buffer[256];
  	  printf ("Enter a number: ");
  	  fgets (buffer, 256, stdin);
  	  
  	  i = atoi (buffer);
  	  printf ("The value entered is %d. Its double is %d.\n",i,i*2);
  	  return 0;
  }
  
  

  结果：
  Enter a number: 73
  The value entered is 73. Its double is 146.

• 转换为 long 类型

  long int atol ( const char * str );
  

  将C字符串 str 解释为一个long类型的整数。其他和 atoi 函数一样。

  或者使用

  long int strtol (const char* str, char** endptr, int base);
  

  将C字符串 str 按照指定的基数 base 解释为long int 类型的整数。如果 endptr 不为空指针，则该函数还将 endptr 的值设置为指向该数字后面的第一个字符。如果将base设为0，则该函数将根据 str 的格式来自动决定基数。其他和 atoi 函数一样。

  例子

  /* strtol example */
  #include       /* printf */
  #include      /* strtol */
  
  int main () {
  	  char szNumbers[] = "2001 60c0c0 -1101110100110100100000 0x6fffff";
  	  char * pEnd;
  	  long int li1, li2, li3, li4;
  	  
  	  li1 = strtol (szNumbers, &pEnd,10);
  	  li2 = strtol (pEnd, &pEnd,16);
  	  li3 = strtol (pEnd, &pEnd,2);
  	  li4 = strtol (pEnd, NULL,0);
  	  
  	  printf ("The decimal equivalents are: %ld, %ld, %ld and %ld.\n", li1, li2, li3, li4);
  	  return 0;
  }
  

  结果：The decimal equivalents are: 2001, 6340800, -3624224 and 7340031

• 转换为 unsigned long 类型

  unsigned long int strtoul (const char* str, char** endptr, int base);
  

  将C字符串 str 解释为一个unsigned long类型的整数。其他和 atol 函数一样。

• 转换为 long long 类型

  long long int atoll ( const char * str );
  

  将C字符串 str 解释为一个long long类型的整数。其他和 atol 函数一样。

  或者使用

  long long int strtoll (const char* str, char** endptr, int base);
  

  将C字符串 str 按照指定的基数 base 解释为long long int 类型的整数。其他和 strtol 函数一样。

• 转换为 unsigned long long 类型

  unsigned long long int strtoull (const char* str, char** endptr, int base);
  

  将C字符串 str 按照指定的基数 base 解释为unsigned long long 类型的整数。其他和 strtol 函数一样。

• 转换为 float 类型

  float strtof (const char* str, char** endptr);
  

  将C字符串 str 解释为 float 类型的浮点数（根据当前本地环境），如果 endptr 不是空指针，则该函数还将endptr的值设置为指向该数字后面的第一个字符。如果转换失败，则返回 0.0f。此函数会首先忽略前导空白，并接受正负号、指数（e/E）、十六进制数（0x/0X开头）。

  例子

  /* strtof example */
  #include       /* printf, NULL */
  #include      /* strtof */
  
  int main () {
  	  char szOrbits[] = "686.97 365.24";
  	  char* pEnd;
  	  float f1, f2;
  	  
  	  f1 = strtof (szOrbits, &pEnd);
  	  f2 = strtof (pEnd, NULL);
  	  printf ("One martian year takes %.2f Earth years.\n", f1/f2);
  	  return 0;
  }
  

  结果：One martian year takes 1.88 Earth years.

• 转换为 double 类型

  double atof (const char* str);
  

  将C字符串 str 解释为 double 类型的浮点数。其他和 strtof 函数一样。

  或者使用

  double strtod (const char* str, char** endptr);
  

  将C字符串 str 解释为 double 类型的浮点数。其他和 strtof 函数一样。

• 转换为 long double 类型

  long double strtold (const char* str, char** endptr);
  

  将C字符串 str 解释为 long double 类型的浮点数。其他和 strtod 函数一样。

2. 数字转换为C字符串

• 诸如 itoa 的函数，并不是标准函数，只是某些编译器支持。

• 要实现数字转换为C字符串，可以使用 sprintf 函数。包含头文件

  int sprintf( char * str,  const char * format, ... );
  

  将格式化之后的C字符串存储到 str 指定的缓冲区中，并且在内容之后会自动附加终止空字符。缓冲区的大小应足够大，以包含整个结果字符串，更安全的版本为 snprintf。

  int snprintf( char * s, size_t n, const char * format, ... );
  

  与 sprintf 函数一样，只是此函数将格式化之后的C字符串存储到 s 指定的缓冲区时，最大只会填充 n 个字符。如果生成的字符串长度超过n-1个字符，则剩余的字符将被丢弃并且不会被存储，且该函数返回被丢弃的字符个数。在写入内容后会自动附加终止空字符。

  数字转换为C字符串示例：

  sprintf(str, "%d", value);	 // converts to decimal base.
  sprintf(str, "%x", value); 	 // converts to hexadecimal base.
  sprintf(str, "%o", value);   //	converts to octal base.
  

3. C++ 字符串转换为数字

• 包含头文件

• 转换为 int 类型

  int stoi (const string&  str, size_t* idx = 0, int base = 10);
  int stoi (const wstring& str, size_t* idx = 0, int base = 10);
  

  将字符串 str 按照指定的基数 base 解释为 int 类型的整数。
  如果idx不是空指针，则该函数还将idx的值设置为该数字后str中第一个字符的位置。
  如果将base设为0，则该函数将根据 str 的格式来自动决定基数。
  该函数在内部使用 strtol （wcstol）函数来进行转换。

  例子

  // stoi example
  #include    // std::cout
  #include      // std::string, std::stoi
  
  int main () {
  	  std::string str_dec = "2001, A Space Odyssey";
  	  std::string str_hex = "40c3";
  	  std::string str_bin = "-10010110001";
  	  std::string str_auto = "0x7f";
  	
  	  std::string::size_type sz;   // alias of size_t
  	
  	  int i_dec = std::stoi (str_dec,&sz);
  	  int i_hex = std::stoi (str_hex,nullptr,16);
  	  int i_bin = std::stoi (str_bin,nullptr,2);
  	  int i_auto = std::stoi (str_auto,nullptr,0);
  	
  	  std::cout << str_dec << ": " << i_dec << " and [" << str_dec.substr(sz) << "]\n";
  	  std::cout << str_hex << ": " << i_hex << '\n';
  	  std::cout << str_bin << ": " << i_bin << '\n';
  	  std::cout << str_auto << ": " << i_auto << '\n';
  	
  	  return 0;
  }
  

  结果：
  2001, A Space Odyssey: 2001 and [, A Space Odyssey]
  40c3: 16579
  -10010110001: -1201
  0x7f: 127

• 转换为 long 类型

  long stol (const string&  str, size_t* idx = 0, int base = 10);
  long stol (const wstring& str, size_t* idx = 0, int base = 10);
  

  将字符串 str 按照指定的基数 base 解释为 long 类型的整数。其他和 stoi 函数一样。

• 转换为 unsigned long 类型

  unsigned long stoul (const string&  str, size_t* idx = 0, int base = 10);
  unsigned long stoul (const wstring& str, size_t* idx = 0, int base = 10);
  

  将字符串 str 按照指定的基数 base 解释为 unsigned long 类型的整数。该函数在内部使用 strtoul （wcstoul）函数来进行转换。其他和 stoi 函数一样。

• 转换为 long long 类型

  long long stoll (const string&  str, size_t* idx = 0, int base = 10);
  long long stoll (const wstring& str, size_t* idx = 0, int base = 10);
  

  将字符串 str 按照指定的基数 base 解释为 long long 类型的整数。该函数在内部使用 strtoll （wcstoll）函数来进行转换。其他和 stoi 函数一样。

• 转换为 unsigned long long 类型

  unsigned long long stoull (const string&  str, size_t* idx = 0, int base = 10);
  unsigned long long stoull (const wstring& str, size_t* idx = 0, int base = 10);
  

  将字符串 str 按照指定的基数 base 解释为 unsigned long long 类型的整数。该函数在内部使用 strtoull （wcstoull）函数来进行转换。其他和 stoi 函数一样。
  
  

• 转换为 float 类型

  float stof (const string&  str, size_t* idx = 0);
  float stof (const wstring& str, size_t* idx = 0);
  

  将字符串 str 解释为 float 类型的浮点数，如果idx不是空指针，则该函数还将idx的值设置为该数字后str中第一个字符的位置。该函数在内部使用 strtod （wcstod）函数来进行转换。

  例子

  // stof example
  #include    // std::cout
  #include      // std::string, std::stof
  
  int main () {
  	  std::string orbits ("686.97 365.24");
  	  std::string::size_type sz;     // alias of size_t
  	
  	  float mars = std::stof (orbits, &sz);
  	  float earth = std::stof (orbits.substr(sz));
  	  std::cout << "One martian year takes " << (mars/earth) << " Earth years.\n";
  	  return 0;
  }
  

  结果：
  One martian year takes 1.88087 Earth years.

• 转换为 double 类型

  double stod (const string&  str, size_t* idx = 0);
  double stod (const wstring& str, size_t* idx = 0);
  

  将字符串 str 解释为 double 类型的浮点数，如果idx不是空指针，则该函数还将idx的值设置为该数字后str中第一个字符的位置。该函数在内部使用 strtod （wcstod）函数来进行转换。
  
  

• 转换为 long double 类型

  long double stold (const string&  str, size_t* idx = 0);
  long double stold (const wstring& str, size_t* idx = 0);
  

  将字符串 str 解释为 long double 类型的浮点数，如果idx不是空指针，则该函数还将idx的值设置为该数字后str中第一个字符的位置。该函数在内部使用 strtold （wcstold）函数来进行转换。
  
  

4. 数字转换为C++字符串

• 使用 to_string 函数。

  string to_string (int val);
  string to_string (long val);
  string to_string (long long val);
  string to_string (unsigned val);
  string to_string (unsigned long val);
  string to_string (unsigned long long val);
  string to_string (float val);
  string to_string (double val);
  string to_string (long double val);
  

  将 val 解释为 string，并返回转换结果。

• 使用 to_wstring 函数。

  wstring to_wstring (int val);
  wstring to_wstring (long val);
  wstring to_wstring (long long val);
  wstring to_wstring (unsigned val);
  wstring to_wstring (unsigned long val);
  wstring to_wstring (unsigned long long val);
  wstring to_wstring (float val);
  wstring to_wstring (double val);
  wstring to_wstring (long double val);
  

  将 val 解释为 wstring，并返回转换结果。

  例子

  // to_wstring example
  #include    // std::wcout
  #include      // std::wstring, std::to_wstring
  
  int main () {
  	  std::wstring pi = L"pi is " + std::to_wstring(3.1415926);
  	  std::wstring perfect = std::to_wstring(1+2+4+7+14) + L" is a perfect number";
  	  std::wcout << pi << L'\n';
  	  std::wcout << perfect << L'\n';
  	  return 0;
  }
  

  结果：
  pi is 3.141593
  28 is a perfect number

参考：http://www.cplusplus.com/reference/string/
           http://www.cplusplus.com/reference/cstdlib/
           http://www.cplusplus.com/reference/cstdio/sprintf/