Операнды это: 1.3.1. Операнды и операции | Электроника для всех

     х: 00011010 11101011
     г: 00101100 00110110
--------------------------
результат: 00110110 11011101 // это значение 14045

 

      х: 00011010 11101011
—————————
сдвинуто: 01101011 10101100 // это значение 27564

 

      г: 00101100 00110110
---------------------------
сдвинуто: 00000010 11000011 // это значение 707

 

      х: 00011010 11101011
---------------------------
     ~ x: 11100101 00010100 // это значение -6892

 

Примеры кода

Операторы сравнения — cppreference.com

Сравнивает аргументы.

[править] Двустороннее сравнение

Выражения оператора двустороннего сравнения имеют вид

1) Возвращает true , если lhs меньше rhs, false в противном случае.

2) Возвращает true , если lhs больше rhs, false в противном случае.

3) Возвращает true , если lhs меньше или равно rhs, false в противном случае.

4) Возвращает true , если lhs больше или равно rhs, false в противном случае.

5) Возвращает true , если lhs равно rhs, false в противном случае.

6) Возвращает true , если lhs не равно rhs, false в противном случае.

Во всех случаях для встроенных операторов lhs и rhs должны иметь либо

• арифметический или перечисляемый тип (см. Операторы арифметического сравнения ниже)
• тип указателя (см. Операторы сравнения указателей ниже)

после применения стандартных преобразований lvalue-to-rvalue, массива в указатель и функции в указатель. Сравнение не рекомендуется, если оба операнда имеют тип массива до применения этих преобразований. (начиная с C ++ 20)

В любом случае результат будет bool prvalue.

[править] Операторы арифметического сравнения

Если операнды имеют арифметический или перечисляемый тип (с ограниченным или незаданным диапазоном), обычных арифметических преобразований выполняются для обоих операндов в соответствии с правилами для арифметических операторов. Значения сравниваются после преобразований:

[править] Пример

 #include 
int main ()
{
    std :: cout << std :: boolalpha;
    int n = -1;

    int n2 = 1;
    std :: cout << "-1 == 1?" << (n == n2) << '\ n'
              << "Сравнение двух значений со знаком: \ n"
              << "-1 <1?" << (n  1?" << (n> n2) << '\ n';

    беззнаковое int u = 1;
    std :: cout << "Сравнение подписанного и беззнакового: \ n"
              << "-1 <1?" << (n  1?" << (n> u) << '\ n';

    static_assert (sizeof (символ без знака)  1?" << (n> uc) << '\ n';
} 

Выход:

 -1 == 1? ложный
Сравнение двух значений со знаком:
 -1 <1? правда
 -1> 1? ложный
Сравнение подписанного и неподписанного:
 -1 <1? ложный
 -1> 1? правда
Сравнение подписанного и меньшего беззнакового:
 -1 <1? правда
 -1> 1? ложь 

[править] Операторы сравнения указателей

Операторы сравнения могут использоваться для сравнения двух указателей.

Для сравнения следующих пар указателей можно использовать только операторы равенства (operator == и operator! =):

• два указателя на элементы
• константа нулевого указателя с указателем или указателем на член

Во-первых, преобразования указателя (преобразования указателя на элементы, если аргументы являются указателями на элементы), преобразования указателя функций (начиная с C ++ 17) и квалификационные преобразования применяются к обоим операндам для получения составного указателя типа , как следует

2) Если один операнд является константой нулевого указателя, а другой - указателем, составной тип в точности соответствует типу указателя

• указатель на cv1 недействителен, и
• указатель на cv2 T, где T - тип объекта или пустота,

• P1, указатель на (возможно cv-квалифицированный) T1, и
• P2, указатель на (возможно cv-квалифицированный) T2,

• MP1, указатель на член T1 типа (возможно cv-квалифицированный) U1, и
• MP2, указатель на член T2 типа (возможно cv-квалифицированный) U2,

6) Если типы операндов P1 и P2 представляют собой многоуровневый смешанный указатель и указатель на типы элементов с одинаковым количеством уровней, которые отличаются только квалификациями cv на любом из уровней, тип составного указателя является cv- комбинированный тип П1 и П2

В приведенном выше определении cv-объединенный тип двух типов указателей P1 и P2 является типом P3, который имеет такое же количество уровней и тип на каждом уровне, что и P1, за исключением того, что cv-квалификации на каждом уровне устанавливаются следующим образом :

a) на каждом уровне, кроме высшего, объединение cv-квалификаций P1 и P2 на этом уровне

