Составной оператор

Составной оператор представляет собой несколько операторов и объявлений,

заключенных в фигурные скобки:

{ [oбъявление]

:

оператор; [оператор];

:

}

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

ставится.

Выполнение составного оператора заключается в последовательном выполнении

составляющих его операторов.

Пример:

int main ()

{

int q,b;

double t,d;

:

if (...)

{

int e,g;

double f,q;

:

}

:

return (0);

}

Переменные e,g,f,q будут уничтожены после выполнения составного оператора.

Следует отметить, что переменная q является локальной в составном операторе,

т.е. она никоим образом не связана с переменной q объявленной в начале функции

main с типом int. Следует отметить также, что выражение стоящее после return

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

9.4. Оператор "IF"

Формат оператора:

if (выражение) оператор-1; [else оператор-2;]

Выполнение оператора if начинается с вычисления выражения. Далее выполнение

осуществляется по следующей схеме:

- если выражение истинно (т.е. отлично от 0), то выполняется оператор-1.

- если выражение ложно (т.е. равно 0),то выполняется оператор-2.

- если выражение ложно и отсутствует оператор-2 (в квадратные скобки

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

оператор.

После выполнения оператора if значение передается на следующий оператор

программы, если последовательность выполнения операторов программы не будет

принудительно нарушена использованием операторов перехода.

Пример:

if (i < j) i++:

else { j = i-3; i++; }

Этот пример иллюстрирует также и тот факт, что на месте оператор-1, так же

как и на месте оператор-2 могут находиться сложные конструкции.

Допускается использование вложенных операторов if. Оператор if может быть

включен в конструкцию if или в конструкцию else другого оператора if. Чтобы

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

конструкции во вложенных операторах if, используя фигурные скобки. Если же

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

наиболее близким if, для которого нет else.

Примеры:

int main ()

{

int t=2, b=7, r=3;

if (t>b)

{

if (b < r) r=b;

}

else r=t;

return (0);

}

В результате выполнения этой программы r станет равным 2.

Если же в программе опустить фигурные скобки, стоящие после оператора if, то

программа будет иметь следующий вид:

int main ()

{

int t=2,b=7,r=3;

if (a>b)

if (b < c) t=b;

else r=t;

return (0);

}

В этом случае r получит значение равное 3, так как ключевое слово else

относится ко второму оператору if, который не выполняется, поскольку не

выполняется условие, проверяемое в первом операторе if.

Следующий фрагмент иллюстрирует вложенные операторы if:

char ZNAC;

int x,y,z;

:

if (ZNAC == '-') x = y - z;

else if (ZNAC == '+') x = y + z;

else if (ZNAC == '*') x = y * z;

else if (ZNAC == '/') x = y / z;

else...

Из рассмотрения этого примера можно сделать вывод, что конструкции

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

достаточно надежными. Другим способом организации выбора из множества различных

вариантов является использование специального оператора выбора switch.

Замечание: Если несколько условий выражения составляют утверждение, то

каждое условие должно быть на отдельной строке.

Пример:

if ((degrees > limit_degrees)

||(x.tenth_minutes > ONE_MINUTE)

||((degrees == limit_degrees)

&& (x.tenth_minutes!= 0)

)

)

{

statementl;

statement2;

}

9.5. Оператор "SWITCH"

Оператор switch предназначен для организации выбора из множества различных

вариантов. Формат оператора следующий:

switch (выражение)

{ [объявление]

:

[ case константное-выражение1]: [ список-операторов1]

[ case константное-выражение2]: [ список-операторов2]

:

:

[ default: [ список операторов ]]

}

Выражение, следующее за ключевым словом switch в круглых скобках, может быть

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

Значение этого выражения является ключевым для выбора из нескольких вариантов.

Тело оператора switch состоит из нескольких операторов, помеченных ключевым

словом case с последующим константным-выражением. Следует отметить, что

использование целого константного выражения является существенным недостатком,

присущим рассмотренному оператору.

Так как константное выражение вычисляется во время трансляции, оно не может

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

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

Все константные выражения в операторе switch должны быть уникальны. Кроме

операторов, помеченных ключевым словом case, может быть, но обязательно один,

фрагмент, помеченный ключевым словом default.

Список операторов может быть пустым, либо содержать один или более

операторов. Причем в операторе switch не требуется заключать последовательность

операторов в фигурные скобки.

Следует отметить также, что в операторе switch можно использовать свои

локальные переменные, объявления которых находятся перед первым ключевым словом

case, однако в объявлениях не должна использоваться инициализация.

Схема выполнения оператора switch следующая:

- вычисляется выражение в круглых скобках;

- вычисленные значения последовательно сравниваются с константными

выражениями, следующими за ключевыми словами case;

- если одно из константных выражений совпадает со значением выражения, то

управление передается на оператор, помеченный соответствующим ключевым

словом case;

- если ни одно из константных выражений не равно выражению, то управление

передается на оператор, помеченный ключевым словом default, а в случае его

отсутствия управление передается на следующий после switch оператор.

Следует отметить интересную особенность использования оператора switch:

конструкция со словом default может быть не последней в теле оператора switch.

Ключевые слова case и default в теле оператора switch существенны только при

начальной проверке, когда определяется начальная точка выполнения тела оператора

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

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

управления из тела оператора switch. Таким образом, программист должен сам

позаботится о выходе из case, если это необходимо. Чаще всего для этого

используется оператор break.

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

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

case.

Пример:

int i=2;

switch (i)

{

case 1: i += 2;

case 2: i *= 3;

case 0: i /= 2;

case 4: i -= 5;

default:;

}

Выполнение оператора switch начинается с оператора, помеченного case 2.

Таким образом, переменная i получает значение, равное 6, далее выполняется

оператор, помеченный ключевым словом case 0, а затем case 4, переменная i примет

значение 3, а затем значение -2. Оператор, помеченный ключевым словом default,

не изменяет значения переменной.

Рассмотрим ранее приведенный пример, в котором иллюстрировалось

использование вложенных операторов if, переписанной теперь с использованием

оператора switch.

char ZNAC;

int x,y,z;

switch (ZNAC)

{

case '+': x = y + z; break;

case '-': x = y - z; break;

case '*': x = y * z; break;

case '/': x = u / z; break;

default:;

}

Использование оператора break позволяет в необходимый момент прервать

последовательность выполняемых операторов в теле оператора switch, путем

передачи управления оператору, следующему за switch.

Следует отметить, что в теле оператора switch можно использовать вложенные

операторы switch, при этом в ключевых словах case можно использовать одинаковые

константные выражения.

Пример:

:

switch (a)

{

case 1: b=c; break;

case 2:

switch (d)

{ case 0: f=s; break;

case 1: f=9; break;

case 2: f-=9; break;

}

case 3: b-=c; break;

:

}

9.6. Операторы "BREAK", "CONTINUE", "GOTO"

Оператор break обеспечивает прекращение выполнения самого внутреннего из

объединяющих его операторов switch, do, for, while. После выполнения оператора

break управление передается оператору, следующему за прерванным.

Оператор continue, как и оператор break, используется только внутри

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

оператора, следующего за прерванным оператором, а с начала прерванного

оператора. Оператор continue, как и оператор break, прерывает самый внутренний

из объемлющих его циклов.

Оператор goto имеет формат

goto <имя-метки>;

...

имя-метки: оператор;

и обеспечивает передачу управления на оператор, помеченный меткой <имя-метки>.

Помеченный оператор должен находиться в той же функции, что и оператор goto, а

используемая метка должна быть уникальной, т.е. одно имя-метки не может быть

использовано для разных операторов программы.

Использование оператороа goto в практике программирования на языке СИ

настоятельно не рекомендуется, так как затрудняетcя понимание программ и

возможность их модификаций.

9.6.1. Оператор "BREAK"

Рассмотрим пример:

while ((ch = getchar())!= EOF)

{

if (ch == '\n')

break;

putchar(ch);

}

Здесь приводится цикл, реализующий эхо-печать символов и завершающийся при

чтении либо признака EOF, либо символа "новая строка". Сделаем логику этого

фрагмента программы более понятной, объединив обе проверки в одном выражении:

while ((ch = getchar())!= EOF && ch!= '\n')

putchar(ch);

Если Вы обнаружите, что "BREAK" является частью оператора "IF", посмотрите,

нельзя ли по-другому выразить это условие (как это сделано в приведенном

примере), чтобы необходимость его использования отпала.

9.6.2. Оператор "CONTINUE"

Рассмотрим пример:

while ((ch = getchar())!= EOF)

{

if (ch == '\n')

continue;

putchar(ch);

}

Здесь приводится цикл, реализующий эхо-печать символов и завершающийся при

чтении признака EOF. Символы "новая строка" просто пропускаются. Запишем этот

фрагмент более компактно:

while ((ch = getchar())!= EOF)

if (ch!= '\n')

putchar(ch);

Стоит заметить, что очень часто, так же как и в данном случае, изменение

условия в операторе "IF" на обратное позволяет исключить необходимость введения

в цикл оператора "CONTINUE". С другой стороны, оператор "CONTINUE" помогает

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

вложенные операторы "IF ELSE".

9.6.3. Оператор "GOTO"

Рассмотрим несколько ситуаций, которые реализуются с помощью оператора

"GOTO", а затем покажем, как это можно осуществить другими средствами языка Си:

1) Работа в ситуации, когда в операторе "IF" требуется выполнить более

