Основы программирования

Глава 5
Индекс материала
Глава 5
ОСНОВНЫЕ ОПЕРАЦИИ
Операция сложения: +
Операция вычитания: -
Операция умножения: *
Операция деления: /
Порядок выполнения операций
НЕКОТОРЫЕ ДОПОЛНИТЕЛЬНЫЕ ОПЕРАЦИИ
Операции увеличения и уменьшения: ++ и --
Операция уменьшения: --
Старшинство операций
Не будьте слишком умными
ВЫРАЖЕНИЯ И ОПЕРАТОРЫ
Составные операторы (блоки)
Резюме: выражения и операторы
ПРЕОБРАЗОВАНИЕ ТИПОВ
Операция приведения
Резюме: операции в языке Си
ПРИМЕР ПРОГРАММЫ
ЧТО ВЫ ДОЛЖНЫ БЫЛИ УЗНАТЬ В ЭТОЙ ГЛАВЕ
ВОПРОСЫ И ОТВЕТЫ
Все страницы

Операции, выражения и операторы

КЛЮЧЕВЫЕ СЛОВА
while


ОПЕРАЦИИ
+  -  *  /  %  ++  --  (тип)

В гл 3 и 4 мы говорили о типах данных, используемых в языке Си. Здесь же мы рассмотрим способы обработки данных - для этого язык Си имеет широкий набор возможностей. Начнем с основных арифметических операций сложения, вычитания, умноже ния и деления. Чтобы сделать наши программы более интересными и поучительными, мы впервые в этой главе коснемся циклов. А пока, чтобы ввести вас в курс дела, приведем простую программу, выполняющую несложные арифметические действия

/* размер обуви1 */
#define OFFSET 7 64
#define SCALE 0 325
main( )
{
/* пересчет размера обуви в размер ноги в дюймах */
float shoe, foot;
shoe =90;
foot = SCALE*shoe + OFFSET,
printf(" Размер обуви (мужской) размер ноги\n"),
printf(" %10 lf %13 2f дюйм\n" , shoe, foot),
}

Здорово в нашей программе выполняется умножение и сложе ние, т.е. берется ваш размер обуви (если вы носите размер 9), а вам сообщается длина стопы в дюймах. Вы скажете, что могли бы решитъ данную задачу в уме за меньшее время, чем потребовалось для вода самой программы в машину. Это, конечно, правильно. Создание программы, способной оперировать только одним размером обуви, выглядит как ненужная трата времени и усилий. Мы бы придать программе большую эффективность, сделав ее диалоговой, но и это окажется непроизводительным использовани ем возможностей машины.

Нам нужно лишь каким то образом заставить компьютер выполнить повторяющиеся вычисления. Вообще говоря, именно эта по является одной из главных причин использования машин. Для выполнения арифметических вычислений. Язык Си предлагает несколько способов реализации повторяющихся вычислений, сейчас обсудим один из них. Данный способ, называемый "while", дает возможность использовать операторы языка более интересным образом. Ниже приводится модификация нашей программы, занимающейся пересчетом размеров обуви.

/* размер обуви2 */ 
#define OFFSET 7 64
#define SCALE 0 325
main()
{
/* пересчет размера обуви в размер ноги в дюймах */
float shoe, foot;
printf("Размер обуви (мужской) размер ноги\n");
shoe = 3.0;
while(shoe < 18.5)
{
foot = SCALE *shoe + OFFSET;
printf(" %10 lf %13 2f %l6 2f дюйма\n" , shoe, foot);
shoe = shoe + 1.0;
}
printf"'Ecли эта обувь годится вам, носите ее \n");
}

Вот результат работы программы, размер обуви2, приведенный в сокращеннoм виде.

Размер обуви (мужской)                     Размер ноги
3.01 8.61 дюйма
4.0 8.94 дюйма
... ...
... ...
17.0 13.16 дюйма
18.0 13.46 дюйма

Если эта обувь годиться вам, носите ее.

(Значения констант для данной программы пересчета были по лучены во время нашего визита инкогнито в обувной магазин. В единственном обнаруженном там классификаторе размеров приво дились данные только относительно мужской обуви. Лица, интере сующиеся размерами женской обуви, должны посетить обувной магазин сами).

Цикл while работает следующим образом. Когда программа в процессе выполнения впервые достигает оператора while, осушествляется проверка истинности условия, заключенного в круглые скобки. В этом случае соответствующее выражение имеет вид:

shoe < 18.5

где символ < означает "меньше". Вначале переменная shoe была инициализирована значением 3.0, которое, как видно, меньше 18.5. Поэтому данное условие истинно, и осуществляется переход к следующему оператору, который переводит размер обуви в дюймы. После этого результаты выводятся на печать. Следующий оператор

shoe = shoe + 1.0;

увеличивает значение переменной shoe на 1.0, делая его равным 4.0. В этом месте программы происходит возврат к началу фрагмента while, где вышеупомянутое условие проверяется вновь. По чему именно здесь? Это происходит потому, что следующей строкой программы является закрывающая фигурная скобка } - тело цикла while заключено в фигурные скобки. Операторы, располо женные между ними, являются той частью программы, которая может выполняться повторно. Теперь давайте вернемся к нашей программе: 4 меньше 18.5 ? Безусловно Поэтому весь набор операторов, заключенный в фигурные скобки и следующий за ключевым словом while, выполнится опять. (Специалисты по вычислительной технике в этом случае говорят, что программа выполняет эти операторы "в цикле"). Это продолжается, пока значение переменной shoe не достигнет величины 19.0. Когда условие

shoe < 18.5

станет ложным, поскольку 19.0 не меньше 18.5. При этом произойдет передача управления оператору, следующему сразу за телом цикла while. В нашем случае им является завершающий оператор printf().

Вы можете легко модифицировать эту программу, чтобы она осуществляла другие преобразования. Например, замените значение константы SCALE на 1.8, а константы OFFSET - на 32.0, и вы изучите программу, которая переводит температуру по Цельсию в температуру по Фаренгейту. Если заменить значение SCALE на 0.6214, a OFFSET на 0, то программа будет переводить мили в километры. Производя эти изменения, вы, по видимому, во избежание путаницы должны будете поменять также и печатаемые сообщения.

Цикл while служит удобным и гибким средством управления выполнения программы. Вернемся теперь к обсуждению набора основных операций, которые мы можем использовать в программах.


"Операции" в языке Си применяются для представления арифметических действий. Например, выполнение операции + приводит к сложению двух величин, стоящих слева и справа от этого знака. Если слово "операция" кажется вам странным, подумайте тогда, как назвать эти понятия. Нам слово "операция" представляется лучшим термином, чем, скажем, "арифметические транзакторы" мы рассмотрим операции =, +, -, * и /. (В языке Си нет операции возведения в степень. В одной из следующих глав будет представлена программа, реализующая данную функцию).

