it-swarm.com.ru

Конвертировать char в int в C и C ++

Как преобразовать char в int в C и C++?

309
mainajaved

Зависит от того, что вы хотите сделать:

чтобы прочитать значение в виде кода ASCII, вы можете написать

char a = 'a';
int ia = (int)a; 
/* note that the int cast is not necessary -- int ia = a would suffice */

чтобы преобразовать символ '0' -> 0, '1' -> 1 и т. д., вы можете написать

char a = '4';
int ia = a - '0';
/* check here if ia is bounded by 0 and 9 */
435
Foo Bah

Ну, в коде ASCII номера (цифры) начинаются с 48. Все, что вам нужно сделать, это:

int x = (int)character - 48;
71
Vlad Isoc

C и C++ всегда продвигают типы как минимум до int. Кроме того, символьные литералы имеют тип int в C и char в C++.

Вы можете преобразовать тип char, просто присвоив int.

char c = 'a'; // narrowing on C
int a = c;
59
Matt Joiner

char - это всего лишь 1-байтовое целое число. В типе char нет ничего волшебного! Точно так же, как вы можете назначить short для int или int для long, вы можете назначить char для int.

Да, имя типа данных примитива бывает "char", что подразумевает, что он должен содержать только символы. Но на самом деле "char" - это просто плохое имя, которое может сбить с толку всех, кто пытается выучить язык. Лучшее имя для него - int8_t, и вы можете использовать это имя, если ваш компилятор следует последнему стандарту Си.

Хотя, конечно, вы должны использовать тип char при обработке строки, поскольку индекс классической таблицы ASCII умещается в 1 байт. Однако вы можете также обрабатывать строки с обычными целочисленными значениями, хотя в реальном мире нет практической причины, по которой вы захотите это сделать. Например, следующий код будет отлично работать:

  int str[] = {'h', 'e', 'l', 'l', 'o', '\0' };

  for(i=0; i<6; i++)
  {
    printf("%c", str[i]);
  }

Вы должны понимать, что символы и строки - это просто числа, как и все остальное в компьютере. Когда вы пишете "а" в исходном коде, он предварительно обрабатывается до числа 97, которое является целочисленной константой.

Так что если вы напишите выражение, как

char ch = '5';
ch = ch - '0';

это на самом деле эквивалентно

char ch = (int)53;
ch = ch - (int)48;

который затем проходит через целочисленные продвижения языка C

ch = (int)ch - (int)48;

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

ch = (char)( (int)ch - (int)48 );

Между строк происходит много таких тонких вещей, где char неявно рассматривается как int.

29
Lundin

(Этот ответ касается стороны C++, но проблема расширения знака существует и в C).

Обработка всех трех типов char (signed, unsigned и char) более сложна, чем кажется на первый взгляд. Значения в диапазоне от 0 до SCHAR_MAX (что составляет 127 для 8-битного char) просты:

char c = somevalue;
signed char sc = c;
unsigned char uc = c;
int n = c;

Но когда somevalue находится за пределами этого диапазона, только прохождение unsigned char дает вам согласованные результаты для "одинаковых" значений char во всех трех типах:

char c = somevalue;
signed char sc = c;
unsigned char uc = c;
// Might not be true: int(c) == int(sc) and int(c) == int(uc).
int nc = (unsigned char)c;
int nsc = (unsigned char)sc;
int nuc = (unsigned char)uc;
// Always true: nc == nsc and nc == nuc.

Это важно при использовании функций из ctype.h , таких как isupper или toupper, из-за расширения знака:

char c = negative_char;  // Assuming CHAR_MIN < 0.
int n = c;
bool b = isupper(n);  // Undefined behavior.

Обратите внимание, что преобразование через int неявное; это тот же UB:

char c = negative_char;
bool b = isupper(c);

Чтобы исправить это, пройдите unsigned char, что легко сделать, обернув ctype.h функции через safe_ctype :

template<int (&F)(int)>
int safe_ctype(unsigned char c) { return F(c); }

//...
char c = CHAR_MIN;
bool b = safe_ctype<isupper>(c);  // No UB.

std::string s = "value that may contain negative chars; e.g. user input";
std::transform(s.begin(), s.end(), s.begin(), &safe_ctype<toupper>);
// Must wrap toupper to eliminate UB in this case, you can't cast
// to unsigned char because the function is called inside transform.

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