b) если результирующая cv-квалификация на любом уровне отличается от cv-квалификации P1 или P2 на том же уровне, то const добавляется к каждому уровню между верхним и этим уровнем.

Например, тип составного указателя void * и const int * - const void *. Тип составного указателя для int ** и const int ** - const int * const *. Обратите внимание, что до разрешения CWG1512 нельзя сравнивать int ** и const int **.

Обратите внимание, что это означает, что любой указатель можно сравнить с void *.

Результат сравнения двух указателей на объекты (после преобразований) определяется следующим образом:

1) Если два указателя указывают на разные элементы одного и того же массива или на подобъекты в разных элементах одного и того же массива, указатель на элемент с более высоким нижним индексом сравнивает большее значение . Другими словами, результаты сравнения указателей такие же, как и результат сравнения индексов элементов, на которые они указывают.

2) Если один указатель указывает на элемент массива или на подобъект элемента массива, а другой указатель указывает на один за последним элементом массива, последний указатель сравнивается с большим .Указатели на объекты, не являющиеся массивами, обрабатываются как указатели на массивы из одного: & obj + 1 сравнивает больше, чем & obj .

Результат сравнения на равенство двух указателей (после преобразований) определяется следующим образом:

1) Если оба указателя являются значениями нулевого указателя, они сравниваются равными

2) Если указатели являются указателями на функцию и указывают на одну и ту же функцию, тогда сравнить равно

4) Все остальные указатели сравнивают неравно

Результат сравнения двух указателей на члены (после преобразований) определяется следующим образом:

1) Если оба указателя на член являются значениями указателя на нулевой член, они сравниваются равными .

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

3) В противном случае, если любой из них является указателем на виртуальную функцию-член, результат не указан.

4) В противном случае два указателя на член сравниваются как равные тогда и только тогда, когда они будут ссылаться на один и тот же член одного и того же самого производного объекта или того же подобъекта, если они были разыменованы с помощью гипотетического объекта соответствующего типа класса

5) Иначе сравнивают неравно.

Если указатель p сравнит равное с указателем q , p <= q и p> = q оба дают true и p и p> q оба дают ложь .

Если указатель p сравнивает больше , чем указатель q , то p> = q , p> q , q <= p и q

все дают true и p <= q , p , q> = p и q> p все дают false .

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

 int x, y;

