Как преобразовать int в double c
Перейти к содержимому

Как преобразовать int в double c

  • автор:

Преобразование int в double внутри тела метода в C#

Пишу простой метод (калькулятор), принимающий на вход три параметра (string — что за операция будет применена, int a — первый операнд, int b — второй операнд), но нужно как то реализовать операцию деления (т.е. прям внутри метода переконвертировать переменную «result», переменную «a» и переменную «b» в double). Как это можно сделать максимально просто?

static int Calc(String Operation, int a, int b) < int result = 0; if (Operation == "sum") < result = a + b; >else if (Operation == "multiple") < result = a * b; >else if (Operation == "minus") < result = a - b; >else if(Operation == "devide") < double.Parse(result) = double.Parse(a) / double.Parse(b); >return result; > 

Отслеживать
задан 12 окт 2022 в 6:11
1 1 1 бронзовый знак

Привести один из аргументов к double, например (double)a/b будет достаточно. Parse — это для строк. Ну, и над результатом никаких операций не нужно. Не забудьте проверить b на ноль, преподаватель наверняка обратить на это внимание. Ну, и метод должен возвращать double.

12 окт 2022 в 6:39
А как отдельный if в методе будет возвращать double, если остальные if в этом методе возвращают int?
12 окт 2022 в 9:36

Никак. C# язык со строгой типизацией. Поэтому result и должен быть double, и метод должен возвращать double. При этом явно к double результат сложения двух целых не обязательно — это произойдёт автоматически: learn.microsoft.com/en-us/dotnet/csharp/language-reference/…

Как преобразовать int в double c

Если в арифметических операциях участвуют значения разных типов, то компилятор неявно пытается привести их к одному типу. Кроме того, когда мы присваиваем переменной какое-либо значение, это значение всегда приводится к типу переменной. Например:

char c = 6; int d = c;

Переменной d, которая представляет тип int, присваивается значение типа char, поэтому компилятор выполняет приведение значения от типа char к типу int.

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

Рассмотрим, какие преобразования применяет компилятор при арифметических операциях:

  1. Если один из операндов имеет тип long double , то второй операнд тоже будет преобразован в тип long double
  2. Если предыдущий пункт не выполняется и если один из операндов имеет тип double , то второй операнд тоже будет преобразован к типу double
  3. Если предыдущий пункт не выполняется и если один из операндов имеет тип float , то второй операнд тоже будет преобразован к типу float
  4. Если предыдущий пункт не выполняется и если один из операндов имеет тип unsigned long int , то второй операнд тоже будет преобразован к типу unsigned long int
  5. Если предыдущий пункт не выполняется и если один из операндов имеет тип long , то второй операнд тоже будет преобразован к типу long
  6. Если предыдущий пункт не выполняется и если один из операндов имеет тип unsigned , то второй операнд тоже будет преобразован к типу unsigned
  7. Если предыдущий пункт не выполняется то оба операнда приводятся к типу int
int a = 10; #include int main(void) < int number1 = 10; double number2 = 4; double result = number1 + number2; // 14.000000 printf("result = %f \n", result); // result = 14.000000 return 0; >

В выражении number1 + number2 число number2 представляет тип double , поэтому число number1 будет автоматически приводиться к числу double. И результат операции сложения также будет представлять тип double .

Операция преобразования

С помощью специальной операции преобразования мы можем явным образом привести данные к нужному типу. Например:

int a = 10; int b = 4; int c = a / b; // 2 double d = a / b; // 2.00000 double e = (double)a / (double)b; // 2.50000 printf("c = %d \n", c); printf("d = %f \n", d); printf("e = %f \n", e);

В выражении int c = a / b; результат деления будет целочисленный — 2, при котором дробная часть будет отброшена, так как оба операнда операции представляют целые числа.

В выражении double d = a / b; результат деления будет представлять вещественное число — 2.00000, но так как оба операнда являются целыми числами, то опять же результат операции будет представлять целое число 2, и только поле выполнения деления произойдет присвоение результата переменной d с приведением значения 2 от типа int к типу double.

В выражении double e = (double)a / (double)b применяется явное преобразование данных к типу double, поэтому и результат деления будет представлять вещественное число — 2.50000.

Для выполнения операции приведении в скобках указывается тот тип, к которому надо привести значение:

int number = 70; char symbol = (char) number; printf("symbol = %c \n", symbol); // F printf("symbol (int code) = %d \n", symbol); // 70

В ряде случаев преобразования сопровождаются потерей информации, например, когда числа большей разрядности (скажем размером 4 байт) получаем число меньшей разрядности (например, в 2 байта). Без потери информации проходят следующие цепочки преобразований:

char -> short -> int -> long

unsigned char -> unsigned short -> unsigned int -> unsigned long

float -> double -> long double

При всех остальных преобразованиях, которые не входят в эти цепочки, мы можем столкнуться с потерей точности данных. Так, в примере выше преобразование от int к char не является безопасным, поэтому к таким преобразованиям следует относиться с осторожностью. Например:

#include int main(void) < int number1 = 300; char code = number1; // потеря точности - число number1 усекается до 1 байта printf("code = %d \n", code); // code = 44 return 0; short number2 = 100000; // потеря точности - число 100000 усекается до 2 байт printf("number2 = %d \n", number2); // number2 = -31072 >

Здесь две ситуации небезопасных преобразований. В первом случае число типа int , которое равно 300, присваивается переменной типа char . В итоге переменная code будет равна 44. Почему? Число 300 в двоичной системе:

0000000100101100

Оставляем только первый младший байт:

00101100

И у нас получается число 44 в десятичной системе.

Во втором случае число 100000 (которое по умолчанию представляет тип int ), усекается до разрядности типа short — до двух байт.

short number = 100000;

В итоге число number в реальности будет равно -31072.

2 int to double

Author24 — интернет-сервис помощи студентам

Вот такой вопрос. В памяти хранится 2 int числа — рубли и копейки, при выводе выводятся через запятую.
В задании нужно поделить введенное количество денег на double.
Вопрос — как мне переделать два int числа в double, то есть если а=355, в=54, то требуемое мне число double должно иметь вид 355,54.
Спасибо.

94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
Ответы с готовыми решениями:

Преобразовать 2 числа int в 1 число float(double) | double int1.int2
Всем привет. Изучая азы C++, столкнулся с такой проблемой. Есть два значения типа int, их.

Double, int , long double
Как вычислить диапазоны типов вручную указанных в название темы?

int* to double*
double* myDoublePtr; int myInt = 5; int* myIntPtr; myIntPtr = &myInt; // cout.

Как преобразовать int в double c

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

Ряд преобразований компилятор может производить неявно, то есть автоматически. Например:

#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

Преобразования в арифметических операциях

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

  1. long double
  2. double
  3. float
  4. unsigned long long
  5. long long
  6. unsigned long
  7. long
  8. unsigned int
  9. 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 double

bool -> 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 .

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *