Как преобразовать тип char в int в языке программирования?
Перевод символьного значения в целочисленное значение может быть достигнуто несколькими способами. Один из наиболее распространенных способов является использование функции `atoi` из стандартной библиотеки Си. Эта функция принимает в качестве аргумента строку `char` и возвращает соответствующее целое число.
Вот пример использования функции `atoi`:
c #include #include int main()
В этом примере строка `»1234″` преобразуется в целое число `1234` с помощью функции `atoi`.
Еще один способ это использование приведения типов. Если `char value` содержит символьное значение, то мы можем преобразовать его в соответствующее целое значение, выполнив явное приведение типа следующим образом:
c char value = '5'; int num = (int)value; printf("num = %d\n", num);
В этом примере значение `char value` `’5’` явно приводится к типу `int`. Результатом будет целочисленное значение `53`, которое соответствует коду символа ‘5’.
Также возможно использование функции `sscanf` для считывания числовых значений из строковых переменных. Например:
c char str[] = "1234"; int num; sscanf(str, "%d", &num); printf("num = %d\n", num);
В этом примере `sscanf` используется для считывания целочисленного значения из переменной `str`. Функция принимает строку формата `»%d»`, обозначающую, что она должна искать целочисленное значение, и сохранять его в переменную `num`.
В целом, перевод символьного значения в целочисленное значение может быть реализован множеством способов, и выбор наиболее подходящего зависит от конкретных требований проекта.
Конвертировать char в int в C и C ++
@Matt: было бы неплохо быть более конкретным. вопрос об обобщении просто предлагает обобщенные ответы, которые не применимы или даже не подходят для вашей задачи. имейте в виду, что когда вам приходится спрашивать, вы, вероятно, не знаете достаточно, чтобы правильно обобщать.
Cheers and hth. — Alf 17 фев. 2011, в 14:18
@Alf P. Steinbach: Первоначальный вопрос был неопределенным в отношении того, на каком языке. С ключевыми словами c и c++ , я думаю, ответы на оба языка являются разумными.
Matt Joiner 17 фев. 2011, в 14:25
Исходя из моего большого опыта работы на других технических форумах, моя интуиция заключается в том, что ОП на самом деле означает «как взять текстовое представление числа (в базе 10) и преобразовать его в соответствующее число?» Вообще говоря, неофиты C и C ++ обычно имеют невероятно смутные представления о том, как работает текст на этих языках и что на самом деле означает char .
Karl Knechtel 17 фев. 2011, в 15:56
@KarlKnechtel: Если это правда (я даю примерно 50/50, так как многие ранние руководства также поощряют получение значений ASCII из символов, даже если ASCII не охватывает весь диапазон), ОП требует ясности — но это обман of stackoverflow.com/questions/439573/… .
Fred Nurk 17 фев. 2011, в 16:51
У ОП было три часа, чтобы уточнить этот вопрос, и он не смог этого сделать. Как это, нет никакого способа узнать, что на самом деле спрашивают. Проголосовал за закрытие.
sbi 17 фев. 2011, в 17:27
Вообще-то, возможно, это что-то вроде дурака .
T.E.D. 17 фев. 2011, в 17:52
возможный дубликат символа в целое число в C
Helen 17 фев. 2011, в 19:59
Обратите внимание, что даже если вы можете выполнять неявное приведение назад и вперед, когда дело доходит до int и char, есть некоторые действительно важные вещи, которые необходимо знать: 1) в зависимости от ситуации вы можете потерять знак минус вашего числа (хранится как char) если ты не осторожен Вот почему есть знак со знаком и без знака; 2) sizeof (char) = 1Byte (всегда; здесь я исключаю символ WIDE, который может быть больше 8 бит), но sizeof (int) = не менее 4Bytes! Char — это целочисленный тип с некоторыми ограничениями. Я советую вам избегать использования char для математических вычислений, если только вам это не нужно.
rbaleksandar 17 июль 2013, в 03:21
Показать ещё 6 комментариев
Поделиться:
11 ответов
Зависит от того, что вы хотите сделать:
чтобы прочитать значение как код 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 */ Foo Bah 17 фев. 2011, в 15:49
Поделиться
а = (а — «0»)% 48;
Kshitij Banerjee 31 окт. 2013, в 21:25
@KshitijBanerjee Это не очень хорошая идея по двум причинам: он дает вам отрицательное число для символов ascii перед ‘0’ (например, & -> -10), и это дает вам числа больше 10 (например, x -> 26)
SheetJS 28 дек. 2014, в 18:14
int ia = a — ‘0’ — это то, что вам нужно
funk 05 май 2015, в 21:27
Kevin Zakka 03 окт. 2015, в 10:42
@ kevin001 Если вы хотите преобразовать char в int, а символ ‘1’ предоставляет число ascii, отличное от 1 , вам нужно удалить смещение ‘0’ чтобы выровнять его, чтобы считать от 0 до 9. Последовательные числа 1-9 соседствуют в целом числе ascii.
krisdestruction 09 окт. 2015, в 17:36
Нет литья требуется / желательно
Craig Estey 11 окт. 2015, в 22:14
этот трюк «0» удивителен. очень помог мне
rain_ 14 июль 2016, в 13:16
Можете ли вы описать принцип этой магии?
JustLogin 26 янв. 2019, в 20:52
Показать ещё 6 комментариев
C и С++ всегда поддерживают типы по меньшей мере int . Кроме того, символьные литералы имеют тип int в C и char в С++.
Вы можете преобразовать тип char , просто назначив int .
char c = 'a'; // narrowing on C int a = c; Matt Joiner 17 фев. 2011, в 14:15
Поделиться
Вы также можете использовать крайне недооцененный унарный operator+() для этой цели.
Cubbi 17 фев. 2011, в 14:14
-1 Ответ неверен только для осмысленного толкования вопроса. Это (code int a = c; ) сохранит любые отрицательные значения, с которыми стандартные функции библиотеки C не могут иметь дело. Стандартные библиотечные функции C устанавливают стандарт того, что значит обрабатывать значения char как int .
Cheers and hth. — Alf 17 фев. 2011, в 14:14
@ Наваз — . при условии, что он хочет простой тип, а не фактическое преобразование.
T.E.D. 17 фев. 2011, в 14:21
@ Альф П. Штайнбах: Я не согласен, это выходит за рамки вопроса и предполагает слишком много. Также обратите внимание, что добавление символьных буквальных интерпретаций направлено на ответ @Sayam Ahmed. Этот ответ сводится к int a = c; как достаточно.
Matt Joiner 17 фев. 2011, в 14:26
@TED . хм .. может быть .. этот вопрос сейчас кажется недостаточно ясным ..
Nawaz 17 фев. 2011, в 14:27
@Matt: я держу вниз голосов. Я бы усилил это, если это возможно! Интерпретация вопроса, которую вы и другие предположили, не имеет смысла, потому что она слишком тривиальна, и потому что для конкретной комбинации типов OP есть не очень тривиальная очень важная практическая проблема. Совет, который вы даете, непосредственно опасен для новичка. Скорее всего, это приведет к неопределенному поведению для их программ, которые используют функции классификации символов стандартной библиотеки C. Реф. на ответ @ Sayam, он удалил этот ответ.
Cheers and hth. — Alf 17 фев. 2011, в 15:22
-1 за неправильность: isupper () будет иметь неопределенные результаты, если передан 1252 старшего символа.
Chris Becke 17 фев. 2011, в 15:34
Что вы подразумеваете под «всегда продвигать»? Значения повышаются во время неявных преобразований, передачи определенных типов параметров (например, в функцию varargs) и когда оператор должен сделать свои операнды совместимыми типами. Но, безусловно, бывают случаи, когда значение не продвигается (например, если я передаю символ функции, ожидающей символ), иначе у нас не было бы типов, меньших, чем int.
Adrian McCarthy 18 май 2013, в 19:44
Не работал для меня. Я должен был сделать: например, «5» — «0» = 5
Koray Tugay 24 нояб. 2013, в 07:47
Мы должны сделать num-‘0 ‘, чтобы это работало.
Shivendra 30 май 2017, в 19:50
Показать ещё 8 комментариев
Ну, в ascii коды начинаются от 48. Все, что вам нужно сделать, это:
int x = (int)character - 48; Vlad Isoc 09 июнь 2015, в 09:55
Поделиться
Или более читабельно: ‘ int x = character — ‘0’
chad 27 июль 2016, в 22:37
@chad: не только более читабельный, но и более портативный. C и C ++ не гарантируют представление ASCII, но они гарантируют, что независимо от того, какое представление используется, представления десяти десятичных цифр являются смежными и в числовом порядке.
Ben Voigt 17 апр. 2017, в 00:16
char — всего 1 байтовое целое число. В char нет ничего волшебного! Так же, как вы можете назначить короткий для int или int long, вы можете назначить char для int.
Да, имя примитивного типа данных оказывается «char», что указывает на то, что оно должно содержать только символы. Но на самом деле «char» — это просто плохой выбор имени, чтобы смутить всех, кто пытается выучить язык. Лучшее имя для него — int8_t, и вы можете использовать это имя вместо этого, если ваш компилятор следует последнему стандарту C.
Хотя при обработке строк вы должны использовать тип char, потому что индекс классической таблицы ASCII соответствует 1 байту. Тем не менее, вы могли бы обрабатывать строки с помощью обычных ints, хотя в реальном мире нет практической причины, почему вы когда-либо захотите это сделать. Например, следующий код будет работать отлично:
int str[] = ; for(i=0; i
Вы должны понимать, что символы и строки — это просто цифры, как и все остальное на компьютере. Когда вы пишете ‘a’ в исходном коде, он предварительно обрабатывается в число 97, которое является целочисленной константой.
Итак, если вы пишете выражение типа
char ch = '5'; ch = ch - '0'; это фактически эквивалентно
char ch = (int)53; ch = ch - (int)48; который затем проходит целые рекламные акции на языке C
ch = (int)ch - (int)48; а затем усечен до char, чтобы соответствовать типу результата
ch = (char)( (int)ch - (int)48 ); Там много таких тонких вещей, которые происходят между строками, где char неявно рассматривается как int.
Lundin 17 фев. 2011, в 15:19
Поделиться
Поскольку вопрос не помечен ascii , вы не должны предполагать какую-либо конкретную кодировку. Установка char равной int8_t , неверна, поскольку она также может быть uint8_t или uint24_t .
Roland Illig 31 март 2018, в 20:18
@RolandIllig Нет, char всегда равен 1 байту, и если в int8_t uint8_t существуют типы int8_t / uint8_t (что весьма вероятно), они смогут соответствовать результату char , потому что тогда он будет 8 бит. В очень экзотических системах, таких как различные устаревшие DSP, char будет 16 бит, а uint8_t не будет. Написание кода для совместимости с устаревшими DSP не имеет смысла, так же как написание для совместимости с системами дополнения или знака и величины. Огромная трата времени, поскольку такие системы практически не существуют в реальном мире.
Lundin 01 апр. 2018, в 20:11
(Этот ответ относится к С++ стороне вещей, но проблема расширения знака существует и в C.)
Обработка всех трех типов char (подписанный, неподписанный и «char» ) более деликатный, чем первый. Значения в диапазоне от 0 до SCHAR_MAX (что составляет 127 для 8-бит char):
char c = somevalue; signed char sc = c; unsigned char uc = c; int n = c; Но когда какое-то значение выходит за пределы этого диапазона, только просмотр без знака 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. Это важно при использовании функций из , таких как 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, что легко сделать с помощью функций wrapping через safe_ctype:
template int safe_ctype(unsigned char c) < return F(c); >//. char c = CHAR_MIN; bool b = safe_ctype(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); // Must wrap toupper to eliminate UB in this case, you can't cast // to unsigned char because the function is called inside transform. Это работает, потому что любая функция, берущая любой из трех типов char, может также принимать два других типа char. Это приводит к двум функциям, которые могут обрабатывать любой из типов:
int ord(char c) < return (unsigned char)c; >char chr(int n) < assert(0 // Ord and chr are named to match similar functions in other languages // and libraries. Ord (c) всегда дает вам неотрицательное значение - даже если он прошел отрицательный char или отрицательный знак char - и chr принимает любое значение ord производит и возвращает тот же самый char.
На практике я, скорее всего, просто использовал бы беззнаковые char вместо их использования, но они вкратце завершают листинг, обеспечивают удобное место для добавления проверки ошибок для int-to-w9812 > и будут короче и более ясно, когда вам нужно использовать их несколько раз в непосредственной близости.
Как преобразовать char в int
С++ является статически типизированным языком программирования. То есть если мы определили для переменной какой-то тип данных, то в последующем мы этот тип изменить не сможем. Соответственно переменная может получить значения только того типа, который она представляет. Однако нередко возникает необходимость присвоить переменной значения каких-то других типов. И в этом случае применяются преобразования типов.
Ряд преобразований компилятор может производить неявно, то есть автоматически. Например:
#include int main() < unsigned int age; std::cout #include int main() < unsigned int age; std::cout g++:error: narrowing conversion of '-25' from 'int' to 'unsigned int' [-Wnarrowing]Примеры неявных преобразований
Рассмотрим, как выполняются некоторые базовые преобразования:
-
Переменной типа bool присваивается значение другого типа. В этом случае переменная получает false , если значение равно 0. Во всех остальных случаях переменная получает true .
bool a = 1; // true bool b = 0; // false bool c = 'g'; // true bool d = 3.4; // true
int c = true; // 1 double d = false; // 0
int a = 3.4; // 3 int b = 3.6; // 3
float a = 35005; // 35005 double b = 3500500000033; // 3.5005e+012
unsigned char a = -5; // 251 unsigned short b = -3500; // 62036 unsigned int c = -50000000; // 4244967296
Преобразования в арифметических операциях
В арифметических операциях необходимо, чтобы оба операнда представляли один и тот же тип. Если же операнды имеют разные типы, то компилятор автоматически выбирает операнд с типом который имеет меньший диапазон значений и пытается его преобразовать в тип второго операнда, который имеет больший диапазон значений. С точки зрения преобразований в операциях типы можно расположить следующим образом в порядке приоритета (от более высокого к более низкому):
- long double
- double
- float
- unsigned long long
- long long
- unsigned long
- long
- unsigned int
- int
То есть, если в операции участвует число типа float и типа long double , то компилятор автоматически преобразует операнд типа float в тип long double (который в соответствии с вышеуказанным списком имеет более высокий приоритет).
Операнды типов char, signed char, unsigned char, short и unsigned short всегда при операциях преобразуются как минимум в тип int
Например, программист заработал за 8 часовой рабочий день 100,2$, рассчитаем его заработок за час:
#include int main() < double sum ; int hours ; double revenuePerHour ; std::cout double.С одной стороны, это может показаться довольно удобно. С другой стороны, подобные преобразования могут привести к нежелательным результатам. Например:
#include int main() < int n ; unsigned int x ; std::cout bool -> char -> short -> int -> double -> long doublebool -> char -> short -> int -> long -> long long
unsigned char -> unsigned short -> unsigned int -> unsigned long
float -> double -> long double
Примеры безопасных преобразований:
short a = 'g'; // преобразование из char в short int b = 10; double c = b; // преобразование из int в double float d = 3.4; double e = d; // преобразование из float в double double f = 35; // преобразование из int в doubleНо также есть опасные преобразования. При подобных преобразованиях мы потенциально можем потерять точность данных. Как правило, это преобразования от типа с большей разрядностью к типу с меньшей разрядностью.
unsigned int a = -25; // 4294967271 unsigned short b = -3500; // 62036В данном случае переменным a и b присваивается значения, которые выходят за пределы диапазона допустимых значений для данных типов.
И в подобных примерах многое зависит от компилятора. В ряде случаев компиляторы при компиляции выдают предупреждение, тем не менее программа может быть успешно скомпилирована. В других случаях компиляторы не выдают никакого предупреждения. Собственно в этом и заключается опасность, что программа успешно компилируется, но тем не менее существует риск потери точности данных. Значение переменной - это всего лишь набор битов в памяти, которые интерпретируются в соответствии с определенным типом. И для разных типов один и тот же набор битов может интерпретироваться по разному. Поэтому важно учитывать диапазоны значений для того или иного типа при присвоении переменной значения.
Если речь идет об инициализации переменных, то, чтобы избежать опасных преобразований, когда может произойти потеря точности, рекомендуется использовать инициализацию в фигурных скобках:
unsigned int a ; // ! Ошибка unsigned short b ; // ! ОшибкаВ этом случае компилятор сгенерирует ошибку, и программа не скомпилируется.
Явные преобразования типов
Для выполнения явных преобразований типов (explicit type conversion) применяется оператор static_cast
static_cast(value)Данный оператор преобразует значение в круглых скобках - value к типу, который указан в угловых скобках - type . Слово static в названии оператора отражает тот факт, что приведение проверяется статически, то есть во время компиляции.
Применение оператора static_cast указывает компилятору, что мы уверены, что в этом месте надо применить преобразование, поэтому даже при инициализации в фигурных скобках компилятор не сгенерирует ошибку. Например, программист заработал за 8 часовой рабочий день 100,2$, рассчитаем его заработок за час, но в виде значения unsigned int :
#include int main() < double sum ; unsigned int hours ; unsigned int revenuePerHour < static_cast(sum/hours) >; // revenuePerHour = 12 std::cout (тип) значениеТо есть перед преобразуемым значением в круглых скобках указывался тип, в который надо выполнить преобразование. Например, используем эту операцию в ранее приведенном коде:
#include int main() < double sum ; unsigned int hours ; unsigned int revenuePerHour < (unsigned int)sum/hours>; // revenuePerHour = 12 std::cout static_cast .
Как преобразовать char в int
Віримо в перемогу ЗСУ!
Працюємо з 09:00 до 18:00 Пн-Сб Працюємо з 09:00 до 19:00 Пн-Пт --> Магазин у відпустці до 19.08.2023 -->
- Ваша корзина пуста!
- Главная
- Статьи
- Преобразование Char в Integer и обратно
Преобразование целочисленных переменных int в символьные переменные char в Arduino IDE - довольно простой процесс, но заслуживающий отдельной напоминалки. Сложнее всего понять зачем вообще нужен тип Char. Напомню, что это однобайтный символьный тип.
Для преобразования Int в Char потребуется сначала переделать integer в строку String, после чего конвертировать String в массив Char. Все так закручено специально, чтобы никто не догадался 🙂
Давайте для начала рассмотрим более простой вариант - преобразование символа Char в Integer, а затем перейдем к основному вопросу.
Шаг 1: Char в Integer
Для конвертации char в integer используйте следующую короткую комбинацию:
int a;
char b;
a=b-'0';
Шаг 2: Integer в Char
В следующем примере будет задействована вспомогательная переменная String. И самое сложное здесь - это преобразование в массив символов при помощи специальной функции.
Код выглядит следующим образом:
int a=1;
char b[2];
String str;
str=String(a);
str.toCharArray(b,2);
Используя этот пример, вы преобразуете integer в char. Однако, в полученном массиве поместится только цифра в пределах от -9 до 99. Для большего количества цифр вам необходимо будет увеличить размер массива и вместо записи:
char b[2];
Нужно будет вставить
char b[5];
таким образом можно будет отобразить в символах integer, который занимает 5 символов. Так же можно использовать массив char и другой длинны.
Спасибо за внимание! До новых встреч!
Arduino UNO R3
Плата контроллера, полюбившаяся всем почитателям этой марки Arduino на базе микропроцессора ATmega3..
Винт М3х30мм оцинкованный
Винт оцинкованный с резьбой М3 для крепления элементов любительских проектовДлина резьбы 30 мм..
Аудио штекер 3,5мм папа
Аудиоштекер 3,5 мм используется для удлиннителей аудиосигнала, для передачи сигнала с аудиоразъема в..
Модуль термопары К-типа MAX6675 0. +1024°C
Модуль для измерения температуры термопары на основе специализированной микросхемы MAX6675Диапа..
Джойстик 3 оси аналоговый влагозащищенный с кнопкой
Джойстик аналоговый для установки в плоскую панельВлагозащищенной является только верхняя часть джой..