bool f (int * p, int * q) {return p 
 В разрешении перегрузки по отношению к определяемым пользователем операторам для каждой пары повышенных арифметических типов  L  и  R , включая типы перечисления, следующие сигнатуры функций участвуют в разрешении перегрузки:
 оператор bool <(L, R);
 оператор bool> (L, R);
 логический оператор <= (L, R);
 оператор bool> = (L, R);
 оператор логического типа == (L, R);
 оператор логического типа! = (L, R);
 Для каждого типа  P , который является либо указателем на объект, либо указателем на функцию, следующие сигнатуры функций участвуют в разрешении перегрузки:
 оператор логического типа <(P, P);
 оператор bool> (P, P);
 оператор логического типа <= (P, P);
 оператор логического типа> = (P, P);
 оператор логического типа == (P, P);
 оператор логического типа! = (P, P);
 Для каждого типа  MP , который является указателем на объект-член или указатель на функцию-член или std :: nullptr_t, в разрешении перегрузки участвуют следующие сигнатуры функций:
 оператор bool == (MP, MP);
 оператор логического типа! = (MP, MP);
 [редактировать] Пример 
 #include 
struct Foo {int n1; int n2; };
союз Union {int n; двойной d; };
int main ()
{
    std :: cout << std :: boolalpha;

    char a [4] = "abc";

    символ * p1 = & a [1];
    символ * p2 = & a [2];
    std :: cout << "Указатели на элементы массива: \ n"
              << "p1 == p2?" << (p1 == p2) << '\ n'
              << "p1 
 Выход:
 Указатели на элементы массива:
p1 == p2? ложный
p1 
 [править] Примечания 
 Поскольку эти операторы группируются слева направо, анализируется выражение a 
 #include 
int main () {
    int a = 3, b = 2, c = 1;
    std :: cout << std :: boolalpha
        << (a 
 Обычным требованием для определяемого пользователем оператора <является строгое слабое упорядочение. В частности, этого требуют стандартные алгоритмы и контейнеры, работающие с типами сравнения: std :: sort, std :: max_element, std :: map и т. Д.
 Хотя результаты сравнения указателей случайного происхождения (например, не все указывают на элементы одного и того же массива) не определены, многие реализации обеспечивают строгий общий порядок указателей, например если они реализованы как адреса в непрерывном виртуальном адресном пространстве. Те реализации, которые этого не делают (например, когда не все биты указателя являются частью адреса памяти и должны игнорироваться для сравнения, или требуется дополнительное вычисление, или в противном случае указатель и целое число не являются отношением 1 к 1), предоставляют специализация std :: less для указателей с такой гарантией.Это позволяет использовать все указатели случайного происхождения в качестве ключей в стандартных ассоциативных контейнерах, таких как std :: set или std :: map.
 Для типов, которые являются EqualityComparable и LessThanComparable, стандартная библиотека C ++ проводит различие между  равенством , которое является значением выражения a == b, и  эквивалентом , который является значением выражения! (A <б) &&! (б <а).
 Сравнение между указателями и константами нулевого указателя было удалено разрешением CWG583, включенным в N3624
 void f (char * p)
{
  если (p> 0) {/ *... * /} // Ошибка с N3624, скомпилированный до N3624
  if (p> nullptr) {/*...*/} // Ошибка с N3624, скомпилированная до N3624
}
int main () {} 
 Трехстороннее сравнение 
 Выражения оператора трехстороннего сравнения имеют вид
 Выражение возвращает такой объект, что
 (a <=> b) <0, если lhs 
 (a <=> b)> 0, если lhs> rhs
 (a <=> b) == 0, если левая и правая равны / эквивалентны.
 Если один из операндов имеет тип bool, а другой - нет, программа имеет неправильный формат.
 Если оба операнда имеют арифметические типы, или если один операнд имеет тип перечисления с незаданной областью, а другой - целочисленный тип, к операндам применяются обычные арифметические преобразования, а затем
 Если требуется сужающее преобразование, отличное от целочисленного типа в тип с плавающей запятой, программа имеет неправильный формат.
 В противном случае, если операнды имеют целочисленный тип, оператор возвращает значение типа std :: strong_ordering:
 std :: strong_ordering :: equal, если оба операнда арифметически равны,
 std :: strong_ordering :: less, если первый операнд арифметически меньше второго
 std :: strong_ordering :: в противном случае больше.
 В противном случае операнды имеют тип с плавающей запятой, и оператор возвращает prvalue типа std :: partial_ordering. Выражение a <=> b дает
 std :: partial_ordering :: less, если a меньше b
 std :: partial_ordering :: больше, если a больше, чем b
 std :: partial_ordering :: эквивалент, если a эквивалентно b (-0 <=> +0 эквивалентно)
 std :: partial_ordering :: unordered (NaN <=> что-либо неупорядочено).
 Если оба операнда имеют одинаковый тип перечисления  E , оператор выдает результат преобразования операндов в базовый тип E и применения <=> к преобразованным операндам.
 Если хотя бы один из операндов является указателем или указателем на член, преобразования массива в указатель, преобразования производного указателя в базовый, преобразования указателя функций и преобразования квалификаций применяются по мере необходимости для преобразования обоих операндов в тот же тип указателя, а результирующий тип указателя является типом указателя объекта, p <=> q ​​возвращает значение типа std :: strong_ordering:
 std :: strong_ordering :: equal if p == q,
 std :: strong_ordering :: less, если p 
 std :: strong_ordering :: больше, если p> q.
 неуказанный результат, если сравнение не определено для этих значений указателя (например, когда они не указывают на один и тот же объект или массив).
 В противном случае программа имеет неверный формат.
 В разрешении перегрузки по отношению к определяемым пользователем операторам для указателя или типа перечисления  T  следующая сигнатура функции участвует в разрешении перегрузки:
 Где  R  - тип категории заказа, определенный выше.
 Пример 
 #include <сравнить>
#include 

int main ()
{
    двойной foo = -0.0;
    двойная полоса = 0,0;

    auto res = foo <=> bar;

    если (res <0)
        std :: cout << "-0 меньше 0";
    иначе, если (res> 0)
        std :: cout << "-0 больше 0";
    иначе // (res == 0)
        std :: cout << "-0 и 0 равны";
} 
 Выход:
 Примечания 
 Трехстороннее сравнение может быть автоматически сгенерировано для типов классов, см. Сравнения по умолчанию.
 Если оба операнда являются массивами, трехстороннее сравнение некорректно.
 беззнаковое int i = 1;
авто г = -1 <я; // существующая ловушка: возвращает false
авто r2 = -1 <=> я; // Ошибка: требуется сужение преобразования 
 (начиная с C ++ 20)
 [править] Стандартная библиотека 
 Операторы сравнения перегружены для многих классов стандартной библиотеки.
 Пространство имен std :: rel_ops предоставляет общие операторы! =,>, <= И> =
 [править] Отчеты о дефектах 
 Следующие ниже отчеты о дефектах, изменяющих поведение, были применены задним числом к ​​ранее опубликованным стандартам C ++.
 DR
 Применяется к
 Behavior как опубликовано
 Правильное поведение
 CWG 583
 С ++ 98 
 С ++ 11
 все шесть операторов сравнения могут использоваться для сравнения указателя 
 с  nullptr  (C ++ 11) или другой константой нулевого указателя (C ++ 98)
 разрешены только операторы равенства
 CWG 1512
 C ++ 98
 правило составного типа указателя было неполным, и, таким образом, 
 не допускал сравнения между int ** и const int **
 выполнено в комплекте
 CWG 1596
 C ++ 98
 объекта, не являющегося массивом, считались принадлежащими массивам с 
 одним элементом только в целях арифметики указателей.
 правило также применяется для сравнения
 [править] См. Также 
 Общие операторы
 назначение
 шаг 
 шаг
 арифметические
 логический
  сравнение 
 член 
 доступ
 другое
 a = b 
 a + = b 
 a - = b 
 a * = b 
 a / = b 
 a% = b 
 a & = b 
 a | = b 
 a ^ = b 
 a << = b 
 а >> = б
 ++ a 
 --a 
 a ++ 
 a--
 + a 
 -a 
 a + b 
 a - b 
 a * b 
 a / b 
 a% b 
 ~ a 
 a & b 
 a | б 
 а ^ б 
 а << б 
 а >> б
! A 
 a && b 
 a || б
 a == b 
 a! = B 
 a  a> b 
 a <= b 
 a> = b 
 a <=> b
 a [b] 
 * a 
 и a 
 a-> b 
 a.б 
 а -> * б 
 а. * б
 а (...) 
 а, б 
? :
 Специальные операторы
 static_cast преобразует один тип в другой связанный тип 
 dynamic_cast преобразует в иерархиях наследования 
 const_cast добавляет или удаляет квалификаторы cv 
 reinterpret_cast преобразует тип в несвязанный тип 
 C-style cast преобразует один тип в другой посредством сочетания  static_cast ,  const_cast 907 , и  reinterpret_cast  
 new создает объекты с динамической продолжительностью хранения 
 delete уничтожает объекты, ранее созданные новым выражением, и освобождает полученную область памяти 
 sizeof запросов размера типа 
 sizeof... запрашивает размер пакета параметров (начиная с C ++ 11) 
 typeid запрашивает информацию о типе типа 
 noexcept проверяет, может ли выражение вызывать исключение (начиная с C ++ 11) 
 alignof запросы выравнивания требований типа (начиная с C ++ 11)
 Операторы - AWS IoT Core 
 Следующие операторы могут использоваться в предложениях SELECT и WHERE.
 И оператор 
 Возвращает результат  Boolean .Выполняет логическую операцию И. Возврат
 истина, если левый и правый операнды верны. В противном случае возвращает false.  Boolean  операнды или нечувствительная к регистру строка "true" или "false"
 операнды обязательны.
  Синтаксис:    выражение  AND  выражение  .
 Левый операнд
 Правый операнд
 Выход
  Логическое значение 
  логический 
  Логическое значение .Истинно, если оба операнда верны. Иначе,
 ложный.
  Строка / Логическое значение 
  Строка / Логическое значение 
 Если все строки являются "истинными" или "ложными" (без учета регистра), они
 преобразован в  Boolean  и нормально обработан как   логическое  И  логическое  .
 Другое значение
 Другое значение
  Не определено .
 Оператор ИЛИ 
 Возвращает результат  Boolean .Выполняет операцию логического ИЛИ. Возврат
 истина, если правый или левый операнды верны. В противном случае возвращает false.  Boolean  операнды или нечувствительная к регистру строка "true" или "false"
 операнды обязательны.
  Синтаксис:    выражение  OR  выражение  .
 Левый операнд
 Правый операнд
 Выход
  Логическое значение 
  логический 
  Логическое значение .Истинно, если любой из операндов истинен. Иначе,
 ложный.
  Строка / Логическое значение 
  Строка / Логическое значение 
 Если все строки являются "истинными" или "ложными" (без учета регистра), они
 конвертируется в логические значения и обрабатывается как обычно   логическое  ИЛИ  логическое  .
 Другое значение
 Другое значение
  Не определено .
 НЕ оператор 
 Возвращает результат  Boolean .Выполняет логическую операцию НЕ. Возврат
 истина, если операнд ложный. В противном случае возвращает истину. A  Логическое значение  Требуется строковый операнд "истина" или "ложь" без учета регистра или операнда.
  Синтаксис:   НЕ  выражение  .
 Операнд
 Выход
  Логическое значение 
  Логическое значение .Истинно, если операнд ложный. Иначе,
 правда.
  Строка 
 Если строка "истина" или "ложь" (без учета регистра), она
 преобразовано в соответствующее логическое значение, а противоположное значение
 возвращается.
 Другое значение
  Не определено .
> оператор 
 Возвращает результат  Boolean .Возвращает истину, если левый операнд больше
 чем правильный операнд. Оба операнда преобразуются в десятичное число   и
 потом сравнил.
  Синтаксис:    выражение >  выражение  .
 Левый операнд
 Правый операнд
 Выход
  Int / Десятичное число 
  Int / Десятичный 
  Логическое значение .Истинно, если левый операнд больше, чем
 правильный операнд. В противном случае - ложь.
  Строка / Int / Десятичное число 
  Строка / Int / Десятичное число 
 Если все строки можно преобразовать в  Decimal , то  Логическое .Возвращает истину, если левый операнд
 больше правого операнда. В противном случае - ложь.
 Другое значение
  Не определено .
  Не определено .
> = оператор 
 Возвращает результат  Boolean . Возвращает истину, если левый операнд больше
 чем или равно правому операнду.Оба операнда преобразуются в  Десятичное число , а затем сравнить.
  Синтаксис:    выражение > =  выражение  .
 Левый операнд
 Правый операнд
 Выход
  Int / Десятичное число 
  Int / Десятичный 
  Логическое значение .Истинно, если левый операнд больше или
 равно правому операнду. В противном случае - ложь.
  Строка / Int / Десятичное число 
  Строка / Int / Десятичное число 
 Если все строки можно преобразовать в  Decimal , то  Логическое .Возвращает истину, если левый операнд
 больше или равно правому операнду. Иначе,
 ложный.
 Другое значение
  Не определено .
  Не определено .
<оператор
 Возвращает результат  Boolean . Возвращает истину, если левый операнд меньше
 чем правильный операнд.Оба операнда преобразуются в десятичное число   и
 потом сравнил.
  Синтаксис:    выражение  <
  выражение  .
 Левый операнд
 Правый операнд
 Выход
  Int / Десятичное число 
  Int / Десятичный 
  Логическое значение .Истинно, если левый операнд меньше
 правый операнд. В противном случае - ложь.
  Строка / Int / Десятичное число 
  Строка / Int / Десятичное число 
 Если все строки можно преобразовать в  Decimal , то  Логическое .Возвращает истину, если левый операнд меньше
 чем правильный операнд. В противном случае - ложь.
 Другое значение
  Не определено 
  Не определено 
<= оператор
 Возвращает результат  Boolean .Возвращает истину, если левый операнд меньше
 чем или равно правому операнду. Оба операнда преобразуются в  Десятичное число , а затем сравнить.
  Синтаксис:    выражение  <=
  выражение  .
 Левый операнд
 Правый операнд
 Выход
  Int / Десятичное число 
  Int / Десятичный 
  Логическое значение .Истинно, если левый операнд меньше или
 равно правому операнду. В противном случае - ложь.
  Строка / Int / Десятичное число 
  Строка / Int / Десятичное число 
 Если все строки можно преобразовать в  Decimal , то  Логическое .Возвращает истину, если левый операнд меньше
 чем или равно правому операнду. В противном случае - ложь.
 Другое значение
  Не определено 
  Не определено 
<> оператор
 Возвращает результат  Boolean .Возвращает истину, если и слева, и справа
 операнды не равны. В противном случае возвращает false.
  Синтаксис:    выражение  <>  выражение  .
 Левый операнд
 Правый операнд
 Выход
  Внутр. 
  Внутр. 
 Истинно, если левый операнд не равен правому операнду.Иначе,
 ложный.
  Десятичное число 
  Десятичное 
 Истинно, если левый операнд не равен правому операнду.Иначе,
 ложный.  Int  преобразуется в  Decimal  перед сравнением.
  Строка 
  Строка 
 Истинно, если левый операнд не равен правому операнду.Иначе,
 ложный.
 Массив
 Массив
 Истинно, если элементы в каждом операнде не равны и не входят в
 такой же порядок.В противном случае ложь
 Объект
 Объект
 Истинно, если ключи и значения каждого операнда не равны.
 В противном случае - ложь.Порядок ключей / значений не имеет значения.
 Нулевой
 Нулевой
 Неверно.
 Любое значение
  Не определено 
 Не определено.
  Не определено 
 Любое значение
 Не определено.
 Несоответствующий тип
 Несоответствующий тип
 Верно.
 = оператор 
 Возвращает результат  Boolean . Возвращает истину, если и слева, и справа
 операнды равны. В противном случае возвращает false.
  Синтаксис:    выражение  =  выражение  .
 Левый операнд
 Правый операнд
 Выход
  Внутр. 
  Внутр. 
 Истинно, если левый операнд равен правому операнду.Иначе,
 ложный.
  Десятичное число 
  Десятичное 
 Истинно, если левый операнд равен правому операнду.Иначе,
 ложный.  Int  преобразуется в  Decimal  перед сравнением.
  Строка 
  Строка 
 Истинно, если левый операнд равен правому операнду.Иначе,
 ложный.
 Массив
 Массив
 Истинно, если элементы в каждом операнде равны и находятся в одном и том же
 заказывать.В противном случае - ложь.
 Объект
 Объект
 Истинно, если ключи и значения каждого операнда равны. Иначе,
 ложный.Порядок ключей / значений не имеет значения.
 Любое значение
  Не определено 
  Не определено .
  Не определено 
 Любое значение
  Не определено .
 Несоответствующий тип
 Несоответствующий тип
 Неверно.
 + оператор 
 Знак "+" - перегруженный оператор.Его можно использовать для конкатенации строк или
 добавление.
  Синтаксис:    выражение  +  выражение  .
 Левый операнд
 Правый операнд
 Выход
  Строка 
 Любое значение
 Преобразует правый операнд в строку и объединяет ее с
 конец левого операнда.
 Любое значение
  Строка 
 Преобразует левый операнд в строку и объединяет правый
 операнд до конца преобразованного левого операнда.
  Внутр. 
  Внутр. 
  Int  значение. Складывает операнды.
  Int / Десятичное число 
  Int / Десятичный 
  Десятичное значение .Складывает операнды.
 Другое значение
 Другое значение
  Не определено .
 - оператор 
 Вычитает правый операнд из левого операнда.
  Синтаксис:    выражение  -  выражение  .
 Левый операнд
 Правый операнд
 Выход
  Внутр. 
  Внутр. 
  Int  значение.Вычитает правый операнд из левого
 операнд.
  Int / Десятичное число 
  Int / Десятичный 
  Десятичное значение .Вычитает правый операнд из левого
 операнд.
  Строка / Int / Десятичное число 
  Строка / Int / Десятичное число 
 Если все строки правильно преобразованы в десятичные числа,  Возвращается десятичное значение .Вычитает правый операнд
 от левого операнда. В противном случае возвращается  Не определено .
 Другое значение
 Другое значение
  Не определено .
 Другое значение
 Другое значение
  Не определено .
 * оператор 
 Умножает левый операнд на правый операнд.
  Синтаксис:    выражение  *  выражение  .
 Левый операнд
 Правый операнд
 Выход
  Внутр. 
  Внутр. 
  Int  значение.Умножает левый операнд на правый
 операнд.
  Int / Десятичное число 
  Int / Десятичный 
  Десятичное значение .Умножает левый операнд на
 правый операнд.
  Строка / Int / Десятичное число 
  Строка / Int / Десятичное число 
 Если все строки правильно преобразованы в десятичные числа,  Возвращается десятичное значение .Умножает левую
 операнд по правому операнду. В противном случае возвращается  Не определено .
 Другое значение
 Другое значение
  Не определено .
 / оператор 
 Делит левый операнд на правый.
  Синтаксис:    выражение  /  выражение  .
 Левый операнд
 Правый операнд
 Выход
  Внутр. 
  Внутр. 
  Int  значение.Делит левый операнд на правый
 операнд.
  Int / Десятичное число 
  Int / Десятичный 
  Десятичное значение .Делит левый операнд на правый
 операнд.
  Строка / Int / Десятичное число 
  Строка / Int / Десятичное число 
 Если все строки правильно преобразованы в десятичные числа,  Возвращается десятичное значение .Делит левый операнд
 по правому операнду. В противном случае возвращается  Не определено .
 Другое значение
 Другое значение
  Не определено .
% оператор 
 Возвращает остаток от деления левого операнда на правый операнд.
  Синтаксис:    выражение %  выражение  .
 Левый операнд
 Правый операнд
 Выход
  Внутр. 
  Внутр. 
  Int  значение.Возвращает остаток от деления
 левый операнд правым операндом.
  Строка / Int / Десятичное число 
  Строка / Int / Десятичное число 
 Если все строки правильно преобразованы в десятичные числа,  Возвращается десятичное значение .Возвращает остаток
 от деления левого операнда на правый операнд. Иначе,  Не определено .
 Другое значение
 Другое значение
  Не определено .
 .
 Оставить комментарий
Добавить комментарий Отменить ответ
Ваш адрес email не будет опубликован. Обязательные поля помечены *
Комментарий *
Имя * 
Email * 
Сайт