Операции в языке Си

Размещено на http://www.allbest.ru/

Билет №1

2). Для каждой группы операций в таблице приоритет одинаков. Чем выше приоритет группы операций, тем выше она расположена в таблице. Порядок выполнения определяет группировку операций и операндов.

() Вызов функции Слева направо

[] Выделение элемента массива

! Логическое отрицание Справа налево

- Изменение знака

++ Увеличение на единицу (increment)

-- Уменьшение на единицу (decrement)

~ Побитовое отрицание (complement)

& Побитовая операция И Слева направо

| Побитовая операция ИЛИ

^ Побитовая операция исключающее ИЛИ (eXclude OR)

<< Сдвиг влево

>> Сдвиг вправо

* Умножение Слева направо

/ Деление

% Деление по модулю

+ Сложение Слева направо

- Вычитание

< Меньше, чем Слева направо

<= Меньше или равно

> Больше, чем

>= Больше или равно

== Равно

!= Не равно

|| Логическая операция ИЛИ Слева направо

&& Логическая операция И Слева направо

= Присваивание Справа налево

+= Сложение с присваиванием

-= Вычитание с присваиванием

*= Умножение с присваиванием

/= Деление с присваиванием

%= Деление по модулю с присваиванием

>>= Сдвиг вправо с присваиванием

<<= Сдвиг влево с присваиванием

&= Побитовое И с присваиванием

|= Побитовое ИЛИ с присваиванием

^= Исключающее ИЛИ с присваиванием

, Запятая Слева направо

Билет№2

2). Арифметические преобразования

Подавляющее большинство операций вызывает преобразование и определяет типы результата аналогичным образом. Приводимая ниже схема в дальнейшем будет называться "обычными арифметическими преобразованиями". Сначала любые операнды типа char или short преобразуются в int, а любые операнды типа float преобразуются в double. Затем, если какой-либо операнд имеет тип double, то другой преобразуется к типу double, и это будет типом результата. В противном случае, если какой-либо операнд имеет тип long, то другой операнд преобразуется к типу long, и это и будет типом результата.

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

Билет№3,15(2)

1) Основные типы данных, операции и выражения

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

Имена переменных. Имена могут состоять из букв латинского алфавита, цифр и символа подчеркивания "_", который считается буквой. Строчные и прописные буквы различаются Beta, beta , BETA - разные имена. Число символов в имени не ограничено. В качестве имен переменных нельзя исползовать зарезервированные слова типа if, else, for, char, int и т.д. Все служебные слова должны быть набраны малыми буквами.

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

Целые константы и константы с плавающей точкой записываются в общепринятой для языков программирования форме:

13, -941, 0, 76; 13.0, 13E+0, -1.76, 0.123e-2, 6.02E23

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

В языке Си существуют правила записи восьмеричных и шестнадцатеричных чисел: если перед целым числом идет 0 (нуль). то это восьмеричная константа: 037, 0776; начальные 0X или 0x указывают на шестнадцатеричное число: 0x f37, 0X1FA.

Символьная константа состоит из заключенного в одиночные кавычки символа, например ' * ' . Символы в языке Си фактически являются целочисленными значениями. Их числовое значение соответствует внутреннему (машинному) представлению символов и некотором принятом стандартном коде. Например, в коде ASCII, широко применяемом в мини- и микрокомпьютерах, значение символа ' A ' равно 65, ' b ' - 98, ' 2' - 50.

Символы, не имеющие графического изображения, и некоторые специальные символы записываются следующим образом: \n - новая строка, \t - табуляция, \0 - нуль (пусто - конец строки), \\ - обратная косая черта, \' апостроф, \b - возврат на шаг, \r - возврат каретки, \f - перевод страницы. Присвоение константам символических имен происходит с помощью процессорного утверждения #define. Например, запись #define MAX 100 перед текстом основной программы определяет имя MAX, являющееся синонимом константы 100.

Строковая константа - это последовательность нуля и более символов, заключенная в двойные кавычки, например "Интересное сообщение" или " " - пустая строка. В конце каждой такой строки транслятор помещает нулевой символ \0, что сильно облегчает программисту поиск конца строки. Технически строка символов представляет собой одномерный массив, каждый элемент которого - один символ.

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

