Деление и остаток от деления

Операция деления (/) применима ко всем простым типам данных. Если оба операнда целочисленные, результат операции округляется до целого числа путем отбрасывания дробной части. Если хотя бы один из операндов вещественный, то дробная часть не отбрасывается, и результат операции будет иметь вещественный тип.

Операция остаток от деления (%) применяется только к целочисленным операндам. Примеры:

int a = 11, b = 4, c;

float x;

x = a/b; //x = 2.0

x = (float)a/b; //x = 2.75

c = a%b; //c = 3

x = a%b; //x = 3.0 (неявное приведение типа)

Операции сдвига (<< и >>)

Они применяются к целочисленным операндам и сдвигают двоичное представление первого операнда влево или вправо на количество двоичных разрядов, заданное вторым операндом. При сдвиге влево (<<) освободившиеся разряды обнуляются. При сдвиге вправо (>>) освободившиеся биты заполняются нулями, если первый операнд беззнакового типа, и знаковым разрядом в противном случае. Примеры:

int a = 3, b = 9, c;

//a = 0…011₍₂₎ = 11₍₂₎

c = a<<1; //c = 110₍₂₎ = 6, т.е. 3*2¹

c = a<<2; //c = 1100₍₂₎ = 12, т.е. 3*2²

c = a<<3; //c = 11000₍₂₎ = 24, т.е. 3*2³

c = a<<4; //c = 110000₍₂₎ = 48, т.е. 3*2⁴

//b = 0…01001₍₂₎ = 1001₍₂₎

c = b>>1; //c = 100₍₂₎ = 4, т.е. 9/2¹ (деление целочисленное).

c = b>>2; //c = 10₍₂₎ = 2, т.е. 9/2²

c = b>>3; //c = 1₍₂₎ = 1, т.е. 9/2³

c = b>>4; //c = 0₍₂₎ = 0, т.е. 9/2⁴

Другими словами, использование операций сдвига влево и вправо приводит соответственно к умножению и делению первого операнда на 2 в степени, задаваемой вторым операндом.

Поразрядные или побитовые логические операции ~, &, |, ^

Они применяются только к целочисленным операндам и работают с их двоичными представлениями.

Унарная операция поразрядного отрицания (~), называемая также поразрядным НЕ, инвертирует каждый разряд в двоичном представлении целочисленного операнда, т.е. превращает единичные биты в нулевые и наоборот.

При поразрядном И (&), называемом также поразрядной конъюнкцией, бит результата равен 1 только тогда, когда соответствующие биты обоих операндов равны 1, например:

int a = 6, b = 5, c; 110₍₂₎

c = a & b //c = 4 101 ₍₂₎

100₍₂₎

При поразрядном ИЛИ (|), называемом также поразрядной дизъюнкцией, бит результата равен 1 тогда, когда соответствующий бит хотя бы одного из операндов равен 1, например:

c = a | b; //c = 7 110₍₂₎

101 ₍₂₎

111₍₂₎

При поразрядном исключающем ИЛИ (^) бит результата равен 1 только тогда, когда соответствующий бит только одного из операндов равен 1, например:

c = a ^ b; //c = 3 110₍₂₎

101 ₍₂₎

011₍₂₎

Операции сравнения <, <=, >, >=, ==,!=

Операции сравнения, называемые также операциями отношения, сравнивают первый операнд со вторым. Результатом операции является значение логического типа ИСТИНА или ЛОЖЬ. В языке С значение ЛОЖЬ представляется нулем, а значение ИСТИНА – любым числом, не равным нулю, обычно единицей. Операции сравнения на равенство и неравенство имеют меньший приоритет, чем остальные операции сравнения.

int a = 5, b;

b = a <= 10; // b = 1

b = a % 2 == 0; // b = 0

 

Логические операции НЕ, И, ИЛИ (!, &&, ||)

Операнды этих логических операций рассматриваются как имеющие значение ЛОЖЬ, если они равны нулю, и значение ИСТИНА – если не равны нулю. Результатом любой логической операции является значение логического типа ИСТИНА или ЛОЖЬ.

Результат унарной операции логическое НЕ (!) есть ЛОЖЬ, если операнд имеет значение ИСТИНА, и ИСТИНА, – если операнд имеет значение ЛОЖЬ.

Результат операции логическое И (&&) имеет значение ИСТИНА, только если оба операнда имеют значение ИСТИНА.

Результат операции логическое ИЛИ (||) имеет значение ИСТИНА, если хотя бы один из операндов имеет значение ИСТИНА.

Если значения первого операнда достаточно, чтобы определить результат операции, второй операнд не вычисляется. Примеры:

int a = 5, b = 10, c;

с = a + b; //с = 15

с =!(a + b); //с = 0

с = a && b; //с = 1

с = a - 5 && b; //с = 0

с = (a && b) - 5; //с = -4

с = a >= 10 && b >= 10; //с = 0

с =!(a >= 10 && b >= 10); //с = 1

с = a >= 10 || b >= 10; // с = 1

с =!a >= 10 ||!b >= 10; //с = 0

с = (...) || 1; //с всегда равно 1

с = (...) && 0; //с всегда равно 0

Условная операция (?:)

Эта операция тернарная, т.е. имеет 3 операнда. Ее формат:

операнд1? операнд2: операнд3

Первый операнд всегда рассматривается с точки зрения его логического значения, и если результат вычисления первого операнда есть ИСТИНА, то результатом условной операции будет значение второго операнда, иначе – третьего операнда. Вычисляется всегда либо второй операнд, либо третий. Примеры:

int a = 5, b = 10, max;

max = (b > a)? b: a; // max = 10

a = (a < b)? a + 1: 5; //при повторе а будет изменяться в диапазоне от 5 до 10

a = a / b? 5: a + 1; //при повторе а будет изменяться в диапазоне от 5 до 10

Условная операция правоассоциативна, т.е. выполняется справа налево. Например, выражение a? b: c? d: e вычисляется как a? b: (c? d: e).

Операция запятая (,)

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

int a, b, c;

c = 2 * (a = 3, b = 7, a + 2) + b; //c = 17

c = a + b; //c = 10

Тот же результат можно получить без использования операции запятая:

int a = 3, b = 7, c;

c = 2 * (a + 2) + b;

c = a + b;

Следующие 3 оператора: a = 1; b = 2; c = 3; можно объединить в один: a = 1, b = 2, c = 3;