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

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

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

.

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

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

Таблица 1. Операции языка С

Операция	Описание	Приоритет		Ассоциация
Первичные и постфиксные операции
[]	индексация массива	16	слева направо
()	вызов функции	16	слева направо
.	элемент структуры	16	слева направо
->	элемент указателя	16	слева направо
++	постфиксный инкремент	15	слева направо
--	постфиксный декремент	15	слева направо
Одноместные операции
++	префиксный инкремент	14	справа налево
--	префиксный декремент	14	справа налево
sizeof	размер в байтах	14	справа налево
(тип)	приведение типа	14	справа налево
~	поразрядное NOT	14	справа налево
!	логическое NOT	14	справа налево
-	унарный минус	14	справа налево
&	взятие адреса	14	справа налево
*	разыменование указателя	14	справа налево
Двухместные и трехместные операции
Мультипликативные
*	умножение	13	слева направо
/	деление	13	слева направо
%	взятие по модулю	13	слева направо
Аддитивные
+	сложение	12	слева направо
-	вычитание	12	слева направо
Поразрядного сдвига
<<	сдвиг влево	11	слева направо
>>	сдвиг вправо	11	слева направо
Отношения
<	меньше	10	слева направо
<=	меньше или равно	10	слева направо
>	больше	10	слева направо
>=	больше или равно	10	слева направо
==	равно	9	слева направо

Операция	Описание	Приоритет	Ассоциация
! =	не равно	9	слева направо
Поразрядные
&	поразрядное AND	8	слева направо
^	поразрядное XOR	7	слева направо
|	поразрядное OR	6	слева направо
Логические
&&	логическое AND	5	слева направо
||	логическое OR	4	слева направо
Условные
? :	условная операция	3	справа налево
Присваивания
=	присваивание	2	справа налево
*=	присвоение произведения	2	справа налево
/=	присвоение частного	2	справа налево
%=	присвоение модуля	2	справа налево
+=	присвоение суммы	2	справа налево
-=	присвоение разности	2	справа налево
<<=	присвоение левого сдвига	2	справа налево
>>=	присвоение правого сдвига	2	справа налево
&=	присвоение AND	2	справа налево
^=	присвоение XOR	2	справа налево
|=	присвоение OR	2	справа налево
,	запятая	1	слева направо

 

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

К арифметическим мы отнесем те операции, которые перечислены в таблице под рубриками “Мультипликативные” и “Аддитивные”. Нужно сказать, что только эти операции (да и то за исключением взятия по модулю) имеет смысл применять к вещественным операндам (типам float, double и long double). Для таких операндов все обстоит вполне понятным образом; это обычные умножение, деление, сложение и вычитание.

Операция взятия по модулю применяется только к целочисленным операндам(char, short, int. long) и дает остаток от деления первого операнда на второй.

Специальной операции деления нацело в С нет — для него применяется обычная операция деления (/). Если оба операнда ее являются целыми, то результат этой операции также будет целым,равным частному от деления с остатком первого операнда на второй.

Функции

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

Синтаксис определения функции:

возвращаемый_тип имя_функции(список_параметров)

{

<тело_функции>

}

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

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

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

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

имя_функции (фактические параметры);

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

Функции, “возвращающие значение” типа void, могут вызываться только таким образом. С другой стороны, возвращаемое функцией значение можно использовать в выражениях наряду с переменными и константами:

double arg = 0.456;

double result = 1. - cos(arg);

Пока мы имели дело всего с тремя функциями: main (), printf () и getch () . Теперь подробнее познакомимся с printf () и другими функциями ввода-вывода стандартной библиотеки С.

Функция вывода printf()

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

ется стандартная функция printf(...), имеющая такой прототип:

int printf("форматная строка", arg1,arg2,....);

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

Функция возвращает количество выведенных байт, которое обычно игнорируется.

Форматная строка может содержать объекты трех типов:

- обычные текстовые символы, имеющие графическое начертание

и обозначенные на клавиатуре, которые должны быть выведены;

- спецификации преобразования формата вывода аргументов;

- управляющие символьные константы.

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

%d - знаковое целое;

%u - беззнаковое целое;

%x - целое в 16-ричной записи;

%f - вещественное с фиксированной точкой

в виде d...d.dddddd;

%e - вещественное с плавающей точкой

в виде d.dddddE-dd;

%c - одиночный символ;

%s - строка символов;

%p - указатель.

Примечание. Более полная информация по спецификациям

приведена ниже.

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

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

printf("%5c %8d %8x",a,a,a);

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

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

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

