Результат вычисления выражения характеризуется значением и типом.

– остальные - слева направо.

a = b = c означает  a = (b = c)

a + b + c означает (a + b) + c

Результат вычисления выражения характеризуется значением и типом.

Выражения

В С++ различаются так называемые L-значения (L-value) и R-значения (R-value). Название произошло от операции присваивания:

– выражение, являющееся L -значением (от слова Left - левый), может располагаться как с левой, так и с правой стороны операции присваивания;

– выражение, являющееся R -значением (от слова Right - правый), может располагаться только с правой, но никак не с левой стороны операции присваивания.

Выражения

• Выражения возвращают в качестве результата либо L -значения, либо R -значения.

• Переменная - частный случай L -значения, а константа - частный случай R -значения.

• Более общим случаем R -значения является обычное арифметическое выражение.

• L -значением в общем случае может быть не только переменная, но и некоторое выражение, ссылающееся на область памяти.

Операции присваивания

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

К операциям они относятся потому, что могут использоваться в выражениях и формируют результат своего выполнения.

Формат операции простого присваивания (=):   операнд_1 = операнд_2

Левым операндом должно быть L -значение, а правым - любое выражение.

Операции присваивания

с = a + (b = 5);

// эквивалентно b=5; c=a+b;

a = b = c;     

// эквивалентно b=c; a=b;

a=(b=s/k)+n;

 // эквивалентно b=s/k; a=b+n;

a=b=c=d=e+2;

// эквивалентно  d=e+2; c=d; b=c; a=b;

Операции присваивания

• В составных операциях присваивания при вычислении выражения, стоящего в правой части, используется и L -значение из левой части.

• *= /= %= += -= &= ^= |= <<= >>=

int k;

k=8;

k*=3; // результат 24

k+=7; // результат 31

Операции присваивания

a += 5;

// эквивалентно a=a+5;

a /= b;     

// эквивалентно a= a/b;

b[i] *=n;

 // эквивалентно b[i]=b[i]*n;

(a=b)+=c;

// эквивалентно  a=b; a=a+c;

// a = b - является L -значением

Операции инкремента и декремента

Имеют две формы записи – префиксную,

++<операнд>, - - < операнд >,

И постфиксную

  < операнд >++ < операнд > - -

k = i ++; // результат операции k=0, i=1

l =++ j; // результат операции L=1, j=1

-- j; // результат операции j=0

l ++; // результат операции L=2

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

Арифметические операции делятся на:

– унарные «+» и «-»;

– бинарные: сложение «+», вычитание «-», умножение «*», деление «/», получение остатка целочисленного деления «%».

• При делении двух целых чисел – результат целый.

• Операция остаток от деления выполняется над целыми (!)

Результат 2

5%2 результат 1

Логические операции

К логическим операциям относятся:

–!– логическое «не» – отрицание;

– &&– логическое «и» – конъюнкция;

– || – логическое «или» – дизъюнкция.

6>2&&3==3

!(6>2&&3==3)

x!=0 && 20/x<5

Операции отношения

<, <=, >, >=, ==,!=

 Операнды могут быть арифметического типа или указателями. Результатом операции является значение true или false.

Операции сравнения на равенство и неравенство имеют меньший приоритет, чем остальные операции сравнения.

int a = 5; int b = 3;

a > b // результат true

a == b // результат false

Сдвиги

– >> – сдвиг вправо битового представления целого числа на количество разрядов, задаваемое правым целочисленным операндом,

– << – сдвиг влево битового представления целого числа на количество разрядов, задаваемое левым целочисленным операндом.

Например:

4<<2 // результат 16: 00000100 << 00010000

5>>1 // результат 2: 00000101 >> 00000010

Операция следования

• Символом операции следования является

      , (запятая).

c = a++, a+b; // результат: а = 4, с = 12;

(b--,c)*=3; // результат: b = 7, с = 36.

int m =5, z;

z =(m = m *5, m *3); // результат: m=25, z=75

int d, k;

k =(d =4, d *8); // результат: d=4, k=32

с =(a=5, b=a*a);

                               // эквивалентно a=5; b=a*a; c=b;

В файле conio.h:

• Rand () – генерация случайного числа

• Srand (<Целое число>) – инициализация генератора случайных чисел.

Преобразования базовых типов

• В выражение могут входить операнды различных типов.

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

• Если операнды разного типа, перед вычислениями автоматически выполняются неявные преобразования типов.

• Обычно короткие типы приводятся к более длинным, что обеспечивает сохранение значимости и точности:

(char, short) -> int -> unsigned int -> long -> unsigned long -> float -> double -> long double

Преобразования базовых типов

• Если один из операндов имеет тип long double, второй приводится к этому же типу в любом случае.

• Если в выражении нет операндов long double, но есть операнд double, все преобразуется к этому типу.

• В том случае, если нет операндов типа double и long double, но есть операнд float, тип остальных операндов меняется на float.

Преобразования базовых типов

• Если у нас нет вещественных операндов, значит, все они представляют собой целые типы.

• Прежде чем определить тип результата, производится преобразование, называемое приведением к целому: все операнды с типом меньше, чем int, заменяются на int.

Преобразования базовых типов

• При приведении к целому типы char, signed char, unsigned char и short int преобразуются в int.

• Тип unsigned short int трансформируется в int, если этот тип достаточен для представления всего диапазона значений unsigned short int, в противном случае unsigned short int заменяется на unsigned int.

• Тип wchar_t и перечисления приводятся к наименьшему целому типу, способному представить все их значения.

Преобразования базовых типов

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

• Если один из них имеет тип unsigned long, то остальные будут того же типа.

• Если в выражении нет объектов unsigned long, но есть объекты типа long, тип остальных операндов меняется на long.

• Преобразование unsigned int в long происходит только в том случае, если тип long способен вместить весь диапазон значений unsigned int.

Преобразования базовых типов

• Если же тип long не способен представить весь диапазон unsigned int, оба операнда приводятся к unsigned long.

• В случае отсутствия операндов типов unsigned long и long, используется тип unsigned int.

•  Если же нет операндов и этого типа, то к int.

Преобразования базовых типов

• В логических операциях и условной операции выполняется неявное преобразование к типу bool.

• При этом любое значение, не равное нулю (даже отрицательное), трактуется как true, а нуль считается false.

• При обратных преобразованиях величин типа bool к целому типу значение true преобразуется в целую константу 1, а значение false - в 0.

Преобразования базовых типов

• Однако в выражениях с операцией присваивания встречается и обратный вариант, когда более "объемный" тип присваивается менее "объемному", например, float в int.

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

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

Операция преобразования типа (часто называемая приведением типа) может записываться в двух эквивалентных формах:

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

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

(unsigned long)(x/3+2);

(long)25;

(unsigned char)123;

Int(3.14) результат: 3

Float(2/3) результат: 0.0

Int(’A’)    результат: 65

Int main()

{

int i,result;

float fp;

char c,s[81];

result = scanf_s("%d %f %c %s", &i, &fp, &c, 1, s, 80);

printf("The number of fields input is %d\n", result);

printf("The contents are: %d %f %c %s \n", i, fp, c, s);

_ getch ();

}

Блок операторов

Пример: 

{  

f=a+b;

a+=10;

}

Условный оператор

Условный оператор

Условный оператор

if (a<b) {

if (a<c) m = a;

else m = c; }

else { if (b<c) m = b;

   else m = c; }

if (b>a) max = b;

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

if (int i = fun(t)) a –= i; else a += i;

if ((c=a+b)!=5) c+=b;

else c=a;

if (x*x + y*y < 1) kol = 2;

else if (x*x + y*y < 4) kol = 1;        else kol = 0;

Условный оператор

Правило вложенности. При записи двух вложенных операторов if с одной альтернативной ветвью возникает неоднозначность:

не понятно, которому из двух операторов if принадлежит альтернативная ветвь.

Для разрешения коллизии используют правило вложения:

else всегда относится к ближайшему if.

Условный оператор

if (<Условие 1>)

if <Условие 2> <Действие 1>

else <Действие 2>

if <Условие 1>

{

if <Условие 2> <Действие 1>

}

else <Действие 2>

Оператор switch