Создать объект который вычисляет значение целочисленного арифметического выражения

Арифметические операторы (справочник по C#)

Следующие операторы выполняют арифметические операции с операндами числовых типов:

• унарные — ++ (приращение), — (уменьшение), + (плюс) и — (минус);
• бинарные — * (умножение), / (деление), % (остаток от деления), + (сложение) и — (вычитание).

Эти операторы поддерживаются всеми целочисленными типами и типами с плавающей запятой.

В случае целочисленных типов эти операторы (за исключением операторов ++ и — ) определяются для типов int , uint , long и ulong . Если операнды принадлежат к другим целочисленным типам ( sbyte , byte , short , ushort или char ), их значения преобразуются в тип int , который также является типом результата операции. Если операнды принадлежат к разным целочисленным типам или типам с плавающей запятой, их значения преобразуются в ближайший содержащий тип, если такой тип существует. Дополнительные сведения см. в разделе Числовые повышения уровня в статье Спецификации языка C#. Операторы ++ и — определяются для всех целочисленных числовых типов и числовых типов с плавающей запятой, а также типа char. Тип результата выражения сложного назначения является типом левого операнда.

Оператор инкремента ++

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

Оператор инкремента поддерживается в двух формах: постфиксный оператор инкремента ( x++ ) и префиксный оператор инкремента ( ++x ).

Постфиксный оператор приращения

Результатом x++ является значение x перед выполнением операции, как показано в следующем примере:

int i = 3; Console.WriteLine(i); // output: 3 Console.WriteLine(i++); // output: 3 Console.WriteLine(i); // output: 4 

Префиксный оператор инкремента

Результатом ++x является значение x после выполнения операции, как показано в следующем примере:

double a = 1.5; Console.WriteLine(a); // output: 1.5 Console.WriteLine(++a); // output: 2.5 Console.WriteLine(a); // output: 2.5 

Оператор декремента —

Унарный оператор декремента — уменьшает операнд на 1. Операндом должна быть переменная, свойство или индексатор.

Оператор декремента поддерживается в двух формах: постфиксный оператор декремента ( x— ) и префиксный оператор декремента ( —x ).

Постфиксный оператор уменьшения

Результатом x— является значение x перед выполнением операции, как показано в следующем примере:

int i = 3; Console.WriteLine(i); // output: 3 Console.WriteLine(i--); // output: 3 Console.WriteLine(i); // output: 2 

Префиксный оператор декремента

Результатом —x является значение x после выполнения операции, как показано в следующем примере:

double a = 1.5; Console.WriteLine(a); // output: 1.5 Console.WriteLine(--a); // output: 0.5 Console.WriteLine(a); // output: 0.5 

Операторы унарного плюса и минуса

Унарный оператор + возвращает значение полученного операнда. Унарный оператор — изменяет знак операнда на противоположный.

Console.WriteLine(+4); // output: 4 Console.WriteLine(-4); // output: -4 Console.WriteLine(-(-4)); // output: 4 uint a = 5; var b = -a; Console.WriteLine(b); // output: -5 Console.WriteLine(b.GetType()); // output: System.Int64 Console.WriteLine(-double.NaN); // output: NaN 

Тип ulong не поддерживает унарный оператор — .

Оператор умножения *

Оператор умножения * вычисляет произведение операндов:

Console.WriteLine(5 * 2); // output: 10 Console.WriteLine(0.5 * 2.5); // output: 1.25 Console.WriteLine(0.1m * 23.4m); // output: 2.34 

Оператор деления /

Оператор деления / делит левый операнд на правый.

Деление целых чисел

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

Console.WriteLine(13 / 5); // output: 2 Console.WriteLine(-13 / 5); // output: -2 Console.WriteLine(13 / -5); // output: -2 Console.WriteLine(-13 / -5); // output: 2 

Чтобы получить частное двух операндов в виде числа с плавающей запятой, используйте тип float , double или decimal :

Console.WriteLine(13 / 5.0); // output: 2.6 int a = 13; int b = 5; Console.WriteLine((double)a / b); // output: 2.6 

Деление чисел с плавающей запятой

Для типов float , double и decimal результатом оператора / является частное двух операндов:

Console.WriteLine(16.8f / 4.1f); // output: 4.097561 Console.WriteLine(16.8d / 4.1d); // output: 4.09756097560976 Console.WriteLine(16.8m / 4.1m); // output: 4.0975609756097560975609756098 

Если один из операндов — это decimal , второй операнд не может быть ни float , ни double , так как ни float , ни double не преобразуется неявно в тип decimal . Необходимо явным образом преобразовать операнд float или double в тип decimal . Дополнительные сведения о числовых преобразованиях см. в разделе Встроенные числовые преобразования.

Оператор остатка %

Оператор остатка % вычисляет остаток от деления левого операнда на правый.

Целочисленный остаток

Для целочисленных операндов результатом a % b является значение, произведенное a — (a / b) * b . Знак ненулевого остатка такой же, как и у левого операнда, как показано в следующем примере:

Console.WriteLine(5 % 4); // output: 1 Console.WriteLine(5 % -4); // output: 1 Console.WriteLine(-5 % 4); // output: -1 Console.WriteLine(-5 % -4); // output: -1 

Используйте метод Math.DivRem для вычисления результатов как целочисленного деления, так и определения остатка.

Остаток с плавающей запятой

Для операндов типа float и double результатом x % y для конечных x и y будет значение z , так что:

• знак z , если отлично от нуля, совпадает со знаком x ;
• абсолютное значение z является значением, произведенным |x| — n * |y| , где n — это наибольшее возможное целое число, которое меньше или равно |x| / |y| , а |x| и |y| являются абсолютными значениями x и y , соответственно.

Этот метод вычисления остатка аналогичен тому, который использовался для целочисленных операндов, но отличается от спецификации IEEE 754. Если вам нужна операция вычисления остатка, которая соответствует спецификации IEEE 754, используйте метод Math.IEEERemainder.

Сведения о поведение оператора % в случае неконечных операндов см. в разделе Оператор остаткаспецификации языка C#.

Для операндов decimal оператор остатка % эквивалентен оператору остатка типа System.Decimal.

В следующем примере показано поведение оператора остатка для операндов с плавающей запятой:

Console.WriteLine(-5.2f % 2.0f); // output: -1.2 Console.WriteLine(5.9 % 3.1); // output: 2.8 Console.WriteLine(5.9m % 3.1m); // output: 2.8 

Оператор сложения +

Оператор сложения + вычисляет сумму своих операндов:

Console.WriteLine(5 + 4); // output: 9 Console.WriteLine(5 + 4.3); // output: 9.3 Console.WriteLine(5.1m + 4.2m); // output: 9.3 

Кроме того, оператор + можно использовать для объединения строк и делегатов. Дополнительные сведения см. в статье Операторы + и += .

Оператор вычитания —

Оператор вычитания — вычитает правый операнд из левого:

Console.WriteLine(47 - 3); // output: 44 Console.WriteLine(5 - 4.3); // output: 0.7 Console.WriteLine(7.5m - 2.3m); // output: 5.2 

Кроме того, оператор — можно использовать для удаления делегатов. Дополнительные сведения см. в статье Операторы — и -= .

Составное присваивание

Для бинарного оператора op выражение составного присваивания в форме

x op= y 

x = x op y 

за исключением того, что x вычисляется только один раз.

Следующий пример иллюстрирует использование составного присваивания с арифметическими операторами:

int a = 5; a += 9; Console.WriteLine(a); // output: 14 a -= 4; Console.WriteLine(a); // output: 10 a *= 2; Console.WriteLine(a); // output: 20 a /= 4; Console.WriteLine(a); // output: 5 a %= 3; Console.WriteLine(a); // output: 2 

Из-за восходящих приведений результат операции op может быть невозможно неявно преобразовать в тип T из x . В этом случае, если op является предопределенным оператором, и результат операции является явно преобразуемым в тип T x , выражение составного присваивания формы x op= y эквивалентно x = (T)(x op y) , за исключением того, что x вычисляется только один раз. В следующем примере продемонстрировано такое поведение.

byte a = 200; byte b = 100; var c = a + b; Console.WriteLine(c.GetType()); // output: System.Int32 Console.WriteLine(c); // output: 300 a += b; Console.WriteLine(a); // output: 44 

В предыдущем примере значение является результатом преобразования значения 44 300 в byte тип.

В контексте проверка переполнения проверка, приведенный выше пример вызывает исключениеOverflowException. Дополнительные сведения см. в разделе арифметического переполнения целочисленного числа.

Вы также можете использовать операторы += и -= для подписки и отмены подписки на события соответственно. Дополнительные сведения см. в разделе Практическое руководство. Подписка и отмена подписки на события.

Очередность и ассоциативность операторов

В следующем списке перечислены арифметические операторы в порядке убывания приоритета:

• Постфиксный инкремент x++ и декремент x—
• Префиксный инкремент ++x и декремент —x , унарные операторы + и —
• Мультипликативные операторы * , / , и %
• Аддитивные операторы + и —

Бинарные арифметические операторы имеют левую ассоциативность. То есть операторы с одинаковым приоритетом вычисляются в направлении слева направо.

Порядок вычисления, определяемый приоритетом и ассоциативностью операторов, можно изменить с помощью скобок ( () ).

Console.WriteLine(2 + 2 * 2); // output: 6 Console.WriteLine((2 + 2) * 2); // output: 8 Console.WriteLine(9 / 5 / 2); // output: 0 Console.WriteLine(9 / (5 / 2)); // output: 4 

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

Арифметическое переполнение и деление на нуль

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

Целочисленное арифметическое переполнение

Деление целого числа на ноль всегда вызывает исключение DivideByZeroException.

В случае целочисленного арифметического переполнения итоговое поведение определяется проверяемым или непроверяемым контекстом проверки переполнения:

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

Вместе с проверяемыми и непроверяемыми операторами можно использовать операторы checked и unchecked , чтобы управлять контекстом проверки переполнения, в котором вычисляется выражение:

int a = int.MaxValue; int b = 3; Console.WriteLine(unchecked(a + b)); // output: -2147483646 try < int d = checked(a + b); >catch(OverflowException) < Console.WriteLine($"Overflow occurred when adding to ."); > 

По умолчанию арифметические операции выполняются в непроверяемом контексте.

Арифметическое переполнение с плавающей запятой

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

double a = 1.0 / 0.0; Console.WriteLine(a); // output: Infinity Console.WriteLine(double.IsInfinity(a)); // output: True Console.WriteLine(double.MaxValue + double.MaxValue); // output: Infinity double b = 0.0 / 0.0; Console.WriteLine(b); // output: NaN Console.WriteLine(double.IsNaN(b)); // output: True 

Для операндов типа decimal арифметическое переполнение всегда выдает исключение OverflowException, а деление на нуль — DivideByZeroException.

Ошибки округления

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

Console.WriteLine(.41f % .2f); // output: 0.00999999 double a = 0.1; double b = 3 * a; Console.WriteLine(b == 0.3); // output: False Console.WriteLine(b - 0.3); // output: 5.55111512312578E-17 decimal c = 1 / 3.0m; decimal d = 3 * c; Console.WriteLine(d == 1.0m); // output: False Console.WriteLine(d); // output: 0.9999999999999999999999999999 

См. заметки в справочной документации по System.Double, System.Single и System.Decimal.

Возможность перегрузки оператора

Определяемый пользователем тип может перегружать унарные ( ++ , — , + и — ) и бинарные ( * , / , % , + и — ) арифметические операторы. При перегрузке бинарного оператора соответствующий оператор составного присваивания также неявно перегружается. Явная перегрузка составного оператора присваивания для пользовательского типа невозможна.

Проверенные операторы, определяемые пользователем

Начиная с C# 11 при перегрузке арифметического оператора можно использовать ключевое слово checked , чтобы определить проверенную версию этого оператора. Следующий пример показывает, как это сделать:

public record struct Point(int X, int Y) < public static Point operator checked +(Point left, Point right) < checked < return new Point(left.X + right.X, left.Y + right.Y); >> public static Point operator +(Point left, Point right) < return new Point(left.X + right.X, left.Y + right.Y); >> 

При определении проверенного оператора следует также определить соответствующий оператор без модификатора checked . Проверенный оператор вызывается в проверенном контексте. Оператор без модификатора checked вызывается в непроверенном контексте. Если указать только оператора без модификатора checked , он будет вызываться как в контексте checked , так и в unchecked .

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

• Проверенный оператор вызывает OverflowException.
• Оператор без модификатора checked возвращает экземпляр, который представляет усеченный результат.

Сведения о разнице в поведении встроенных арифметических операторов см. в разделе Арифметическое переполнение и деление на ноль.

Модификатор checked можно использовать только при перегрузке следующих операторов:

• Унарные операторы ++ , — и —
• Бинарные операторы * , / , + и —
• Операторы явного преобразования

Контекст проверки переполнения в теле проверенного оператора не изменяется при наличии модификатора checked . Контекст по умолчанию определяется значением параметра компилятора CheckForOverflowUnderflow. С помощью операторов checked и unchecked можно явно указать контекст проверки переполнения, как показано в примере в начале этого раздела.

Спецификация языка C#

Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:

• Постфиксные операторы инкремента и декремента
• Префиксные операторы инкремента и декремента
• Оператор унарного плюса
• Оператор унарного минуса
• Оператор умножения
• Оператор деления
• Оператор остатка
• Оператор сложения
• Оператор вычитания
• Составное присваивание
• Операторы checked и unchecked
• Восходящие приведения числовых типов

См. также

• Операторы и выражения C#
• System.Math
• System.MathF
• Числовые значения в .NET

Совместная работа с нами на GitHub

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

Создать объект, который вычисляет значение целочисленного арифметического выражения

Скажите, пожалуйста, что не так с кодом, написала, вроде, все работает, но преподаватель говорит, что решение не соответствует поставленной задаче.
Создать объект, который вычисляет значение целочисленного арифметического выражения.
Операция деления заменена на операцию вычисления целочисленного остатка.
Объект обладает следующей функциональностью:
— выполняет первую операцию выражения, в качестве параметров передается первый целочисленный параметр, символ операции (+,-,*,%), второй целочисленный параметр;
— вычисляет вторую и далее операцию, в качестве параметров передается символ операции (+,-,*,%), второй целочисленный параметр;
— возвращает значение вычисленного выражения (значение можно получить после выполнения трех операции).

Написать программу, которая обязательно вводит значения и выполняет первую операцию.
Далее, в цикле осуществляет ввод очередной операции и значения второго аргумента.
Если на месте операции введен символ «C», то программа завершает работу, иначе выполняет очередную операцию и выводит результат каждой третьей операции.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79

#include #include #include using namespace std; class Fraction { int x,y,i = 1; char ch; public: Fraction(int x,int y,char ch) { this->x = x; this->y = y; this->ch = ch; } void Calculate(int &x,int &y,char &ch){ while(ch != 67) { if(i > 1) { cin >> ch; if(ch == 67) { break; } cin >> y; } if(ch == 42) { x = x * y; Cout(x); } else if(ch == 43) { x = x + y; Cout(x); } else if(ch == 45) { x = x - y; Cout(x); } else { x = x % y; Cout(x); } i++; } } void Cout(int &x){ if(!(i % 3)) { if(i > 3) { cout  endl; } cout  x; } } ~Fraction(){ } }; int main() { int x,y; char ch; cin >> x >> ch >> y; Fraction a(x,y,ch); return(0); }

Создать объект который вычисляет значение целочисленного арифметического выражения

Арифметические операции производятся над числами. Значения, которые участвуют в операции, называются операндами. В языке программирования C++ арифметические операции могут быть бинарными (производятся над двумя операндами) и унарными (выполняются над одним операндом). К бинарным операциям относят следующие:

+ Операция сложения возвращает сумму двух чисел:

int a ; int b ; int c ; // 17 int d ; // 11

В этом примере результат операций применяется для инициализации переменных, но мы также можем использовать операцию присвоения для установки значения переменных:

int a ; int b ; int c = a + b; // 17 int d = 4 + b; // 11

int a ; int b ; int c ; // 3 int d ; // -3

int a ; int b ; int c ; // 70 int d ; // 28

int a ; int b ; int c ; // c = 5 int d ; // d = 0

При делении стоит быть внимательным, так как если в операции участвуют два целых числа, то дробная часть (при ее наличии) будет отбрасываться, даже если результат присваивается переменной float или double :

#include int main() < int a ; int b ; float c ; // c = 5 double d ; // d = 0 std::cout #include int main() < float a ; int b ; float c ; // c = 5.2 double d ; // d = 0.8 std::cout %
 
Операция получения остатка от целочисленного деления:
 
int a ; int b ; int c ; // c = 26 % 5 = 26 - 5 * 5 = 1 int d ; // d = 4 % 5 = 4
Некоторые особенности при работе с числами с плавающей точкой
При сложении или вычитании чисел с плавающей точкой, которые сильно отличаются по значению, следует проявлять осторожность. Например, сложим число 1.23E-4 ( 0.000123 ) и 3.65E+6 (3650000). Мы ожидаем, что сумма будет равна 3650000,000123 . Но при преобразовании в число с плавающей запятой с точностью до семи цифр это становится следующим
3.650000E+06 + 1.230000E-04 = 3.650000E+06
Или соответствующий код на С++:
#include int main() < float num1< 1.23E-4 >; // 0.000123 float num2< 3.65E+6 >; // 3650000 float sum ; // sum =3.65e+06 std::cout
То есть первое число никак не изменилось, поскольку для хранения точности отводится только 7 цифр.






Также стоит отметить, что стандарт IEEE, который реализуется компиляторами С++, определяет специальные значения для чисел с плавающей точкой, в которых мантисса на бинарном уровне состоит только из нулей, а экспонента, которая состоит из одних единиц, в зависимости от знака представляет значения +infinity (плюс бесконечность +∞) и -infinity (минус бесконечность -∞). И при делении положительного числа на ноль, результатом будет +infinity , а при делении отрицательного числа на ноль - -infinity .
Другое специальное значение с плавающей точкой, определенное этим стандартом, представляет значение NaN (не число). Это значение представляет результат операции, который не определяется математически, например, когда ноль делится на ноль или бесконечность на бесконечность. Результатом любой операции, в которой один или оба операнда являются NaN , также является NaN .
Для демонстрации рассмотрим следующую программу:
#include int main() < double a< 1.5 >, b<>, c<>, d ; double result < a / b >; std::cout  
1.5/0 = inf -1.5/0 = -inf 0/0 = nan nan + 1.5 = nan
Инкремент и декремент
Также есть две унарные арифметические операции, которые производятся над одним числом: ++ (инкремент) и -- (декремент). Каждая из операций имеет две разновидности: префиксная и постфиксная:

   Префиксный инкремент . Увеличивает значение переменной на единицу и полученный результат используется как значение выражения ++x







#include int main() < int a ; int b <++a>; std::cout Постфиксный инкремент.
 
Увеличивает значение переменной на единицу, но значением выражения x++ будет то, которое было до увеличения на единицу
 
#include int main() < int a ; int b ; std::cout Префиксный декремент.
 
Уменьшает значение переменной на единицу, и полученное значение используется как значение выражения --x
 
#include int main() < int a ; int b ; std::cout Постфиксный декремент.
 
Уменьшает значение переменной на единицу, но значением выражения x-- будет то, которое было до уменьшения на единицу





 
#include int main() < int a ; int b ; std::cout левоассоциативными - такие операторы выполняются слева направо и правоассоциативными - выполняются справа налево. Подавляющее большинство операторов левоассоциативны (например, бинарные арифметические операции), поэтому большинство выражений оценивается слева направо. Правоассоциативными операторами являются все унарные операторы, различные операторы присваивания и условный оператор.
 
Кроме того, одни операции имеют больший приоритет, чем другие и поэтому выполняются вначале. Операции в порядке уменьшения приоритета:
 
++ (инкремент), -- (декремент)
 
* (умножение), / (деление), % (остаток от деления)
 
+ (сложение), - (вычитание)
 
 
Приоритет операций следует учитывать при выполнении набора арифметических выражений:
 
int a = 8; int b = 7; int c = a + 5 * ++b; // 48
Хотя операции выполняются слева направо, но вначале будет выполняться операция инкремента ++b , которая увеличит значение переменной b и возвратит его в качестве результата, так как эта операция имеет больший приоритет. Затем выполняется умножение 5 * ++b , и только в последнюю очередь выполняется сложение a + 5 * ++b Следует учитывать, что если в одной инструкции для одной переменной сразу несколько раз вызываются операции инкремента и декремента, то результат может быть неопределенным, и много зависит от конкретного компилятора. Например:
int count ; int result = ++count * 3 + count++ * 5;
Так, и g++, и clang++ скомпилируют данный код, и результат переменной result будет таким, как в принципе и ожидается - 16, но компилятор clang++ также сгенерирует предупреждение.
Переопределение порядка операций
Ввод-вывод, оператор присваивания, арифметические операции
В этом сообщении указывается имя файла и номер строки, в которой обнаружена ошибка ( test.cpp:5 ), а также описание ошибки ( `c' undeclared — объект с именем c не объявлен).






Объявление переменной имеет следующий вид:
Например, переменные n и m типа int можно объявить такой строкой:
int n, m;
Переменную x типа double можно объявить такой строкой:
double x;
Значения переменных сразу после объявления не определены и являются произвольными. Предположение о том, что все переменные первоначально имеют нулевые значения, является ошибочным.
Идентификатор переменной — это ее имя, которое должно быть последовательностью букв латинского алфавита, символа подчеркивания и цифр, начинающейся с буквы. Примеры правильных идентификаторов: а , i , Year , school179 . Имена переменных чувствительны к регистру букв, то есть Number , number , NUMBER и nUMbeR — это четыре разных переменных.
Типы данных
При объявлении переменной мы должны указать ее тип. Существует несколько стандартных типов, кроме того, программист может создавать собственные типы данных. Для представления целых чисел существуют следующие стандартные типы:
В языках С, C++ есть следующие стандартные типы данных для представления целых чисел.
 
 
Тип
 
Описание
 
Размер
 
Диапазон
 
Синоним 
 
 
int
 
Целые числа
 
4 байта
 
-2 31 ..2 31 -1
 

 
 
unsigned int
 
Беззнаковые целые
 
4 байта
 
0..2 32 -1
 
unsigned 
 
 
long int
 
Длинные целые
 
4 байта
 
-2 31 ..2 31 -1
 
long 
 
 
unsigned long
 
Беззнаковые длинные
 
4 байта
 
0..2 32 -1
 

 
 
short int
 
Короткие целые
 
2 байта
 
-2 15 ..2 15 -1
 
short 
 
 
unsigned short
 
Беззнаковые короткие
 
2 байта
 
0..2 16 -1
 


При этом в стандарте языка C++ не оговаривается конкретный размер каждого из вышеперечисленных типов, для каждого компилятора они могут быть своими. Приведенные выше числа верны для компиляторов GCC, MS VC++ , а вот для Borland C++ версии 3.1 размер переменной типа int — 2 байта.
Действительные числа можно записывать в виде десятичных дробей как с фиксированной точкой (например, 3.1415926, 100.001, -10000000.0), так и с плавающей точкой. В последнем случае число имеет вид e 
, где — дробное число (положительное или отрицательное), называемое , а 
— целое число (положительное или отрицательное), называемое . Число, записанное таким образом, равно f×10 p . Фактически, порядок означает, на какое число позиций нужно сдвинуть вправо десятичную точку в записи числа . Если же порядок меньше нуля, то сдвиг десятичной точки осуществляется влево. Примеры записи чисел с плавающей точкой: 3.14e1 означает 31.4 
3.14e5 означает 314000 
3.14e-3 означает 0.00314 
-1e6 означает -1000000 
-1e-6 означает -0.000001
Для представления действительных чисел существует два стандартных типа:
 
 
Имя типа
 
Размер 
 
 
float
 
4 байта 
 
 
double
 
8 байт 

Как правило, для хранения целых чисел следует использовать тип int , а для действительных чисел — double .
Арифметические операторы
Арифметическая инструкция — это некоторое выражение, состоящее из констант, идентификаторов переменных и арифметических операторов, которая завершается точкой с запятой. Самый главный арифметический оператор — это оператор присваивания ‘ = ’, который присваивает одной переменной, идентификатор которой указывается слева от оператора ‘ = ’ значение некоторого выражения, которое стоит справа. Например:
a=2; 
b=a+1;
В последней строке встретился оператор сложения ‘ + ’. Кроме оператора сложения, есть еще операторы вычитания ‘ - ’, умножения ‘ * ’, деления ‘ / ’ и взятия остатка от деления целых чисел ‘ % ’.
Особого внимания заслуживает оператор деления. Если оба его аргумента имеют целочисленный тип (то есть один из типов, перечисленных в первой таблице или целочисленные константы), то этот оператор рассматривается, как оператор деления целых чисел с остатком. Если же хотя бы один из операторов будет иметь дробный тип, то оператор деления выполняется, как оператор деления десятичных дробей.
В арифметическом выражении сначала выполняются слева направо все операторы умножения и деления, затем слева направо все операторы сложения и вычитания, затем справа налево все операторы присваивания. При необходимости порядок действий можно изменить при помощи скобок.
Ввод-вывод
Текстовые строки при выводе на экран необходимо заключать в двойные кавычки. Если хочется вывести на экран несколько объектов (переменных, текстовых строк и т.д.), то их нужно разделять между собой оператором ‘ 
Для того, чтобы считать значение переменной нужно использовать объект ‘ cin ’ и оператор ‘ >> ’, который надо называть . При этом считывание данных будет производиться со стандартного ввода программы, как правило, являющегося клавиатурой. Если хочется за одну операцию считать несколько переменных, то их идентификаторы нужно разделять между собой оператором ‘ >> ’.
Более сложный пример
Обобщим все изложенное выше в более сложной программе, которая находит сумму двух введенных чисел.


Похожие публикации:

Trojan agent что это
Как пустить трафик через wireguard на микротик
Как увеличить кол во строк в excel
Как увеличить разрешение экрана на ноутбуке 1366х768 до 1920ч1080