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

 

Бинарными арифметическими операциями являются +, –, *, / и операция деления по модулю %. Имеется унарная операция – , но не существует унарной операции +.

При делении целых дробная часть отбрасывается. Выражение:

x % y

дает остаток от деления x на y и, следовательно, равно нулю, когда х делится на y точно. Например, год является високосным, если он делится на 4, но не делится на 100, исключая то, что делящиеся на 400 годы тоже являются високосными. Поэтому

 

if(year%4 == 0 && year%100 != 0 || year%400 == 0)

год високосный;

else

год невисокосный;

 

Операцию % нельзя использовать с типами float или double. Операции + и – имеют одинаковое старшинство, которое младше одинакового уровня старшинства операций *, / и %, которые в свою очередь младше унарного минуса. Арифметические операции группируются слева направо. (Сведения о старшинстве и ассоциативности всех операций собраны в таблице в конце этой главы). Порядок выполнения ассоциативных и коммутативных операций типа + и – не фиксируется; компилятор может перегруппировывать даже заключенные в круглые скобки выражения, связанные такими операциями.

Таким образом, а+(b+c) может быть вычислено как (a+b)+c. Это редко приводит к какому-либо расхождению, но если необходимо обеспечить строго определенный порядок, то нужно использовать явные промежуточные переменные.

Действия, предпринимаемые при переполнении и антипереполнении (т.е. при получении слишком маленького по абсолютной величине числа), зависят от используемой машины.

 

Операции отношения и логические операции

 

Операциями отношения являются

=> > =< < .

Все они имеют одинаковое старшинство. Непосредственно за ними по уровню старшинства следуют операции равенства и неравенства:

== != ,

которые тоже имеют одинаковое старшинство. Операции отношения младше арифметических операций, так что выражения типа i<lim-1 понимаются как i<(lim-1), как и предполагается.

Логические связки && и || более интересны. Выражения, связанные операциями && и ||, вычисляются слева направо, причем их рассмотрение прекращается сразу же как только становится ясно, будет ли результат истиной или ложью. Учет этих свойств очень существенен для написания правильно работающих программ. Рассмотрим, например, оператор цикла в считывающей строку функции getline, которую мы написали в главе 2:

 

for(i=0;i<lim-1 && (c=getchar())!='\n' && c!=eof; ++i)

s[i]=c;

 

Ясно, что перед считыванием нового символа необходимо проверить, имеется ли еще место в массиве s, так что условие i<lim-1 должно проверяться первым. И если это условие не выполняется, мы не должны считывать следующий символ.

Так же неудачным было бы сравнение символа в переменной c с eof до обращения к функции getchar: прежде чем проверять символ, его нужно считать.

Старшинство операции && выше, чем у ||, и обе они младше операций отношения и равенства. Поэтому такие выражения, как

i<lim-1 && (c = getchar()) != '\n' && c != eof

не нуждаются в дополнительных круглых скобках.

 

Но так как операция != старше операции присваивания, то для достижения правильного результата в выражении

(c = getchar()) != '\n'

скобки необходимы.

 

Унарная операция отрицания ! преобразует ненулевой или истинный операнд в 0, а нулевой или ложный операнд в 1. Обычное использование операции ! заключается в записи

if( ! inword )  вместо if( inword == 0 )

 

Tрудно сказать, какая форма лучше. Конструкции типа ! inword читаются довольно удобно («если не в слове»). Но в более сложных случаях они могут оказаться трудными для понимания.

Упражнение 3-1. Напишите оператор цикла, эквивалентный приведенному выше оператору for, не используя операции &&.

 

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

 

Если в выражениях встречаются операнды различных типов, то они преобразуются к общему типу в соответствии с небольшим набором правил. В общем, автоматически производятся только преобразования, имеющие смысл, такие как, например, преобразование целого в плавающее в выражениях типа f+i. Выражения же, лишенные смысла, такие как использование переменной типа float в качестве индекса, запрещены.

Во-первых, типы char и int могут свободно смешиваться в арифметических выражениях: каждая переменная типа char автоматически преобразуется в int. Это обеспечивает значительную гибкость при проведении определенных преобразований символов.

Пример 3-2. Примером может служить функция atoi, которая ставит в соответствие строке цифр ее численный эквивалент.

 

atoi(char s[]) // Преобразование s в целое

{

int i, n;

n = 0;

for ( i = 0; s[i]>='0' && s[i]<='9'; ++i)

n = 10 * n + s[i] - '0';

return(n);

}

Kак уже обсуждалось в главе 2, выражение s[i]-'0' имеет численное значение находящегося в s[i]символа, потому что значение символов '0', '1' и т.д. образуют возрастающую последовательность расположенных подряд целых положительных чисел.

Пример 3-3. Другой пример преобразования char в int дает функция lower, преобразующая данную прописную букву в строчную. Если выступающий в качестве аргумента символ не является прописной буквой, то lower возвращает его неизменным. Приводимая ниже программа справедлива только для набора символов ASCII.

 

lower(int c) // Преобразование прописных в строчные

{

if ( c >= 'A' && c <= 'Z' )

return( c + 'a' - 'A');

else    // @ записано вместо 'a' строчного

return(c);

}

 

Эта функция правильно работает при коде ASCII, потому что численные значения, соответствующие в этом коде прописным и строчным буквам, отличаются на постоянную величину, а каждый алфавит является сплошным – между a и z нет ничего, кроме букв. Это последнее замечание для набора символов EBCDIC систем IBM 370 оказывается несправедливым, в силу чего эта программа на таких системах работает неправильно – она преобразует не только буквы.

