如何将char *转换为int?

时间:2010-02-10 15:31:06

标签: c++

我需要将char *转换为整数。例如:

data.SetBytFldPos(*attribute->value());

属性类中的值是char *。 'SetBytFldPos'采用int。

9 个答案:

答案 0 :(得分:6)

很多方法。最简单的方法是使用strtol() function

答案 1 :(得分:6)

您不会将char *转换为int。 您可能希望解析十进制字符串。这是由atoi()完成的。 atoi(“1”)== 1.

答案 2 :(得分:3)

如果您需要确保您的char *代表有效的int,您可以使用Boost Lexical Cast

#include <boost/lexical_cast.hpp>

try {
    data.SetBytFldPos(boost::lexical_cast<int>(*attribute->value()));
} catch (bad_lexical_cast) {
    // something is wrong
}

答案 3 :(得分:1)

您还可以编写通用的“转换字符串到X模板”。

template <class T>
T parse(const std::string& s)
{
  T out;
  std::stringstream ss(s);
  ss >> out;
  return out;
}

用法:

int x = parse<int>("123");
float y = parse<float>("3.14159");

答案 4 :(得分:0)

您可以使用atoi()函数

data.SetByteFldPos(atoi(attribute->value()));

答案 5 :(得分:0)

有一个名为atoi的简单C函数不太好,因为错误处理在最好的情况下是不直观且容易忘记的。 (C)函数strtol要好得多,习惯优先选择atoi。以下是手册页中的示例代码:

   #include <stdlib.h>
   #include <limits.h>
   #include <stdio.h>
   #include <errno.h>

   int
   main(int argc, char *argv[])
   {
       int base;
       char *endptr, *str;
       long val;

       if (argc < 2) {
           fprintf(stderr, "Usage: %s str [base]\n", argv[0]);
           exit(EXIT_FAILURE);
       }

       str = argv[1];
       base = (argc > 2) ? atoi(argv[2]) : 10;

       errno = 0;    /* To distinguish success/failure after call */
       val = strtol(str, &endptr, base);

       /* Check for various possible errors */

       if ((errno == ERANGE && (val == LONG_MAX || val == LONG_MIN))
               || (errno != 0 && val == 0)) {
           perror("strtol");
           exit(EXIT_FAILURE);
       }

       if (endptr == str) {
           fprintf(stderr, "No digits were found\n");
           exit(EXIT_FAILURE);
       }

       /* If we got here, strtol() successfully parsed a number */

       printf("strtol() returned %ld\n", val);

       if (*endptr != '\0')        /* Not necessarily an error... */
           printf("Further characters after number: %s\n", endptr);

       exit(EXIT_SUCCESS);
   }

请注意,atoi(argv[2])转换完全没有任何错误检查。并非strtol非常简单直观地检查错误,但它至少更好。

答案 6 :(得分:0)

我能想到四种方式:

  • atoi。如果无法解析您的字符串,请注意此函数返回0。
  • strtolatoi的更强大版本。这可能会导致编译器警告,因为您需要int并且其返回值为long
  • 提升图书馆的lexical_cast如果您可以使用Boost,我喜欢这个。
  • 使用stringstream,如下所示。

代码示例:

std::string str(*attribute->value());
std::istringstream myStrm(str);
int val;

myStrm >> val;

答案 7 :(得分:0)

你可以

// needed
#include <sstream>

// source, target
char const * p = "123";
int ival;

// conversion
std::stringstream ss(p);
ss >> ival;

请注意,我们通常会谈论“字符串”,而不是char *,只要我们不指代指针。

答案 8 :(得分:0)

我相信这可以解决问题。

int pow(int a, int b)                                                                                                                                                                                                                                                                               
{                                                                                                                                                                                                                                                                                                   
    int val = 1;                                                                                                                                                                                                                                                                                    
    for (int i = 0; i < b; i++)                                                                                                                                                                                                                                                                     
        val *= a;                                                                                                                                                                                                                                                                                   
    return val;                                                                                                                                                                                                                                                                                     
}                                                                                                                                                                                                                                                                                                     

int cp_length(char* cp)                                                                                                                                                                                                                                                                             
{                                                                                                                                                                                                                                                                                                   
    int i = 0;                                                                                                                                                                                                                                                                                      
    while (cp [i] != '\0')                                                                                                                                                                                                                                                                          
        i++;                                                                                                                                                                                                                                                                                        
    return i;                                                                                                                                                                                                                                                                                       
}                                                                                                                                                                                                                                                                                                   

int cptoi(char* cp)                                                                                                                                                                                                                                                                                 
{                                                                                                                                                                                                                                                                                                   
    int val = 0;                                                                                                                                                                                                                                                                                    
    for (int j = cp_length(cp) - 1, i = 0; j >= 0; j--, i++)                                                                                                                                                                                                                                        
        if (cp [i] < 0x30 || cp [i] > 0x39) // if the character is not a digit                                                                                                                                                                                                                      
            continue;                                                                                                                                                                                                                                                                               
        else                                                                                                                                                                                                                                                                                        
            val += (cp [0] == '-' ? -(cp [i] - 0x30) * pow(10, j) : +(cp [i] - 0x30) * pow(10, j)); // accounts for negativity                                                                                                                                                                      

    // This is the thing you need.
    return val;                                                                                                                                                                                                                                                                                     
}