одного оператора:

if (size > 12)

goto a;

goto b;

a: cost = cost * 1.05;

flag = 2;

b: bill = cost * flag;

Обычный подход, применяемый в языке Си и заключающийся в использовании

составного оператора или блока, упрощает понимание смысла программы:

if (size > 12);

{

cost = cost * 1.05;

flag = 2;

}

bill = cost * flag;

2) Осуществление выбора из двух вариантов:

if (ibex > 14)

goto a;

sheds = 2;

goto b;

a: sheds = 3;

b: help = 2 * sheds;

Наличие в языке Си структуры "IF-ELSE" позволяет реализовать такой выбор

более наглядно:

if (ibex > 14)

sheds = 3;

else

sheds = 2;

help = 2 * sheds;

3) Реализация бесконечного цикла:

readin: scanf("%d", &score);

if (score < 0)

goto stage2;

.............................; /* большое количество операторов */

goto readin:

stage2:.....................; /* дополнение */

Эквивалентный фрагмент, в котором используется цикл "WHILE", выглядит так:

scanf("%d, &score);

while(score >= 0)

{

.............................; /* большое количество операторов */

scanf("%d, &score);

}

.............................; /* дополнение */

4) Пропуск операторов до конца тела цикла: используйте оператор "CONTINUE".

5) Выход из цикла: используйте оператор "BREAK". Фактически "BREAK" и "CONTINUE"

