Типы с плавающей точкой: float, double, long double
Типы данных с плавающей точкой хранятся в памяти компьютера в виде мантиссы со знаком и порядка со знаком. В 32-разрядных персональных компьютерах величины типа float занимают 4 байта, из которых один двоичный разряд отводится под знак мантиссы, 24 разряда под мантиссу и 8 разрядов под порядок. При этом обеспечивается точность представления данных, равная 7 десятичным цифрам. Для величин типа double, занимающих 8 байт, под мантиссу и порядок отводится 53 и 11 разрядов соответственно. При этом обеспечивается точность представления, равная 15 десятичным цифрам. Спецификатор long перед именем типа double указывает, что под величину типа long double отводится 10 байт. Обеспечиваемая точность – 19 десятичных цифр.
Диапазоны значений вещественных типов данных для 32-разрядного компьютера
| Тип | Диапазон значений | Размер (байт) | Точность |
| Float | 3.4e-38 . . . 3.4e+38 | ||
| Double | 1.7e-308 . . . 1.7e+308 | ||
| long double | 3.4e-4932 . . . 3.4e+4932 |
Тип void
Кроме перечисленных к простым типам данных относится тип void, но множество значений этого типа является пустым. Он используется для описания функций, которые не возвращают значений, а также для указания пустого списка аргументов функции, например:
void main(void) {}
Тема 3. Выражения
В любой программе требуется производить какие-то вычисления. Для вычисления значений используются выражения, которые состоят из операндов, объединенных знаками операций. Операнды задают данные для вычислений и чаще всего являются переменными или константами. Операции выполняются в соответствии с их приоритетами. Для изменения порядка выполнения операций используются круглые скобки. Примеры выражений:
a + 2
(a + b)*c
В первом выражении + является знаком операции, а а и 2 – операндами. Во втором выражении знаками операций являются + и *, а операндами a, b и c. При этом скобки необходимы, иначе первой выполнялась бы операция умножения.
Рассмотрим составные части выражений и правила их вычислений.
Переменные
Переменная – это именованная область оперативной памяти, предназначенная для хранения данных определенного типа. Во время выполнения программы значение переменной может изменяться. Все переменные, используемые в программе, должны быть описаны явным образом. При описании каждой переменной задаются ее имя и тип. Например:
int a;
float x;
Здесь описаны целая переменная с именем a и вещественная переменная с именем x.
Имя переменной служит для обращения к области памяти, в которой хранится значение переменной. Имя дает программист, с учетом, что оно должно соответствовать правилам именования идентификаторов языка С, отражать смысл хранимой величины и быть легко распознаваемым.
Тип переменной выбирается исходя из диапазона и требуемой точности представления данных. Например, нет необходимости описывать переменную вещественного типа для хранения величины, которая может принимать только целые значения, - хотя бы потому, что целочисленные операции выполняются гораздо быстрее.
В одном операторе можно описать несколько переменных одного типа, разделяя их запятыми:
int a, b, с;
При описании переменной можно присвоить ей некоторое начальное значение, т.е. инициализировать ее, например:
int a, b = 100, с;
float x = 0.05, y = 2.37e4;
char ch1 = 65, ch2 = ‘A’;
Здесь описаны:
- переменные a, b и с типа int, при этом переменная b имеет начальное значение 100;
- переменные x и y типа float, которым присвоены начальные значения 0.05 и 23700 соответственно;
- переменные ch1 и ch2 типа char, которым присвоено одно и то же начальное значение 65 (прописная латинская буква A кодируется числом 65).
Существует другая форма записи инициализирующих значений, использующая круглые скобки вместо знака равенства. В соответствии с ней предыдущие операторы описания переменных будут выглядеть так:
int a, b(100), с;
float x(0.05), y(2.37e4);
char ch1(65), ch2(‘A’);
При инициализации можно использовать не только константу, но и выражение – главное, чтобы на момент описания оно было вычисляемым, например:
int a = 5, b = 100;
int с = a * b + 25;
Инициализировать переменную прямо при объявлении не обязательно, но перед тем, как ее использовать в вычислениях, это сделать все равно придется.
Именованные константы
Можно запретить изменять значение переменной, задав при ее описании ключевое слово const, например:
const int A = 5, B = 100, MIN = 100, MAX = 800;
const int C = A * B + 25, STEP = (MAX – MIN)/100;
const float X = 0.05, Y = 2.37e4, PI = 3.14;
Такие величины называются именованными константами или просто константами. Именованные константы должны обязательно инициализироваться при описании. Они применяются в программах для того, чтобы вместо значений констант можно было использовать их имена. Это делает программу более понятной и облегчает внесение в нее изменений, поскольку изменить значение достаточно только в одном месте программы (там, где константа описана и инициализирована). Например, число p = 3.14 может быть впоследствии заменено более точным значением 3.14159 и т.д.
В хорошо написанной программе вообще не должно встречаться иных чисел, кроме 0 и 1, все остальные числа должны задаваться именованными константами с именами, отражающими их назначение. Имена именованных констант принято записывать заглавными буквами, чтобы они отличались от обычных переменных.
Операции
В соответствии с количеством операндов, которые используются в операциях, они делятся на унарные (один операнд), бинарные (два операнда) и тернарную (три операнда).
Операции языка С в порядке убывания их приоритетов
| № | Операции | Выполнение |
| () [] . -> ! ~ ++ -- + - * & (тип) sizeof | слева направо справа налево | |
| * / % + - << >> < <= > >= == != & ^ | && || ?: = += -= *= /= %= &= ^= |= <<= >>= , | слева направо слева направо слева направо слева направо слева направо слева направо слева направо слева направо слева направо слева направо справа налево справа налево слева направо |
В таблице операций первые две строки задают унарные операции, а все последующие – бинарные и одну тернарную (строка 13). Строки упорядочены по убыванию приоритетов операций, при этом операции, записанные в одной строке, имеют одинаковый приоритет. Например, операции *, / и % (строка 3) имеют одинаковый приоритет, который выше, чем приоритет бинарных операций + и - (строка 4).
Операции присваивания
Операции присваивания (строка 14) задают новое значение переменной и подразделяются на простые и сложные. Формат операции простого присваивания:
переменная = выражение
Механизм выполнения операции присваивания такой: вычисляется выражение и его результат заносится в память по адресу, который определяется именем переменной, находящейся слева от знака операции. То, что ранее хранилось в этой области памяти, теряется. Примеры с операцией присваивания:
int a, b = 5, c = 5;
float x = 1.0, y = 33.0;
a = b + c/2;
b = a;
x = x + 0.5;
Рассмотрим последний оператор. Сначала из ячейки памяти, в которой хранится значение переменной х, выбирается это значение. Затем к нему прибавляется 0.5, после чего полученный результат записывается в ту же самую ячейку, а то, что там хранилось ранее, теряется безвозвратно.
Необходимо отметить, что результат вычисления выражения характеризуется значением и типом, например, для b и с равных 5 выражение b + c/2 имеет значение 7 и тип int, т.к. при делении целых чисел дробная часть отбрасывается.
Если операнды, входящие в выражение, разного типа, то перед вычислениями выполняются преобразования более коротких типов в более длинные для сохранения значимости и точности. Такие преобразования называются неявным приведением типов и выполняются автоматически. При этом целочисленные константы имеют по умолчанию тип int, а вещественные – тип double. Например, выражение b + c/2.0 имеет значение 7.5 и тип double. Если же рассмотреть операторы:
a = b + c/2.0;
х = b + c/2.0;
то переменная а, поскольку она целого типа, получит значение 7, а переменная х, поскольку она вещественная, получит значение 7.5. Другие примеры:
х = 10.0 + 9/10; //х = 10.0
х = 10 + 9.0/10; //х = 10.9
х = 5/9*(у – 32.0); //х = 0 для любого значения у
х = 5*(у – 32)/9; //х = 0.555556 для у = 33.0
x = 5.0;
x = 5; //присваивание с неявным приведением типа int к типу float
unsigned char ch1 = 255, ch2;
a = ch1 + 1; //a = 256
ch2 = ch1 + 1; // ch2 = 0
Операция присваивания в отличие от большинства других операций является правоассоциативной, т.е. выполняется справа налево:
a = b = c означает a = (b = c)
Это отличается, например, от операции сложения, для которой a + b + c означает (a + b) + c. Поэтому можно выполнить такое присваивание: a = b = c = 10; (вместо цепочки: a = 10; b = 10; c = 10;).
В сложных операциях присваивания (+=, -=, *=, /= и др.) при вычислении выражения, стоящего в правой части, используется значение из левой части. Например, выражение a += b является более компактной записью выражения a = a + b, выражение a *= b можно использовать вместо выражения a = a * b и т.д.
Инкремент и декремент
Унарные операции инкремента (++) и декремента (--), называемые также операциями увеличения и уменьшения на единицу, имеют две формы записи: префиксную, когда знак операции записывается перед операндом, и постфиксную – после операнда. В префиксной форме сначала изменяется операнд, а затем его значение используется при вычислении выражения, а в постфиксной форме сначала вычисляется выражение с использованием исходного значения операнда, после чего операнд изменяется. Операции инкремента и декремента можно применить только к операндам, которые хранят свои значения в оперативной памяти. Примеры:
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 (потеря информации)