В языке Си знак равенства не означает "равно". Он означает операцию присваивания некоторого значения. С помощью оператора

bmw = 2002,

переменной с именем bmw присваивается значение 2002, т.е. элемент слева от знака = - это имя переменной, а элемент справа - ее значение. Мы называем символ = "операцией присваивания". Еще раз хотим обратить ваше внимание на то, что смысл указанной строки не выражается словами "bmw равно 2002". Вместо этого нужно говорить так "присвоить переменной bmw значение 2002". В этой операции действие выполняется справа налево.

Возможно, различие между именем переменной и ее значением покажется вам незначительным. В таком случае давайте рассмотрим следующий сравнительно часто используемый при программировании оператор

i =i + 1;

С математической точкизрения это бессмыслица. Если вы прибавляете единицу к конечному числу, результат не может быть равен исходному числу. Но как оператор присваивания данная строка имеет вполне определенный смысл, который можно выразить, например, такой длинной фразой "Взять значение переменной с именем i, к нему прибавить 1, а затем присвоить новое значение переменной с именем i".

i = i + 1,

РИС. 5.1.

Оператор вида

2002 = bmw,

на языке Си не имеет смысла, поскольку 2002 - число. Вы не можете присвоить константе какое-то значение; ее значением является она сама. Поэтому, сидя за клавиатурой, помните, что элемент, стоящий слева от знака =, всегда должен быть именем переменной.

Тем из вас, кто предпочитает знать правильные названия понятий, скажем, что вместо использованного ранее термина "элемент" обычно употребляют слово "операнд". Операнды - это то, над чем выполняются операции. Например, вы можете описать процесс "поедания" гамбургера как применение операции "поедание" к oпeранду "гамбургер"1).

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

/* таблица результатов турнира по гольфу */
main( ) {
int Jane, tarzan, cheeta, cheeta = tarzan = jane = 68;
printf("cheeta tarzan jane\n");
printf("Cчет первой партии %4d %8d %8d \n", cheeta, tarzan, jane);
}

В то время как многие языки запрещают применять такое троиное присваивание, присутствующее в данной программе, для Си это обычная практика. Присваивания выполняются справа налево сначала переменная jane получает значение 68, затем переменная tarzan и наконец переменная cheeta. Результат выглядит так:

cheeta     tarzan  jane
Счет первой партии 68 68 68

В языке Си имеется несколько других операции присваивания, которые отличаются от операции, описанной в данном разделе, и мы обещаем рассказать о них в следующей главе.


Выполнение операции + приводит к сложению двух величин, стоящих слева и справа от этого знака. Например, в результате работы оператора

printf(" %d", 4 + 20);

на печать будет выведено число 24, а не выражение

4 + 20

Операнды могут быть как переменными, так и константами. Поэтому при выполнении оператора

income = salary + bribes,

компьютер возьмет значения двух переменных, стоящих в правой части, сложит их и присвоит затем полученную сумму переменной income.

Операция + называется "бинарной", или "диадической". Эти названия отражают тот факт, что она имеет дело с двумя операндами.


Выполнение операции вычитания приводит к вычитанию числа, расположеного справа от знака -, из числа, стоящего слева от этого знака. Оператор

takehome = 224.00 - 24.00;

присваивает переменной takehome значение 200.


Операция изменения знака: -

Знак минус используется также для указания или изменения алгебраического знака некоторой величины. Например, в результате выполнения последовательности операторов

rocky = -12;
smokey = -rocky;

переменной smokey будет присвоено значение 12.

Когда знак минус используется подобным образом, данная oneрация называется "унарной". Такое название указывает на то, что она имеет дело только с одним операндом.

 


Операция умножения обозначается знаком *. При выполнении оператора

cm = 2.54 * in;

значение переменной in умножается на 2.54, и результат присваивается переменной cm.

Вы хотите иметь таблицу квадратов натуральных чисел? В языке Си нет функции, осуществляющей возведение в квадрат; вместо этого мы можем использовать умножение.

/* квадраты чисел */
main( ) /* получение таблицы квадратов */
{
int num = 1;
while(num < 21) {
printf("%10d %10d", n, n*n);
n = n + 1;
}

Эта программа выводит на печать первые 20 целых чисел и их квадраты, в чем вы сами легко можете убедиться. Теперь давайте рассмотрим более интересный пример. Вы, наверное, слышали историю о том, как один могущественный правитель обещал наградить ученого, оказавшего ему большую услугу. Ученый, когда его спросили, что бы он хотел получить в награду, указал на шахматную доску и промолвил: "Положите одно пшеничное зерно на первую клетку, два - на вторую, четыре на третью, восемь на следующую и т. д.". Правитель, которому явно недоставало математической эрудиции, был поражен, услышав такую скромную просьбу,- ведь он уже приготовил богатые дары. Программа, приведенная ниже, показывает, в какое смешное положение попал правитель. В ней вычисляется количество зерен, которое надо положить на каждую клетку, а также промежуточные результаты (суммы зерен по числу клеток). Поскольку вы, возможно, не знакомы с урожаями пшеницы, мы, кроме того, сравниваем промежуточные суммы зерен с приблизительными цифрами годового урожая пшеницы в США.

/* пшеница */
#define SQUARES 64 /* число клеток на шахматной доске */
#define CROP 7E14 /* урожай пшеницы в США, выраженный в числе зерен */
main( ) {
double current, total, int count = 1;

printf(" клетка число зерен сумма зерен доля\n");
printf("от урожая в США\n"),
total = current = 1.0; /* начинаем с одного зерна */
printf("%4d %15.2е %13.2е %12.2e\n", count, current, total, total/CROP);
while (count < SQUARES){
count = count + 1;
current =2.0 * current; /* у двоение числа зерен на следующей клетке*/
total = total + current; /* коррекция суммы */
printf(" %4d %15.2е %13.2е %12 2e\n" , count, current, total, total/CROP); }
}

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

На первых 10 клетках оказалось чуть более тысячи зерен пшеницы. Но давайте посмотрим, сколько зерен на пятидесяти клетках.

Добыча ученого превысила весь годовой урожай пшеницы в США. Если вы захотите узнать, что окажется на 64 клетках, выполните программу сами.

Этот пример иллюстрирует феномен экспоненциального роста возрастание населения земного шара и использование нами энергетических ресурсов подчиняются тому же закону.

 

 

Не каждый знает, что заработок в интернете без вложений существует и многие новички уже неплохо зарабатывают.


В языке Си символ / указывает на операцию деления. Величина, стоящая слева от этого знака, делится на величину, расположенную справа от него. Например, в результате выполнения оператора:

four = 12.0/3.0;

перееменной four будет присвоено значение 4.0. Заметим, что над данными целого типа операция деления производится не так, как над данными с плавающей точкой в первом случае результат будет целым числом, а во втором - числом с плавающей точкой. У целого числа нет дробной части, что делает деление 5 на 3 затруднительным, поскольку результат не является целым. В языке Си принято правило, согласно которому дробная часть у результата деления целых чисел oтбрасывается. Это действие называется "усечением".

Попробуйте выполнить приведенную ниже программу, чтобы посмотреть, как осуществляется усечение результата и чем деление чисел отличается от деления чисел с плавающей точкой.

/*Примеры деления */
main()
{
printf(" деление целых: 5/4 это %d \n" , 5/4);
printf(" деление целых 6/3 это %d \п" , 6/3);
printf(" деление целых 7/4 это %d \п" , 7/4);
printf(" деление чисел с плавающей точкой 7 /4 это %2.2f \n", 7 /4 );
printf(" смешанное деление 7 /4 это %2.2f \n" , 7 /4);
}

Мы включили в нашу программу также случай "смешанных" типов, осуществляя детение вещественного числа на целое. Язык Си менее строго "подходит" к подобным вопросам, чем некоторые другие языки, и позволяет выполнять такие операции, но, вообще говоря, смещения типов следует избегать. Вот результаты выполнения указанной программы. Обратите внимание на то, что результат деления целых чисел округляется не до ближайшего целого, а всегда до меньшего целого числа. Когда мы смешиваем целые числа и числа с плавающей точкой, результат будет таким же, как если бы оба операнда были числами с плавающей точкой, поскольку в этом случае перед деле нием целое преобразуется в число с плавающей точкой.

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


Рассмотрим следующую строку:

butter = 25.0 + 60.0 * n / SCALE;

В этом операторе имеются операции сложения, умножения и деления. Какая операция будет выполнена первой? Будет ли 25.0 складываться с 60.0, затем результат 85.0 умножаться на n, а произведение делиться на значение константы SCALE? Или 60.0 умножается на n, результат складывается с 25.0, а сумма затем делится на величину SCALE? Или же существует какой-то другой порядок вы полнения операций? Пусть переменная n равна 6.0, а константа SCALE - 2.0. Если вы выполните данные операции, используя эти значения, вы найдете, что при первом способе вычисления результат равен 255, а при втором - 192.5 При выполнении данной Си программы на машине реализуется, по-видимому, какой-то другой порядок вычислений, поскольку на деле переменная butter получит значение 205.0.

Совершенно очевидно, что изменение порядка выполнения действий может приводить к различным результатам, поэтому язык Си нуждается в наборе непротиворечивых правил, указывающих, какое действие осуществлять первым. Язык Си делает это, за давая приоритет той или иной операции. Каждой операции назна чается уровень старшинства. Умножение и деление имеют более высокий уровень, чем сложение и вычитание, поэтому они выполняются первыми. Если же две операции имеют один и тот же уровень старшинства, они выполняются в том порядке, в котором присутствуют в операторе. Для большинства операций обычный порядок - слева направо. (Операция = является исключением из этого правила.) Поэтому в операторе

butter = 25.0 + 60.0 * n / SCALE;

порядок операций следующий:
60.0 * n - первое умножение (или, возможно, деление) (если n = 6, то 60.0 * n = 360.0).
360.0/SCALE - второе умножение (или, возможно, деление) и наконец (поскольку SCALE = 2.0):
25.0 + 180.0 - первое сложение (или, возможно, вычитание) дает 205.0.

Многие программисты предпочитают представлять порядок вычислений с помощью диаграммы специального вида, называемой "правом выражения". Ниже приводится пример такой диаграммы. Диаграмма показывает, как исходное выражение сводится к одному значению.

Если вы захотите, скажем, чтобы сложение выполнялось перед делением, тогда вы должны делать то же, что и мы в приведенной ниже строке:

hour = (25.0 + 60.0 * n) / SCALE;

В первую очередь выполняется все, что заключено в скобки; внутри действуют обычные правила. В данном примере сначала вы умножение, а затем сложение. С помощью этих действий вычисляется выражение в скобках, и только потом результат делится на значение константы SCALE.

 

Мы можем составить таблицу правил, касающихся уже использованных нами операции. (В приложении В в конце книги приведена таблица, где содержатся правила, относящиеся ко всем операциям языка Си.)

Таблица 5.1.

Операции в порядке уменьшения уровня старшинства
ОПЕРАЦИИ ПОРЯДОК ВЫЧИСЛЕНИЯ
( ) слева направо
-(унарный) слева направо
* / слева направо
+ -(вычитание) слева направо
= справа налево

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

/* применение правил старшинства */
main( ){
int top, score;
top = score = -(2 + 5)*6 + (4 + 3*(2 + 3));
printi("top = %d \n", top);
}

Какое значение будет выведено на печать в результате работы данной программы? Вначале вычислите его сами, а затем выполните программу или прочитайте нижеследующее объяснение, чтобы проверить свой ответ. (Надеемся, что вы получите правильный ре зультат.)

Итак, выражения, стоящие в скобках, имеют наивысший приоритет. Двигаясь слева направо, встречаем первое выражение скобках (2+5). Вычисляя его, получаем

top = score = -7*6 + (4 + 3*(2 + 3))

Следущее выражение в скобках - это (4 + 3*(2 + 3)). Отбрасываем скобки, получаем 4 + 3*(2 + 3). Вот как! Еще одни скобки! Тогда первым шагом является нахождение суммы 2+3. Выражение примет вид:

top = score = -7*6 + (4 + 3*5)

Мы должны еще завершить вычисление выражения в скобках. По-скольку умножение * имеет приоритет более высокий, чем сложение, выражение теперь выглядит так

top = score = -7*6 + (4 + 15)

имеем

top = score = -7*6 + 19.

Что же дальше? Если вы предполагаете, что нужно найти произведение 7*6, то вы ошибаетесь. Заметим, что унарный минус (измениние знака) имеет более высокий приоритет, чем умножение *. Поэтому сначала число 7 заменяется на -7, а затем -7 умножается на 6. Строка примет вид

top = score = -42 + 19

после этого в результате сложения получим

toр  = score = -23

Затем переменной score присваивается значение -23, и, наконец, переменная top получает то же значение -23. Напомним, что операция = выполняется справа налево.


В языке Си имеется около 40 операций, но некоторые из них используются гораздо чаще, чем другие. Те операции, которые мы толькo что рассмотрели, являются наиболее общеупотребительными. Кроме того, нам хотелось бы привести еще три полезные операции. Операция деления по модулю используется в целочисленной арифметикe. Ее результатом является остаток от деления целого числа, стоящего слева от знака операции, на число, расположенное справa от него. Например, 13 % 5 (читается как "13 по модулю 5") имеет значение 3, поскольку справедливо равенство 13 = 2*5 + 3.

Не пытайтесь производить данную операцию над числами с плавающей точкой она просто не будет выполняться.

На первый взгляд эта операция может показаться некоторым экзотическим средством, используемым лишь математиками, но на самом деле она применяется на практике и довольно удобна при программировании ряда задач. Одно широко распространенное применение - содействие пользователю в управлении ходом программы. Предположим, например, что вы пишите программу обработки счетов, которая должна предусматривать дополнительную плату раз в три месяца. Для этого нужно только вычислить оста ток от деления номера месяца на 3 (т.е. month % 3), проверить, равен ли результат 0, и, если равен, добавить к счету величину до полнительной платы. После того как вы познакомились с "оператором if", вы сможете лучше представить себе, как все это работает.

Приведем пример программы, использующей операцию %

/* секунды в минуты */
/* переводит секунды в минуты и секунды */
#define SM 60 /* число секунд в минуте */
main( )
{
int sec, mm, left;
printf(" Перевод секунд в минуты и секунды ! \n");
printf(" Укажите число секунд, которое вы хотели бы перевести в минуты \n" );
scanf(" %d", &sec); /* ввод числа секунд */
mm = sec % SM; /* число минут */
left = sec % SM; /* оставшееся число секунд */
printf(" %d секунды это %d минуты, %d секунды \n", sec, mm, left);
}

Вот результат ее работы

Перевод секунд в минуты и секунды!
Укажите число секунд, которое вы хотели бы перевсти в минуты.
234
234 секунды это 3 минуты 54 секунды.

Недостатком этой диалоговой программы является то, что она обрабатывает только одну входную величину. Сумеете ли вы сами изменить программу так, чтобы она предлагала вам вводить новые значения? Мы вернемся к этой задаче в разделе вопросов в конце главы, но, если вы найдете свое собственное решение, мы будем очень рады.


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

/*выполнение сложения */
main( ) /*увеличение префиксная и постфиксная формы */
{
int ultra = 0, super = 0;

while (super < 6) {
super++;
++ultra;
printf(" super = %d, ultra = %d\n", super, ultra); }
}

Результаты работы программы "выполнение сложения" выглядят слeдyющим образом

super = 1, ultra = 1
super = 2, ultra = 2
super = 3, ultra = 3
super = 4, ultra = 4
super = 5, ultra = 5

Вот это да! Мы досчитали до 5! Дважды! Одновременно! (Если вы захотите считать дальше, вам необходимо будет только изменить параметр, определяющий верхний предел счета в операторе while).

Признаемся, что мы могли бы получить тот же результат, заменив два оператора увеличения следующими операторами присваивания

super = super + 1, ultra = ultra + 1,

Данные операторы выглядят достаточно простыми. В связи с этим возникает вопрос зачем нужен еще один дополнительный оператор, не говоря уже о двух, да еще в сокращенной форме?

Во первых, компактная форма делает ваши программы более изящными и легкими для понимания. Эти операции придают им блеск, что приятно само по себе.
Например, мы можем переписать часть программы "размер обуви2" следующим образом.

size = 3.0;
while(size < 18.5) {
foot = SCALE*size + OFFSET;
printf("%10.1f %20.2f дюймов\n", size, foot);
++size;
}

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

size = 2.0;
while(++size < 18.5) {
foot = SCALE *size + OFFSET;
printf( %10.1f %20.2f дюйма\n" , size, foot); }

Здесь мы объединили в одном выражении операцию увеличения переменной на 1 и проверку истинности условия в операции while. Подобного типа конструкция настолько часто встречается в языке Си, что заслуживает более подробного рассмотрения. Во-первых, как она работает. Очень просто значение переменнной size увеличивается на единицу, а затем сравнивается с 18.5. Если оно меньше, то выполняются операторы, заключенные в фигурные скобки. После этого переменная size увеличивается на единицу один раз и т. д. Данный цикл повторяется до тех пор, пока значение переменной size не станет слишком большим. Мы изменили значение переменной size с 3.0 на 2.0, чтобы скомпенсировать увеличение переменной size перед ее первоначальным использованием для вычисления переменной foot.

 

Во-первых, чем нас привлекает этот способ? Своей компактноcтью. Кроме того (что еще более важно), с его помощью можно объединить в одном выражении два процесса, управляющие циклом. Первый процесс - это проверка, можно продолжать или нет? В данном случае проверяется, меньше ли размер обуви 18.5. Второй процесс заключается в изменении переменной, значение которой проверяется, - в данном случае размер обуви увеличивается на 1. Предположим, мы забыли изменить ее значение. Тогда переменная size всегда будет меньше 18.5, и выполнение цикла никогда не закончится. При выполнении программы компьютер, "пойманный в бесконечный цикл", будет выводить на печать одну за другой идентичные строки. В конце концов вы можете потерять интерес, ожидая результатов, и должны будете каким-то образом пре кратить выполнение программы. Наличие проверки и изменения параметра цикла в одном выражении помогает программистам не забывать вводить в программу коррекцию параметра цикла.

Дополнительное преимущество использования операции увеличения заключается в том, что обычно в результате компиляции по лучается несколько более эффективный объектный код, поскольку она идентична соответствующей машинной команде.

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

main( )
{
int a = 1, b = 1;
int aplus, plusb;
aplus = a++; /* постфиксная форма */
plusb = ++b; /* префиксная форма */
printf(" a aplus b plusb \n");
printf("%5d %5d %5d %5d\n", a, aplus, b, plusb);
}

Если вы все сделали правильно, то, насколько мы помним, в качестве результата вы должны получить следующие строки

а   aplus   b   plusb
2 1 2 2

Как и предполагалось, значения обеих переменных, а и b, увеличились на 1. Однако переменной aplus значение а было присвоено перед изменением а, в то время как переменной plusb значение b было присвоено после изменения b. В этом и заключается разница между префиксной и постфиксной формами.

aplus = а++ - постфикс: переменная а изменяется после того как ее значение используется
plusb = ++b - префикс: переменная b изменяется перед тем как ее значение используется

 

В тех случаях, когда одна из этих операций увеличения используется сама по себе, как, например, в операторе ego++, не имеет значения какой формой вы пользуетесь. Выбор приобретает смысл, когда операция и ее операнд являются частью некоторого "высшего" выражения, как, например, в операторах присваивания, которые мы только что рассматривали. В подобной ситуации необходимо иметь представление о результате, который вам хотелось бы получить. Напомним, например, следующий оператор

while(++size < 18.5) 

При его использовании мы получили таблицу перевода вплоть до размера 18. Но, если бы мы вместо этого записали операцию увеличения в виде size++, в таблицу попал бы и размер 19, поскольку значение переменной size увеличивалось бы после сравнения, а не до этого.

Конечно, вы могли бы использовать менее красивый способ - оператор присваивания

size = size +1;

Тогда никто не поверит вам, что вы умеете по-настоящему программировать на языке Си.

Думаем, что при чтении книги вы уже обратили внимание на приведенные примеры использования операций увеличения. Как вы думаете, могли ли мы всегда пользоваться любой из них или внешние условия диктовали нам конкретный выбор? Говоря о примерах, нам необходимо привести еще один.

Спят ли когда-нибудь компьютеры? Конечно, спят, но они обычно не рассказывают нам об этом. Программа, приведенная ниже показывает, что происходит в действительности.

/* овцы */
#define MAX 40
main( ) {
int count = 0,
printf(" Я считаю овец, чтобы уснуть \n");
while(++ count < MAX)
printf(" %d миллионов овец, а я еще не уснул \n", count);
printf(" %d миллионов овец, а я хр-р-р р \n" , count);
}

Попробуйте выполнить ее и посмотрите, работает ли она так, как должна по вашему мнению. Конечно, значение константы МАХ для вашего компьютера можно взять другим. (Кстати, что произойдет призамене префиксной формы операции увеличения постфиксной формой?)


Каждой операции увеличения соответствует некоторая операция уменьшения, при этом вместо символов ++ мы используем --

-- count, /* префиксная форма операции уменьшения */
count --, /* постфиксная форма операции уменьшения */

Ниже приводится пример, иллюстрирующий, как машины могут быть законченными лириками

/* бутылки */
#define MAX 100
main( ) {
int count = MAX + 1;
while(-- count > 0) {
printf(" %d бутылок пива на полке, %d бутылок пива!\n", count, count);
printf(" Сними одну и пусти ее по кругу, \n");
printf("%d бутылок пива! \n \n", count-1); }
}

Начальные результаты выглядят так:

100 бутылок пива на полке, 100 бутылок пива!
Сними одну ипусти ее по кругу,
99 бутылок пива!
99 бутылок пива на полке, 99 бутылок пива!
Сними одну ипусти ее по кругу,
98 бутылок пива!

Постепенно количество бутылок сходит на нет, и программа завершит свою работу следующим образом

1 бутылок пива на полке, 1 бутылок пива!
Сними одну ипусти ее по кругу,
0 бутылок пива!

По-видимому, у нашего законченного лирика имеются трудности со склонением существительных с количественными числительными, но это можно устранить, используя условные операторы, показываемые в гл. 7. Необходимо заметить, что смысл операции > словами выражается как "больше". Так же как и операция <, она является "операцией отношения". Подробнее операции отношения мы рассмотрим внизу.


В соответствии с принятым в языке Си порядком вычислений операции увеличения и уменьшения имеют очень высокий уровень старшинства; только круглые скобки обладают более высоким приоритетом. Поэтому выражение x*y++ означает (x)*(y++), а не (x*y)++, что очень удобно, поскольку последнее выражение смысла не имеет. (Операции увеличения и уменьшения применяются к переменной, в то время как произведение х*у само по себе не является переменной в отличие от сомножителей).

Не путайте только старшинство этих операций с порядком вычислений. Предположим, у нас есть последовательность операторов:

y  = 2;
n = 3;
nextnum = (у + n ++ )*6;

Какое значение примет переменная nextnum? Подставляя в выражение соответствующие значения, получаем

nextnum = (2 + 3)*6= 5*6 = 30

Только после того как выражение вычислено, значение переменной n увеличивается до 4. Старшинство операций говорит, что операция ++ имеет отношение только к n; кроме того, оно указывает, когда значение переменной n используется при вычислении выражения, но момент изменения значения n определяется семантикой данной операции.


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

while (num < 21)
{
printf("%10d %10d\n", num*num++);
}

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

5

будет напечатано

6

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

Другим возможным источником неприятностей служит оператор вида

ans = num/2 + 5*(1 + num++);

Опять проблема заключается в том, что компилятор может выполнять действия не в том порядке, который вы ожидали. Вы можете считать, например, что сначала он определит значение num/2, а затем перейдет к другой части выражения. Но компилятор может вычислить сначала последний член, увеличить переменною num, а затем использовать новое значение при нахождении num/2. Никакой гарантии в этом случае не существует.

Избежать эти трудности достаточно просто:
1. Не применяйте операции увеличения или уменьшения к переменной присутствующей в более чем одном аргументе функции.
2. Не применяйте операции увеличения или уменьшения к переменной, которая входит в выражение более одного раза.


Мы использовали термины "выражение" и "оператор" на протяжении всех первых глав; теперь настало время изучить их более подробно. Операторы служат основными элементами, из которых строится программа на языке Си; большинство же операторов сосостоит из выражений. Исходя из этого, вначале разумно рассмотреть выражения, что мы и сделаем.

Выражение представляет собой объединение операций и операндов. (Напомним, что операндом называется то, над чем выполняется операция.) Простейшее выражение состоит из одного операнда отталкиваясь от него, вы можете строить более сложные конструкции. Приведем несколько выражений.

4
-64+21
a*(b + c/d)/20
q = 5*2
х = ++q % 3 q > 3

Нетрудно заметить, что операнды могут быть константами, переменными или их сочетаниями. Некоторые выражения состоят из меньших выражении, которые мы можем назвать подвыражениями. Например, с/d - это подвыражение в нашем четвертом примере.

Важным свойством языка Си является то, что каждое выражение в Си имеет значение. Чтобы определить это значение, мы выполняем операции в порядке, определяемом уровнями старшинства. Значения первых нескольких выражений очевидны, но что можно сказать относительно выражений со знаком = ? Они просто имеют те же значения, что и переменная, стоящая слева от знака =. Эта переменная получает его в результате вычисления выражения, стоящего справа от знака. А выражение q > 0? Подобное выражение, связанное с операцией отношения, имеет значение 1, если оно истинно, и 0, если оно ложно. Приведем несколько выражении и их значения

Выражение            Значение
-4+6 2
с = 3 + 8 11
5 > 3 1
6 + (с = 3 + 8) 17

Последний пример выглядит довольно странно. Но он полностью соответствует правилам языка Си, поскольку данное выражение представляет собой сумму двух подвыражении, каждое из которых имеет значение.

Операторы служат основными строительными блоками программы. Программа состоит из последовательности операторов с добавлением небольшого количества знаков пунктуации. Оператор является законченной инструкцией для компьютера. В языке Си указанием на наличие оператора служит символ "точка с запятой", стоящий в конце него. Поэтому

legs = 4

это всего лишь выражение (которое может быть частью большего выражения), но

legs = 4;

является оператором. Что делает инструкцию законченной? Она должна выполнять некоторое действие полностью. Выражение

2 + 2

не является законченной инструкцией, а служит указанием компьютеру сложить 2 и 2, но не говорит, что делать с результатом.

kids = 2 + 2;

служит указанием компилятору (а затем компьютеру) поместить результат (4) в ячейку памяти, помеченную именем kids. После записи в память числа 4 компьютер может приступить к выполнению следующих действий.

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

/ * сумма */
main( ) /* нахождение суммы первых 20 целых чисел */
{
int count, sum; /* оператор описания */
count = 0; /* оператор присваивания */
sum = 0; /* то же самое */
while(count++ < 20) /* while */
sum = sum + count; /* оператор */
printf (" sum = %d\n" , sum); /* вызов функции */
}

Давайте обсудим этот пример. К данному моменту оператор описания должен быть вам уже довольно хорошо знаком. Тем не менее мы напомним, что с его помощью определяются имена и типы переменных и им отводятся ячейки памяти.

Оператор присваивания - это основная рабочая сила большинства программ с его помощью переменной присваивается некоторое значение. Он состоит из имени переменной, за которым следует знак операции присваивания (=), а затем выражение, оканчивающееся символом "точка с запятой". Отметим, что оператор while включает в себя оператор присваивания. Оператор вызова функции приводит к выполнению последовательности операторов, образующих тело функции. В нашем примере функция printf( ) вызывается для того, чтобы вывести на печать результаты работы программы.

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

 

Оператор while принадлежит к классу операторов, иногда называемых "структурированными операторами", поскольку они обладают структурой более сложной, чем структура простого оператора присваивания. В следующих главах мы познакомимся с другими типами структурированных операторов.


"Составной оператор" представляет собой два или более операторов, объединенных с помощью фигурных скобок; он называется также "блоком". В нашей программе размер обуви2 мы использовали такой оператор, чтобы иметь возможность включить в оператор while несколько простых операторов. Сравните между собой фрагменты программы:

/* фрагмент1 */
index = 0;
while (index ++ < 10) sam = 10 * index + 2;
printf(" sam = %d\n", sam);

/* фрагмент2*/
index = 0;
while(index ++ < 10) {
sam = 10*index + 2;
printf(" sam = %d\n", sam);
}

В фрагменте 1 в цикл while включен только оператор присваивания. (При отсутствии фигурных скобок область действия оператора while распространяется от ключевого слова while до следующего символа "точка с запятой".) Печать данных будет произведена только один раз - после завершения цикла.

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

 

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

while(index++ < 10) { 
sam = 10 * index + 2;
printf(" sam = %d\n", sam);
}

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


Выражение состоит из операций и операндов. Примерами простейших выражений являются константы или переменные (операция отсутствует), такие, как 22 или beebop. Более сложные выражения - это 55 + 22 и vap = 2*(vip + (mgx = 4 )).

Оператор служит камандой компьютеру. Операторы бывают простыми и составными. Простые операторы оканчиваются символом "точка с запятой". Примеры:

1. Операторы описания                 int toes;
2. Операторы присваивания toes = 12;
3. Операторы вызова функции printf(" %d\n", toes);
4. Управляющие операторы while (toes < 20) toes = toes + 2;
5. Пустой оператор ;

Составные операторы, или блоки, состоят из одного или более операторов (ко торые в свою очередь сами могут быть составными), заключенных в фигурные скобки. Оператор while, приведенный ниже, содержит, например, составной oпeратор

while(years < 100) {
wisdom = wisdom + 1;
printf(" %d %d\n" , years, wisdom);
}

 


В операторах и выражениях, вообще говоря, должны использоваться переменные и константы только одного типа. Если все же вы смешаете типы в одном выражении, то компилятор с языка Си не считает программу неправильной, как это произошло бы при программировании на Паскале. Вместо этого компилятор использует набор правил для автоматического преобразования типов. Это очень удобно, но может оказаться и опасным, особенно если вы допустили смешение типов нечаянно. (Например, программа lint, работающая в операционной системе UNIX, проверяет несоответствие типов.) Нам представляется разумным привести несколько основных правил, касающихся преобразования типов:
1. Если операция выполняется над данными двух различных типов, обе величины приводятся к "высшему" из двух типов. Этот процесс называется "повышением" типа.
2. Последовательность имен типов, упорядоченных от "высшего" к "низшему", выглядит так: double, float, long, int, short и char. Применение ключевого слова unsigned повышает ранг соответствующего типа данных со знаком.
3. В операторе присваивания конечный результат вычисления выражения в правой части приводится к типу переменной, которой должно быть присвоено это значение. Данный процесс может привести к "повышению" типа, как описано выше, или к "понижению, при котором величина приводится к типу данных, имеющему более низкий приоритет.

Повышение" типа обычно происходит гладко, в то время как понижение" может привести к затруднениям. Причина этого проста: все число целиком может не поместиться в элементе данных низшего типа. Переменная типа char может иметь целое значение 101, но не 22334. Пример, приведенный ниже, иллюстрирует применение этих правил.

/* Преобразования */
main()
{
char ch;
int i;
float fl;
fl = i = ch = 'А'; /* строка 8 */
printf(" ch = %c, i = %d, fl = %2.2f\n", ch, i, fl);
ch = ch + 1; /* строка 10 */
i = fl + 2*ch; /* строка 11 */
fl = 2.0*ch + 1; /* строка 12*/
printf(" ch = %c, i = %d, fl = %2.2f\n", ch, i, fl);
ch = 2.0e30; /* строка 14 */
printf(" Теперь ch = %с \n" , ch);
}

Выполнив программу "преобразования", получим следующие результаты:

ch =A, i = 65, fl = 65.00
ch =B, i = 197, fl = 329.00
Теперь ch =

Вот что происходит в программе.
Строки 8 и 9: Величина ' А' присваивается символьной переменной ch. Переменная i получает целое значение, являющееся преобразованием символа ' А' в целое число, т. е ' 65'. И наконец, перемен ная fl получает значение 65.00, являющееся преобразованием числа 65 в число с плавающей точкой.
Строки 10 и 13: Значение символьной переменной 'А' преобразуется в целое число 65, к которому затем добавляется 1. После этого получившееся в результате число 66 преобразуется в код символа В и помещается в переменную ch.
Строки 11 и 13. При умножении на 2 значение переменной ch преобразуется в целое число (66). При сложении с величиной переменной fl получившееся в результате число (132) преобразуется в число с плавающей точкой. Результат (197.00) преобразуется в число целого типа и присваивается переменной i.
Строки 12 и 13. Перед умножением на 2.0 значение переменной ch(' В') преобразуется в число с плавающей точкой. Перед выполнением сложения величина переменной i(197) преобразуется в число с плавающей точкой, а результат операции (329.00) присваивается переменной fl.
Строки 14 и 15: Здесь производится попытка осуществить преобразование типов в порядке убывания старшинства - переменная ch полагается равной сравнительно большому числу. Результаты оказываются неутешительными. Независимо от переполнения и усечения, которые имеют место, в итоге на нашей системе мы пoлучили код, соответствующий какому-то непечатаемому знаку.

На самом деле существует еще один вид преобразования типов. Для, сохранения точности вычислений при арифметических операциях все величины типа float преобразуются в данные типа double. Это существенно уменьшает ошибку округления. Конечный результат, естественно, преобразуется обратно в число типа float, если это диктуется соответствующим оператором описания. Вам нет не обходимости заботиться о выполнении подобных преобразований, но должно быть приятно сознавать, что компилятор стоит на страже ваших интересов.


Самое лучшее - это вообще избегать преобразования типов особенно в порядке убывания ранга. Но иногда оказывается удобным применять такие преобразования при условии, что вы ясно представляете себе смысл выполняемых действий. Преобразования типов, которые мы обсуждали до сих пор, выполнялись автоматически. Кроме того, существует возможность точно указывать тип данных, к которому необходимо привести некоторую величину.

Этот способ называется "приведением" типов и используется следующим образом: перед данной величиной в круглых скобках записывается имя требуемого типа. Скобки и имя типа вместе образуют операцию приведения". В общем виде она записывается так

(тип)

где фактическое имя требуемого типа подставляется вместо слова "тип".
Рассмотрим две нижеследующие строки, где mice - это переменная типа int. Вторая строка содержит две операции приведения

mice = 1.6 + 1.7;
mice = (int)1.6 + (int)l.7;

В первом примере используется атоматическое преобразование типов. Сначала числа 1.6 и 1.7 складываются - результат равен 3.3. Затем путем отбрасывания дробной части полученное число преобpaзyeтcя в 3 для согласования с типом int переменной mice. Во втором примере 1.6 и 1.7 преобразуются в целые числа 1, так что переменной mice присваивается значение, равное 1+1, или 2.

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

 



Резюме: операции в языке Си

 

Ниже перечислены операции, которые мы уже обсудили.

=      Присваивает величину справа от знака переменной слева от него 
+ Прибавляет величину справа от знака к величине слева от него
- Вычитает величину справа от знака из величины слева от него
- Унарная операция, изменяет знак величины справа от знака
* Умножает величину справа от знака на величину слева от него
/ Делит величину слева от знака на величину справа от него.
Результат усекается, если оба операнда целые числа
% Дает остаток при делении величины слева от знака на величину
справа от него (только для целых чисел)
++ Прибавляет 1 к значению переменной слева от знака (префиксная форма)
или к значению переменной справа от знака (постфиксная форма)
-- Аналогичная операции ++, но вычитает 1
sizeof Дает размер операнда, стоящего справа, в байтах.
Операнд может быть спецификацией типа, заключенного в круглые скобки,
как, например, sizeof (float), или именем конкретной переменной,
массива и т. п., например sizeof foo
(тип) Операция приведения: приводит величину, стоящую справа, к типу,
определяемому ключевым словом (или словами) в скобках. Например,
(float)9 преобразует целое число 9 в число с
плавающей точкой 9.0.

 


На рис. 5.8 приведена программа, которая может оказаться полезной тем, кто занимается бегом, и которая иллюстрирует некоторые положения данной главы. Она выглядит довольно длинной, но все вычисления в ней выполняются шестью операторами, помещенными в конце. Большей частью программа занимается организацией диалога между машиной и пользователем. Мы ввели в программу достаточно большое число комментариев, чтобы сделать ее почти самодокументируемой. Просмотрите ее, а затем мы объясним некоторые ее моменты.

/* бег */
# define SM 60 /* число секунд в минуте */
# define SH 3600 /* число секунд в часе */
# define МК 0.62137 /* число миль в километре */
main()
{
float distk, distm; /* дистанция в км и милях */
float rate; /* средняя скорость в милях в час */
int min, sec; /* время бега в минутах и секундах */
int time; /* время бега в секундах */
float mtime; /* время пробега одной мили в секундах */
int mmin, msec; /* время пробега одной мили в минутах и секундах */

printf(" Эта программа пересчитывает ваше время пробега дистанции, выраженной в км, \n");
printf(" во время, требуемое для пробега одной мили, и вашу среднюю \n");
printf(" скорость в милях в час,\n");
printf(" Укажите, пожалуйста, дистанцию в километрах.\n");
scanf(" %f ", &distk);
printf(" Введите затем время в минутах и секундах. \n ");
printf(" Начните с ввода минут. \n");
scanf(" %d", &min);
printf(" Теперь вводите секунды. \n");
scanf(" %d", &sec);
time = SM * mm + sec; /* переводит время в секунды */
distm = MK * distk; /* переводит километры в мили */
rate = distm / time*SH; /* число миль в сек * число
сек в час = число миль в час */
mtime = (float)time / distm; /* время/дистанция = время на милю */
mmin = (int)mtime / SM; /* находит целое число минут */
msec = (int)mtime % SM; /* находит остаток в секундах */
printf("Bы пробежали %1.2f KM (%1.2f мили) за %d мин %d с \n",
distk, distm, mm, sec);
printf(" Эта скорость соответствует пробегу мили за %d : мин", mmin);
printf("%d c.\n Ваша средняя скорость %l.2f миль/ч \n", msec, rate);
}

РИС. 5. 8. Программа, полезная для тех, кто занимается бегом

Здесь мы применили тот же подход, который использовали в программе секунды в минуты для перевода времени, выраженного в секундах, в минуты и секунды. Кроме того, нам пришлось воспользоваться преобразованиями типов. Почему? Потому что для той части программы, которая занимается переводом секунд в ми нуты, нам требуются аргументы целого типа, а при преобразовании из метрической системы в мили используются числа с плавающей точкой. Мы применили операцию приведения для того, чтобы сделать эти преобразования явными.

Честно говоря, нашу программу можно было бы написать, используя только автоматическое преобразование типов. Мы так и делали, применяя операцию приведения переменной mtime к типу int, чтобы при вычислении времени все операнды были целого типа. Однако такая версия компилятора работает всего на одной из двух доступных нам систем. Использование операции приведения не только проясняет ваш замысел человеку, знакомящемуся c вашей программой, но и упрощает ее компиляцию.

Вот результат работы данной программы.

Эта программа пересчитывает ваше время пробега дистанции, выраженной в км,
во время, требуемое для пробега одной мили, и вашу среднюю скорость, в милях в час.
Укажите, пожалуйста дистанцию в километрах.
10,0.
Введите затемвремя в минутах и секундах.
Начните с ввода минут.
36.
Теперь введите секунды.
23
Вы пробежали 10,00 км (6,21 мили) за 36 мин. 23 с.
Эта скорость соответствует пробегу мили за 5 мин 51 с.
Ваша средняя скорость 10.25 миль/ч

 


Как использовать операции: +,-,*,/,%,++, --, (type).
Что такое операнд: это - величина, над которой выполняется операция.
Что такое выражение: совокупность операций и операндов.
Как вычислять значение выражения: в соответствии с порядком старшинства.
Как распознать оператор: по символу.
Виды операторов: операторы описания, присваивания, while, составной.
Как сформировать составной оператор: заключить последовательность операторов в фигурные скобки {}.
Как сформируется оператор while: while (проверка условия) оператор.
Как вычисляются выражения со смешанными типами данных: с помощью автоматического преобразования типов.


1. Предположим, все переменные имеют тип int. Определите значение каждой из последующих переменных:
а.     х = (2+3)*6,
б.     х = (12+6)/2*3,
в.     y = x = (2+3)/4,
г.     y = 3 + 2*(x = 7/2 ),
д.     x = (int)3.8 + 3.3,

2. Мы подозреваем, что в программе, приведенной ниже, имеется несколько ошибок. Сумеете ли вы помочь нам их обнаружить?

main( )
{
int i = 1,
float n;

printf(" Внимание! Сейчас появится несколько дробей. \n");
while (i < 30)
n = 1/ i;
printf(" %f", n);
printf(" Вот и все! Конец! \n"),
}


3. Ниже приведена первая попытка сделать программу "секунды в минуты" диалоговой. Программа нас не удовлетворяет. Почему? Как ее улучшить?

#define SM 60
main( )
{
int sec, mm, left,
printf( Эта программа переводит секунды в минуты и секунды \n );
printf( 'Укажите число секунд \n ),
printf( Для окончания работы программы необходимо ввести 0 \n);
while (sec < 0){
scanf( %d", &sec),
mm = sec/SM,
left = sec % SM,
printf("%d с это % d мин %d с \n", sec, mm, left),
printf(" Введите следующее значение \n"),
}
printf( До свидания!\n ),
}



Ответы

1.     а. 30
б. 27(а не 3). Результат 3 можно получить в случае (12 + 6)/(2*3)
в. х = 1, у = 1 (деление целых чисел)
г. х = 3 (деление целых чисел) и у = 9
д. х = 6, так как (int)3.8=3.3 + 3.3 = 6.3, это число будет преобразовано в число 6, поскольку х имеет тип int

2.     Строка 3: должна оканчиваться точкой с запятой, а не запятой.
Строка 7: оператор while представляет собой бесконечный цикл, потому что величина переменной i остается равной 1 и всегда будет меньше 30. По всей видимости, мы собирались написать while(i+ + < 30).
Строки 7-9: отступы в строках подразумевают, по видимому, что из операторов, расположеных в строках 8 и 9, мы намеревались сформировать блок, но отсутствие фигурных скобок означает, что цикл while включает в себя только оператор, расположенный на строке 8; поэтому фигурные скобки должны быть обязательно добавлены.
Строка 8: поскольку 1 и i - оба целого типа, результат деления будет равен 1 при i, равном 1, и 0 - для всех больших значений. Необходимо писать так n = 1.0/i; перед делением значение переменной i будет приведено к типу данных с плавающей точкой и будет получен ненулевой результат.
Строка 9: мы опустили символ "новая строка" в управляющей строке; это приведет к тому, что числа будут печататься на одной строке, если так допускается устройством вывода.

3. Основная трудность лежит в согласовании между оператором, выполняющим проверку (величина переменной sec больше 0 или нет?), и оператором scanf( ), осуществляющим ввод значения переменной sec. В частности, когда проверка выполняется первый раз, переменная sec в программе еще не получает своего значения, и поэтому сравнение будет производиться с некоторой случайной величиной (мусором"), которая может оказаться в соответствующей ячейке памяти. Одно решение, хотя и некрасивое, заключается в инициализации переменной sec, скажем величиной 1, в результате чего первый раз сравнение выполнится. Но здесь обнаруживается вторая проблема. Когда при окончании работы мы набираем величину 0, чтобы остановить программу, оказывается, что значение переменной sec проверяется только после завершения шага цикла и происходит вывод на печать результатов для 0 секунд. На самом деле нам хотелось бы, чтобы оператор scanf( ) выполнялся перед тем, как осуществляется проверка в операторе while. Этого можно достичь путем следующей модификации средней части программы

scanf(" %d," &sec);
while(sec > 0){
mm = sec / SM;
left = sec % SM;
printf(" %d с это %d мин %d с \n", sec, mm, left);
printf(" Введите следующее значение \n");
scanf(" %d ", &sec);
}

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

УПРАЖНЕНИЯ

Ниже приводятся задачи, решения которых мы не даем. Чтобы узнать, работает ли ваша программа, необходимо выполнить ее на вашей машине.
1. Измените нашу программу "сумма" так, чтобы она определяла сумму первых 20 чисел. (Если хотите, можете считать, что эта программа вычисляет, сколько денег вы получите за 20 дней, если в первый день вы получите 1 долл , во второй - 2, в третий - 3 и т.д.). Модифицируйте потом свою программу таким образом, чтобы вы могли в диалоговом режиме указать ей, до какого дня следует вести расчет, т. е. замените константу 20 переменной, значение которой присваивается в результате операции ввода.

2. А теперь модифицируйте свою программу так, чтобы она вычисляла сумму квадратов целых чисел (Или, если вам так больше нравится, сколько вы всего получите денег, если в первый день вам заплатят 1 долл , во второй - 4, в третий - 9 и т. д. Это гораздо более прибыльное дело!) Учтите, что в языке Си нет функции возведения в квадрат, но вы можете использовать тот факт, что квадрат числа n - это просто n*n.

3. Измените свою программу так, чтобы после завершения вычислений она запрашивала у вас новое значение переменной и выполняла вычисления повторно. Окончание работы программы должно происходить при вводе 0. (Указание, используйте такую конструкцию, как цикл в цикле См также вопрос 3 и решение к нему ).

 
iPhone 4g купить. Купить apple iPhone 4. iPhone 4g 32gb цена.