являются специальными формами оператора "GOTO". Преимущество их использования

заключается в том, что, во-первых, названия этих операторов говорят об

осуществляемых ими функциях, а во-вторых, поскольку они не используют меток,

отсутствует опасность пометить не тот оператор программы.

9.7. Оператор "FOR"

Оператор for - это наиболее общий способ организации цикла. Он имеет

следующий формат:

for (выражение 1; выражение 2; выражение 3) тело

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

переменных, управляющих циклом.

Выражение 2 - это выражение, определяющее условие, при котором тело цикла

будет выполняться.

Выражение 3 определяет изменение переменных, управляющих циклом после

каждого выполнения тела цикла.

Схема выполнения оператора for:

1) Вычисляется выражение 1.

2) Вычисляется выражение 2.

3) Если значения выражения 2 отлично от нуля (истина), выполняется тело цикла,

вычисляется выражение 3 и осуществляется переход к пункту 2, если выражение 2

равно нулю (ложь), то управление передается на оператор, следующий за

оператором for.

Существенно то, что проверка условия всегда выполняется в начале цикла. Это

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

сразу будет ложным.

Пример:

int main()

{ int i,b;

for (i=1; i<10; i++) b="i*i;" return 0; }

В этом примере вычисляются квадраты чисел от 1 до 9.

Некоторые варианты использования оператора for повышают его гибкость за счет

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

Пример:

int main()

{ int top, bot;

char string[100], temp;

for (top=0, bot=100; top < bot; top++, bot--)

{ temp=string[top];

string[bot]=temp;

}

return 0;

}

В этом примере, реализующем запись строки символов в обратном порядке, для

управления циклом используются две переменные: top и bot. Отметим, что на месте

выражение 1 и выражение 3 здесь используются несколько выражений, записанных

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

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

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

выхода из цикла обычно используют дополнительное условие и оператор break.

Пример:

for (;;)

{...

... break;

...

}

Так как согласно синтаксису языка Си оператор может быть пустым, тело

оператора for также может быть пустым. Такая форма оператора может быть

использована для организации поиска.

Пример:

for (i=0; t[i]<10; i++);

В данном примере переменная цикла i принимает значение номера первого

элемента массива t, значение которого больше 10.

9.8. Оператор "WHILE"

Оператор цикла while называется циклом с предусловием и имеет следующий

формат:

while (выражение) тело;

В качестве выражения допускается использовать любое выражение языка Си, а в

качестве тела любой оператор, в том числе пустой или составной.

Схема выполнения оператора while:

1) Вычисляется выражение.

2) Если выражение ложно, то выполнение оператора while заканчивается и

выполняется следующий по порядку оператор. Если выражение истинно, то

выполняется тело оператора while.

3) Процесс повторяется с пункта 1.

Оператор цикла вида

