Как преобразовать из const char * в unsigned int С++

Ответ 1

#include <iostream>
#include <sstream>

const char* value = "1234567";
stringstream strValue;
strValue << value;

unsigned int intValue;
strValue >> intValue;

cout << value << endl;
cout << intValue << endl;

Вывод:

1234567

1234567

Ответ 2

Что вы подразумеваете под конвертированием?

Если вы говорите о чтении целого числа из текста, у вас есть несколько вариантов.

Boost lexical cast: http://www.boost.org/doc/libs/1_44_0/libs/conversion/lexical_cast.htm

Строковый поток:

const char* x = "10";
int y;
stringstream s(x);
s >> y;

Или старые добрые функции C atoi() и strtol()

Ответ 3

Если вы действительно хотите преобразовать указатель на константный символ в unsigned int, вы должны использовать его в С++:

const char* p;
unsigned int i = reinterpret_cast<unsigned int>( p );

Это преобразует адрес, на который указывает указатель, в целое число без знака.

Если вы хотите преобразовать содержимое, на которое указывает указатель, в unsigned int, вы должны использовать:

const char* p;
unsigned int i = static_cast<unsigned int>( *p );

Если вы хотите получить целое число из строки и, следовательно, интерпретируете const char * как указатель на массив const char, вы можете использовать одно из решений, упомянутых выше.

Ответ 4

Путь C:

#include <stdlib.h>
int main() {
    const char *charVar = "16";
    unsigned int uintVar = 0;

    uintVar = atoi(charVar);

    return 0;
}

Способ С++:

#include <sstream>
int main() {
    istringstream myStream("16");
    unsigned int uintVar = 0;

    myStream >> uintVar;

    return 0;
}

Обратите внимание, что ни в одном случае я не проверял код возврата преобразования, чтобы убедиться, что он действительно сработал.

Ответ 5

В C это можно сделать, используя atoi, который также доступен для С++ через cstdlib.

Ответ 6

atoi функция преобразует const char * в int, который может быть неявно преобразован в unsigned. Это не будет работать для больших целых чисел, которые не помещаются в int.

Более С++ - ish способ использовать строки и потоки

#include <sstream>
#include <string>

int main()
{
   std::string strVar;
   unsigned uintVar;
   std::istringstream in(strVar);
   in >> uintVar;
}

Простым, но нестандартным способом было бы использовать boost lexical cast.

НТН

Ответ 7

Обычно я использую эту общую функцию для преобразования строки в "что-либо":

  #include <sstream>
  // Convert string values into type T results.
  // Returns false in case the conversion fails.
  template <typename T>
  bool getValueFromString( const std::string & value, T & result )
  {
    std::istringstream iss( value );
    return !( iss >> result ).fail();
  }

просто используйте его, как в:

int main()
{
  const char * a_string = "44";
  unsigned int an_int;
  bool         success;

  // convert from const char * into unsigned int
  success = getValueFromString( a_string, an_int );


  // or any other generic convertion
  double       a;
  int          b;
  float        c;
  // conver to into double
  success = getValueFromString( "45", a );

  // conve rto into int
  success = getValueFromString( "46", b );

  // conver to into float
  success = getValueFromString( "47.8", c );
}

Ответ 8

Без дополнительной информации нет правильного ответа на этот вопрос. Что вы пытаетесь преобразовать точно? Если charVar является ascii-представлением строки, тогда вы можете сделать то, что предложили другие, и используйте строки, atoi, sscanf и т.д.

Если вы хотите фактическое значение, на которое указывает charVar, вместо этого вам нужно что-то вроде:

intValue = (unsigned int)(*charVal);

Или, если charVal является указателем на первый байт целого числа без знака, то:

intValue = *((unsigned int*)(charVal));

Ответ 9

const char* charVar = "12345";
unsigned int uintVar;
try {
  uintVar = std::stoi( std::string(charVar) );
}
catch(const std::invalid_argument& e) {
  std::cout << "Invalid Arg: " << e.what() << endl;
}
catch(const std::out_of_range& e) {
  std::cout << "Out of range: " << e.what() << endl;
}

Ответ 10

Вы также можете использовать strtoul или _tcstoul, чтобы получить беззнаковое длинное значение из const char*, а затем передать значение в unsigned int.

http://msdn.microsoft.com/en-us/library/5k9xb7x1(v=vs.71).aspx

Ответ 11

const char* charVar = "1864056953";
unsigned int uintVar = 0;

for (const char* it = charVar; *it != 0; *it++){

    if ((*it < 48) || (*it > 57)) break;            // see ASCII table

    uintVar *= 10;                                  // overflow may occur
    uintVar += *it - 48;                            // 
}

std::cout << uintVar << std::endl;
std::cout << charVar << std::endl;

Ответ 12

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

#include<iostream>

unsigned long cstring_to_ul(const char* str, char** end = nullptr, int base = 10)
{
    errno = 0; // Used to see if there was success or failure

    auto ul = strtoul(str, end, base);

    if(errno != ERANGE)
    {
       return ul;
    }

    return ULONG_MAX;
}

Что это будет сделано, так это создать оболочку метода метода strtoul (const char * nptr, char ** endptr, int base) из C. Для получения дополнительной информации об этой функции вы можете прочитать описание из man здесь https://linux.die.net/man/3/strtoul

При сбое у вас будет errno = ERANGE, что позволит вам выполнить проверку после вызова этой функции вместе со значением ULONG_MAX.

Пример использования этого может быть следующим:

int main()
{
    unsigned long ul = cstring_to_ul("3284201");

    if(errno == ERANGE && ul == ULONG_MAX)
    {
        std::cout << "Input out of range of unsigned long.\n";
        exit(EXIT_FAILURE);
    }

    std::cout << "Output: " << ul << "\n";
 }

Это даст выход

Выход: 3284201