В форматах вывода вещественных чисел допустимо дополнительно указывать число цифр после десятичной точки, которые следует вывести. Так, спецификация %9.5f означает, что для вывода числа разрешается занять 9 позиций и после точки следует напечатать 5 значащих цифр. Если же размеры полей не заданы, то по умолчанию выводятся шесть знаков после десятичной точки для спецификации %f и шесть значащих цифр (с учетом одной цифры в целой части) для спецификации %e.

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

Приведем варианты по умолчанию для вещественных переменных. Пусть имеется число a = 1234.56. По умолчанию оно будет выведено так:

Спецификация формата Будет выведено

------------------------------------------------

%f 1234.560000

%e 1.23456E+03

При выводе целых чисел типа long или вещественных чисел типа double перед буквой-спецификатором следует указывать прописную латинскую букву l (эль):

long k=70000;

double t=0.0032;

...............

printf("\n %ld %lf",k,t);

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

Спецификация преобразования

Синтаксис спецификатора преобразования имеет такой вид:

%[флаги] [поле][.точность][размер]символ типа

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

Таблица.2. Элементы спецификатора преобразования

Элемент	Символ	Аргумент	Описание
флаг	-		Выровнять вывод по левому краю поля.
	0		Заполнить свободные позиции нулями вместо пробелов.
	+		Всегда выводить знак числа.
	пробел		Вывести пробел на месте знака, если число положительное.
	#		Вывести 0 перед восьмеричным или Ох перед шестнадцатеричным значением.
поле	число		Минимальная ширина поля вывода.
точность	число		Для строк — максимальное число выводимых символов; для целых — минимальное число выводимых цифр; для вещественных — число цифр дробной части.
размер	h		Аргумент -- короткое целое.
	1		Аргумент — длинное целое.
	L		Аргумент имеет тип long double.
Элемент	Символ	Аргумент	Описание
символ типа	d	целое	Форматировать как десятичное целое со знаком.
	i	целое	То же, что и d.
	о	целое	Форматировать как восьмеричное без знака.
	U	целое	Форматировать как десятичное без знака.
	х	целое	Форматировать как шестнадцатеричное в нижнем регистре.
	Х	целое	Форматировать как шестнадцатеричное в верхнем регистре.
	f	вещественное	Вещественное в форме [-]dddd.dddd.
	е	вещественное	Вещественное в форме [-]d.dddde[+|-]dd.
	Е	вещественное	То же, что и е, с заменой е на Е.
	g	вещественное	Использовать форму f или е в зависимости от величины числа и ширины поля.
	G	вещественное	То же, что и g — но форма f или Е.
	с	символ	Вывести одиночный символ.
	s	строка	Вывести строку
	р	указатель	Вывести указатель в виде шестнадцатеричного числа ХХХХХХХХ.

 

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

Escape-последовательности

В строках языка С для представления специальных (например, непечатаемых) символов используются escape-последователъности,состоящие из обратной дробной черты, за которой следует один или несколько символов. (Название появилось по аналогии с командами управления терминалом или принтером, которые действительно представляли собой последовательности переменной длины, начинающиеся с кода ESC.) В приведенных примерах функции printf () вы уже встречались с одной такой последовательностью — \n. Сама обратная косая черта называетсяescape-символом..

В таблице 3 перечислены возможные esc-последовательности.

Таблица 3. Escape-последовательности языка С

Последовательность	Название	Описание
\а	Звонок	Подает звуковой сигнал.
\b	Возврат на шаг	Возврат курсора на одну позицию назад.
\f	Перевод страницы	Начинает новую страницу.
\n	Перевод строки	Начинает новую строку.
\r	Возврат каретки	Возврат курсора к началу текущей строки.
\t	Табуляция	Переход к следующей позиции табуляции.
\v	Вертикальная табуляция	Переход на несколько строк вниз.
\\		Выводит обратную дробную черту.
\'		Выводит апостроф (одинарную кавычку).
\"		Выводит кавычку (двойную).

 

Кроме того, esc-последовательности могут представлять символы в ASCII-коде — в восьмеричном или шестнадцатеричном формате:

\000	От одной до трех восьмеричных цифр после esc-символа.
\хНН или \ХНН	Одна или две шестнадцатеричных цифры после esc-символа.

 

Функция ввода информации с клавиатуры scanf()

Для ввода данных любого типа с клавиатуры используется стандартная функция scanf(...), обращение к которой таково:

scanf("форматная строка", &arg1,&arg2,....);

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

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

Предупреждение. Ввод по scanf() часто при-

водит к неверному результату, если пользо-

ватель отклоняется от шаблона формата. По-

этому надежнее усложнить способ ввода, ис-

пользуя другие функции, например, gets() и

sscanf().

Обратите особое внимание на то, что за форматной строкой перечисляются не аргументы, а их адреса! Это сделано потому, что задачей функции является изменение значения объекта, для чего необходимо знать именно его адрес. Например:

int a,b;

scanf("%d %d",&a,&b);

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

scanf("%d,%d",&a,&b);

Если требуется ввести некоторую символьную строку, то для нее предварительно необходимо зарезервировать место:

char name[80];

scanf("%s",name);

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

Можно считать, что функция scanf() воспринимает отдельные слова, а не предложения. Поэтому если вы вводите только текст, то удобнее применять функцию gets(). Она воспринимает вводимый текст, включая пробелы, вплоть до нажатия клавиши Enter.

Конечно, если заранее известно количество вводимых слов, то можно заставить правильно работать и функцию scanf() - достаточно записать спецификацию %s для каждого отдельного слова.

Итак, функция scanf() использует пробел, символы табуляции и новой строки для разбиения входного потока символов на отдельные поля. Она сама согласует последовательность спецификаторов с перечнем полей. Единственным исключением из этого правила является спецификация %c, приводящая к чтению к а ж д о г о следую-

щего символа, даже если он является пробелом.

Особо подчеркнем, что при вводе вещественных чисел типа double по форматам %f или %e о б я з а т е л ь н о использовать в формате префикс l ( прописная латинская буква "эль"!!), иначе ввод будет неверен:

double a;

.........

scanf("%lf",&a);

И еще одна неприятная особенность функции scanf(). Ввод числа, как известно, всегда завершается нажатием клавиши Enter. При этом функции scanf() передается символ '\n'. Она считывает все символы до него, интерпретируя их как некоторое число, но сам символ '\n' остается в буфере клавиатуры! При последующем вызове функции scanf() чтение начнется именно с этого символа, что приведет к неверному вводу.

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

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

Обычно это делается в два этапа. Сначала производится ввод числа как обычной символьной строки функцией gets(), которая помещает введенные символы в заранее

зарезервированный буфер. Затем производится преобразование содержимого буфера в число требуемого типа при помощи стандартных функции преобразования:

int atoi(char *buffer) - в целое число;

long atol(char *buffer) - в длинное целое число;

double atof(char *buffer) - в вещественное число.

Приведем пример такой функции ввода вещественного числа:

#include<stdio.h>

#include<stdlib.h>

double f_accept(void)

{

char buf[20]; /* Буфер для ввода строки */

printf(“Введи вещественное число - ”); // Подсказка для ввода

gets(buf);

return atof(buf);

}

Рекомендуем вам запомнить этот надежный способ.

Ввод и вывод в GUI –приложениях

Простейший объект для ввода – поле редактирования (Edit). Он позволяет выполнять как ввод, так и вывод информации (как числовой, так и символьной). Информация хранится в его свойствеText, доступ к которому возможен через указатель:

Edit1->Text.

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

а) для целого числа: intk=StrToInt(Edit1->Text);

б) для вещественного числа: doublea=StrToFloat(Edit1->Text);

При занесении (для вывода) значений в указанное свойство поля редактирования преобразование чисел в строку можно не проводить – это выполняется автоматически:

Edit1->Text= 15;

Edit1->Text= -4.7;

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

Edit1->Text = IntToStr(15);

Edit1->Text = FloatToStr(-4.7);

Строго говоря, свойство Textявляется строкой типаAnsiString, которая несколько отличается от стандартногоchar-массива. При этом используется их взаимное преобразование:

AnsiStringstr;AnsiStringstr= “Privet”;

char *p = “Privet”; char mas[20];

…………………. ………………………….

str = AnsiString(p); strcpy(mas, str.c_str());

Введение

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

a/b;

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

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

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

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

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

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

Любой оператор блока может иметь метку. В принципе на такую метку разрешена передача управления даже извне блока. Это следует делать осмотрительно, поскольку происходит обход объявлений локальных переменных и всех операторов, расположенных выше по тексту.

Основные сведения об условных операторах

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

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

0 если x <= 0

y =

x если x > 0

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

да нет

y = 0

y = x

В тексте программы такому алгоритму соответствует условный оператор:

if(условие) оператор_1;

else оператор_2;