for (выражение-1; выражение-2; выражение-3) тело;

может быть заменен оператором while следующим образом:

выражение-1;

while (выражение-2)

{ тело

выражение-3;

}

Так же как и при выполнении оператора for, в операторе while вначале

происходит проверка условия. Поэтому оператор while удобно использовать в

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

Внутри операторов for и while можно использовать локальные переменные,

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

9.9. Оператор "DO WHILE"

Оператор цикла do while называется оператором цикла с постусловием и

используется в тех случаях, когда необходимо выполнить тело цикла хотя бы один

раз. Формат оператора имеет следующий вид:

do тело while (выражение);

Схема выполнения оператора do while:

1) Выполняется тело цикла (которое может быть составным оператором).

2) Вычисляется выражение.

3) Если выражение ложно, то выполнение оператора do while заканчивается и

выполняется следующий по порядку оператор. Если выражение истинно, то

выполнение оператора продолжается с пункта 1.

Чтобы прервать выполнение цикла до того, как условие станет ложным, можно

использовать оператор break.

Операторы while и do while могут быть вложенными.

Пример:

int i,j,k;

...

i=0; j=0; k=0;

do { i++;

j--;

while (a[k] < i) k++;

}

while (i<30 && j<-30);

9.10. Оператор "RETURN"

Оператор return завершает выполнение функции, в которой он задан, и

возвращает управление в вызывающую функцию, в точку, непосредственно следующую

за вызовом. Функция main передает управление операционной системе. Формат

оператора:

return [выражение];

Значение выражения, если оно задано, возвращается в вызывающую функцию в

качестве значения вызываемой функции. Если выражение опущено, то возвращаемое

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

наличие не обязательно.

Если в какой-либо функции отсутствует оператор return, то передача

управления в вызывающую функцию происходит после выполнения последнего оператора

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

не должна иметь возвращаемого значения, то ее нужно объявлять с типом void.

Таким образом, использование оператора return необходимо либо для

немедленного выхода из функции, либо для передачи возвращаемого значения.

Пример:

int sum (int a, int b)

{ renurn (a+b); }

Функция sum имеет два формальных параметра a и b типа int, и возвращает

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

Возвращаемое оператором return значение равно сумме фактических параметров.

Пример:

void prov (int a, double b)

{ double c;

if (a<3) return; else if (b>10) return;

else { c=a+b;

if ((2*c-b)==11) return;

}

}

В этом примере оператор return используется для выхода из функции в случае

выполнения одного из проверяемых условий.

9.11. Оператор "SIZEOF"

Оператор sizeof позволяет определить размер памяти, которая соответствует

идентификатору или типу. Оператор sizeof имеет следующий формат:

sizeof(выражение)

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

типа, заключенное в скобки. Отметим, что не может быть использовано имя типа

void, а идентификатор не может относится к полю битов или быть именем функции.

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

размер всего массива (т.е. произведение числа элементов на длину типа), а не

размер указателя, соответствующего идентификатору массива.

Когда sizeof применяются к имени типа структуры или объединения или к

идентификатору имеющему тип структуры или объединения, то результатом является

фактический размер структуры или объединения, который может включать участки

памяти, используемые для выравнивания элементов структуры или объединения. Таким

образом, этот результат может не соответствовать размеру, получаемому путем

сложения размеров элементов структуры.

Пример:

struct { char h;

int b;

double f;

} str;

int a1;

a1 = sizeof(str);

Переменная а1 получит значение, равное 12, в то же время если сложить длины

всех используемых в структуре типов, то получим, что длина структуры str равна

7. Несоответствие имеет место в виду того, что после размещения в памяти первой

переменной h длинной 1 байт, добавляется 1 байт для выравнивания адреса

переменной b на границу слова (слово имеет длину 2 байта для машин серии IBM PC

AT /286/287), далее осуществляется выравнивание адреса переменной f на границу

двойного слова (4 байта), таким образом в результате операций выравнивания для

размещения структуры в оперативной памяти требуется на 5 байт больше. В связи с

этим целесообразно рекомендовать при объявлении структур и объединения

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

структуру следует записать в следующем виде:

struct { double f;

int b;

char h;

} str;

Используйте операцию 'sizeof' с именем переменной, а не с типом данных. Этот

подход является более безопасным, так как если изменить тип этой переменной,

операция sizeof по-прежнему возвратит правильный ответ. В противоположность

этому, если применять операцию sizeof к типу данных переменной и позже

изменить ее тип (и при этом не модифицируется параметр операции sizeof),то

в программу будет внесена ошибка.

Поиск по сайту: