Язык С. Операции в языке С презентация

Объявление переменных
Для хранения информации в компьютере необходимо выделить память для нее. Чтобы сохранить один элемент информации в компьютере, нужно идентифицировать как место в памяти, так и объем памяти, требуемый для хранения этой информации.
int counter;
counter – это переменная, т.к. ее значение
можно изменять:
counter = 125;
Оператор объявления переменной.
С момента объявления программа будет использовать имя counter для обозначения значения, хранящегося в данном месте памяти
Тип хранимых данных
Имя переменной
Точка с запятой – конец оператора

Хранение переменных в памяти компьютера
Фундаментальной единицей памяти компьютера является бит. Его можно рассматривать как электронный переключатель, который может быть установлен в одно из двух положений: "включен" и "выключен". Положение "выключен" представляет значение 0, а положение "включен" — значение 1. Порция памяти, состоящая из 8 битов называется байт.
Тип переменной определяет размер выделяемой для хранения информации памяти – 1, 2, 4 или 8 байт.

Хранение переменных
в памяти компьютера
Примеры объявления переменных:
char c;
short s;
int k;
float f;
Присваивание значений:
c = 5;
s = 6;
k = 7;
f = 0.5;
120000
120001
120002
120003
120004
120005
120006120007
120008
120009
120010
120011
120012
Адрес Память
ячейки
c
05
06
00
07
00
00
00
00
00
00
3F
s
k
f

Знаковые и беззнаковые переменные
Переменные целых типов могут быть знаковыми и беззнаковыми:
char c;
unsigned char uc;
short s;
unsigned short us;
int k;
unsigned int uk;
Информация, хранимая в них интерпретируется по разному:
c = -2;
uc = 254;
т.к. у беззнаковых переменных нет отрицательных значений.

Знаковые и беззнаковые переменные
Переменные целых типов могут быть знаковыми и беззнаковыми:
char c;
unsigned char uc;
short s;
unsigned short us;
int k;
unsigned int uk;
Диапазоны значений также отличаются

Логический тип
В языке С++ добавлен еще один тип - логический или тип bool.
Величины логического типа могут принимать только значения true или false, яв­ляющиеся зарезервированными словами. Внутренняя форма представления значения false — 0 (нуль). Любое другое значение интерпретируется как true.
bool b1 = true;
bool b2 = false;
При преобразовании к целому типу true имеет значение 1, а false — 0.
int i1 = b1; // i1 = 1
int i1 = b2; // i1 = 0

Объявление переменных
Когда в программе объявляется переменная, например int или float, то не просто выделяется память для нее, но также устанавливается, какие операции допустимы с этой переменной (напр., % - для int, но не для float).
То есть, спецификация базового типа выполняет три вещи:
• Определяет, сколько памяти нужно объекту.
• Определяет, как интерпретируются биты памяти (типы long и float могут занимать одинаковое количество бит памяти, но транслируются в числовые значения по-разному.)
• Определяет, какие операции, или методы, могут быть применены с использованием этого объекта данных.
Для встроенных типов информация об операциях встроена в компилятор.
Примеры объявлений с начальной инициализацией:
int k = 10;
float f = 20.5;
bool b = true;

Объявление констант
Константами называют неизменяемые величины. Различаются целые, вещест­венные, символьные и строковые константы.
Символьные константы в C++ можно записать несколькими способами. Обычные символы, такие как буквы, знаки препинания и цифры, проще всего заключать в одиночные кавычки. Такая форма записи будет символизировать числовой код символа.
Например, в системе ASCII установлены следующие соответствия:
'А' соответствует числу 65, коду ASCII для символа А;
'5' соответствует 53, коду ASCII для цифры 5;
' ' соответствует 32, коду ASCII для символа пробела;
char c1 = 'A'; // c1 присваивается код буквы A (число 65)
можно записать и так:
char c1 = 65; // 16-ричное 41