int ord(char c) { return (unsigned char)c; }
char chr(int n) {
  assert(0 <= n);  // Or other error-/sanity-checking.
  assert(n <= UCHAR_MAX);
  return (unsigned char)n;
}

// Ord and chr are named to match similar functions in other languages
// and libraries.

ord(c) всегда дает вам неотрицательное значение - даже если передано отрицательное char или отрицательное signed char - и chr принимает любое значение, которое ord создает и возвращает точно такое же char.

На практике я, вероятно, просто использовал бы unsigned char вместо того, чтобы использовать их, но они лаконично переносят приведение, предоставляют удобное место для добавления проверки ошибок для int- в -char, и будут короче и понятнее, когда вам нужно использовать их несколько раз в непосредственной близости.

16
Fred Nurk

Используйте static_cast<int>:

int num = static_cast<int>(letter); // if letter='a', num=97

Редактировать: Возможно, вам следует избегать использования (int)

int num = (int) буква;

проверить Зачем использовать static_cast <int> (x) вместо (int) x? для получения дополнительной информации.

10
herohuyongtao

Это зависит от того, что вы подразумеваете под "конвертировать".

Если у вас есть серия символов, представляющих целое число, например "123456", то в C есть два типичных способа сделать это: использовать специальное преобразование, например atoi () или strtol () или универсальное sscanf () . C++ (который на самом деле является другим языком, маскирующимся под обновление) добавляет третий, stringstreams.

Если вы хотите, чтобы точный битовый шаблон в одной из переменных int обрабатывался как char, это проще. В C разные целочисленные типы действительно больше относятся к состоянию ума, чем к отдельным отдельным "типам". Просто начните использовать его там, где запрашивается chars, и с вами все будет в порядке. Возможно, вам понадобится явное преобразование, чтобы компилятор прекратил ныть время от времени, но все, что нужно сделать, это отбросить все лишние биты после 256.

6
T.E.D.

У меня есть абсолютно null навыки в C, но для простого разбора:

char* something = "123456";

int number = parseInt(something);

... это сработало для меня:

int parseInt(char* chars)
{
    int sum = 0;
    int len = strlen(chars);
    for (int x = 0; x < len; x++)
    {
        int n = chars[len - (x + 1)] - '0';
        sum = sum + powInt(n, x);
    }
    return sum;
}

int powInt(int x, int y)
{
    for (int i = 0; i < y; i++)
    {
        x *= 10;
    }
    return x;
}
5
Henke

Предположительно, вы хотите это преобразование для использования функций из стандартной библиотеки C.

В этом случае do (синтаксис C++)

typedef unsigned char UChar;

char myCppFunc( char c )
{
    return char( someCFunc( UChar( c ) ) );
}

Выражение UChar( c ) преобразуется в unsigned char, чтобы избавиться от отрицательных значений, которые, кроме EOF, не поддерживаются функциями C.

Затем результат этого выражения используется в качестве фактического аргумента для формального аргумента int. Где вы получаете автоматическое продвижение на int. В качестве альтернативы вы можете написать этот последний шаг явно, например, int( UChar( c ) ), но лично я нахожу это слишком многословным.

Ура & hth.,

3
Cheers and hth. - Alf

Для char или short для int вам просто нужно присвоить значение.

char ch = 16;
int in = ch;

То же самое для int64.

long long lo = ch;

Все значения будут 16.

0
Riwels

У меня были проблемы с преобразованием массива char, такого как "7c7c7d7d7d7d7c7c7c7d7d7d7d7c7c7c7c7c7c7d7d7c7c7c7c7d7c7d7d7d7c7c2e2e2e", в его действительное целочисленное значение, которое могло бы быть представлено 7C как одно шестнадцатеричное значение. Итак, после поиска помощи я создал это и подумал, что было бы здорово поделиться.

Это разделяет строку char на правильные целые числа и может быть полезна большему количеству людей, чем только я;)

unsigned int* char2int(char *a, int len)
{
    int i,u;
    unsigned int *val = malloc(len*sizeof(unsigned long));

    for(i=0,u=0;i<len;i++){
        if(i%2==0){
            if(a[i] <= 57)
                val[u] = (a[i]-50)<<4;
            else
                val[u] = (a[i]-55)<<4;
        }
        else{
            if(a[i] <= 57)
                val[u] += (a[i]-50);
            else
                val[u] += (a[i]-55);
            u++;
        }
    }
    return val;
}

Надеюсь, поможет!

0
Mathorlaz