Инкремент и декремент

Унарные операции инкремента (++) и декремента (--), называемые также операциями увеличения и уменьшения на единицу, имеют две формы записи: префиксную, когда знак операции записывается перед операндом, и постфиксную – после операнда. В префиксной форме сначала изменяется операнд, а затем его значение используется при вычислении выражения, а в постфиксной форме сначала вычисляется выражение с использованием исходного значения операнда, после чего операнд изменяется. Операции инкремента и декремента можно применить только к операндам, которые хранят свои значения в оперативной памяти. Примеры:

int a = b = 2, c, d;

c = ++a; //a = 3, c = 3

d = b++; //d = 2, b = 3

c = a + b; //c = 6

d = a-- * ++c / (--b + 1); //c = 7, b = 2, d = 7, a = 2

a = 10++; //неверно

a = (--b + 5)++; //неверно

Унарный плюс и унарный минус (строка 2)

Унарный плюс (+) перед операндом можно не ставить, т.к. он подразумевается по умолчанию. Унарный минус (-) меняет знак операнда на противоположный.

Явное преобразование типа

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

int a = 9, b = 10;

float x;

x = a/b; //x = 0

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

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

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

a = 256;

b = a; //b = 256

b = (char)a; //b = 0 (потеря информации)

Операция определения размера sizeof

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

sizeof выражение

sizeof (выражение), sizeof (тип)

Примеры:

short a, b = 5;

int c;

float x = 10;

a = sizeof(char); //a = 1

a = sizeof b; //a = 2

a = sizeof(b + 1); //a = 4 (целая константа имеет по умолчанию тип int)

a = sizeof(x + 1); //a = 4

a = sizeof(x + 1.0); //a = 8 (вещественная константа имеет по умолчанию тип double)

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

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

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

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