Объявление констант
Для записи символьных констант, соответствующих неграфическим символам, используют так называемые управляющие последовательности (или esc-последовательности):
'\n' – соответствует коду 10 – переход на новую строку
'\r' – соответствует коду 13 – возврат каретки;
'\t' – соответствует коду 9 – табуляция;
Можно также применять управляющие последовательности на основе
восьмеричных или шестнадцатеричных кодов символа. Например, комбинация клавиш
имеет ASCII-код 26, соответствующий восьмеричному значению 032 и шестнадцатеричному 0x1a. Этот символ можно представить с помощью одной из управляющих последовательностей: \032 или \0x1a.
char c1 = '\032';

Объявление констант
Для записи строковых констант используют последовательность символов, заключенную в кавычки:
”Hello!”
Можно использовать и управляющие последовательности:
”Hello!\n”
В конец каждого строкового литерала компилятором добавляется нулевой символ (код 0). Поэтому длина строки всегда на единицу больше количества символов в ее записи.
char str[6] = ”Hello”; // 6 символов
Пустая строка "" имеет длину 1 байт.
Обратите внимание на разницу между строкой из одного символа, например, "А", и символьной константой 'А‘:
char c = ‘A’;
char str[2] = ”A”;
Пустая символьная константа недопустима.

Объявление констант
Целочисленный литерал, или константа, представляет собой число, записываемое явно, например: 42.
Язык С позволяет записывать целые числа в трех различных системах счисления: с основанием 10, с основанием 8 и с основанием 16.
Если первой цифрой константы является 0, то это число восьмеричное (основание 8), например:
042 – это 8-ричное значение, соответствующее десятичному числу 34.
Если первыми двумя символами являются 0х или 0Х, то это шестнадцатеричное значение (основание 16), например:
0x42 – это 16-ричное значение, соответствующее десятичному числу 66.
int a1 = 42; // a1 присваивается значение 42
int a2 = 0xA5; // a2 присваивается 16-ричное значение,
// соответствующее десятичному 165
int a3 = 042; // a3 присваивается 8-ричное значение,
// соответствующее десятичному 34

Объявление констант
Вещественные константы записываются с десятичной точкой или в экспоненциальной форме:
5.7
0.2Е6
Вещественная константа в экспоненциальном формате представляется в виде мантиссы и порядка. Мантисса записывается слева от знака экспоненты (Е или е), по­рядок — справа от знака. Значение константы определяется как произведение мантиссы и возведенного в указанную в порядке степень числа 10. Обратите внимание, что пробелы внутри числа не допускаются, а для отделения целой части от дробной используется не запятая, а точка.
float f = 0.2E6; // переменной f присваивается число 200000
Если требуется записать отрицательную целую или вещественную константу, то перед ней ставится знак унарный минус (-), например:
-218
-4.8

Именованные константы
Если константа используется во множестве мест программы, то гораздо удобнее дать ей имя – создать так называемую именованную константу. По символическому имени константы можно судить о том, что собой представляет константа. Кроме того, если понадобится изменить ее значение, то для этого достаточно будет модифицировать единственное определение.
Например, в программе необходимо задать максимальное значение диапазона измерений – 100, которое будет использоваться в нескольких местах программы.
Для этого будет удобным создать символическую константу с именем MAX и значением 100.

Именованные константы
Для определения символических констант можно использовать директиву препроцессора #define:
#define MAX 100
Директива сообщает препроцессору следующее: найти в программе экземпляры символической константы MAX и заменить каждое вхождение значением 100. Например, если в программе есть строка:
counter = MAX;
то препроцессор заменит слово MAX на 100 и в процессе выполнения программы переменной counter будет присвоено значение 100.
Таким образом, директива #defіnе работает подобно команде глобального поиска и замены в текстовом редакторе. После произведенных замен происходит компиляция измененной программы.
Имя константы
Значение константы

Именованные константы
В C++ имеется более удобный способ создания символических констант - с помощью ключевого слова const.
Общая форма для создания константы выглядит следующим образом:
const тип имя = значение;
Например, для создания константу с именем MAX и значением 100:
const int MAX = 100;
Константа инициализируется при ее объявлении.
После инициализации константы, ее значение установлено. Компилятор не позволяет в последующем изменять значение MAX.
Ключевое слово const называется квалификатором, т.к. оно уточняет, что означает объявление.
Имя константы
Значение константы

Операции в языке С
Программирование вычислений предполагает, что над данными программы выполняются некоторые преобразования. Для этого в С и С++ определены операции соответствующих типов: арифметические, логические, сравнения, логические поразрядные, присваивания и др.
В соответствии с количеством операндов, которые используются в операциях, они делятся на:
унарные (один операнд)
–a
бинарные (два операнда)
a + b
тернарную (три операнда)
?:

Арифметические операции
Арифметические операции:
int a = 25, b = 2, c;
c = a / b;
c = a % b;
c = -b; // унарный минус: с = -2, b не изменяется
float f = 25, g = 2, h;
h = f / g;
c = 25 % 2; // остаток от деления 25 на 2: 1

Арифметические операции
Порядок выполнения операций:
Приоритет имеют операции *, /, %
Если одинакового приоритета – по очереди слева направо
с = 3 + 4 * 5; // результат: 23
c = 2 * 3 + 4 * 5; // результат: 26
c = 80 / 4 * 5; // результат: 100
При выполнении деления результат зависит от типа операндов:
int a = 25, b = 2, c;
c = a / b; // деление целых сопровождается отбрасыванием
// дробной части, получаем: 12
float f = 25, g = 2, h;
h = f / g; // результат: 12.5
h = a / b; // результат: 12

Арифметические операции
К арифметическим относят также операции:
Эти операции, называемые также инкрементом и декрементом, имеют две формы записи — префиксную, когда операция записывается перед операндом:
++a; // эквивалентно a = a + 1;
и постфиксную:
a++; // эквивалентно a = a + 1;
В префиксной форме сначала изменяется операнд, а затем его значение становится результи­рующим значением выражения, а в постфиксной форме значением выражения является исходное значение операнда, после чего он изменяется.
int c, a = 5;
c = ++a; // c = 6, a = 6
a = 5;
c = a++; // c = 5, a = 6

Операции сравнения
Операции сравнения:
Результатом операции сравнения является одно из двух значений:
true (1) или false(0).
Используется в операторах условия:
if (i < MAX-1)
. . . .
Все операции сравнения имеют одинаковый приоритет, но более низкий, чем арифметические операции, поэтому выражение типа i < MAX-1 будет выполняться так же, как i < (MAX-1).

Операции сравнения
Операции сравнения:
Сравнивать на равенство или неравенство вещественные переменные не рекомендуется, например:
if (f == 3.1415)
. . . .
if (f != 1.23)
. . . .
будут работать неправильно.

Логические операции
Логические операции
Результатом логических операций является одно из двух значений:
true (1) или false (0).
Выражения, между которыми стоят операторы && или || , вычисляются слева направо. Вычисление прекращается, как только становится известна истинность или ложность результата.
a < 0 || a >= MAX
Унарный оператор ! преобразует ненулевой операнд в 0, а нулевой в 1.
!(a < 0 || a >= MAX)
Обычно оператор ! используют в конструкциях вида:
if (!valid)
что эквивалентно
if (valid == 0)

Логические операции
Приоритет оператора && выше, чем оператора || , однако их приоритеты ниже, чем приоритет операторов отношения и равенства. Из сказанного следует, что выражение вида
year % 4 == 0 && year % 100 != 0 || year % 400 == 0
не требует дополнительных скобок.
Используется в операторах условия:
if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
printf("%d високосный год\п", year);
else
printf("%d невисокосный год\п", year);

Битовые операции
Битовые операции
Битовые операции можно применять только к целочисленным операндам, т. е. к операндам типов char , short , int и long - знаковым и беззнаковым.
char a, b = 5, c = 11; // b = 00000101, c = 00001011
a = b & c; // a = 00000001
a = b | c; // a = 00001111
a = ~c; // a = 11110100
a = b ^ c; // a = 00001110

Битовые операции
Битовые операции
Поразрядные операторы & и ! следует отличать от логических операторов && и !!.
char a, b = 5, c = 2; // b = 00000101, c = 00000010
a = b & c; // a = 0
a = b && c; // a = 1 (true)

Битовые операции
Битовые операции
Оператор & используется, например, для обнуления нужных разрядов:
a = a & 0x0F; (обнуляет все старшие разряды, кроме четырех младших),
а оператор | – для установки битов:
a = a | 0x0F; (устанавливает четыре младших разряда в 1)

Битовые операции
Битовые операции
Операторы << и >> сдвигают влево или вправо свой левый операнд на число битовых позиций, задаваемое правым операндом, который должен быть неотрицательным.
х << 2 сдвигает значение х влево на 2 позиции, заполняя освобождающиеся биты нулями, что эквивалентно умножению х на 4. Сдвиг вправо беззнаковой величины всегда сопровождается заполнением освобождающихся разрядов нулями. Сдвиг вправо знаковой величины происходит с распространением знакового разряда ("арифметический сдвиг").
unsigned char a = 10, b; // a = 00001010 (десятичное 10)
b = a << 2; // 00101000 (40), a – не изменилось!

Операции присваивания
Операции присваивания
Оператор присваивания – бинарный, результат выполнения – значение операнда, поэтому можно записывать так:
a = b = c = d = 1;
Выполняется справа налево.

Операторы присваивания
Оператор a += 10; эквивалентен a = a + 10;
Оператор a -= 10; эквивалентен a = a - 10;
Оператор a *= 10; эквивалентен a = a * 10;
Оператор a /= 10; эквивалентен a = a / 10;
Оператор a %= 10; эквивалентен a = a % 10;
Оператор a *= b + 1; эквивалентен a = a * (b + 1);
Оператор a <<= 2; эквивалентен a = a << 2;
Оператор a >>= 8; эквивалентен a = a >> 8;
т.е. сдвигается сам аргумент
unsigned short us = 46607; // us = 1011 0110 0000 1111
us >>= 8; // us = 0000 0000 1011 0110 (десятичное 182)

Операция преобразования типа
Конструкция вида (имя-типа) выражение
приводит выражение к указанному в скобках типу, например:
(double)(i + 1)
преобразует значение выражения из целого типа в double.
Обычно преобразование типа осуществляется неявно:
int a = 15, b = 6;
float g, f = 3.5;
g = a + f; // a неявно приводится к типу float (g = 18.5).
Но в формуле
g = a / b; // g = 2
для правильного результата нужно использовать оператор преобразования типа:
g = (float)a / b; // g = 2.5
В языке С++ принято писать так:
double(i + 1);
g = float(a) / b;

Операция определения размера
Операция определения размера sizeof предназначена для вычисления размера объекта или типа в байтах, и имеет две формы:
sizeof выражение
sizeof (тип)
Например:
float x = 1;
short k, a;
a = sizeof (float); // a = 4
a = sizeof (short); // a = 2
a = sizeof x; // a = 4
a = sizeof (x + 3.14); // a = 4;
a = sizeof (k + 1); // a = 2;

Условная операция (?:)
Эта операция тернарная, то есть имеет три операнда. Ее формат:
операнд_1 ? операнд_2 : операнд_3
Если результат вычисления операнда 1 равен true, то результатом условной операции будет значение второго операнда, иначе — третьего операнда.
Например:
чтобы записать в z большее из а и b, можно написать:
z = (а > b) ? а : b;
k = (k < n) ? k + 1 : 1;
если k меньше n, то k увеличивается на 1, а иначе к присваивается значение 1.