Операторы C++

Введение

В этом практическом занятии вы научитесь использовать операторы в C++. Вы узнаете, как использовать арифметические операторы, операторы сравнения, логические операторы и битовые операторы.

Предварительный просмотр содержания

Для базовых числовых и логических данных мы используем операторы для работы с ними. Как и в других языках, C++ обеспечивает полную поддержку операторов. Начните изучать их.

• Арифметические операции
• Операции с смешанными типами
• Комплексные операторы присваивания
• Преобразование типов
• Операторы сравнения и логические операторы

Арифметические операции

C++ поддерживает следующие арифметические операторы для чисел:

Все вышеперечисленные операторы - это бинарные операторы, они принимают два операнда. Умножение, деление и остаток имеют преимущество перед сложением и вычитанием.

Важно заметить, что int/int дает int, при этом результат отбрасывается, 1/2 → 0 (а не 0.5).

Операции с различными типами

Если оба операнда арифметической операции принадлежат к одному и тому же типу, операция выполняется в этом типе, и результат принадлежит этому типу. Однако, если два операнда принадлежат к разным типам, компилятор преобразует значение меньшего типа в больший тип (известный как неявное преобразование типа). Затем операция выполняется в большем типе.

Например

/* Testing mix-type arithmetic operations */
#include <iostream>
#include <iomanip>   // needed for formatting floating-point numbers
using namespace std;

int main() {
   int i1 = 2, i2 = 4;
   double d1 = 2.5, d2 = 5.0;

   // floating-points in fixed format with 1 decimal place
   cout<<fixed<<setprecision(1);

   cout << i1 << " + " << i2 << " = " << i1+i2 << endl;  // 6
   cout << d1 << " + " << d2 << " = " << d1+d2 << endl;  // 7.5
   cout << i1 << " + " << d2 << " = " << i1+d2 << endl;  // 7.0  <==

   cout << i1 << " - " << i2 << " = " << i1-i2 << endl;  // -2
   cout << d1 << " - " << d2 << " = " << d1-d2 << endl;  // -2.5
   cout << i1 << " - " << d2 << " = " << i1-d2 << endl;  // -3.0 <==

   cout << i1 << " * " << i2 << " = " << i1*i2 << endl;  // 8
   cout << d1 << " * " << d2 << " = " << d1*d2 << endl;  // 12.5
   cout << i1 << " * " << d2 << " = " << i1*d2 << endl;  // 10.0 <==

   cout << i1 << " / " << i2 << " = " << i1/i2 << endl;  // 0    <==
   cout << d1 << " / " << d2 << " = " << d1/d2 << endl;  // 0.5
   cout << i1 << " / " << d2 << " = " << i1/d2 << endl;  // 0.4  <==
   return 0;
}

Вывод:

2 + 4 = 6
2.5 + 5.0 = 7.5
2 + 5.0 = 7.0
2 - 4 = -2
2.5 - 5.0 = -2.5
2 - 5.0 = -3.0
2 * 4 = 8
2.5 * 5.0 = 12.5
2 * 5.0 = 10.0
2 / 4 = 0
2.5 / 5.0 = 0.5

Переполнение / Переполнение вниз

// Range of int is [-2147483648, 2147483647]
   int i1 = 2147483647;      // max int
   cout << i1 + 1 << endl;   // -2147483648 (overflow)
   cout << i1 * i1 << endl;  // 1

   int i2 = -2147483648;     // min int
   cout << i2 - 1 << endl;   // 2147483647 (underflow)
   cout << i2 * i2 << endl;  // 0

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

Операторы комбинированного присваивания

C++ также предоставляет так называемые комплексные операторы присваивания, перечисленные ниже:

x = 5;
cout << x++ << endl;  // Сохранить x (5); Увеличить x (=6); Вывести старое x (5).
x = 5;
cout << ++x << endl;  // Увеличить x (=6); Вывести x (6).

Неявное преобразование типов против явного приведения типов

Когда вы присваиваете значение базового (встроенного) типа переменной другого базового типа, C++ автоматически преобразует значение в тип приемника, если два типа совместимы. Например:

• Если вы присваиваете значение int переменной double, компилятор автоматически преобразует значение int в double (например, из 1 в 1.0) и присваивает его переменной double.
• Если вы присваиваете значение double переменной int, компилятор автоматически преобразует значение double в значение int (например, из 1.2 в 1) и присваивает его переменной int. Дробная часть будет отброшена и потеряна. Некоторые компиляторы выдают предупреждение/ошибку "возможна потеря точности"; другие нет.

 int i;
 double d;

 i = 3;
 d = i;    // Присвоить значение int переменной double
 cout << "d = " << d << endl;  // 3.0

 d = 5.5;
 i = d;    // Присвоить значение double переменной int
 cout << "i = " << i << endl;  // 5 (отброшено, без предупреждения!)

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

cout << (double)5 << endl;  // int 5 → double 5.0
cout << (int)5.5 << endl;   // double 5.5 → int 5

double aDouble = 5.6;
int anInt = (int)aDouble; // возвращает 5 и присваивает anInt. aDouble не меняется!

// C++ также поддерживает функциональный стиль приведения типа.
cout << double(5) << endl;     // 5.0
cout << int(5.5) << endl;      // 5
cout << int(aDouble) << endl;  // 5

Относительные и логические операторы

Важно отметить, что часто вам нужно сравнивать два значения перед принятием решения о действии, которое необходимо предпринять. C++ предоставляет шесть операторов сравнения (или относительных операторов):

Таблицы истинности выглядят следующим образом:

// Возвращает true, если x находится между 0 и 100 (включительно)
(x >= 0) && (x <= 100)
// неправильно использовать 0 <= x <= 100

// Возвращает true, если x находится вне диапазона от 0 до 100 (включительно)
(x < 0) || (x > 100)   //или
!((x >= 0) && (x <= 100))

// Возвращает true, если год является високосным
// Год является високосным, если он делится на 4, но не делится на 100, или если он делится на 400.
((year % 4 == 0) && (year % 100!= 0)) || (year % 400 == 0)

Резюме

Эта часть относительно простая, вы должны связать ее с предыдущим разделом. Не нужно их запоминать, нужно понять их логику.