int a, b; int low; char c; float x, dl;

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

int p = 1; float eps = 1.0 e-5;

Арифметические операции. Существуют арифметические операции: +, - , * , / и вычисление остатка от деления - %. Есть унарная операция - (унарный минус). При делении целых чисел дробная часть отбрасывается. Порядок выполнения операциями совпадает с общепринятыми: операции + и- имеют одинаковый приоритет, причем он ниже приоритета операций /, * и % . Самый высокий приоритет унарный минус.

2). Понятие оператора

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

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

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

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

Типично использование составного оператора в качестве тела другого оператора, например оператора if.

Оператор-выражение

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

Условный оператор if

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

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

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

Далее выполнение осуществляется по следующей схеме:

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

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

- если выражение ложно и отсутствует оператор2, то выполняется следующий за if оператор.

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

Оператор пошагового цикла for

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

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

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

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

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

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

3. Если значения выражения 2 отлично от нуля (истина), выполняется тело цикла, вычисляется выражение 3 и осуществляется переход к пункту 2, если выражение 2 равно нулю (ложь), то управление передается на оператор, следующий за оператором for.

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

Оператор цикла с предусловием while

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

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

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

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

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

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

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

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

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

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

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

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

3. Если выражение ложно, то выполнение оператора do while заканчивается и выполняется следующий по порядку оператор. Если выражение истинно, то выполнение оператора продолжается с пункта 1.

Оператор продолжения continue передает управление на следующую итерацию в операторах цикла do, for, while. Он может появиться только в теле этих операторов. Остающиеся в теле цикла операторы при этом не выполняются.

Оператор-переключатель switch

Синтаксис:

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

{

[<объявление>]

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

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

[default:] [<оператор>]

}

Оператор-переключатель switch предназначен для выбора одного из нескольких альтернативных путей выполнения программы. Выполнение оператора-переключателя начинается с вычисления значения выражения переключения (выражения, следующего за ключевым словом switch в круглых скобках). После этого управление передается одному из <операторов> тела переключателя. Оператор, следующий за ключевым словом default, выполняется, если ни одна из констант варианта не равна значению выражения переключения. Если же слово default опущено, то ни один оператор в теле переключателя не выполняется, и управление передается на оператор, следующий за переключателем в программе.

Оператор разрыва break прерывает выполнение операторов do, for, while или switch. Он может содержаться только в теле этих операторов. Управление передается оператору программы, следующему за прерванным.

Оператор перехода goto

Оператор перехода goto передает управление непосредственно на <оператор>, помеченный <меткой>. Метка представляет собой обычный идентификатор. Область действия метки ограничивается функцией, в которой она определена; из этого следует, во-первых, что каждая метка должна быть отлична от других меток в той же самой функции; во-вторых, что нельзя передать управление по оператору goto в другую функцию.

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

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

Билет №4

1). Целые константы

Согласно правилам языка Си, число без десятичной точки и без показателя степени рассматривается как целое. Поэтому 22 и -273 - целые константы. Но число 22.0 нецелое, потому что в его записи имеется десятичная точка, и число 22Е3 тоже нецелое, поскольку в записи использован порядок. Кроме того, указывая целое число, нельзя использовать запятые. Нужно записать 23456 вместо 23,456.

Если вы хотите ввести некоторую константу типа long, то можете это сделать, указав признак L или l в конце числа. Использование прописной буквы L более предпочтительно, поскольку ее труднее спутать с цифрой 1. Примером такой константы служит число 212L. Очевидно, что само по себе число 212 не очень большое, но добавление признака L гарантирует, что в памяти для него будет отведено необходимое число байтов. Это может оказаться важным для достижения совместимости, если данное число должно использоваться вместе с другими переменными и константами типа long.

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

Первый: если целое начинается с цифры 0, оно интерпретируется как восьмеричное число. Восьмеричные числа - это числа, представляемые "по основанию восемь" (т. е. их запись состоит из комбинаций степеней числа восемь). Например, 020 - это удвоенная первая степень основания восемь, т. е. восьмеричный эквивалент числа 16. При отсутствии в первой позиции нуля это просто обыкновенное (десятичное) число 20.