Если условие (или выражение, записанное вместо него) истинно, то выполняется оператор_1, в противном случае выполняется оператор_2. В качестве любого оператора может быть записан составной оператор, т.е. блок.

Конкретно для нашего случая, оператор запишется так:

if(x <= 0) y = 0;

else y = x;

Часто, но не всегда, условие представляет собой два арифметических выражения, соединенных одним из знаков операции отношения:

a == b - a тождественно равно b;

a != b - a не равно b;

a > b - a больше b;

a >= b - a больше или равно b ;

a < b - a меньше b;

a <= b - a меньше или равно b.

Такие условия позволяют сравнивать два операнда. Результат проверки истинности условия – это логическая переменная, которая может принимать одно из двух значений (true – false, т.е. истина - ложь). В языке СИ эти значения адекватны целым числам: истина – единица, ложь - нуль. Поэтому язык СИ разрешает использовать в качестве условий одиночные арифметические выражения(АВ) и даже константы. При этом нулевое значение АВ, независимо от типа – целое или вещественное, трактуется как логическая «ложь», а любое ненулевое – как «истина». Например, вычисление значения функции y = sin(x)/x может быть записано так:

x = ...;

if(x) y = sin(x)/x;

else y = 1.0;

Полезно подумать, почему для вычисления использован условный оператор, а не простое присваивание вида y = sin(x)/x.

Допустимо записывать короткий вариант условного оператора - без ветви else. Такой оператор при ложности условия не выполняет никаких действий.

Запишем фрагмент реализации разветвления с помощью короткого условного оператора. Это вполне возможно, несмотря на отсутствие у него ветви «else»:

y = 0;

if(x > 0) y = x;

Обратите внимание на характерный прием: сначала переменной y произвольно присваивается конкретное значение, а потом проверяется, угадали мы или нет. Если отношение x > 0 окажется истинным, то значение «y» перевычисляется.

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

&& - операция И (AND);

|| - операция ИЛИ (OR);

! - операция НЕ (NOT);

Предупреждение. Логические операции И, ИЛИ

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

операциями, которые обозначаются одиночными

символами & и | соответственно.

Приведем два примера их использования:

a>b && a<c a>0 || b >0 || !(a==b)

Выполнение логической операции "И"(&&) производится так. Последовательно слева направо вычисляются значения всех операндов. Как только будет найден нулевой операнд, дальнейшие вычисления прекращаются, и все логическое выражение получает значение нуль (т.е."ложь"). Если ни один из операндов не оказался нулевым, логическое выражение получает значение “единица”, которое трактуется как "истина".

Похожим образом выполняется логическая операция "ИЛИ"(||). Последовательное вычисление операндов досрочно прекращается, как только будет найден ненулевой операнд, в результате чего все логическое выражение считается истинным и получает значение “единица”. Нулевым оно будет лишь тогда, когда все операнды также будут иметь нулевое значение.

Вычисление выражений, содержащих только логические

операции, прекращается, как только удается

однозначно определить результат.

Операция логического отрицания "!" может стоять перед целой (или булевой) переменной, изменяя тем самым ее логическое значение на противоположное, т.е. ненулевое значение - на нуль, а нуль - на единицу. Результат выполнения операции имеет тип int.

Например:

int k = 0;

if(!k)

{

........ /* Выполняемые действия */

}

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

if(a>b || c>d || e>f) .....

Условное арифметическое выражение

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

<условие> ? <выражение_1> : <выражение_2>

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

int min(int a,int b)

{

return ( a < b ? a : b );

}

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

#define min(a,b) ( a < b ? a: b)

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

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

y = (x <= 0)? 0:x ;

Иногда вместо выражений можно использовать даже операторы.

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

(i < j) ? printf("i<j") : printf("i>=j");

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

printf("Меньшее число = %d", (i>j) ? j:i);

Разветвление на несколько направлений

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

• вложенная структура условных операторов;

• переключатель switch.

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

Синтаксическая структура такова:

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

{

case константа_1:

оператор(ы);

break;

case константа_2:

оператор(ы);

break;

.......................

default:

оператор(ы);

}

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

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

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

Обычно ветвь default располагается в самом конце тела переключателя, и в этом случае нет необходимости завершать ее оператором break. Порядок расположения вариантов, включая default, никакого значения не имеет, хотя разумнее записывать сначала те варианты, которые предположительно будут выбираться чаще. Допустимо любой вариант одновременно помечать несколькими разными метками. Например, для определения нажатия клавиши Y без учета регистра можно написать:

switch(ch = getch())

{

case 'Y':

case 'y':

оператор(ы);

break;

..........

}