При преобразовании символьных переменных в целые возникает один тонкий момент. Дело в том, что сам язык не указывает, должны ли переменным типа char соответствовать численные значения со знаком или без знака. Может ли при преобразовании char в int получиться отрицательное целое? К сожалению, ответ на этот вопрос меняется от машины к машине, отражая расхождения в их архитектуре. На некоторых машинах (PDP-11, например) переменная типа char, крайний левый бит которой содержит 1, преобразуется в отрицательное целое («знаковое расширение»). На других машинах такое преобразование сопровождается добавлением нулей с левого края, в результате чего всегда получается положительное число.

Определение языка «C» гарантирует, что любой символ из стандартного набора символов машины никогда не даст отрицательного числа, так что эти символы можно свободно использовать в выражениях как положительные величины. Но произвольные комбинации двоичных знаков, хранящиеся как символьные переменные на некоторых машинах, могут дать отрицательные значения, а на других положительные.

Наиболее типичным примером возникновения такой ситуации является случай, когда значение 1 используется в качестве eof. Рассмотрим программу:

 

char c;

c = getchar();

if ( c == eof )

...

 

На машине, которая не осуществляет знакового расширения, переменная c всегда положительна, поскольку она описана как char, а так как eof отрицательно, то условие никогда не выполняется. Чтобы избежать такой ситуации, мы всегда предусмотрительно использовали int вместо char для любой переменной, получающей значение от getchar.

Основная же причина использования int вместо char не связана с каким-либо вопросом о возможном знаковом расширении. просто функция getchar должна передавать все возможные символы (чтобы ее можно было использовать для произвольного ввода) и, кроме того, отличающееся значение eof. Следовательно значение eof не может быть представлено как char, а должно храниться как int.

Другой полезной формой автоматического преобразования типов является то, что выражения отношения, подобные i>j, и логические выражения, связанные операциями && и ||, по определению имеют значение 1, если они истинны, и 0, если они ложны. Таким образом, присваивание:

isdigit = c >= '0' && c <= '9';

 

полагает isdigit равным 1, если c – цифра, и равным 0 в противном случае. (В проверочной части операторов if, while, for и т.д. «истина» просто означает «не нуль»).

 

Неявные арифметические преобразования работают в основном, как и ожидается. В общих чертах, если операция типа + или *, которая связывает два операнда (бинарная операция), имеет операнды разных типов, то перед выполнением операции «низший» тип преобразуется к «высшему» и получается результат «высшего» типа. Более точно, к каждой арифметической операции применяется следующая последовательность правил преобразования.

1. Типы char и short преобразуются в int, а float в double.

2. Затем, если один из операндов имеет тип double, то другой преобразуется в double, и результат имеет тип double.

3. В противном случае, если один из операндов имеет тип long, то другой преобразуется в long, и результат имеет тип long.

4. В противном случае, если один из операндов имеет тип unsigned, то другой преобразуется в unsigned и результат имеет тип unsigned.

5. В противном случае операнды должны быть типа int, и результат имеет тип int.

 

Подчеркнем, что все переменные типа float в выражениях преобразуются в double; в языке «C» вся плавающая арифметика выполняется с двойной точностью.

Преобразования возникают и при присваиваниях; значение правой части преобразуется к типу левой, который и является типом результата. Символьные переменные преобразуются в целые либо со знаковым расширением, либо без него, как описано выше. Обратное преобразование int в char ведет себя хорошо – лишние биты высокого порядка просто отбрасываются. Таким образом, если:

 

int i;

char c;

i = c;

c = i;

 

то значение символа c не изменяется. Это верно независимо от того, вовлекается ли знаковое расширение или нет.

 

Если х типа float, а i типа int, то как

х = i;

так и

i = х;

 

приводят к преобразованиям; при этом float преобразуется в int отбрасыванием дробной части. Тип double преобразуется во float округлением. Длинные целые преобразуются в более короткие целые и в переменные типа char посредством отбрасывания лишних битов высокого порядка.

 

Так как аргумент функции является выражением, то при передаче функциям аргументов также происходит преобразование типов: в частности, char и short становятся int, а float становится double. Именно поэтому мы описывали аргументы функций как int и double даже тогда, когда обращались к ним с переменными типа char и float.

Наконец, в любом выражении может быть осуществлено («принуждено») явное преобразование типа с помощью конструкции, называемой перевод (cast). В этой конструкции, имеющей вид:

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

 

выражение преобразуется к указанному типу по правилам преобразования, изложенным выше. Фактически точный смысл операции перевода можно описать следующим образом: выражение как бы присваивается некоторой переменной указанного типа, которая затем используется вместо всей конструкции. Например, библиотечная процедура sqrt ожидает аргумента типа double и выдаст бессмысленный ответ, если к ней по небрежности обратятся с чем-нибудь иным. Таким образом, если n – целое, то выражение:

sqrt((double)n)

 

до передачи аргумента функции sqrt преобразует n к типу double.

 

Отметим, что операция перевод преобразует значение n в надлежащий тип; фактическое содержание переменной n при этом не изменяется. Операция перевода имрация перевода имеет тот же уровень старшинства, что и другие унарные операции, как указывается в таблице в конце этой главы.

Упражнение 3-2. Составьте программу для функции htoi(s), которая преобразует строку шестнадцатеричных цифр в эквивалентное ей целое значение. При этом допустимыми цифрами являются цифры от 1 до 9 и буквы от а до f.