Второй: целое, начинающееся с символом 0х или 0Х интерпретируется как шестнадцатеричное число, т. е. число, записываемое по основанию 16. Поэтому запись 0х20 представляет собой удвоенную первую степень числа 16, или 32.

Восьмеричные и шестнадцатеричные числа чрезвычайно популярны среди программистов. Поскольку 8 и 16 являются степенями числa 2, а 10 - нет, использование этих систем счисления при работе на машине является вполне естественным. Например, число 65536, которое часто возникает при программировании на 16-разрядных компьютерах, в шестнадцатеричной записи имеет вид 10000. Если вы захотите больше узнать о восьмеричных и шестнадцатеричных числах, вы сможете найти дополнительный материал в приложении Ж.

Билет№5

1). Константы с плавающей точкой

Числа с плавающей точкой представляют десятичные значения с дробной частью. Они могут быть выражены в стандартной или научной форме записи. Число в стандартной форме записи состоит из целого числа, за которым следуют десятичная точка и дробная часть. Например, 2.0,3.14159 и 0.6667 представляют допустимые числа с плавающей точкой в стандартной записи. Научная форма записи использует стандартную форму записи числа с плавающей точкой, к которой добавлен суффикс, указывающий степенную функцию числа 10, на которую нужно умножить данное число. Для указания экспоненциальной функции используют символ Е или е, за которым следует десятичное число (положительное или отрицательное). Примерами могут служить 6.022Е23, 314159Е-05 и 2е+100.

По умолчанию в Java константам с плавающей точкой присвоен тип double. Чтобы указать константу типа float, к ней нужно дописать символ F или f. Константу типа double можно также указать явно, дописывая к ней символ D или d. Но, естественно, это излишне. Используемый по умолчанию тип double занимает в памяти 64 бита, в то время как менее точный тип float требует для хранения только 32 битов.

2) ОПЕРАТОРЫ ВОЗВРАТА

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

оператор-возврата ::= return [выражение];

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

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

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

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

Примеры:

return; -- в процедуре return KEY_VALUE(LAST_INDEX); -- в функции

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

Ссыпки: атрибут А, вызов функции 6.4, выражение 4.4, именованное число 3.2, зарезервированное слово 2.9, исключение CONSTRAINT_ERROR 11.1, модуль-задача 9.1, настраиваемое тело 12.1, неявное преобразование типа 4.6, обозначение типа 3.3.2, оператор блока 5.6, оператор принятия 9.5, подтип 3.3, подтип результата 6.1, спецификация подпрограммы 6.1, тело задачи 9.1, тело пакета 7.1, тело подпрограммы 6.3, тело процедуры 6.3, тело функции 6.3, универсальный вещественный тип 3.5.6, универсальный целый тип 3.5.4, числовой литерал 2.4.

числовой операция константа переменная

ОПЕРАТОРЫ ПЕРЕХОДА

Оператор перехода определяет явную передачу управления на помеченный меткой оператор.

оператор перехода ::= goto имя-метки;

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

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

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

Пример:<<COMPARE>> if A(l) < ELEMENT then if LEFT(I) /= 0 then I := LEFT(t); goto COMPARE; end if; -- некоторые операторы end if;

Билет№7

1). Символьные константы

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

Пример char c; c='a'; c='b';

Для кодов, не имеющих видимого представления на экране, предусмотрены специальные обозначения: `\n '-переход к началу новой строки (соответствует нажатию клавиши Enter); `\t'-горизонтальная табуляция; `\a'-звуковой сигнал; `\b'-возврат на один символ; `\v'-вертикальная табуляция, `\r'- возврат каретки.

Такие обозначения называют Escape-последовательности, они используются также для символов кавычка `\”', апостроф '\'' и обратный слэш `\\'.

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

· нормальные символы

· многосимвольные константы

· широкие символы

Вот посмотрите как каждый их типов объявляется:

char a='a';

int b = 'ab';

wchar_t c = L'ab';

Обратите внимание на то, что b имеет тип int. Именно это позволяет использовать два байта для константы. Широкая константа имеет ширину 4 байта. Все остальное будет игнорироваться.

2). Условный оператор

Условный оператор реализует выполнение определённых команд при условии, что некоторое логическое выражение (условие) принимает значение «истина» true. В большинстве языков программирования условный оператор начинается с ключевого слова if.

Встречаются следующие формы условного оператора:

Условный оператор с одной ветвью

if условие then команды end

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

Условный оператор с двумя ветвями

if условие then команды1 else команды2 end

при истинности условия выполняются команды1 при ложности -- команды2. При необходимости проверить последовательно несколько условий возможно каскадирование условных операторов:

if условие1

then команды1

else if условие2 then команды2

else if условие3 then команды3

...

else if условиеN-1 then командыN-1

else командыN end;

В этом случае условия будут проверяться последовательно, и как только встретится истинное, будет выполнен соответствующий набор команд и исполнение перейдёт к команде, следующей за условным оператором. Если ни одно из условий не окажется истинным, выполняются командыN из ветви else.

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

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

if условие1 then команды1

elsif условие2 then команды2

elsif условие3 then команды3

...

else командыN end;

Порядок выполнения этого оператора в точности соответствует вышеприведённому каскаду простых операторов if-then-else, а отличие чисто формальное: вместо вложенных нескольких условных операторов эта конструкция является единым целым и содержит дополнительное ключевое слово elsifвпвыкпкункугнркегнелоарвенкункго, требующее после себя очередное условие.

Билет №8

1). Строковая константа (литерал) - последовательность символов (включая строковые и прописные буквы русского и латинского а также цифры) заключенные в кавычки (") . Например: "Школа N 35", "город Тамбов", "YZPT КОД".

Отметим, что все управляющие символы, кавычка ("), обратная дробная черта (\) и символ новой строки в строковом литерале и в языке программирования Смвольной константе представляются соответствующими управляющими последовательностями. Каждая управляющая последовательность представляется как один символ. Например, при печати литерала "Школа \n N 35" его часть "Школа" будет напечатана на одной строке, а вторая часть "N 35" на следующей строке.

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

Строковый литерал имеет тип char[] . Это означает, что строка рассматривается как массив языке программирования Смволов. Отметим важную особенность, число элементов массива равно числу символов в строке плюс 1, так как нулевой символ (символ конца строки) также является элементом массива. Все строковые литералы рассматриваются компилятором как различные объекты. Строковые литералы могут располагаться на нескольких строках. Такие литералы формируются на основе использования обратной дробной черты и клавиши ввод. Обратная черта с символом новой строки игнорируется компилятором, что приводит к тому, что следующая строка является продолжением предыдущей. Например:

"строка неопределенной \n

длины"

полностью идентична литералу

"строка неопределенной длинны" .

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

2) Оператор-переключатель switch используется для выбора одного из нескольких альтернативных путей выполнения программы. Выполнение даного оператора начинается с вычисления значения, которое идет после switch в скобках. После этого выполняется та часть кода этого оператора, где значение условия совпадет с веткой case. После ветки case обязательно идет оператор break, который обрывает дальнейшее выполнение оператора switch и передает выполнение программы в точку, которая следует сразу после блока switch. Для лучшего понимания рассмотрим пример. Эдесь вычисляемым значением будет целая переменная а, в зависимости от значения переменной а, будет выполнятся та ветка case, которая будет равна а. В случае, если ни одно из case не равно а, то выполнится ветка default.

int a=1; int b=100;

switch (a) // вычисляем а = 1

{

case -5: // эта ветка не выполнится, так как 1 не равно -5

b=-5;

break;

case 1: // а эта ветка выполнится, 1 = 1

b=2; // после выполнения этой ветки b присвоится 2

break;

default: // эта ветка выполнится, если ни одна из веток case не выполнилась

b=0;

}

Следует добавить, что веток case в операторе switch может быть сколько угодно, а ветка default может опускаться (не использоваться).

Основное назначение оператора switch - заменить оператор if, когда в нем есть множество вложенных условий.

Билет № 9

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

Следующие общепринятые определения надлежит хорошо помнить, понимать и знать:

Оператор - это действие или команда, которую может выполнить компьютер (вернее просто язык программирования).

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

Программа это запись алгоритма на языке компьютера (на языке программирования).

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

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

3. Некоторые обозначения операций, принятые в языке С.

Приведем примеры обозначения операций, принятые в языке С:

· (..) - открывающая и закрывающая скобки. Показывают старшинство выполнения действий в скобках.

· . обыкновенная десятичная точка. Отделяет целую часть от дробной части числа.

· ++ увеличение на единицу (increment).

· -- уменьшение на единицу (decrement).

· + сложение.

· - вычитание.

· * умножение.

· / деление.

· > больше.

· < меньше.

· = равно.

· == не равно.

· && логическое умножение или конъюнкция.

· || логическое сложение или дизъюнкция.

· # знак операции препроцессора.

· и так далее...

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

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

В языке С существует только одна операция, которая требует три операнда. Это операция "?", которая будет рассмотрена нами попозже.

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

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

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

4. Арифметические операции и их особенности в языке С.

В языке С к арифметическим операциям относятся следующие операции:

· - вычитание или унарный минус;

· + сложение;

· * умножение;

· / деление;

· % деление по модулю;

· ++ увеличение на единицу;

· -- уменьшение на единицу;

Операции сложения, вычитания, умножения и деления действуют так же, как в большинстве алгоритмических языков программирования. операции выполняются так: сначала вычисляется значение левого выражения (операнда), затем вычисляется значение выражения, стоящего справа от знака действия. Далее, в том случае, когда операнды имеют общий тип данных, этот же тип имеет и результат. Поэтому, если применяется деление "/" к целым числам, например, 11/3, то результат тоже будет целым, то есть в данном случае 3. А выражение 1/2 в этом случае будет равно нулю.

Операция "%" деление по модулю дает остаток от целочисленного деления. Она может применяться к целочисленным переменным. Теперь решим небольую задачу.

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

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

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

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

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

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

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

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

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

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

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

{ тело

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

}

Так же как и при выполнении оператора for, в операторе while вначале происходит проверка условия. Поэтому оператор while удобно использовать в ситуациях, когда тело оператора не всегда нужно выполнять.

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

Билет№10

1). Операция присваивания

Рассматриваемая операция в языке С обозначается как "=". Оператор присваивания может использоваться в выражениях, которые включают в себя оператры сравнения или логические операторы. Например:

if ((f=x-y)>0) printf ("Число x больше, чем y");

Здесь вначале вычисляется величина x-y, которая присваивается переменной f. Далее ее значение сравнивается с нулем.

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

a=b=c=d=x*y;

Здесь Вы видите многократное использование знака присвоения "=". Как выполняется такой оператор? Сначала вычисляется значение правой части выражения: x*y. Далее полученное число записывается в память, отведенную под переменную "d". После этого это же значение записывается в память, отведенную под величину "с" и так далее под величины: "b" и "a".

В левой части оператора присвоения должно стоять выражение, которому можно присваивать значение. Такие выражения в языке С, например, просто переменная, называются величиной lvalue. Например, выражение 2=2 ошибочно, так как константе нельзя присвоить никакое значение. Поэтому константа не является величиной lvalue.

В языке С имеются еще дополнительные операции со знаком присвоения. Это +=, -=, /=, %=. Поясним немного данные операции. Так, например, вместо выражения a=a+5 можно написать a += 5. Здесь операция "+=" это аддитивная операция присвоения. В результате ее выполнения величина, стоящая справа от знака "=", то есть число 5, прибавляется к значению переменной, указанной слева от знака "=".

Отметим, что аналогично выполняются и такие операции, как:

m-=20, что означает то же самое, что и m=m+20;

m*=20, что означает то же самое, что и m=m820;

m/=10, что означает то же самое, что и m=m/10;

m%=10, что означает то же самое, что и m=m%10.

Указанные операции имеют тот же приоритет, что и операция "=". То есть приоритет этих операций ниже, чем приоритет арифметических операций. Отметим, что операция x+=5 выполняется значительно быстрее, чем операция x=x+5.

2) Оператор цикла 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);

Билет№11

1). Операции отношения

Как мы уже знаем, один из стандартных типов переменных в языке MetaQuotes Language 4 -- тип bool. Переменная типа bool может принимать только два значения: ИСТИНА (true) и ЛОЖЬ (false). Значение ЛОЖЬ представляется в виде нулевого значения, а ИСТИНА -- ненулевого.

Значение операции отношения или логической операции будет иметь тип bool.

Операции отношения

Операция Результат

a == b Истина, если a равно b Ложь, если a не равно b

a != b Истина, если a не равно b Ложь, если a равно b

a < b Истина, если a меньше b Ложь, если a больше или равно b

a <= b Истина, если a меньше или равно b Ложь, если a больше b

a > b Истина, если a больше b Ложь, если a меньше или равно b

a >= b Истина, если a больше или равно b Ложь, если a меньше b

Примечание: в связи с тем, что числа с плавающей точкой (тип double) не могут быть представлены точно в связи с ограниченным количеством значащих цифр после запятой (в MetaQuotes Language 4 точность -- 15 значащих цифр), нельзя производить сравнение таких чисел на равенство (==) или неравенство (!=) без предварительной нормализации (о нормализации вещественных чисел я расскажу в следующих выпусках).

2) Оператор 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.

Билет№12

1). Логические операции

Напомню, что значение ЛОЖЬ (false) представляется в виде нулевого значения, а ИСТИНА (true) -- ненулевого.

В этом выпуске я рассмотрю логические операции НЕ (!), ИЛИ (||) и И (&&).

Логическое отрицание НЕ (!)

Операнд A	Значение выражения !A
ИСТИНА (true)	ЛОЖЬ (false)
ЛОЖЬ (false)	ИСТИНА (true)

Пример:

bool b;

b = false; // переменная b равна false (ЛОЖЬ)

b = !b; // переменная b равна true (ИСТИНА)

b = !b; // переменная b равна false (ЛОЖЬ)

Логическая операция ИЛИ (||)

Результат логической операции ИЛИ равен true, если хотя бы один из операндов равен true. Если оба операнда равны false, то и результат логического ИЛИ также будет равен false.

Операнд A	Операнд B	Значение выражения A || B
ЛОЖЬ (false)	ЛОЖЬ (false)	ЛОЖЬ (false)
ЛОЖЬ (false)	ИСТИНА (true)	ИСТИНА (true)
ИСТИНА (true)	ЛОЖЬ (false)	ИСТИНА (true)
ИСТИНА (true)	ИСТИНА (true)	ИСТИНА (true)

Пример

bool a = true; // a равно true

bool b = false; // b равно false

b = b || a; // b равно true

Логическая операция И (&&)

Результат операции логического И будет равен true только в случае, если оба операнда равны true. Во всех иных случаях результат операции будет равен false.

Операнд A	Операнд B	Значение выражения A && B
ЛОЖЬ (false)	ЛОЖЬ (false)	ЛОЖЬ (false)
ЛОЖЬ (false)	ИСТИНА (true)	ЛОЖЬ (false)
ИСТИНА (true)	ЛОЖЬ (false)	ЛОЖЬ (false)
ИСТИНА (true)	ИСТИНА (true)	ИСТИНА (true)

Пример:

bool a = true; // a равно true

bool b = false; // b равно false

b = b && a; // b равно false

2). Определение функции

Определение функции должно располагаться в глобальной области видимости, до начала функции main. Рассмотрим пример, простого определения:

int simple_function ()

{

return 0;

}

Определение функции состоит из заголовка и тела. Заголовок фукнции включает в себя:

Тип возвращаемого значения

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

int simple_function()

float simple_function()

char simple_function()

В первом случае функция должна вернуть целое число (int), во втором - вещественное число (float), а в третьем случае - символ (char).

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

Идентификатор или имя функции

Идентификатор (имя) функции задаётся точно также, как и любой другой идентификатор. В данном примере мы создали функцию с идентификатором simple_function (simple - простой).

Список аргументов или параметров

Список аргументов функции записывается в круглых скобках после имени функции. В данном примере список аргументов пуст.

Список аргументов записывается через запятую. Каждый элемент списка состоит из типа и идентификатора. Рассмотрим пример заголовка функции со списком из двух аргументов:

int simple (int a, float b)

В скобках мы записали два аргумента: a и b. У аргумента a тип int, а у аргумента b тип float.

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

Билет№13

1). Побитовые операции

· Дополнение до единицы. В каждом разряде единица заменяется нулем, а нуль - единицей. Пример:

int b = 141; // начальное значение переменной b равно 141,

// что в двоичном представлении равно 10001101

b = ~b; // переменная b стала равна 01110010, т.е. 114

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

Пример:

int b = 141; // начальное значение переменной b равно 141,

// что в двоичном представлении равно 10001101

b = b >> 2; // переменная b стала равна 00100011, т.е. 67

· Сдвиг влево. Двоичное представление первого операнда сдвигается влево на количество разрядов, равное значению второго операнда. Появившиеся "правые" разряды будут заполняться нулями.

Пример:

int b = 141; // начальное значение переменной b равно 141,

// что в двоичном представлении равно 10001101

b = b << 2; // переменная b стала равна 1000110100, т.е. 564

· Побитовая операция И. Результат будет содержать единицу в тех разрядах, где соответствующие разряды первого и второго операнда содержат единицу. В других случаях соответствующий бит результата будет равен 0.

Пример:

int a = 25; // начальное значение переменной a равно 25,

// что в двоичном представлении равно 00011001

int b = 141; // начальное значение переменной b равно 141,

// что в двоичном представлении равно 10001101

a = a & b; // переменная a стала равна 00001001, т.е. 9

· Побитовая операция ИЛИ. Результат будет содержать ноль в тех разрядах, где соответствующие разряды первого и второго операнда содержат ноль. В других случаях соответствующий бит результата будет равен 1.

Пример:

int a = 25; // начальное значение переменной a равно 25,

// что в двоичном представлении равно 00011001

int b = 141; // начальное значение переменной b равно 141,

// что в двоичном представлении равно 10001101

a = a | b; // переменная a стала равна 10011101, т.е. 157

· Побитовая операция исключающее ИЛИ. Значение результирующего выражения будет содержать 1 в тех разрядах, в которых x и y имеют разные двоичные значения, и 0 - во всех остальных разрядах.

Пример:

int a = 25; // начальное значение переменной a равно 25,

// что в двоичном представлении равно 00011001

int b = 141; // начальное значение переменной b равно 141,

// что в двоичном представлении равно 10001101

a = a ^ b; // переменная a стала равна 10010100, т.е. 148

2). Вызов функции

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

int sum (int a, int b)

{

int c;

c = a + b;

return c;

}

int main()

{

int s;

s = sum(2,2); // вызов функции

cout << s;

return 0;

}

В результате выполнения программы, на экран будет выведено: 4.

Вызов функции состоит из идентификатора функции и списка аргументов в круглых скобках. Вот несколько вызовов функции sum:

int x = 5;

int y = 4;

int z;

sum(0,1); // 1

sum(x,2); // 7

sum(x,y); // 9

z = sum(x,y); // z = 9

Вызывающее окружение

То место, откуда вызывается функция, называется вызывающим окружением. Вызывающим окружением функции sum является функция main, а вызывающим окружением функции main является отладчик или операционная система.

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

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

int simple (int a)

{

return 1;

}

int main ()

{

int b;

b = simple(0.5);

return 0;

}

В списке аргументов мы указали тип int, а в функцию передаётся вещественное значение 0.5. Так делать нельзя.

Рассмотрим более полезный пример: напишем функцию для передвижения персонажа:

int x; // глобальная переменная

int move_x (int dx)

{

x = x + dx;

return x;

}

int main ()

{

int ch;

char act;

while (1)

{

act = _getch();

ch = static_cast(act);

if (ch == 75) // была нажата стрелочка влево

move_x(-1);

else if (ch == 77) // была нажата стрелочка вправо

move_x(1);

} // конец while

return 0;

} // конец main

Обратите внимание, что для тела if и else if не стоит скобочек. Скобочки ветвлений можно опускать, если в теле ветвления всего один оператор.

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

Создадим ещё одну функцию, а заодно уберём из main часть кода:

int x; // глобальная переменная

int move_x (int dx)

{

x = x + dx;

return x;

}

void move (int ch)

{

if (ch == 75) // была нажата стрелочка влево

move_x(-1);

else if (ch == 77) // была нажата стрелочка вправо

move_x(1);

}

int main ()

{

int ch;

char act;

while (1)

{

act = _getch();

ch = static_cast(act);

move(ch); // вызов функции move

} // конец while

return 0;

} // конец main

Обратите внимание, что в функции move на месте типа возвращаемого значения стоит void, кроме того, в теле move нет оператора return.

Билет № 14

1) Адресные операции

& Операция получения адреса операнда.

Операндом может быть любое l-выражение. Операция возвращает адрес объекта или функции, на который ссылается операнд. Операция невыполнима по отношению к объектам, определённым со спецификатором register, поскольку существует вероятность того, что они не располагаются в памяти и не имеют определённого адреса.

* Операция обращения по адресу или операция косвенного обращения.

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

Билет № 16

1). Операции над структурами и объединениями

Операция принадлежности (точка) используется совместно с именем структуры (или объединения) для задания элемента этой структуры (иди объединения). Если name является именем структуры, а member - элементом, указанным в структурном шаблоне, то name.member определяет этот элемент структуры. Операцию принадлежности можно аналогичным образом применять и к объединениям.

Пример

struct {

int code;

float cost;

} item;

item.code = 1265;

Выполняется присваивание значения элементу code структуры item.

-> Косвенная адресация (определение принадлежности) элемента используется совместно с указателем на структуру (или объединение) для идентификации того или иного элемента этих структур (или объединения). Предположим, что ptrstr является указателем на структуру, a member - элементом, указанным в структурном шаблоне. Тогда ptrstr -> member определяет, что это элемент структуры, на которую ссылается указатель. Операцию косвенной адресации элемента можно применять аналогичным образом и к объединениям.

Пример:

struct {

int code;

float cost;

} item, *ptrst;

ptrst = &item;

ptrst-> code = 3451;

Эти операторы присваивают значение элементу code структуры item. Следующие три выражения эквивалентны:

ptrst -> code item.code (*ptrst).code

2). Указатели и массивы

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

Объявление

int a[10];

Определяет массив a размера 10, т. е. блок из 10 последовательных объектов с именами a[0], a[1], ..., a[9].

Запись a[i] отсылает нас к i-му элементу массива. Если pa есть указатель на int, т. е. объявлен как

int *pa;

то в результате присваивания

pa = &a[0];

pa будет указывать на нулевой элемент a, иначе говоря, pa будет содержать адрес элемента a[0].

Теперь присваивание

x = *pa;

будет копировать содержимое a[0] в x.

Если pa указывает на некоторый элемент массива, то pa+1 по определению указывает на следующий элемент, pa+i - на i-й элемент после pa, a pa-i - на i-й элемент перед pa. Таким образом, если pa указывает на a[0], то

*(pa+1)

есть содержимое a[1], a+i - адрес a[i], a *(pa+i) - содержимое a[i].

Сделанные замечания верны безотносительно к типу и размеру элементов массива a. Смысл слов "добавить 1 к указателю", как и смысл любой арифметики с указателями, состоит в том, чтобы pa+1 указывал на следующий объект, a pa+i - на i-й после pa.

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

pa = &a[0];

ра и a имеют одно и то же значение. Поскольку имя массива является синонимом расположения его начального элемента, присваивание pa=&a[0] можно также записать в следующем виде:

pa = a;

Еще более удивительно (по крайней мере на первый взгляд) то, что a[i] можно записать как *(a+i). Вычисляя a[i], Си сразу преобразует его в *(a+i); указанные две формы записи эквивалентны. Из этого следует, что полученные в результате применения оператора & записи &a[i] и a+i также будут эквивалентными, т. е. и в том и в другом случае это адрес i-го элемента после a. С другой стороны, если pa - указатель, то его можно использовать с индексом, т. е. запись pa[i] эквивалентна записи *(pa+i). Короче говоря, элемент массива можно изображать как в виде указателя со смещением, так и в виде имени массива с индексом.