Языки Программирования. Язык C. Конспект лекций

ЯЗЫКИ
учебно-методический комплекс
ПРОГРАММИРОВАНИЯ
Учебная программа дисциплины

Конспект лекций. Язык С
Конспект лекций. Ассемблер
Электронный
Методические указания по лабораторным работам

Методические указания по самостоятельной работе
Банк тестовых заданий в системе UniTest
Красноярск
ИПК СФУ
2008
УДК 004.438
ББК 32.973
Н73
Электронный учебно-методический комплекс по дисциплине «Языки программи-
рования» подготовлен в рамках инновационной образовательной программы «Ин-
форматизация и автоматизированные системы управления», реализованной в ФГОУ
ВПО СФУ в 2007 г.
Рецензенты:
Красноярский краевой фонд науки;
Экспертная комиссия СФУ по подготовке учебно-методических комплексов дис-
циплин
Новиков, Е. А.
Н73 Языки программирования. Язык С. Версия 1.0 [Электронный ресурс] : кон-
спект лекций / Е. А. Новиков, Ю. А. Шитов. – Электрон. дан. (3 Мб). – Красно-
ярск : ИПК СФУ, 2008. – (Языки программирования : УМКД № 147-2007 / рук.
творч. коллектива Ю. А. Шитов). – 1 электрон. опт. диск (DVD). – Систем. тре-
бования : Intel Pentium (или аналогичный процессор других производителей)
1 ГГц ; 512 Мб оперативной памяти ; 3 Мб свободного дискового пространст-
ва ; привод DVD ; операционная система Microsoft Windows 2000 SP 4 /
XP SP 2 / Vista (32 бит) ; Adobe Reader 7.0 (или аналогичный продукт для чте-
ния файлов формата pdf).
ISBN 978-5-7638-1250-3 (комплекса)
ISBN 978-5-7638-1459-0 (конспекта лекций)
Номер гос. регистрации в ФГУП НТЦ «Информрегистр» 0320802545
от 02.12.2008 г. (комплекса)
Настоящее издание является частью электронного учебно-методического ком-
плекса по дисциплине «Языки программирования», включающего учебную програм-
му, конспект лекций «Языки программирования. Ассемблер», методические указания
по лабораторным работам, методические указания по самостоятельной работе, кон-
трольно-измерительные материалы «Языки программирования. Банк тестовых зада-
ний», наглядное пособие «Языки программирования. Презентационные материалы».
Приведены теоретические сведения по языку С, его типам и структурам данных,
рассмотрены типовые задачи программирования.
Предназначен для студентов направления подготовки специалистов 090102.65
«Компьютерная безопасность» укрупненной группы 090000 «Информационная безо-
пасность».
© Сибирский федеральный университет, 2008
Рекомендовано к изданию
Инновационно-методическим управлением СФУ
Редактор Т. И. Тайгина
Разработка и оформление электронного образовательного ресурса: Центр технологий элек-
тронного обучения информационно-аналитического департамента СФУ; лаборатория по разработке
мультимедийных электронных образовательных ресурсов при КрЦНИТ
Содержимое ресурса охраняется законом об авторском праве. Несанкционированное копирование и использование данного про-
дукта запрещается. Встречающиеся названия программного обеспечения, изделий, устройств или систем могут являться зарегистрирован-
ными товарными знаками тех или иных фирм.
Подп. к использованию 01.10.2008

Объем 3 Мб
Красноярск: СФУ, 660041, Красноярск, пр. Свободный, 79
ОГЛАВЛЕНИЕ
ВВЕДЕНИЕ ................................................................. 8
ЛЕКЦИЯ 1. ОСНОВНЫЕ УСТРОЙСТВА ЭВМ И ИХ
НАЗНАЧЕНИЕ. ИСТОРИЯ РАЗВИТИЯ ЯЗЫКОВ ........ 9
1. Введение .......................................................................................................................... 9
2. Основные устройства ЭВМ и их назначение .......................................................... 10
3. История развития языков ........................................................................................... 11
ЛЕКЦИЯ 2. ОБЩИЕ ПРИНЦИПЫ ПОСТРОЕНИЯ
ЯЗЫКОВ ПРОГРАММИРОВАНИЯ. ПРЕПРОЦЕССОР
И МАКРООБРАБОТКА. ЭТАПЫ РЕШЕНИЯ ЗАДАЧ
НА КОМПЬЮТЕРЕ .................................................... 15
1. Общие принципы построения языков программирования ................................. 15
2. Препроцессор и макрообработка. ............................................................................. 18
3. Этапы решения задач на компьютере ...................................................................... 19
ЛЕКЦИЯ 3. СОВРЕМЕННЫЕ ИНТЕГРИРОВАННЫЕ
СРЕДЫ. ВСТРОЕННЫЙ ОТЛАДЧИК.
БИБЛИОТЕКА ПРОГРАММ И КЛАССОВ .................. 21
1. Современные интегрированные среды .................................................................. 21
2. Встроенный отладчик ................................................................................................. 22
3. Библиотеки программ и классов ............................................................................... 23
ЛЕКЦИЯ 4. ПРОСТЕЙШАЯ ПРОГРАММА. ВЫВОД
ТЕКСТА НА ЭКРАН. ДИРЕКТИВЫ CLRSCR()
И GETCH() ................................................................ 26
1. Простейшая программа ............................................................................................... 26
2. Вывод текста на экран ................................................................................................ 28
3. Препроцессор ................................................................................................................ 29
4. Директивы clrscr() и getch() ........................................................................................ 31
ЛЕКЦИЯ 5. ПАМЯТЬ. ПЕРЕМЕННЫЕ. ВЫВОД НА
ЭКРАН. ЗАПИСЬ В ПЕРЕМЕННЫЕ ТИПА INT
И FLOAT. ВВОД С КЛАВИАТУРЫ ............................ 35
1. Память ............................................................................................................................ 35
2. Переменные ................................................................................................................... 35
3. Вывод переменных на экран ..................................................................................... 36
4. Запись в переменные типа int и float........................................................................ 37
5. Ввод с клавиатуры....................................................................................................... 40
Языки программирования. Язык С. Конспект лекций -3-

ЛЕКЦИЯ 6. АРИФМЕТИЧЕСКИЕ ОПЕРАЦИИ.

МАТЕМАТИЧЕСКИЕ ВЫРАЖЕНИЯ И ФУНКЦИИ .... 44
1. Арифметические операции ........................................................................................ 44
2. Математические выражения и функции .................................................................. 50
ЛЕКЦИЯ 7. ОПЕРАЦИИ СРАВНЕНИЯ И
ЛОГИЧЕСКИЕ ОПЕРАЦИИ. УСЛОВНЫЕ
ОПЕРАТОРЫ ............................................................ 54
1. Операции сравнения и логические операции ......................................................... 54
2. Условные операторы .................................................................................................. 55
ЛЕКЦИЯ 8. ЦИКЛЫ .................................................. 62
1. Цикл for .......................................................................................................................... 62
2. Цикл while ....................................................................................................................... 65
3. Цикл do – while. ............................................................................................................. 67
ЛЕКЦИЯ 9. МАССИВЫ. НЕКОТОРЫЕ ПРОСТЕЙШИЕ
ЗАДАЧИ. МАТРИЦЫ ................................................ 70
1. Массивы ......................................................................................................................... 70
2. Некоторые простейшие задачи ................................................................................. 72
3. Матрицы. ........................................................................................................................ 79
4. Перебор элементов матрицы..................................................................................... 81
ЛЕКЦИЯ 10. УКАЗАТЕЛИ. СВЯЗЬ УКАЗАТЕЛЯ
С МАССИВАМИ. ДИНАМИЧЕСКАЯ ПАМЯТЬ .......... 88
1. Указатели........................................................................................................................ 88
2. Способы инициализации указателей ....................................................................... 90
3. Связь указателя с одномерным массивом ............................................................. 94
4. Двумерный массив ...................................................................................................... 95
5. Динамическая память .................................................................................................. 97
ЛЕКЦИЯ 11. ФАЙЛЫ И СИМВОЛЫ ....................... 101
1. Файлы ........................................................................................................................... 101
2. Символы ...................................................................................................................... 103
3. Стандартные программы.......................................................................................... 108
ЛЕКЦИЯ 12. СТРОКИ И МАССИВЫ СТРОК.
ДОСТУП К ФУНКЦИОНАЛЬНЫМ КЛАВИШАМ ...... 109
1. Строки ........................................................................................................................... 109
2. Стандартные функции для работы со строками ................................................. 113
3. Массив строк ............................................................................................................... 113
4. Доступ к функциональным клавишам ................................................................... 117

ЛЕКЦИЯ 13. СТРУКТУРЫ И УКАЗАТЕЛИ

НА СТРУКТУРУ ....................................................... 122
1. Структуры .................................................................................................................... 122
2. Указатели на структуру.............................................................................................. 127
ЛЕКЦИЯ 14. ГРАФИЧЕСКИЙ ИНТЕРФЕЙС.
УПРАВЛЕНИЕ В ГРАФИЧЕСКОМ И ТЕКСТОВОМ
РЕЖИМАХ .............................................................. 133
1. Интерфейс пользователя ......................................................................................... 133
2. Графический интерфейс пользователя................................................................. 133
3. Оконный интерфейс .................................................................................................. 133
4. Текстовый режим ....................................................................................................... 134
5. Графический режим ................................................................................................... 135
ЛЕКЦИЯ 15. ФУНКЦИИ. ОБЛАСТЬ ДЕЙСТВИЯ.
ПЕРЕДАЧА ПЕРЕМЕННЫХ И МАССИВОВ
В ФУНКЦИИ............................................................ 140
1. Функции ........................................................................................................................ 140
2. Локальные и глобальные переменные ................................................................. 142
3. Область действия функции ...................................................................................... 144
4. Передача параметров в функцию ........................................................................... 145
5. Передача массивов в функцию ............................................................................... 148
ЛЕКЦИЯ 16. ОБРАБОТКА ИСКЛЮЧЕНИЙ.
АБСТРАКТНЫЕ ТИПЫ ДАННЫХ.
ИНКАПСУЛЯЦИЯ. КЛАССЫ И ОБЪЕКТЫ ............. 152
1. Обработка исключений ............................................................................................. 152
2. Абстрактные типы данных ....................................................................................... 154
3. Инкапсуляция .............................................................................................................. 156
4. Классы и объекты ...................................................................................................... 156
ЛЕКЦИЯ 17. РЕАЛИЗАЦИЯ АБСТРАКТНЫХ
ТИПОВ ДАННЫХ .................................................... 160
1. Реализация АТД на примере комплексных чисел ............................................... 160
2. Конструктор класса .................................................................................................... 161
3. Деструктор класса ...................................................................................................... 161
4. Файл реализации ........................................................................................................ 162
5. Файл приложения ....................................................................................................... 163
ЛЕКЦИЯ 18. СПЕЦИФИКАЦИЯ
И ПАРАМЕТРИЗАЦИЯ ............................................ 166
1. Спецификация ............................................................................................................. 166
2. Параметризация .......................................................................................................... 169

ЛЕКЦИЯ 19. ГЕНЕРАТОР КОДА/ПРИЛОЖЕНИЙ ... 172

1. Генератор кодов ......................................................................................................... 172
2. Пример формирования окна .................................................................................... 174
ЛЕКЦИЯ 20. РЕКУРСИЯ ........................................ 177
1. Общие сведения о рекурсии .................................................................................... 177
2. Пример рекурсивной функции ................................................................................. 178
3. Формы рекурсивного обращения ........................................................................... 183
4. Выполнение действий на рекурсивном спуске .................................................... 185
ЛЕКЦИЯ 21. РЕКУРСИЯ (ОКОНЧАНИЕ)................ 191
1. Выполнение действий на рекурсивном возврате ............................................... 191
2. Выполнение действий на рекурсивном спуске и возврате ............................... 195
ЛЕКЦИЯ 22. БЫСТРАЯ СОРТИРОВКА .................. 199
1. Быстрая сортировка с использованием рекурсивных функций ...................... 199
2. Быстрая сортировка с использованием циклов.................................................. 210
ЛЕКЦИЯ 23. ОДНОСВЯЗНЫЕ СПИСКИ ................. 213
1. Односвязный список ................................................................................................. 213
2. Формирование списка ............................................................................................... 214
3. Операции над списком .............................................................................................. 220
4. Программа обработки списка................................................................................... 234
ЛЕКЦИЯ 24. СТЕК И ОЧЕРЕДЬ.............................. 239
1. Стек................................................................................................................................ 239
2. Операции над стеком ................................................................................................. 239
3. Программа обработки стека ..................................................................................... 239
ЛЕКЦИЯ 25. ДВУСВЯЗНЫЕ СПИСКИ .................... 246
1. Двусвязные списки .................................................................................................... 246
2. Формирование списка ............................................................................................... 247
3. Операции над списком .............................................................................................. 249
4. Программа обработки списка................................................................................... 253
ЛЕКЦИЯ 26. ДЕРЕВО ............................................ 258
1. Дерево как рекурсивный тип данных..................................................................... 258
2. Алгоритм формирования дерева ............................................................................ 259
ЛЕКЦИЯ 27. БИНАРНОЕ ДЕРЕВО ......................... 272
1. Обходы дерева ........................................................................................................... 272
2. Идеально сбалансированное дерево ..................................................................... 281
3. Удаление узла из дерева ........................................................................................... 283
ЛЕКЦИЯ 28. СОРТИРОВКА ................................... 287
План ................................................................................................................................... 287
1. Классы сортировок .................................................................................................... 287
2. Сортировка выбором ................................................................................................ 288

3. Сортировка обменом (методом пузырька) ........................................................... 289

4. Сортировка вставками .............................................................................................. 297
5. Пирамидальная сортировка ..................................................................................... 303
ЛЕКЦИЯ 29. АНАЛИЗ АРИФМЕТИЧЕСКИХ
ВЫРАЖЕНИЙ. ИНФИКСНАЯ И ПОСТФИКСНАЯ
ФОРМЫ ЗАПИСИ ................................................... 307
1. Форма записей арифметических выражений ....................................................... 307
2. Преобразование инфиксной формы записи в постфиксную ............................ 309
3. Вычисление выражения в постфиксной форме .................................................. 313
4. Рекурсивно-нисходящий алгоритм разбора выражения.................................... 318
ЛЕКЦИЯ 30. ГРАФЫ. ОБХОД ГРАФА В ГЛУБИНУ
И ШИРИНУ ............................................................. 338
1. Графы ........................................................................................................................... 338
2. Формы представления графа .................................................................................. 339
3. Обходы графа в глубину .......................................................................................... 340
4. Обходы графа в ширину ........................................................................................... 349
ЛЕКЦИЯ 31. ОСТОВНЫЕ ДЕРЕВЬЯ (КАРКАСЫ).
ОСТОВНЫЕ ДЕРЕВЬЯ МИНИМАЛЬНОЙ
СТОИМОСТИ .......................................................... 362
1. Определение каркаса ................................................................................................. 362
2. Определение каркаса при обходе графа в глубину............................................. 364
3. Определение каркаса при обходе графа в ширину ............................................. 366
4. Алгоритм Прима определения каркаса .................................................................. 373
5. Алгоритм Крускала определения каркаса ............................................................. 376
ЛЕКЦИЯ 32. СТАНДАРТНАЯ БИБЛИОТЕКА
ШАБЛОНОВ. КОНТЕЙНЕРЫ И ИТЕРАТОРЫ ........ 379
1. Контейнеры.................................................................................................................. 379
2. Итераторы .................................................................................................................... 382
3. Операции с контейнерами ........................................................................................ 384
ЛЕКЦИЯ 33. ПАРАЛЛЕЛЬНОЕ
ПРОГРАММИРОВАНИЕ .......................................... 388
1. Классификация параллелизма ................................................................................ 388
2. Проектирование программы .................................................................................... 388
3. Реализация параллелизма (MPI) .............................................................................. 389
4. Базовые функции MPI ............................................................................................... 393
ЗАКЛЮЧЕНИЕ ........................................................ 398
БИБЛИОГРАФИЧЕСКИЙ СПИСОК ........................ 399

ВВЕДЕНИЕ
Курс лекций «Языки программирования» соответствует государствен-

ному образовательному стандарту (спец. 075200 – «Компьютерная
безопасность»).
Методически лекции по освоению языка программирования
выстраиваются по следующей схеме:
постановка задачи;
инструменты языка, необходимые для решения задачи;
решение задачи.
Подобная схема исключает из изложения те конструкции языка,
которые не требуются при рассмотрении задачи. Простое перечисление
средств языка без применения их для решения задач малоэффективно с точки
зрения освоения материала.
При изучении материала лекций полезно обращать внимание на
комментарии к директивам программы: в них объясняются трудности,
возникающие при переводе алгоритма решения задачи на язык
программирования. Для более успешного освоения материала полезно
изучить программы, данные в лекциях. Надо понимать, что чем больше из
разных источников будет привлекаться дополнительный материал, тем более
глубокие будут знания и устойчивее приобретенные навыки при
программировании задач.
По убеждениям и опыту авторов освоение конструкций языка
принципиальных теоретических трудностей не представляет. И они в полной
мере могут быть преодолены студентами самостоятельно.

ЛЕКЦИЯ 1. ОСНОВНЫЕ УСТРОЙСТВА ЭВМ И ИХ
НАЗНАЧЕНИЕ. ИСТОРИЯ РАЗВИТИЯ ЯЗЫКОВ
План
1. Введение.
2. Основные устройства ЭВМ и их назначение.
3. История развития языков.
1. Введение
Информация в переводе с латинского языка означает разъяснение,

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

ЛЕКЦИЯ 1. ОСНОВНЫЕ УСТРОЙСТВА ЭВМ И ИХ НАЗНАЧЕНИЕ. ИСТОРИЯ РАЗВИТИЯ ЯЗЫКОВ
1. Введение
ческих функций. Проведение таких вычислений без особых устройств было

затруднительным. Заметим, что необходимость в таких устройствах была
уже на ранних стадиях развития цивилизации. Еще в 2600 г. до новой эры
применялось счетное устройство абак (подобие счет). Однако простые
устройства оказывались бесполезными для решения достаточно сложных
задач, которые возникали по мере развития науки и техники. Прошло
несколько тысяч лет, прежде чем были спроектированы и построены новые
счетные устройства. Такая длительная пауза была вызвана тем, что долгое
время для проведения расчетов использовалась римская (не позиционная)
система счисления. Суть римской системы счисления состояла в том, что
значения символов, которые обозначали числа, не менялись от места
(позиции), которое они занимали при записи числа (XV, VX). И только после
того как арабская (позиционная) система счисления вытеснила римскую,
возникли предпосылки для развития счетных устройств.
Одним из самых значительных прорывов в этом направлении было
изобретение Блеза Паскаля (физик, математик, выдающийся ученный).
Б. Паскаль придумал устройство (1640–1645), которое могло производить
четыре арифметических действия над пятизначными числами.
В 1694 г. Лейбниц (математик, механик) создал машину, которая
помимо четырех арифметических операций могла выполнять извлечение
квадратного корня.
В 1887 г. шведский инженер Однер разработал счетное устройство –
арифмометр. Идеи, реализованные при создании арифмометра, легли в
дальнейшем в основу многих других счетных устройств (например,
арифмометр «Феликс»).
Научно-техническая революция XIX в. была связана с необходимостью
увеличения расчетов во всех областях знаний. Это требовало построения
надежных быстродействующих счетных машин, которые могли бы
выполнять действия с большими числами. Бурное развитие электроники в
начале XX в. создало условия для производства вычислительных устройств
на принципиально новой основе. К 1940 г. сошлись потребности в
скоростном вычислении и возможности его реализации. В 1945 г. математик
Джон фон Нейман сформулировал основные принципы построение ЭВМ, а в
следующем году первая электронная вычислительная машина (ЭВМ) начала
действовать. Сейчас подавляющее большинство вычислительных машин
конструируются на основе идей Неймана. В дальнейшем аббревиатуры ЭВМ
и ПК (персональный компьютер) будут использоваться как синонимы.
2. Основные устройства ЭВМ и их назначение
Основными устройствами ЭВМ (в том числе и современного

компьютера) являются:
арифметическое устройство (АУ),
устройство управления,

2. Основные устройства ЭВМ и их назначение
запоминающие устройства (ЗУ),

внешние устройства ввода и вывода информации.
В современных персональных компьютерах арифметическое
устройство и устройство управления объединены в одно, которое называется
процессором. Обработку (преобразование) информации, управление всеми
устройствами, которые существуют в ПК, и синхронизацию (согласование
порядка) работ всех устройств в компьютере осуществляет процессор.
Запоминающие устройства подразделяются на оперативное
запоминающее устройство (ОЗУ) и внешнюю память (винчестеры, диски,
флэшки). Эти устройства предназначены для записи и хранения информации.
ЭВМ любую информацию переводит в число, которое записано в виде
набора битов. Слово бит <bit> образовано из выражения Binary digIT
(двоичная цифра). Двоичная цифра – это число, которое может принимать
одно из двух значений: 0 или 1. Элементом оперативной памяти является
байт. Байт – это устройство, которое состоит из восьми бит. В байт можно
записать любую комбинацию из 0 и 1. Общее число 0 и 1 в байте должно
равняться восьми. Все байты в памяти нумеруются. Номер байта в
оперативной памяти называется адресом. Существуют следующие единицы
измерения памяти:
Кбайт (один килобайт) = 1024 байт,
Мбайт (один мегабайт) = 1024 Кбайт,
Гбайт (один гигабайт) = 1024 Мбайт.
Устройства ввода (клавиатура, сканер) предназначены для ввода
информации в память ПК. При вводе происходит автоматическое
преобразование информации из обычного формата в тот формат, который
требует компьютер для своей работы.
Устройство вывода (экран монитора, печать) выводит информацию из
памяти компьютера на внешние носители. Формат выводимой информации
определяется пользователем.
3. История развития языков
Управляет работой компьютера программа. Программа – это

последовательность (набор) некоторых директив, которые может выполнить
компьютер. Естественно, эта последовательность должна быть написана с
соблюдением правил и ограничений, которые надо знать. Программу можно
сравнить с выполнением некоторой последовательности команд меню любой
информационной системы. Если порядок выполнения команд меню будет
неправильным или не все команды меню будут выполнены, то поставленная
цель не будет достигнута. Если информационная система настроена на
выполнение команд меню, то ПК настроен на выполнение некоторого набора
директив. Фактически, формат записи директив определяется языком
программирования. Язык программирования – это набор правил, по которым
для ПК формируется директива, которую он обязательно выполнит.

В дальнейшем слова директива, код, команда, оператор, указание будут

использоваться как синонимы.
Для машин первого поколения программы создавались в машинном
коде (или на машинном языке). Это означает, что каждая операция, которую
могла выполнить ЭВМ, имела код (свой номер). Программист, формируя
директиву для компьютера, должен был указать код операции и
местоположения информации, над которой надо было выполнить данную
операцию. Например, директива сложения двух чисел могла выглядеть так:
001 0345 0363 0211.
В представленном коде наборы чисел означают следующее:

001 – операция сложения,
0345 – адрес первого числа,
0363 – адрес второго числа,
0211 – адрес для записи результата.
Последовательность подобных директив и составляла код программы.
Заметим, что в зависимости от задачи таких директив в программе могло
быть от нескольких сотен до нескольких тысяч и даже десятков тысяч.
И программы занимали иногда несколько объемных книг. Оставляем за
скобками технологию запуска подобных задач на счет. Это был довольно
трудозатратный процесс. Ясно, что сопровождать, разбираться, искать
ошибки в таком объемном и непрозрачном с точки зрения информативности
документе трудно.
Ученые попытались изменить ситуацию: 1) упростить процесс
программирования, 2) сделать код программы читаемым и информативным
при его рассмотрении. Достижением в этом направлении стала замена
машинного кода языком Ассемблера. Язык Ассемблер представлял собой
символьную запись машинного кода. В этом языке коды операций
заменялись понятным символьным обозначением, а области памяти для
записи и хранения также обозначались удобным, осмысленным
программистом набором символом. Однако ЭВМ понимает только
машинный код. Поэтому потребовалась особая программа (транслятор),
которая символьную – более понятную запись программы – переводила в
машинный код.
Язык Ассемблер решил далеко не все проблемы, связанные с
программированием на ЭВМ. Одной из главных проблем была следующая.
Для составления программы пользователь обязан был знать все
элементарные операции, которые могла выполнять машина. Это сводилось к
тому, что программист должен был мыслить в терминах аппаратуры
конкретной ЭВМ. Решение задачи, которая не связана с конструкцией ЭВМ,
требовало знание этой конструкции. Более того, в этом случае для разных по
архитектуре ЭВМ программы несовместимы. Другими словами, если
используется Ассемблер, то для ЭВМ разных структур при решении одной и
той же задачи требуется разрабатывать свою программу. Это почти

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

разные правила уличного движения. Данную проблему, да и много других,
связанных с ассемблером, решили языки программирования (ЯП) высокого
уровня. Эти языки позволили программисту мыслить и писать программы в
терминах задачи, а не в терминах конкретной ЭВМ.
Одним из первых языков высокого уровня был язык Фортран. Он
разрабатывался в период с 1954 по 1957 год. Реализация языка была
опубликована в 1956 году. В это время компьютеры использовались в
основном для научных задач механики, физики, математики и др. Они были
еще маломощными по быстродействию, небольшими и дорогостоящими. Это
все отразилось на концепциях языка Фортран. Однако и сейчас Фортран
является одним из популярных и широко используемых языков
программирования.
Попытка создания универсального языка программирования привела к
появлению языка Алгол 60, который оказал значительное влияние на
последующие языки программирования. По одним данным Алгол 60 имел
колоссальный успех, по другим – был провалом. Долгое время Алгол
фактически был единственным средством для представления алгоритмов в
научной литературе и первым машинно-независимым языком. Структура
языка Алгол в дальнейшем повлияла на архитектуру ЭВМ. Однако Алгол у
пользователей не получил широкого распространения и не стал
доминирующим языком, потому что был труден для понимания, а некоторые
его свойства делали реализацию языка неэффективной.
В 1967 г. был представлен проект языка SIMULA 67, который
представлял собой расширенную версию языка Алгол 60. В языке SIMULA 67
была разработана конструкция класса. Это положило начало понятию
абстракции данных. В дальнейшем эту концепцию использовал Бьерн
Страуструп при создании языка C++. И хотя сам язык SIMULA 67 не
получил широкого распространения, его концепция классов и производных
классов оказала принципиальное влияние на языки следующего поколения.
Популярным языком в конце 1970-х гг. был язык Бейсик. Его
популярность объясняется простотой в изучении. Большинство конструкций
Бейсик произошли от языка Фортран. Заметим, что язык Бейсик мог быть
реализован на компьютерах с небольшой памятью.
В 1971 г. Николаус Вирт опубликовал исходное описание языка
Паскаль, основой которого можно считать Алгол 60. Язык Паскаль
создавался как язык для обучения программированию. Из-за простоты и
выразительности синтаксиса язык Паскаль быстро завоевал популярность
среди студентов. Паскаль – это типизированный язык. В нем разработана
развитая система структур данных и проводится полная проверка типов.
Язык Delphi происходит от языка Паскаль. Он создавался для возможности
объектно-ориентированной поддержки.
У языка C (Си) – четыре предка: Алгол 68, CPL, BCPL и B. Алгол 68
был разработан в 60-е гг. ХХ в. в Европе. Он оказал сильное влияние на
последующее развитие языков программирования. Но сам язык не получил

широкого распространения. Считается, что это произошло потому, что он

был труден для изучения. Язык CPL был разработан в Лондоне с целью
приспособить Алгол 68 к существующим ЭВМ. Язык BCPL был близок к
CPL. Разработчики этого языка пытались сохранить лучшие черты CPL и
упростить его. Язык B разрабатывался для создания операционной системы
UNIX на базе языка BCPL. Работа велась над упрощением языка BCPL. Но
простата BCPL и B привела к тому, что при помощи этих языков можно было
решать ограниченный класс задач. По этой причине и ряду других в 1971 г.
началась работа над языком С – наследником языка B. Автором этого языка
был Дэнис Ритчи. Он завершил свою работу в 1972 г. Дэнис Ритчи был
известен работами по системному программному обеспечению,
операционным системам, языкам программирования. И, по-видимому, как
специалист по системному программированию, Ритчи создал язык, близкий к
аппаратуре. Поэтому программист мог не очень вникать в архитектуру
компьютера.
Язык С++ (C++) является расширенной версией языка С, в ней
сохранены все его сильные стороны. Язык был создан для поддержки
объектно-ориентированного программирования (ООП). Язык С++
представляет собой развитие и совершенствование лучших свойств
предшествующих языков программирования. Язык С++ разрабатывал Бьерн
Страуструп. Первая публикация о С++ была сделана в 1983 г., но развитие и
модификация языка проводились до конца 1980 годов. Язык С++ стал
популярным языком у программистов. Одной из причин такой популярности
является почти полная совместимость С и С++. Кроме того, хорошие
компиляторы для С++ доступны и недороги. Для языка С++ в настоящее
время разработаны мощные интегрированные среды (Builder C++, Visual
C++ 6), которые поддерживают концепции ООП.

ЛЕКЦИЯ 2. ОБЩИЕ ПРИНЦИПЫ ПОСТРОЕНИЯ
ЯЗЫКОВ ПРОГРАММИРОВАНИЯ.
ПРЕПРОЦЕССОР И МАКРООБРАБОТКА.
ЭТАПЫ РЕШЕНИЯ ЗАДАЧ НА КОМПЬЮТЕРЕ
План
1. Общие принципы построения языков программирования.

2. Препроцессор и макрообработка.
3. Этапы решения задач на компьютере.
1. Общие принципы построения языков программирования
При проектировании языка программирования необходимы критерии

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

ЛЕКЦИЯ 2. ОБЩИЕ ПРИНЦИПЫ ПОСТРОЕНИЯ ЯЗЫКОВ ПРОГРАММИРОВАНИЯ
Большое значение имеют ключевые слова, при помощи которых

формируются управляющие конструкции языка. Чем ближе по смыслу
ключевые слова к принятой терминологии, которая реально используется при
решении задачи, тем программа более понятна и читаема.
Форма и смысл директив должны быть связаны между собой.
Особенно это важно для понимания языка на первом этапе его изучения.
Поддержка абстракций является важной характеристикой на
современном этапе развития языков программирования. Абстракция
позволяет использовать сложные структуры, не вникая в детализацию
формирования этих структур. Поддержка абстракции влияет на легкость
использования языка.
Программа, составленная на языке программирования, должна быть
надежной. На надежность программы влияют:
обработка исключительных ситуаций,
проверка типов,
совмещение имен,
легкость чтения и эксплуатации.
В дальнейшем рассмотрим эти положения подробнее при изучении
конкретного языка программирования.
Стоимость языка программирования зависит от многих его
характеристик. В стоимость языка входят затраты:
на обучение программиста,
создание программы,
компиляцию программы,
выполнение программы,
приобретение языка,
низкую надежность,
эксплуатацию программы (внесение исправлений, модификация,
сопровождение программного обеспечения).
Итак, для простоты представления и читаемости алгоритмов, которые
должны выполняться на компьютере, применяются языки программирования
(ЯП). Программа представляет собой алгоритм решения некоторой задачи.
Она преобразовывает некоторую начальную информацию. Эта начальная
информация характеризуется различными типами данных (числами,
символами, строкам и более сложными структурами). Алгоритм определяет
вычислительные операции, при помощи которых преобразовывается
информация. ЯП должен содержать соглашения о типе информации,
функциях и операторах, при помощи которых происходит преобразование
данных, и быть устроен так, что алгоритм, сформулированный в виде
программы, выполняется на компьютере. И хотя все языки нацелены на
решение одинаковых задач, тем не менее многие из них различаются по
своим концепциям.
ЯП имеют сходство с естественными языками и математическими
формулами. С помощью языков устанавливается способ записи программ.
Одной из проблем при описании языка является то, что пользователи языка

совершенно разные люди. А успех языка зависит от ясности его описания.

Разработчики языков программирования должны уметь определять способ
образования выражений, директив и программных конструкций языка.
Изучение языков может быть разделено на исследование синтаксиса и
семантики. Синтаксис языка – это форма, семантика – смысл его директив,
выражений, программных конструкций.
Итак, внешняя форма программ на ЯП устанавливается с помощью
синтаксиса языка, который определяет формальный язык. Синтаксис
описывается с помощью определенных правил или формул, которые задают
множество предложений. Знание синтаксических правил позволяет
установить, принадлежит ли некоторая написанная последовательность слов
предложениям данного языка. Кроме того, эти правила определяют
структуру предложений языка, которые позволяют установить их смысл
(семантику). Следовательно, определения, связанные со структурой, следует
рассматривать еще и как средство распознавания смысла (или средства
определения семантики языка [4]). Значение и способ действия программы на
каком-либо языке уточняются путем задания семантики, то есть
установлением смысла значений языковых элементов. Итак, синтаксис
и семантика языка определяют его структуру.
Синтаксис языка определяется над некоторым множеством элементов,
которые называются символами. Он задает корректную последовательность
символов, которую можно использовать в программе. Существует форма
записи для формального описания синтаксиса языков программирования.
Эту форму записи независимо друг от друга предложили Джон Бэкус и Ноам
Хомски. Формализм, который используется при определении языка, его
синтаксиса, называется бэкус-нуровой формой (БНФ). Форма БНФ
представляет собой способ описания синтаксиса. Существует еще одна
форма описания синтаксиса языка – синтаксическая диаграмма. Есть
правила построения синтаксической диаграммы. Используя эти правила,
можно строить синтаксическую диаграмму любой конструкции языка. Это, в
свою очередь, облегчает проведение синтаксического анализа конструкций.
БНФ и синтаксические диаграммы предназначены для построения программ
грамматического разбора синтаксических структур ЯП. Для описания
семантики выбирают математическую форму описания, то есть
математическим объектам сопоставляют конструкции языка.
Для того чтобы программу, написанную на каком-либо языке,
компьютер выполнил, необходимо переводить ее на язык соответствующей
машины. Процесс перевода программы на машинный язык называется
компиляцией. Роль компиляторов выполняют трансляторы, которые
являются специальными программами, способными анализировать текст
программ и генерировать машинный код. Компьютер выполняет код
программы на машинном языке и выдает результат обработки информации,
согласно реализованному алгоритму. Заметим, что компиляция не
единственный метод реализации языка, но большинство коммерческих
реализаций выполняются с помощью компилятора.

Препроцессор – инструмент языка C++, при помощи которого

происходит обработка текста программы перед компиляцией (трансляцией).
Директивы (операторы) препроцессора начинаются с символа #. При каждом
запуске компилятора сначала запускается препроцессор, который находит
инструкции, начинающиеся символом #. Эти инструкции изменяют текст
исходной программы.
В результате появляется новый, временный файл, который пользователю
не виден. Сам компилятор анализирует не исходный файл, а тот, который
был сформирован в результате макрообработки. Директивы препроцессора
перечислены в справочном материале данного комплекса. С назначением
некоторых из них познакомимся позже.
Наиболее часто используются в программах директивы препроцессора
#include и #define. Директива #include дает указание компилятору
присоединить к программе файл, имя которого следует сразу за этой
инструкцией. При помощи директивы #define происходит поиск и замена
одного набора символов на другой. Эту же директиву препроцессора можно
использовать для определения макросов. Макрос представляет собой часть
программы, которая может выглядеть и действовать как функция.
Содержимое макроса, которое задается после #define, подставляется во время
работы препроцессора и создает так называемый встраиваемый код.
Макрос – это символическое имя некоторых операций. В языке C некоторые
библиотечные функции реализованы как макросы.
Макросы имеют большое значение в C, но в C++ они используются
значительно реже. Первое правило о макросах: не используйте их, если нет
необходимости это делать. Практически каждый макрос свидетельствует о
недостатке в языке или программе. Так как макросы изменяют код
программы до обработки его компилятором, то они создают проблемы для
многих инструментов разработки интегрируемой среды. Поэтому при
использовании макросов можно ожидать худшей работы отладчиков,
генераторов списков и т. д. При помощи макросов можно создать свой
собственный язык. Но если попытается сделать что-нибудь нетривиальное
в этом направлении, то это либо невозможно, либо слишком трудоемко.
Большинство компиляторов содержат ряд полезных встроенных
макрокоманд, например, __DATE__, __TIME__, __LINE__ (дата, время,
строка и т. д.). Каждая такая команда окружена двумя знакам подчеркивания.
Встретив один из этих макросов, препроцессор делает соответствующую
замену. Вместо __DATE__ устанавливается дата. Вместо __TIME__ –
текущее время. Директива __LINE__ заменяется номером строки исходного
текста.

В языке C++ многие возможности директив препроцессора можно

заменить директивами языка. Более того, автор языка Страуструп выражал
свое намерение освободить язык от препроцессора.
Задание для самостоятельной работы. Изучить директивы #define, #line,
#if, #else, assert().
3. Этапы решения задач на компьютере
Решение любой задачи на компьютере состоит из нескольких этапов:

1) постановка задачи,
2) выбор модели,
3) разработка метода решения,
4) разработка алгоритма решения,
5) составление программы,
6) отладка программы,
7) расчет задачи по программе, обработка и анализ результатов.
Первые два этапа, как правило, выходят за рамки возможностей
студентов и считаются заданными. Фактически формулировка задачи неявно
закрывает эти этапы. Остальные этапы присутствуют, однако на шестой и
седьмой этапы редко акцентируется внимание. Для учебных программ эти
этапы сводятся к простой проверке решения на 1–2 тестовых задачах. Для
реальных задач этапы шесть и семь важны. Что касается обработки и анализа
результата, то это требует от программиста высокого уровня квалификации,
компетенции и глубины знания проблемы. В учебных задачах студент, как
правило, работает в рамках третьего, четвертого и пятого этапов. Очень часто
оказывается, что третий этап для задачи известен, а этапы три и четыре по
своей сути тождественны, то есть решение третьего этапа тождественно
этапу четыре и, наоборот, алгоритм решения фактически является методом
решения. Распределение трудностей этапов три и четыре может быть самым
разнообразным. Здесь возможны любые комбинации трудностей. Если
построить таблицу распределения трудностей этапов три и четыре, она
может выглядеть так.
Распределения трудностей этапов 3 и 4
Этап 3 т т н/т н/т

Этап 4 т н/т т н/т
Важным моментом третьего этапа является выбор структуры данных

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

3. Этапы решения задач на компьютере
начальной информации от источника задачи. Программист сам решает

вопрос о том, в каком виде ему надо представить входную информацию. Это
не значит, что он должен требовать от заказчика изменить форму
представления начальных данных. Форма представления данных должна
иметь естественный, сложившийся вид. Вопрос о переформатирования
начальной информации к удобному для программы виду должен решаться
автоматически в рамках самой программы. Начинающий программист даже
для простых задач, в которых вопрос о структуре данных не столь важен,
должен по возможности всегда продумывать вопрос о представлении
данных. Н. Вирт в книге «Алгоритмы + структуры данных = программы»
подчеркивает важность вопроса о структуре данных при проектировании
программы.
Далее не будем проводить разделение решения задачи на этапы, так как
для учебных задач они часто размыты и не столь четко отделены друг от
друга. Однако иногда будем отмечать, к какому этапу отнести те или иные
рассуждения при анализе ее решения. В учебном курсе, как правило,
трудными задачами являются те, для которых требуется разработать метод
решения. Такие задачи можно разделить на два класса. Первый класс не
требует специальных знаний для разработки метода решения, второй класс
задач такие специальные знания предполагает. Задачи, для которых
требуется разработать метод решения, скорее относятся к математике, чем к
программированию, что и делает их трудными для студентов.

ЛЕКЦИЯ 3. СОВРЕМЕННЫЕ ИНТЕГРИРОВАННЫЕ
СРЕДЫ. ВСТРОЕННЫЙ ОТЛАДЧИК.
БИБЛИОТЕКА ПРОГРАММ И КЛАССОВ
План
1. Современные интегрированные среды.

2. Встроенный отладчик.
3. Библиотеки программ и классов.
1. Современные интегрированные среды
Интегрированная среда (IDE – Integrated Development Environment)

представляет собой некоторый единый комплекс для разработки программ.
Она позволяет легко создавать, открывать, просматривать, редактировать,
сохранять, компилировать и отлаживать любые программы. Управляет
работой IDE набор команд меню. Комплекс современных IDE представляет
собой большой набор инструментальных средств для построения программ.
В этом комплексе объединяются трансляторы, система управления работой
компиляций, редакторы, редакторы ресурсов, стандартные библиотеки,
справочный материал, примеры программ, система отладки программ и
система управления процессом отладки, которые демонстрируют
возможности использования операторов языка. Интегрируемая среда
содержит опции для своей настройки, которая соответствует требованиям
пользователя. Подробное описание IDE содержится в документации.
Изложение всех возможностей IDE потребовало бы объемного пособия. И
изучить все эти возможности IDE – сложная задача из-за большого объема
информации. Но принцип работы с IDE прост, и он присутствует во всех
информационных системах. Все возможности управления и настройки IDE
заключены в командах меню и их опциях. Многие из возможностей IDE
имеют автоматические значения по умолчанию, которые позволяют
среднестатистическому пользователю легко подготавливать программу и
запускать ее. Мощные возможности IDE требуются при разработке больших
информационных систем. Для учебной цели нет особой необходимости знать
на первых шагах все сложные возможности IDE. Так как материал курса
осваивается не на реальных задачах, а на небольших по объему задачах
средней сложности, то для успешного освоения курса надо, чтобы
пользователь умел:
загрузить (запустить) IDE;
пользоваться редактором IDE;
пользоваться файловой системой IDE;
пользоваться системой помощи и подсказок IDE;
пользоваться системой компиляции и запуска программ;
выходить из IDE.

ЛЕКЦИЯ 3. СОВРЕМЕННЫЕ ИНТЕГРИРОВАННЫЕ СРЕДЫ. ВСТРОЕННЫЙ ОТЛАДЧИК
1. Современные интегрированные среды
Здесь мы специально не идентифицируем имена команд меню, которые

выполняют перечисленные задачи. Каждая интегрируемая среда (Borland
C/C++, Visual C++, Visual C++ 6, Builder C++, Delphi) эти задачи выполняет
своим набором команд меню. Команды из любой вышеперечисленной IDE
легко и быстро демонстрируются на компьютере на практических занятиях.
По мере возрастания сложности составляемых программ постепенно
осваиваются более сложные возможности конкретной интегрируемой среды.
При разработке больших программных систем обойтись без знаний более
глубоких возможностей IDE нельзя. Слабое знание IDE может привести к
неоправданной трудоемкости при проектировании программ и недостаткам
конечного продукта. Но подобные системы лучше использовать и изучать
при проектировании больших программ. Необходимость в IDE возникла как
раз при разработке больших и очень больших программ. Поэтому очень
трудно демонстрировать возможности интегрируемой среды на учебных
примерах. Трудность не в демонстрации, а в неэффективности и
громоздкости использования мощного инструментария IDE для простых
модельных задач. Получается стрельба из пушки по воробью. И в этом
случае трудно мотивировать необходимость изучения IDE там, где что-то
можно реализовать проще. Кроме того, при рассмотрении модельных задач
программирования многие возможности интегрируемой среды просто
становятся невостребованными. Здесь возникает еще один методический
аспект. Детальное изучение IDE на самом деле требует полнокровного
учебного курса со своим набором модельных задач, содержание которых
направлено не на составление программ для обработки структур данных, а на
демонстрацию возможностей IDE. Поэтому (по мнению авторов) наиболее
эффективное изучение интегрируемой среды сводится к демонстрации
некоторых принципиальных возможностей IDE на простых примерах,
оставляя студентам право, по мере необходимости, осваивать более глубокие
возможности самостоятельно. Заметим, что понятия встроенный отладчик,
генераторы кода / приложений фактически являются элементами, которые
формируют, наряду с другими возможностями, структуру IDE.
2. Встроенный отладчик
Отладка программы, то есть устранение возможных ошибок либо в

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

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

останавливать выполняемую программу на заданной команде, которая
называется точкой останова (или контрольной точкой);
просматривать значение переменных в памяти.
До того как стали появляться интегрируемые системы со встроенными
отладчиками, программист отлаживал программу, расставляя в некоторых
контрольных точках вывод информации из интересующих его переменных.
У современных встроенных отладчиков много возможностей. Но для
эффективного поиска ошибки в процессе обработки информации программой
достаточно выполнять программу медленно и следить за значениями
переменных в режиме выполнения программы. Одна из самых мощных
возможностей интегрированного отладчика – вывод содержимого
переменных программы. Это достигается помещением переменных
программы в окно наблюдения (Watches). Для того чтобы поместить какую-
либо переменную в окно наблюдения в интегрируемой среде Borland надо:
установить курсор на имя переменной;
нажать Ctrl+F7;
нажать Enter.
После помещения переменной в окно надо перейти к пошаговому
выполнению программы. Пошаговое выполнение программы происходит при
нажатии клавиши F7 при условии, что курсор находится в окне рабочего
поля языка C++. В окно наблюдения можно поместить несколько
переменных. Пошаговое выполнение программы при желании можно
прекратить. Для этого надо нажать Ctrl+F9 и тем самым перейти в рабочий
режим, то есть в режим непрерывного выполнения директив.
Если программа большая и содержит много строк, то пошаговое
выполнение программы трудоемко по времени. В этом случае можно
использовать точки останова. Чтобы задать точку останова в интегрируемой
среде Borland надо:
установить курсор на строку останова;
нажать клавишу F2 или в команде меню DEBUG выбрать вариант
Breakpoints.
Обратим внимание на то, что в различных IDE порядок действий и
инструменты (клавиши), при помощи которых выполняются эти действия
для поставленных задач, могут быть разными. Для использования
возможностей отладчика в конкретной интегрируемой среде надо
предварительно ознакомиться с его описанием и инструкцией.
3. Библиотеки программ и классов
Составляя программы, мы постоянно будем использовать некоторые

функции. Эти функции (например, clrscr(), getch(), cout, printf() и т. д.) входят
в состав стандартной библиотеки. Современные задачи настолько сложны,
что с ними невозможно справиться, если не привлекать дополнительные

инструменты, которые содержат готовые библиотеки. Современная

библиотека играет роль инфраструктуры, которая обеспечивает успешное
решение проблемы. Без хорошего дополнительного окружения, которое
содержится в библиотеке, вряд ли можно надеяться на успешное завершение
поставленной задачи. Стандартная библиотека C++ содержит множество
встроенных функций, которые программисты могут использовать в своих
программах. По существу все эти функции не являются частью языка C++,
но их знает компилятор. При использовании программистом библиотечной
функции компилятор связывает код программы с кодом этой функции.
В C++ библиотека функций содержит стандартную библиотеку
шаблонов (STL). Библиотека шаблонов – это набор классов и функций
общего назначения. При помощи этого набора можно реализовывать
алгоритмы и структуры данных, которые часто используются в процессе
обработки информации. Библиотека шаблонов состоит из трех основных
элементов – контейнеров, алгоритмов и итераторов.
Контейнеры – это объекты, которые содержат другие объекты.
Например, элементами контейнера являются такие АТД (абстрактный тип
данных) как векторы, очереди, списки, стеки. Каждый контейнерный класс
определяет набор функций, которые можно использовать в данном
контейнере, и множество алгоритмов работы над переменными.
Алгоритмы предназначены для обработки содержимого контейнеров.
Они могут совершать поиск нужного элемента, сортировать, определять
максимальный или минимальный элемент и т. д. Все алгоритмы можно
применять к контейнеру любого типа, так как они представляют собой
шаблонные функции. Списки алгоритмов STL, как правило, даются в
таблицах справочного материала в пособиях.
Итераторы – это объекты, которые осуществляют доступ к элементам
контейнера. Фактически итераторы играют роль указателей. Над ними можно
выполнять операции инкремента (++) и декремента (--).
Для плодотворного и успешного использования библиотеки классов
надо, прежде всего, освоить элементы объектно-ориентированного
программирования (ООП) и хорошо ориентироваться в шаблонах. Полное
описание библиотеки STL может занять целую книгу. Возможности средств
данной библиотеки таковы, что можно говорить о STL-программировании.
Формат кодов, которые используют функции STL, естественно, во многом
совпадает с синтаксисом ООП и требует определенных навыков для
корректной записи этих кодов в процессе программирования. В учебных
пособиях описание библиотеки STL, демонстрация ее возможностей и
способы применения, как правило, даются после полного изложения курса
ООП.
Стандартная библиотека должна быть в каждой реализации языка,
чтобы все программисты могли ее использовать. Стандартная библиотека
C++:

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

типами переменных, во время работы программы.
Предоставляет информацию о зависящих от реализации аспектах языка
(например, о диапазоне представления переменных).
Предоставляет функции (например, sin(), log() и т. д.), которые не
могут быть написаны оптимально для всех систем на языке C++.
Предоставляет нетривиальные средства, такие как потоки ввода/
вывода.
Предоставляет средства для расширения возможностей, такие как,
поддержка новых типов данных. Обеспечивает ввод/вывод для определяемых
им новых типов в стиле ввода/вывода для встроенных типов.
Служит общим фундаментом для других библиотек.
Предлагаемые библиотекой C++ средства должны удовлетворять
следующим требованиям:
Быть доступными для каждого пользователя, в том числе для
создателей других библиотек.
Быть достаточно эффективными.
Быть независимыми от алгоритмов, которые используются при
программировании.
Быть удобными и достаточно безопасными в большинстве ситуаций.
Быть завершенными в том, что делают.
Быть безопасными по умолчанию с точки зрения типов.
Хорошо дополнять встроенные типы и операции.
Поддерживать общепринятые стили программирования.
Быть способными к расширению, чтобы работать с типами, которые
определяет пользователь.
Средства стандартной библиотеки распределены по файлам, а они
сгруппированы по выполняемым функциям.

ЛЕКЦИЯ 4. ПРОСТЕЙШАЯ ПРОГРАММА.
ВЫВОД ТЕКСТА НА ЭКРАН.
ДИРЕКТИВЫ CLRSCR() И GETCH()
План
1. Простейшая программа.
2. Вывод текста на экран.
3. Препроцессор.
4. Директивы clrscr() и getch().
1. Простейшая программа
Язык программирования – это некоторый набор символов, директив

(команд, которые может выполнять компьютер) и правил использования
этого набора. Для того чтобы написать простейшую программу на любом
языке программирования, прежде всего надо знать форму представления
директив, последовательность их написания, а также правила, по которым
они выполняются.
Под программой понимается некоторый набор директив, которые
удовлетворяют определенным правилам данного языка. Под директивой
здесь понимается записанное по правилам языка указание, которое
компьютер при рассмотрении обязательно выполнит. Слова директивы,
коды, команды и операторы рассматриваются как синонимы. Сейчас мы
познакомимся с кодом простейшей программы на языке С.
void main()
{
}
Итак, все программы языка С начинаются с директивы void main(), за

которой сразу следует символ { – открывающаяся фигурная скобка, то есть
начало программы. Завершается код программы символом } –
закрывающаяся фигурная скобка, конец программы. Данную программу
можно записать еще в виде
void main()
{ }
или
void main () { }
Представленную программу принято называть пустышкой.

ЛЕКЦИЯ 4. ПРОСТЕЙШАЯ ПРОГРАММА. ВЫВОД ТЕКСТА НА ЭКРАН. ДИРЕКТИВЫ CLRSCR() И GETCH()
Замечание 1. Изменять написание директивы в программе по своему

усмотрению нельзя. Любое изменение директивы является ошибкой, и
программа с неточно записанными директивами компьютером не
воспринимается. Приведем примеры неправильных кодов программы-
пустышки.
Void main()
{
}
void main();
{
}
void main
{
}
void main()
{
}.
Поясним, почему коды представленных программ неправильны.
В программе 1 в слове Void используется заглавная буква V, в программе 2
после директивы void main() поставлена точка с запятой, в программе 3 после
слова main нет скобок, в программе 4 после директивы закрывающая
фигурная скобка поставлена точка.
Замечание 2. Все написанные директивы программы выполняются
компьютером по порядку начиная с первой.
Замечание 3. Директивы открывающая фигурная скобка и
закрывающая фигурная скобка могут использоваться в программе
произвольное количество раз. Программу-пустышку, например, можно
записать так:
void main()
{ { { } } }
или
void main()
{ {} {} {} }
При многократном использовании фигурных скобок надо соблюдать

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

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

1. Загрузить Borland C.
2. Вызвать редактор языка.
3. Использовав символы клавиатуры, набрать текст программы.
4. Использовав комбинацию клавиш Ctrl+F9, активизировать
выполнение набранной программы.
Язык C поддерживает два экрана:
1) рабочего поля языка С;
2) выдачи результатов расчета.
Переход из одного экрана в другой осуществляется нажатием
комбинацией клавиш ALT+F5.
Экран рабочего поля языка C представляет собой окно с набором
команд меню, которые управляют работой интегрируемой среды Borland C.
Экран выдачи результатов предназначен для информации, которую
необходимо вывести пользователю на экран в процессе работы программы.
Естественно, вывод необходимой информации на экран определяет
программист, который разрабатывал данную программу. Информация на
экране может появляться и в процессе работы программы и при ее
завершении. Возможен случай, когда в прцессе работы программы вывод
информации на экран не предусмотрен. Примером последнего случая может
служить программа-пустышка.
Замечание 4. После завершения работы программы компьютер
возвращается в рабочее поле языка C.
2. Вывод текста на экран
Для вывода текста на экран монитора в языке C можно использовать

две директивы (функции):
cout – функция бесформатного вывода информации на экран;

printf – функция форматного вывода текста на экран
Функция cout. Правила формирования вывода текста на экран.

1. Код вывода текста на экран начинается с директивы cout.
2. Выводимый текст должен следовать за символом << (двойной знак
меньше).
3. Выводимый текст заключается в символ “ “ (двойные кавычки).
4. Если в выводимом тексте встретился символ \n (обратный слеш, n),
то после этого символа последующий текст выдается на экран монитора с
новой строки.
5. Код вывода информации на экран завершается символом ; (точкой с
запятой).

2. Вывод текста на экран
Пример 1. cout << “Доброе утро студент”;

Функция printf. Правила формирования вывода текста на экран.
1. Код вывода текста на экран начинается с директивы printf.
2. Выводимый текст находится между символом “ “ (двойные кавычки)
и заключается в круглые скобки.
3. Если в выводимом тексте встретился символ \n (обратный слеш, n),
то после этого символа последующий текст выдается на экран монитора с
новой строки.
4. Код вывода информации на экран завершается символом ; (точкой с
запятой).
Пример 1. printf (“Доброе утро студент”);
3. Препроцессор
Препроцессор – это инструкции компилятору. Эти инструкции

называются директивами препроцессора. Все директивы препроцессора
начинаются со знака #.
Функции (директивы) языка C разбиты на логические группы, которые
распределяются по стандартным файлам. Например, функции cout и printf
соответственно содержатся в файлах iostream.h и stdio.h. Эти файлы, как
правило, располагаются в каталоге INCLUDE.
Стандартные файлы присоединяются к программе директивой
#include, относящейся к директивам препроцессора. Все директивы
препроцессора размещаются перед заголовком void main(). Для того чтобы
иметь возможность в какой-нибудь программе использовать директиву cout,
надо файл iostream.h присоединить к этой программе. Полный вид
директивы, которая присоединяет, например, файл iostream.h к составляемой
программе, имеет вид #include <iostream.h>.
Программа 1 «Доброе утро, студент»
#include <iostream.h>
void main()
{
cout << “Доброе утро, студент!!!”; // Выводит на экран текст,
// который заключен в двойных
// кавычках.
}
После работы данной программы на экране выдачи результатов

появится следующая строка:
Доброе утро, студент!!!
Замечание 4. После завершения работы программы компьютер
возвращается в рабочее поле языка. Чтобы ознакомиться с результатом

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

этого, как говорилось выше, надо нажать клавиши Alt + F5.
Приведем несколько вариантов вывода текстов на экран монитора с
использованием директивы cout. Отметим, что это лишь некоторые
различные возможности, которые можно использовать в процессе написания
программы, если в этом есть необходимость.
1. cout << “Это я, веселый студент, шлю миру горячий привет!!!”;
2. cout << “Это я, веселый” << “ студент,” << “ шлю миру”
<< “ горячий привет!!!”;
3. cout << “Это я,\nстудент, \nшлю миру \nгорячий привет \n!!! \n”;
4. cout << “Это я, веселый студент, шлю миру горячий привет!!! \n”;
5. cout << “Это я, студент, шлю миру горячий привет!!!” << “ \n”;
Приведем результаты выполнения директив в перечисленных

вариантах:
1. Это я, веселый студент, шлю миру горячий привет!!! _
2. Это я, веселый студент, шлю миру горячий привет!!! _
3. Это я,
студент,
шлю миру
горячий привет
!!!
_
4. Это я, веселый студент, шлю миру горячий привет!!!
_
5. Это я, студент, шлю миру горячий привет!!!
_
Символ _ показывает положение курсора после вывода текста на экран

монитора.
Программа «Доброе утро» с использованием функции printf() будет
выглядеть следующим образом.
Программа 2
#include <stdio.h>
void main()
{
printf(“Доброе утро, студент!!!”);
// Выводит на экран текст, который
} // заключен в двойных кавычках.
Замечание 5. Директивы программы, которые расположены между

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

Замечание 6. В языке C текст, который следует после символа //

(двойной слеш), воспринимается компьютером как комментарий для
пояснения программы, а не как коды, которые надо выполнить. Возможность
комментировать директивы программы присутствует в любом языке
программирования. В программе «Доброе утро, студент» такая возможность
была использована.
4. Директивы clrscr() и getch()
Функция getch() ожидает нажатие клавиши. Данную функцию можно

использовать для просмотра экрана выдачи результатов на различных этапах
работы программы. Когда компьютер встречает директиву getch() он
переходит в режим ожидания, при котором на мониторе выдается экран
результатов расчета. И в этом режиме он находится до тех пор, пока
пользователь не нажмет какой-нибудь символ на клавиатуре. Функция getch()
содержится в файле conio.h.
Рассмотрим программу «Доброе утро», в которую включена функция
getch().
Программа 3 «Доброе утро, студент».
#include <stdio.h>
#include <conio.h>
void main()
{
clrscr(); // Очищает экран монитора.
cout << “Доброе утро, студент!!!”; // Выводит на экран выдачи
// текст, который заключен
// в двойных кавычках.
getch();
}
После запуска программы на экране результатов расчета появится

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

«Доброе утро» запустить несколько раз (например, пять), то на экране

выдачи результатов будет следующее:
На экране монитора желательно сохранять только ту информацию,
которая появилась в процессе работы последней программы. В языке C есть
директива clrscr(), которая удаляет информацию с экрана выдачи результатов
расчета. Эту функцию можно использовать для очистки экрана перед
выдачей новых результатов работы программы. Данная функция содержится
в файле stdio.h.
Рассмотрим программу «Доброе утро», в которую включим директиву
clrscr()
Программа 4 «Доброе утро, студент».
#include <stdio.h>
#include <conio.h>
void main()
{
clrscr(); // Очищает экран монитора.
cout << “Доброе утро, студент!!!”; // Выводит на экран выдачи текст,
// который заключен в двойных кавычках.
getch();
}
Как только эта программа начнет работать, код clrscr() удалит с экрана
выдачи результатов расчетов всю информацию, которая находилась там до
последнего запуска программы. Поэтому, сколько бы раз программа «Доброе
утро» ни запускалась, на экране выдачи результата будет сохраняться только
одно сообщение:
То есть будет сохраняться результат последней работы программы.
Любую директиву в программе можно использовать многократно.
Применение той или иной директивы диктуется только условием задачи.
#include <conio.h>
#include <stdio.h>
void main()
{
clrscr();
clrscr();
clrscr();
getch();

getch();
clrscr();
clrscr();
getch();
getch();
}
Программа 5 как правильна, так и бессмысленна. Она пять раза удаляет

информацию с экрана, на котором информация уже отсутствует, и нужно
четыре раза нажать какую-нибудь клавишу, для того чтобы вернуться в среду
языка C.
Поговорим теперь о порядке записей директив в программе. Порядок
записи определяется целью задачи. Для задачи «Доброе утро» возможна,
например, такая последовательность директив:
#include <conio.h>
#include <stdio.h>
void main()
{
cout << “Доброе утро, студент!!!”;
clrscr();
getch();
}
В этом случае компьютер будет выполнять действия в следующем
порядке:
1. На экран монитора выводится текст «Доброе утро, студент!!!». Но
на экране при этом может присутствовать информация о работе предыдущей
программы.
2. Удаляется вся информация с экрана.
3. Компьютер ожидает нажатие клавиши.
4. После нажатия клавиши происходит переход в оболочку языка C.
При выполнении директив в таком порядке после завершения работы
программы на экране монитора будет отсутствовать текст послания. При
последовательности директив
#include <conio.h>
#include <stdio.h>
void main()
{
cout << “Доброе утро, студент!!!”;
getch();
clrscr();
}

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

1. На экран монитора выводится текст «Доброе утро, студент!!!». Но
на экране при этом может присутствовать информация о работе предыдущей
программы.
2. Компьютер ожидает нажатие клавиши, состояние экрана при
ожидании не меняется.
3. После нажатия любой клавиши удаляется вся информация, которая
была на мониторе, и компьютер переходит в оболочку языка C.
В этом случае после завершения работы программы на экране
терминала тоже не появится нужное сообщение. Отсюда вывод:
предложенный порядок расположения директив в двух последних примерах
не выполняет поставленную задачу, потому что на экране монитора после
работы программ не сохраняется текст «Доброе утро, студент!!!». Заметим,
что в процессе выполнения программ данный текст на экране появлялся. Для
подтверждения этого немного изменим код программы первого примера:
#include <conio.h>
#include <stdio.h>
void main()
{ cout << “Доброе утро, студент!!!”;
getch();
clrscr();
getch(); }
Здесь после вывода текста «Доброе утро, студент!!!» компьютер

будет выполнять директиву getch(), т. е. находиться в режиме экрана
результатов расчетов до нажатия клавиши клавиатуры.
Вывод: порядок расположения директив программы определяется
поставленной задачей и не может быть произвольным.

ЛЕКЦИЯ 5. ПАМЯТЬ. ПЕРЕМЕННЫЕ.
ВЫВОД НА ЭКРАН. ЗАПИСЬ В ПЕРЕМЕННЫЕ
ТИПА INT И FLOAT. ВВОД С КЛАВИАТУРЫ
План
1. Память.
2. Переменные.
3. Вывод переменных на экран.
4. Запись в переменные типа int и float.
5. Ввод с клавиатуры.
1. Память
Память компьютера состоит из байтов. Байт – это устройство, которое

содержит 8 битов. Схематично байт представляют в виде прямоугольника,
разделенного на 8 одинаковых частей. Предполагается, что в каждой части
можно зафиксировать два устойчивых состояния: 0 или 1 (рисунок).
Емкость памяти машины измеряется в байтах. Каждый байт в памяти
имеет свой уникальный номер, который называется адресом байта.
Рис. 5.1
2. Переменные
Переменная – это именованная область памяти для записи и хранения

информации. При помощи переменной резервируется (заказывается) память
под информацию, которая используется при выполнении программы. Общая
форма определения переменной имеет следующий вид:
<тип переменной> <имя переменной>
Здесь <тип переменной> – ключевое слово базового типа данных. Тип

переменной определяет размер выделяемой памяти под информацию.

ЛЕКЦИЯ 5. ПАМЯТЬ. ПЕРЕМЕННЫЕ. ВЫВОД НА ЭКРАН. ЗАПИСЬ В ПЕРЕМЕННЫЕ ТИПА INT И FLOAT
2. Переменные
Базовые типы данных

Тип переменных Размер байт Диапазон значений
int 2 –32768÷32767
float 4 3.4E-38÷3.4E+38
long 4 –2147483648÷2147483647
double 8 1.7E-308÷1.7E+308
unsigned long 4 0÷4294967295
Тип определяет операции, которые можно применять для переменных.

Здесь <имя переменной> – идентификатор, т. е. произвольный набор из
символов клавиатуры. Имя переменной определяет составитель программы.
При формировании имени надо соблюдать некоторые ограничения:
нельзя использовать русские буквы и разделители (пробел, запятая,
точка и др.);
имя не должно совпадать со служебными (ключевыми) словами языка C;
прописные и строчные буквы являются разными символами, т. е.
переменные с именами n1 и N1 – разные переменные.
Примеры объявления переменных:
int a, b, c;
В памяти компьютера выделяется три области памяти размером в два

байта под именами a, b, c.
float r1, r2, wer;
В памяти компьютера выделяется три области памяти размером в

четыре байта под именами r1, r2, wer.
3. Вывод переменных на экран
Для вывода информации на экран из переменного можно использовать

директиву cout. При этом надо соблюдать правило – имя переменной, из
которой выводится информация, должно следовать за символом << (двойной
знак меньше). Если определена переменная n1, то код вывода информации из
n1 имеет следующий вид:
cout << “Целое число в n1 = ” << n1 << “\n”;
Представленную директиву компьютер будет выполнять в следующей

последовательности:
На экран результата выдаст текст в кавычках:

3. Вывод переменных на экран
Целое число в n1 =
А затем – информацию из области памяти с именем n1.

Из приведенного примера можно исключить вывод текста:
Целое число в n1 =
В этом случае код вывода информации из переменной n1 будет

выглядеть так:
cout << n1 << “\n”;
Вывод текста на экран включен в код для пояснения процесса работы

компьютера. В данном случае программа сообщает о виде выводимой
информации.
cout – код бесформатного вывода, т. е. вид выводимой информации
определяется типом переменной. И поэтому в данном случае информацию,
которая хранится в области памяти компьютера с именем n1, компьютер
будет трактовать как целое число.
4. Запись в переменные типа int и float
Для записи информации (чисел) в переменные типа int или float можно
использовать оператор присваивания, который определяется символом =
(равно). Например, если код int k1; резервирует два байта памяти под именем
k1 для записи целых чисел, то код k1 =2; записывает (засылает) в эту область
памяти число 2.
Переменная может быть определена при ее объявлении. Например,
возможен в программе код float r1 = 0.8, we = –3.5; При выполнении
данного кода компьютер выделяет две области памяти с именами r1, we и
одновременно занесет в эту память соответственно числа 0.8 и –3.5.
#include <conio.h>
#include <stdio.h>
void main()
{ int a, b, c, z; // Резервируется память для четырех целых чисел.
clrscr(); // Удаляется с экрана выдачи информация.
cout << “Эта программа резервирует память для четырех целых чисел\n”;
cout << “и засылает в переменные a, b и c”
<< “ соответственно числа 2, 5, 7\n”;
a = 2; b = 5; c = 7;
cout << “В память введена следующая информация:\n”;

cout << “a = “ << a << “\nb = “ << b << “\nc = “ << c << “\n”;
getch(); } // Ожидается нажатие клавиши.
В результате работы программы 1 на экране выдачи результатов будет

находиться следующая информация:
Эта программа резервирует память для четырех целых чисел

и засылает в переменные a, b и c соответственно числа 2, 5, 7
В память введена следующая информация:
a=2
b=5
c=7
Замечание 1. При объявлении переменных в выделяемых областях
памяти находятся случайные числа. Этот факт иллюстлируется следующей
программой.
Программа 2. Вывод информации из зарезервированных областей
памяти компьютера.
#include <conio.h>
#include <stdio.h>
void main()
{ int a, b, c, z; // Резервируем память для четырех целых чисел.
clrscr(); // Очищается экран.
cout << “Эта программа резервирует память для четырех целых чисел. \n”;
cout << “В зарезервированной памяти “
<< “находится следующая информация: \n”;
cout << “a = “ << a << “\nb = “ << b << “\nc = “ << c
<< “\nz = “ << z << “\n”;
После выполнения данной программы на экране монитора появится

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

В зарезервированной памяти находится следующая информация:
a = Xa
b = Xb
c = Xc
z = Xz
Значение чисел Xa, Xb, Xc, Xz, которые вывел компьютер, заранее
невозможно определить. Поэтому программист должен сам заботиться об
инициализации заказанной памяти.
Замечание. Переменную можно не инициализировать, если она
используется после того, как ей присвоили какой-либо результат расчета.

Оператор & (амперсант) определяет адрес (т. е. физическую область

места памяти) объявленной в программе переменной.
#include <conio.h>
#include <stdio.h>
void main()
{ int n1, n2, n3, n4; // Резервируется память для четырех целых чисел.
cout << “Эта программа резервирует память для целых чисел. \n”;
cout << “ Имя переменной n1 соответствует адресу – “ << &n1
<< “\n Имя переменной n2 соответствует адресу – “ << &n2
<< “\n Имя переменной n3 соответствует адресу – “ << &n3
<< “\n Имя переменной n4 соответствует адресу – “ << &n4 << “\n“;
getch(); }
После выполнения данной программы на экране монитора появится

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

Имя переменной n1 соответствует адресу – N1
Здесь N1, N2, N3, N4 – номера адресов ячеек памяти, которые компьютер
выделил программе для записи целых чисел.
Если надо выдать адреса в десятичной системе исчисления, следует
перед &n1, &n2, &n3 и &n4 поставить директиву преобразования типа
(unsigned int). Скобки в данном случае являются элементами директивы.
Cоставим программу для простой, но очень важной задачи, – поменять
местами значения переменных x и y.
Следующая программа переставляет числа, которые записаны в
переменных x и y.
#include <conio.h>
#include <stdio.h>
void main()
{ float x = -2.5, y = 5.1, z;
cout << “Значение в x= ” << x << “\nЗначение y= “ << y << “\n”;
z = x; // Пересылается информация из x в z.
x = y; // Пересылается информация из y в x.
y = z; // Пересылается информация из z в y.
cout << “\n Результат работы программы: \n\n”;

cout << “ Значение переменных после перестановки: \n”;

cout << “Значение в x= ” << x << “\nЗначение y= “ << y << “\n”;
getch(); }
5. Ввод с клавиатуры
Для ввода информации в память компьютера с клавиатуры

используются функции (директивы):
cin – бесформатный ввод данных с клавиатуры;

scanf – форматный ввод данных с клавиатуры.
Функции cin и scanf предоставляют возможность взаимодействовать с
программой во время ее работы.
Директива cin находится в стандартном файле iostream.h. Возможные
коды с использованием cin имеют, например, следующий вид:
cin >> x; С клавиатуры вводится информация в переменную x;
cin >> a >> b >> c; С клавиатуры вводится информация в
переменные a, b, c.
Для директивы cin можно сформулировать общие правила ввода
информации в переменную с именем x:
• код ввода информации в память начинается с директивы cin;
• далее следует символ >> (двойной знак больше);
• затем следует имя переменной, в которую надо вводить информацию
(в данном примере имя x);
• директива ввода информации должна заканчиваться символом ;
(точка с запятой).
Итак, надо запомнить, что если для ввода информации с клавиатуры
используется cin, то перед именем каждой переменной, в которую надо
ввести информацию с клавиатуры, должен находиться символ >> (двойной
знак больше).
Код cin >> x; есть директива ввода информации с клавиатуры в
переменную x. Для того чтобы программа выполнила эту директиву, надо,
используя клавиатуру, набрать требуемый набор символов и нажать клавишу
Enter. Директива cin определяет вид вводимой информации автоматически
по типу переменной, который объявляется в программе. Поэтому
рекомендуется перед вводом данных выводить на экран пояснительный текст
по типу вводимых данных.
Приведенная ниже программа демонстрирует ввод целых чисел с
клавиатуры.
void main()
{int a, b, c, z; // Резервируется память для четырех целых чисел.
cout <<“Введи целое число (набери число и нажми Enter) ”;
cin >> a; // Ввод с клавиатуры числа в переменную a.

cout << “Введи целое число (набери число и нажми Enter) ”;

cin >> b; // Ввод с клавиатуры числа в переменную b.
cout << “Введи целое число (набери число и нажми Enter) ”;
cin >> c; // Ввод с клавиатуры числа в переменную c.
cout << “Вы ввели числа: \n”;
cout << “a = “ << a << “\nb = “ << b << “\nc = “ << c << “\n”;
При работе данной программы на экран монитора последовательно
будет выводиться информация:
Введи целое число a (набери на клавиатуре число и нажми Enter)

Введи целое число b (набери на клавиатуре число и нажми Enter)
Введи целое число c (набери на клавиатуре число и нажми Enter)
После вывода на экран очередного сообщения компьютер не будет

выполнять программу до тех пор, пока на клавиатуре не будет набрано число
и не нажата клавиша Enter. Целое число должно соответствовать диапазону
представления переменных типа int. Приведем код программы, которая
демонстрирует ввод трех целых чисел с клавиатуры с применением
директивы cin >> a >> b >> c.
#include <conio.h>
#include <stdio.h>
void main()
cout << “Введи с клавиатуры три целых числа a, b и c,\n”
<< “для этого набери три числа через пробелы, и нажми Enter ”;
cin >> a >> b >> c;
cout << “a = “ << a << “\nb = “ << b << “\nc = “ << c << “\n”;
getch(); }
При работе данной программы, после того как на экране монитора

появится сообщение
Введи с клавиатуры три целых числа a, b и c,

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

нажать клавишу Enter. После этого программа завершит свою работу.

Функция scanf является функцией форматного ввода. Директива scanf

находится в стандартном файле stdio.h. Общий формат кода при
использовании функции scanf() имеет следующий вид:
scanf (<управляющая строка>, <список переменных>).
В управляющей строке указываются форматы вводимых переменных.

Символы, которые используются для формирования управляющей строки,
заключаются в двойные кавычки. В списке переменных через запятую
указываются адреса переменных, в которые надо ввести информацию с
клавиатуры. Возможные коды с использованием scanf имеют, например,
следующий вид:
scanf(“%d”, & x);

scanf(”%d, %f, %g”, &a, &b, &c);
Здесь “%d”, ”%d, %f, %g” являются управляющими строками. В данном

случае в строке указываются спецификаторы преобразования, или коды
форматов для переменных, которые вводятся с клавиатуры. Спецификатор
(формат) %d определяет ввод в переменную x целого числа, а %f и %g
определяют ввод в переменные b и c вещественных чисел. Для того чтобы
программа выполнила код scanf(“%d”, & x); следует, используя клавиатуру,
набрать целое число и нажать клавишу Enter. В отличие от cin, правила
использования scanf несколько сложнее и заключаются в следующем:
• в двойных кавычках размещаются символы, формирующие
инструкцию ввода – управляющую строку, в которой, например,
указываются форматы выводимых данных;
• после управляющей строки через запятые дается список адресов
вводимых переменных. Порядок перечисления списка переменных
определяется инструкциями управляющей строки.
Приведем код программы ввода трех чисел в память машины с
применением директивы scanf.
#include <conio.h>
#include <stdio.h>
void main()
clrscr(); // Очищает экран.
cout << “Введи целое число a (набери число и нажми Enter ”;
scanf(“%d”,&a);
cout << “Введи целое число b (набери число и нажми Enter ”;
scanf(“%d”,&b);
cout << “Введи целое число c (набери число и нажми Enter ”;

scanf(“%d”,&c);
cout << “a = “ << a << “\nb = “ << b << “\nc = “ << c << “\n”;
Управляющая строка каждой директивы scanf программы имеет вид
“%d”, что означает ввод целого числа. При работе данной программы будут
происходить запросы на ввод целых чисел. После вывода на экран
очередного сообщения компьютер не будет выполнять программу до тех пор,
пока на клавиатуре не будет набрано число и не нажата клавиша Enter.
Целое число должно соответствовать диапазону представления переменных
типа int.
Приведем код программы, которая демонстрирует ввод трех целых
чисел с клавиатуры с применением директивы scanf(“%d%d%d”, &a,
&b, &c).
Договоримся в коде программ не писать директивы препроцессора,
присутствие которых, вообще говоря, обязательно. Но формат этих директив
во всех программах одинаковый и добавить в случае необходимости эти
директивы к тексту программы не представляет труда.
Следующая программа вводит три целых числа в память компьютера
через клавиатуру.
void main()
cout << “Введи с клавиатуры три целых числа a, b и c,\n”
<< “Ннабери три числа, разделенных пробелом, и нажми Enter ”;
scanf(“%d%d%d”, &a, &b, &c);
cout << “a = “ << a << “\nb = “ << b << “\nc = “ << c << “\n”;
Управляющая строка в данной программе имеет вид ”%d%d%d”. Это

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

ЛЕКЦИЯ 6. АРИФМЕТИЧЕСКИЕ ОПЕРАЦИИ.
МАТЕМАТИЧЕСКИЕ ВЫРАЖЕНИЯ И ФУНКЦИИ
План
1. Арифметические операции.
2. Математические выражения и функции.
1. Арифметические операции
В языке C (как и в других языках программирования) используются

следующие арифметические операции:
+ сложение
– вычитание
* умножение
/ деление
% остаток от целочисленного деления.
Эти операции можно использовать при составлении программы для
вычисления суммы, разности, произведения или частного двух чисел.
Например, пусть заданы два вещественных числа a и b. Тогда коды
float a=6, b=2, z;
z= a + b; // Число из a сумируется с числом из b
// результат суммы засылается в z.
z= a – b; // Из числа в a вычитается число из b
// результат разности засылается в z.
z= a * b; // Число из a умнажается на число из b

// результат произведения засылается в z.
z= a / b; // Число из a делится на число из b

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

чисел и результат этого вычисления записывается в переменную z.
Приведем код программы, которая использует арифметические
операции.
Задача 1. Вычислить z по формуле z=a+bc, при a=2, b = 5 и c = 7.
Первое, на что мы обратим внимание: параметры a, b и c принимают
целые значения. Отсюда следует вывод, что и z принимает целое значение.
Для того чтобы выполнить эту задачу, мы должны сначала в память
компьютера ввести числа 2, 5 и 7, а затем над этими числами произвести
необходимые операции. Но прежде чем записать в память числа, мы должны
сначала зарезервировать место в памяти для ввода этих чисел. Итак,

ЛЕКЦИЯ 6. АРИФМЕТИЧЕСКИЕ ОПЕРАЦИИ. МАТЕМАТИЧЕСКИЕ ВЫРАЖЕНИЯ И ФУНКЦИИ
простейший анализ задачи приводит к выводу, что в программе для

вычисления z надо зарезервировать четыре области памяти для записи и
хранения четырех целых чисел. Запишем код программы, который выполняет
эту часть задачи.
Следует обратить внимание на вопрос о структуре начальных данных,
так как это важная задача во всем процессе проектирования программ (книга
Н. Вирта: «Алгоритм + структура данных = программа»).
Программа 1. Резервирует память для решения задачи.
void main()
cout << “Эта программа выделяет память для 4 целых чисел \n”;
Теперь зашлем конкретные числа в отведенную память. Запись чисел 2,

5 и 7 в переменные a, b и c можно осуществить последовательностью
следующих директив:
a = 2; b = 5; c = 7;
или директивой (задавать значение переменной можно при ее
объявлении)
int a = 2, b = 5, c = 7;
Добавим перечисленные директивы в код программы 1. Тогда получим

следующую программу.
Программа 2. Засылает в память начальную информацию.
void main()
cout << “Эта программа резервирует память для четырех целых чисел \n”;
a = 2; // В переменную a засылается целое число 2.
b = 5; // В переменную b засылается целое число 5.
c = 7; // В переменную c засылается целое число 7.
Для того чтобы контролировать работу программы, нужно проверить

содержимое заполненных ячеек. Добавляя в программу 2 директивы вывода
информации, введенные в память, получим следующий промежуточный код
программы.
void main()
cout << “Эта программа резервирует память для четырех целых чисел\n”;


a = 2; b = 5; c = 7;
cout << “В память введена следующая информация:\n”;
cout << “a = “ << a << “\nb = “ << b << “\nc = “ << c << “\n”;
Прокомментируем директиву
cout << “a = “ << a << “\nb = “ << b << “\nc = “ << c << “\n”;
Она будет выполняться слева направо, а именно:

произойдет вывод текста в кавычках “a = “ (на экране появится a =);
произойдет вывод значения числа в переменной a (на экране повится
a = 2);
произойдет перевод курсора на новую строку и вывод текста в
кавычках (на экране появится b =);
произойдет вывод значения числа в переменной b (на экране появится
b = 5);
произойдет перевод курсора на новую строку и вывод текста в
кавычках (на экране появится c =);
произойдет вывод значения числа в переменной с (на экране появится
c = 7);
курсор переводится на новую строку.
В результате работы программы 3 на экране выдачи результатов будет
находиться следующая информация:
Эта программа резервирует память для четырех целых чисел

и засылает в переменные a, b и c соответственно числа 2, 5, 7
a=2
b=5
c=7
Теперь для окончательного выполнения задачи 1 в программу 3 после

вывода начальных данных из переменных a, b и c надо добавить директивы:
z = b * c; // Число из b умножается на число из c,

// результат заносится в z.
z = a + z; // Число из a суммируется с числом из z ,
cout << “Результат расчета a + b * c = “ << z << “\n”;
Написанные директивы неявно указывают на факт, что если в

некоторых переменных x и y находятся числа, то умножение (сложение,

деление, вычитание) этих чисел и запись результата в переменную z

происходит при выполнении директивы z = x * y. При этом информация в
переменных x и y сохраняется, а в переменной z происходит удаление той
информации, которая в ней содержалась до записи нового результата.
Заметим, что все сказанное об операциях над числами справедливо для чисел
любого типа.
Теперь окончательно для задачи 1 приведем соответствующий ей код
программы.
void main()
{ int a, b, c, z: // Резервируется память для четырех целых чисел.
cout << “Эта программа вычисляет значение z = a + b * c “
<< “ при а = 2, b = 5 и c = 7. \n”;
a = 2; // В переменную a засылается число 2.
b = 5; // В переменную b засылается число 5.
c = 7; // В переменную c засылается число 7.
cout << “В память введена следующая информация: \n”;
cout << “a = “ << a << “\nb = “ << b << “\nc = “ << c << “\n”;
z = a + z; // Число из z суммируется с числом из a,
// результат заносится в z .
cout << “Результат расчета a + b * c= “ << z << “\n”;
После выполнения этой программы на экране монитора появится

следующий результат:
Эта программа вычисляет значение z = a + bc при а = 2, b = 5 и c = 7.

a=2
b=5
c=7
Результат расчета a + b * c = 37
Дадим другой вариант кода программы для решения задачи 1.
void main()
{ int a = 2, b = 5, c = 7, z; // Резервируется память для 4 целых чисел.
// При определении переменных в память
// засылаются начальные данные.
cout << “Эта программа вычисляет значение z = a + b * c “

<< “ при а = 2, b = 5 и c = 7. \n”;

cout << “a= “ << a << “\nb= “ << b << “\nc= “ << c << “\n”;
z = a + z; // Число из a суммируется с числом из z,
cout << “z = “ << a << “+” << b << “*” << c << “= “ << z
<< “\n”;
Этот вариант программы отличается от предыдущего директивой

выдачи результатов расчета и тем, что числа засылаются в память при
определении переменных. Полезно обратить внимание на организацию
вывода результата расчета с использованием директивы cout. После
выполнения программы на экране появится следующее:
Эта программа вычисляет значение z= a+bc при а = 2, b = 5 и c = 7.

a=2
b=5
c=7
z=2 + 5 * 7 = 37
Если величину z=a+bc надо вычислить при разных значениях

переменных, то определять начальные значения a, b и c в коде программы
неудобно. Неудобно потому, что любое изменение начального значения или
a, b или c требует исправления в коде исходного текста программы. Ниже
приведен код программы вычисления z=a+bc для произвольных (не только
целых) начальных значений чисел a, b и c.
Программа 6. Вычисляет значение z=a+bc при любых начальных
значениях чисел a, b, c.
void main()
{ float a, b, c, z; // Резервируется память для 4 вещественных чисел.
cout << “Эта программа вычисляет значение z = a + b c “
<< “ при любых начальных значениях а, b, c \n”;
cout << “Введи с клавиатуры 4 вещественных числа a b c: \n”;
cin >> a >> b >> c;
cout << “В память введены числа: \n”;
cout << “a= “ << a << “\nb= “ << b << “\nc= “ << c << “\n”;
z = a + b * c; // Число из b умножается на число из c,
// к ac прибавляется число из a и результат заносится в z.
cout << “z = “ << a << “+” << b << “*” << c << “= “ << z << “\n”;

Заметим, что в представленной программе коды:

z = a + z; // Число из a суммируется с числом из z,.
ранее использовавшиеся для вычисления значения z, заменяются на один

код: z = a + b * c;. Этот код можно, например, записать в следующих
вариантах: a= a + b * c; или b = a + b * c; или c=a+b * c;
Следует обратить внимание слушателей на последовательный процесс
решения задачи. На самом деле этот процесс является моделью
проектирования сложных программ. Приведем еще один код программы
решения задачи 1.
Программа 7. Вычисляет значение z=a+bc при любых начальных
знвчениях чисел a, b, c.
void main()
{ float n1, n2, n3, n4; // Резервируется память для 4 целых чисел.
cout << “Эта программа вычисляет значение z = a + bc “
<< “ при любых начальных значениях а, b, c \n”;
cout << “Введи с клавиатуры 4 вещественных числа a b c: \n”;
cin >> n1 >> n2 >> n3;
cout << “a = “ << n1 << “\nb = “ << n2 << “\nc = “ << n3 << “\n”;
n4 = n1+ n2 * n3;
cout << “z = “ << n1 << “+” << n2 << “*” << n3 << “= “ << n4
<< “\n”;
На этом примере демонстрируется тот факт, что имена переменных –

это внутреннее дело программы, т. е. на экран можно выводить символы,
соответствующие обозначениям задачи, а в программе для этих целей
использовать другие имена. Но программу легче проверять, если имена
переменных совпадают с именами обозначений, которые используются в
задаче. Поэтому там, где это возможно, имена, используемые в задаче,
обычно применяют и в самой программе.
В заключение отметим одну принятую условность. Имена переменных
при объяснении программ отождествляют со значением информации,
которая в них содержится, то есть запись
z = a + b * c;

принято объяснять так: к a прибавляется значение b, умноженное на c,

и результат заносится в z. Хотя более правильным было бы следующее
пояснение: к числу из переменной a прибавляется результат умножения
числа из b с числом из c, результат заносится в ячейку с именем z.
2. Математические выражения и функции
Математическое выражение есть комбинация из переменных,

операций, скобок, констант, элементарных математических функций и их
суперпозиций. Набор математических функций в языке С содержится в
стандартном файле math.h. Эти функции можно использовать при
вычислении математических выражений. Дадим неполный перечень этих
функций:
abs(i) – вычисляет абсолютное значение целого переменного i.

fabs(x) – вычисляет абсолютное значение действительного переменного x.
acos(x) – вычисляет угол, косинус которого равен x.
exp(x) – вычисляет значение ех.
sin(x), cos(x), tan(x) – вычисляет значения тригонометрических функций.
pow(x,y) – Вычисляет ху.
log(x) – вычисляет натуральный логарифм ln x.
log10(x) – вычисляет десятичный логарифм lg x.
Программа 8. Определить значение числа e.

void main()
{double e; // Определяется переменная для числа е.
clrscr();
e = exp(1); // Вычисляется e в 1-й степени.
cout << “Число e = “<< e << “\n”;
getch(); }
Программа 9. Вычислить значение sin x. Значение переменной x

задавать в градусах.
#include <math.h>
void main()
{ float x, y;
clrscr();
cout << “Введи угол в градусах для вычисления синуса “;
cin >> x;
cout << “Вы ввели ” << x << “ градусов\n”;
y = x * acos(-1)/180.; // Переводим градусы в радианы.
y = sin(y);
cout << “sin( “ << x << “ градусов) = ” << y << “\n”;
getch(); }

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

выражения.
Задача 2
⎛ ⎞
⎜ sin 2 x + cos 2 y ⎟
Z =⎜ −e|cos x|+ sin y
⎟ ⋅ ln(| x | +1) − x 2 + 1 .
⎜ sin ⎛ x + y ⎞ + 1,5 ⎟
⎜ ⎜ 2 ⎟ ⎟
⎝ ⎝ ⎠ ⎠
Перед составлением программы надо ответить на стандартный набор

вопросов и проделать стандартный набор действий. Перечислим некоторые
из них. Внимательно изучить задачу. Основным результатом этого этапа
должны быть ответы на вопросы:
решалась ли подобная задача раньше;
можно ли разбить задачу на более простые;
какие данные входят в условие задачи;
какова форма представления этих данных в программе;
что вызывает затруднение при решении (можно упростить или
отбросить часть условий, которые создают трудности);
рассмотреть частный случай задачи;
рассмотреть часть задачи.
Задачу 2 можно разбить на подзадачи, решение которых не пред-
ставляет труда, а именно последовательно вычислить значения: z = х2 + 1,
y = z и т. д. Из условия задачи следует, что переменные x, y и z являются
действительными числами.
Если решение можно разбить на подзадачи, то начинающему
программисту (и не только ему) можно порекомендовать технологию
постепенного приближения к окончательному решению задачи. Такая
технология называется программированием снизу вверх. В реальном режиме
технология приближения к решению заключается в следующем:
к некоторому начальному тексту программы последовательно
добавляются новые директивы;
с каждым новым добавлением производится контроль выполнения этих
новых директив.
Программа 10. Окончательный код программы для решения задачи 2.
void main()
{
float x, y, z;
float z1;
cout << “Введи действительное число x = “;
cin >> x;
cout << “Введи действительное число y = “;
cin >> y;
cout << “Введены числа: \nx = “ << x << “\ny = “ << y << “\n”;

z = fabs(cos(x)) + sin(y);
z = exp(z);
z1= sin(x) * sin(x) +cos(y) * cos(y);
z1 = z1/(sin((x + y)/2.) + 1.5);
z = z1 - z; // Вычисляем для задачи 2 значение
// выражения в скобках.
z = z * log(fabs(x) + 1) - sqrt(x*x + 1); // Результат решения задачи.
cout << “\nРезультат вычисления z = “ << z << “\n”;
getch();
}
Следует обратить внимание на контроль начальнных данных при

проектировании программы и на контроль промежуточных результатов
расчета.
Приведем более короткий вариант программы для решения задачи 2.
Если студент освоил теоретический материал, то он сразу может предложить
именно такую, более короткую, реализацию.
void main()
{ float x, y, z;
cout << “Введи действительное число x = “;
cin >> x;
cout << “Введи действительное число y = “;
cin >> y;
cout << “Введены числа: \nx = “ << x << “\ny = “ << y << “\n”;
z=( sin(x)*sin(x)+cos(y)*cos(y)) / (sin((x+y)/2.)+1.5) - exp(fabs(cos(x)) + sin(y));
z=z*log(fabs(x)+1)-sqrt(x*x+1);
cout << “\nРезультат вычисления z= “ << z << “\n”;
getch(); }
Замечание 1. Код данного варианта программы короче, но в этом

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

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

сложения в том порядке, в котором они записаны.
Пример 1. Директива z = a / b * c означает вычисление по следующей
a
формуле: z = ⋅ c .
b
Пример 2. Директива z = a / (b * c) означает вычисление по следующей
a
формуле: z = .
b⋅c

ЛЕКЦИЯ 7. ОПЕРАЦИИ СРАВНЕНИЯ
И ЛОГИЧЕСКИЕ ОПЕРАЦИИ.
УСЛОВНЫЕ ОПЕРАТОРЫ
План
1. Операции сравнения и логические операции.

2. Условные операторы.
1. Операции сравнения и логические операции
В языке C существуют следующие операции сравнения (в некоторой

литературе это операции отношения):
> Больше
>= Больше или равно
< Меньше
<= Меньше или равно
!= Не равно
== Равно
Используя операции сравнения, в программах можно определять,
например, истинность следующих выражений: a<b; c != e+f; a+d > k; и т. д.
Приоритет арифметических операций выше операций отношений. Операции
отношения вычисляют значение, равное 1, если отношение истинно, или 0,
если отношение ложно. Результат от вычисления выражений, в которых
используются операции сравнения, можно присваивать переменным.
Программа 1. Пример демонстрирует действия операций сравнения.
void main()
{ int r;
clrscr();
r = 3 > 8;
cout << “Результат операции 3 > 8 = ” << r << “\n\n” ;
r = 3 < 8;
cout << “Результат операции 3 < 8 = ” << r << “\n\n” ;
r = 8 > 8;
cout << “ Результат операции 8 > 8 = ” << r << “\n\n” ;
r = 8 >= 8;
cout << “ Результат операции 8 >= 8 = ” << r << “\n\n” ;
r = 3 == 8;
cout << “Результат операции 3 == 8 = ” << r << “\n\n” ;
r = 3 != 8;
cout << “Результат операции 3 != 8 = ” << r << “\n\n” ;
r = 3 + 6 > 8;

ЛЕКЦИЯ 7. ОПЕРАЦИИ СРАВНЕНИЯ И ЛОГИЧЕСКИЕ ОПЕРАЦИИ. УСЛОВНЫЕ ОПЕРАТОРЫ
1. Операции сравнения и логические операции
cout << “Результат операции 3 + 6 > 8= ” << r << “\n\n” ;

getch(); }
После выполнения программы на экране появится следующее:
Результат операции 3 > 8 = 0

Результат операции 3 < 8 = 1
Результат операции 8 > 8 = 0
Результат операции 8 >= 8 = 1
Результат операции 3 == 8 = 0
Результат операции 3 != 8 = 1
Результат операции 3 + 6 > 8 = 1
Логические операции:
операция && – логическое И;
операция || – логическое ИЛИ;
операция ! – логическое НЕ.
При помощи этих операций можно составить выражение, которое
одновременно проверяет несколько условий. Например, если x1, x2, x3, x4 и
x5 – отметки студента по пяти предметам, то студент будет отличником тогда
и только тогда, когда значение выражения
(x1 == 5) && (x2 == 5) && (x3 == 5) && (x4==5) && (x5 ==5)
будет истинным, т. е. равным 1.

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

требуемым набором признаков, т. е. из большого объёма информации
выбрать ту, которая необходима пользователю. Поэтому очень часто
условный оператор называют оператором выбора. В языке C существуют две
формы условного оператора. Первая форма условного оператора имеет
следующую структуру:
if (A) { …… }; S1,
Здесь if директива условного оператора (ключевое слово языка С); A –

некоторое выражение; { …..} – блок операторов (некоторая последователь-

ность директив); S1 – первая директива программы, которая следует за

закрывающей фигурной скобкой.
Порядок выполнения условного оператора:
• вычисляется выражение A в круглых скобках;
• если значение выражения A не равно нулю, то выполняется блок
операторов, следующий за оператором if, т. е. последовательно выполняются
все директивы в фигурных скобках;
• если значение выражения A равно нулю, то блок операторов,
который следует за оператором if, пропускается и начинает выполняться
директива S1, которая следует за блоком операторов.
Программа 2. Вычислить цену на товар себестоимостью t руб.
void main()
{ float s, r, r1, r2 = 0; // s – переменная для цены на товар.
// r – переменная для себестоимости товара.
clrscr();
cout << “Введи себестоимость товара в тыс. руб. ”;
cin >> r; // Ввод с клавиатуры стоимости товара.
r1 = r * 0.01;
if (r > 50) // Значение выражения r > 50 будет равно 1, если это
// выражение истинно, и 0, если ложно.
r2 = r * 0.007; // Налог будет вычисляться, если значение r > 50
// будет равно 1.
s = r + r1+ r2;
cout << “Стоимость товара с учетом налога = “ << s << “ \n”;
getch(); }
Вторая форма условного оператора имеет следующую структуру:
if (A) { …… }; else {…….}; S1;
Здесь if … else – директива условного оператора; A – некоторое выражение;

{ …..} – блок операторов; S1 – первая директива программы, которая следует
за условным оператором.
Порядок выполнения условного оператора:
• вычисляется выражение A в круглых скобках;
• если значение выражения A не равно нулю, то выполняется блок
операторов, который следует за оператором if. После этого осуществляется
переход к выполнению директивы S1. Блок операторов, который следует за
служебным словом else, не выполняется;
• если значение выражения A равно нулю, то блок операторов,
который следует за оператором if, пропускается и начинает выполняться блок
операторов, который следует за служебным словом else. Далее выполняется
директива S1.

Программа 3. Даны два числа a, b. Найти максимальное значение из

двух чисел.
Алгоритм решения данной задачи прост. Если значение выражения
a > b истинно, то максимальным числом является число a. Если же значение
выражения a > b ложно, то максимальным числом является число b.
void main()
{ int a, b;
clrscr();
cout << “Введи два целых числа ”;
cin >>a >>b; // Ввод с клавиатуры двух чисел.
if (a > b)
cout << “max из чисел “ << a << “, ” << b << “= “ << a << “\n”;
else
cout << “max из чисел “ << a << “, ” << b << “= “ << b << “\n”;
getch(); }
В программе возможны следующие конструкции при использовании
условных операторов:
if {
if {… }
else {… }
}
else {
if {… }
else {… }
}
Программа 4. Даны три числа a, b, c. Найти максимальное значение из
трех чисел.
Принцип решения задачи заключается в следующем. Если значение
выражения a > b истинно, то максимальное значение определяем, исходя из
чисел a и c. Если же значение выражения a > b ложно, то максимальное
значение определяем, исходя из чисел b и c.
void main()
{ int a, b, c;
clrscr();
cout << “Введи три целых числа (набери три числа через пробелы и”
<< “ нажми Enter)\n”;
cin >> a >> b >> c; // Ввод с клавиатуры трех чисел.
if (a > b)
{ if (a > c)
cout << “max= “ << a << “\n”;
else
cout << “max= “ << c << “\n”;
}

else
{ if (b>c)
cout << “max= “ << b << “\n”;
else
cout << “max= “ << c << “\n”; } getch(); }
Программа 5. Найти максимальное значение из 6 чисел.

Если для данной задачи вычислять максимум по аналогии с
приведенными выше примерами, то код программы получится сложным и
запутанным. Поэтому предложим другой, более простой метод вычисления
максимума, который представлен следующим алгоритмом:
Шаг 1. Устанавливаем переменные a, b, c, d, e и f.
Шаг 2. Определяем значение переменной max по формуле max = a.
Шаг 3. Если max < b, значение max вычисляем по формуле max = b.
Повторяем шаг 3 для переменных c, d, e и f.
void main()
{int a, b, c, d, e, f;
int max;
clrscr();
cout << “Введи 6 целых чисел ”;
cin >> a >> b >> c; // Ввод с клавиатуры.
cin >> d >> e >> f;
max = a;
if (max < b)max = b; // Если max < b истинно, то в max засылается b.
if (max < c)max = c; // Если max < с истинно, то в max засылается с.
if (max < d)max = d; // Если max < d истинно, то в max засылается d.
if (max < e)max = e; // Если max < e истинно, то в max засылается e.
if (max < f)max = f; // Если max < f истинно, то в max засылается f.
cout << “max= “ << max << “\n”;
getch(); }
Код программы состоит из последовательности почти одинаковых

директив. Поэтому без труда можно составить программу вычисления
максимума для любого количества переменных.
Программа 6. Найти корни уравнения a ⋅ x 2 + b ⋅ x + c = 0 .
В зависимости от параметров это уравнение может быть:
квадратным, если a ≠ 0; тождеством, если a = b = c = 0;
линейным, если a = 0, b ≠ 0; не иметь смысла, если a = b = 0, а c ≠ 0.
Алгоритм решения задачи можно сформулировать следующим

образом:
Шаг 1. Устанавливаем значения переменных a, b и c.
Шаг 2. Если a ≠ 0, решаем квадратное уравнение.

Шаг 3. Если а = 0, b ≠ 0, решаем линейное уравнение.

Шаг 4. Если a = b = c = 0, решаем как тождество.
Шаг 5. Если a = b = 0, а c ≠ 0, то констатируем, что решений нет.
void main()
{ float a, b, c, d; // a, b, c – переменные для коэффициентов уравнения.
float x1, x2; // x1, x2 – переменные для корней уравнения.
clrscr();
cout << “Введи коэффициенты уравнения ”;
cin >> a >> b >> c;
if (a != 0) // Если выражение a != 0, то уравнение квадратное.
{ d = b * b - (4 * a * c); // Вычисляем дискриминант.
if (d >= 0) // Если выражение d >= 0 истинно, то
{ d = sqrt(d); // уравнение имеет два корня.
x1= (-b + d)/(2 .* a);
x2 = (-b - d)/(2. * a);
cout <<“Корни :\n x1= “ << x1 << “\nx2= “ << x2 << “\n”; }
else // Если d < 0 ложно, то действительных корней нет.
cout << “Уравнение не имеет действительных корней. \n”;
} // Случай a != 0 рассмотрен.
else // Случай a = 0. Уравнение линейное и имеет вид bx + c = 0
{ if (b != 0) // Случай b не равен нулю.
cout << “Уравнение имеет один корень x1= “ << c/b << “\n”;
else { // Случай b = 0.
if ( c == 0) // Случай a = 0, b = 0, c = 0.
cout << “Любое число является корнем уравнения\n”;
else // Случай a = 0, b = 0, c != 0.
cout << “Уравнение не имеет решений\n”; }
} getch(); }
Оператор выбора switch предназначен для выбора варианта обработки

информации (т. е. данная инструкция, как и условный оператор, управляет
порядком выполнения кодов). Оператор switch имеет следующую общую
форму записи:
switch (<выражение>)
{
case C1:
S1
break;
case C2:
S2
break;
…
case CK:
SK

break;
default:
SD
break;
}
SS;
Здесь switch, case, break, default – ключевые слова языка C; <выражение> –

это код, в котором используются переменные целого или символьного типа;
C1, C2, …, CK – константы, тип которых совпадает с типом <выражение>;
S1, S2, …, SK – последовательность директив; SS – первый код, который
следует после оператора выбора.
Порядок выполнения оператора выбора:
вычисляется <выражение>;
если одна из констант C1, C2, …, CK совпадает со значением
выражения, то программа передает управление на соответствующую метку
case и выполняется соответствующая последовательность операторов до
директивы break. Затем выполняется код SS.
Операторы SD, которые следуют за инструкцией default, выполняются
в том случае, если значение выражения не совпало ни с одной из констант
C1, C2, …, CK. Оператор default может отсутствовать.
Программа 7. Шаблон меню.
void main(void)
{ int k;
clrscr();
cout << "\n\nКоманды меню:\n\n";
cout << "1 Команда\n";
cout << "\nВведи команды меню: ";
scanf("%d",&k);
switch (k)
{
case 1 : cout << "Вы выбрали 1-ю команду ";
getch();
break;
getch();
break;
getch();
break;
getch();

break;
default : cout << "Команда меню с номером" << k
<< "отсутствует\n";
}}
Оператор безусловного перехода, который имеет вид:
goto L ;
Здесь L – имя метки оператора программы. Оператор безусловного перехода

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

ЛЕКЦИЯ 8. ЦИКЛЫ
План
1. Цикл for.
2. Цикл while.
3. Цикл do – while.
Операторы цикла предназначены для многократного повторения

последовательности директив. Язык С поддерживает три формы операторов
цикла: for, while, do – while.
1. Цикл for
Форма оператора цикла for имеет следующий вид:
for (выражение 1; выражение 2; выражение 3) { W; }
Выражение 1 определяет начальное значение переменной, которая

называется управляющим параметром цикла.
Выражение 2 определяет условие продолжения (или завершения)
выполнения оператора цикла.
Выражение 3 изменяет значение управляющего параметра цикла.
W – блок операторов. Блок операторов W называется телом цикла.
Замечание. Если тело цикла состоит из одного оператора, то этот
оператор можно в фигурные скобки не заключать. Возможны следующие
варианты оператора цикла for:
for (; выражение 2; выражение 3) {W;}

for (выражение 1; ; выражение 3) {W;}
for (выражение 1; выражение 2;) {W;}
for (; ;) {W;}
Задача 1. Выдать на экран 20 раз сообщение «Доброе утро, студент!».

Программа 1. Выводит сообщение «Доброе утро, студент!» 20 раз.
void main()
{ clrscr();
S; S; S; S; S; S; S; S; S; S;
S; S; S; S; S; S; S; S; S; S;
getch(); }

1. Цикл for
В представленной программе каждый символ S надо заменить на
директиву cout << “ Доброе утро, студент!\n“. Оператор цикла позволяет
код программы для данной задаче записать короче.
Программа 2. Выводит сообщение «Доброе утро, студент!» заданное
число раз. В программе использовать оператор цикла.
void main()
{ int i, n;
clrscr();
cout << "Введи число выводов сообщения: ";
cin >> n;
for ( i = 1; i <= n; i++) // Начало цикла for.
cout << "Доброе утро, студент! \n"; // Вывод текста на экран.
getch(); }
После запуска данной программы компьютер выводит на экран

монитора n строк с текстом «Доброе утро, студент!».
Программа f_1 имеет очевидное преимущество перед программой f_1а:
она более гибкая, число выводимых сообщений можно задавать во время ее
выполнения. Кроме того, число выдаваемых сообщений не влияет на код
программы. Код f_1а настроен на вывод только 20 сообщений. Изменение
числа выводимых сообщений требует изменений кода программы f_1а.
Оператор цикла for в программе f_1 выполняется следующим образом:
управляющему параметру цикла i присваивается 1;
значение i сравнивается с переменной n;
если i меньше или равно n, то выполняется блок операторов,
заключенный между фигурными скобками. После выполнения последнего
оператора из блока, управление передается на начало оператора цикла.
Оператор цикла увеличивает значение переменной i на 1, затем выполняется
шаг 2 и т. д.;
если значение переменной i больше n, то управление передается на
первый оператор, который следует после тела цикла.
Рассмотрим различные варианты применения цикла for на простых
задачах.
Программа 3. Выводит на экран целые числа от 1 до заданного числа n
(моделируется процесс счета).
void main()
{ int i, s, n; // i, n – параметры цикла;
// s – для формирования порядкового числа.
clrscr();
cout << "Введи число, до которого надо выводить n= ";
cin >> n;
s = 0;
for (i = 1; i <= n; i++)
{ s = s + 1; // В s формируется выводимое число.
cout << "Это " << s << "\n";

1. Цикл for
}
cout << “ Вывод чисел от 1 до ” << n << “ завершен! \n”;
getch(); }
Приведем результат работы программы для n = 4.
Введи число, до которого надо выводить n = 4

Это 1
Это 2
Это 3
Это 4
Вывод чисел от 1 до 4 завершен!
Программа 4. Выводит на экран целые числа от 1 до n.

void main()
{ int i, n;
clrscr();
cin >> n;
for (i = 1; i <= n; i++) // В теле цикла используется i.
cout << "Это " << i << "\n";
getch();
}
Программа 5. Выводит на экран целые числа от заданного числа n до 1.

void main()
{ int i, n;
clrscr();
cin >> n;
for (i = n; i >= 1; i--) // Значение параметра i уменьшается.
cout << "Это " << i << "\n";
getch(); }
Программа 6. Выводит на экран целые числа от n1 до n2 с шагом dt

(n1 <= n2, dt > 0).
void main()
{ int i, n1, n2, dt;
clrscr();
cout << "Введи число, от которого надо выводить n1 = ";
cin >> n1;
cout << "Введи число, до которого надо выводить n2 = ";
cin >> n2;
cout << "Введи шаг для выдачи чисел dt = ";
cin >> dt;

1. Цикл for
for (i = n1; i <= n2; i = i + dt) // Значение i меняется с шагом dt.
cout << "Это " << i << "\n";
getch(); }
Программа 7. Для управления циклом используются два параметра.

void main()
{ float i, j;
clrscr();
for (i = -10, j = 0; i + j <= 0; i++ , j++ )
cout << i << " + “ << j << “= " << (i+j) << "\n";
cout << “\tРабота цикла завершена\n”;
getch(); }
Приведем результат работы программы.
-10 + 0 = -10
-9 + 1 = -8
-8 + 2 = -6
-7 + 3 = -4
-6 + 4 = -2
-5 +5 = 0
Работа цикла завершена
2. Цикл while
Оператор цикла while имеет следующий вид:
while ( <условие>) { W; }
Здесь <условие> – любое выражение, допустимое в языке С; W –

последовательность операторов.
<условие> принимает значение ИСТИНА, если значение выражения
не равно нулю. В противном случае <условие> принимает значение ЛОЖЬ.
Тело цикла выполняется, если <условие> принимает значение ИСТИНА.
В противном случае программа выходит из цикла и выполняет первый
оператор, который следует за телом цикла.
Программа 8. Ввод чисел с клавиатуры в режиме диалога.
void main()
{int k;
clrscr();
cout << "Введи число (Ctrl + z Enter – выход из программы): ";
scanf("%d", &k);
while (!feof(stdin) ) // Начало цикла. Цикл выполняется до тех пор,
// пока не будет введен символ Ctrl + z.
{ cout << "\n Вы ввели число " << k

2. Цикл while
<< "\nДля продолжения ввода нажми Enter";
getch();
clrscr();
cout << "Введи число (Сtrl + z Enter – выход из программы): ";
scanf("%d", &k);
}}
Программа моделирует работу в режиме диалога с пользователем.

Замечание. Функция feof(stdin) возвращает значение 0, если с
клавиатуры вводится число, и значение, не равное 0, при вводе комбинации
символов Ctrl + z.
Программа 9. Выводит цифры, которые формируют целое число.
void main()
{ long a;
clrscr();
cout << " Введи число a = ";
cin >> a;
clrscr();
cout << “Число “ << a << “Состоит из цифр:”;
while (a != 0 )
{cout << a % 10 << “\n”; // Выводит последнюю цифру числа.
a = a / 10; // Отбрасывает последнюю цифру числа.
}
getch(); }
Программа 10. Вычисляет сумму цифр заданного целого числа.

void main()
{ long a;
int s = 0;
clrscr();
cout << "Введи число a = " ;
cin >> a;
while (a != 0 )
{
s = s + a % 10; // Вычисляет и прибавляет последнюю цифру числа к s.
a = a / 10; } // Отбрасывает последнюю цифру числа.
cout << "сумма s= " << s << "\n";
getch(); }
Программа 11. Шаблон меню.

void main(void)
{ int iv = 0;
int k;
while ( !iv )
{ clrscr();

2. Цикл while
cout << "\n\nКоманды меню:\n\n";
cout << "5 Выход\n";
cout << "\nВведи команды меню: ";
scanf("%d",&k);
switch (k)
{
getch();
break;
getch();
break;
getch();
break;
getch();
break;
case 5 : cout << " \n\n Вы вышли из программы!!!.\n ";
cout << " Жми любую клавишу\n ";
iv = 1;
break;
default : cout << "Команда меню с номером" << k
<< "отсутствует\n";
} }
getch(); }
Оператор цикла do – while имеет следующий вид:
do
{ W; }
while ( <условие>)
Здесь <условие> – любое выражение, допустимое в языке С; W –
последовательность операторов.
<условие> принимает значение ИСТИНА, если значение выражения
не равно нулю, ЛОЖЬ – в противном случае. Тело цикла выполняется, если
<условие> принимает значение ИСТИНА.

Задача 2. Для любого x ≥ 0 найти y = m x . Вычислять корень по

1⎛ x ⎞
итерационной формуле yk +1 = ⎜ ( m − 1) y k + ⎟ с точностью ε, где k – шаг
m⎝ ykm−1 ⎠
итерации.
Составлять программу, которая вычисляет значение переменной по
некоторой итерационной формуле y k +1 = f(y k ), – достаточно простая задача.
Для этого необходимо: объявить переменную y; корректно задать начальное
значение; в блоке операторов записать по правилам языка выражение y = f(y).
Продолжительность вычисления в цикле выражения y = f(y) опреде-
ляется заданной точностью ε. Точность вычислений ε контролируется с
помощью неравенства | yk +1 − yk |≤ ε . Здесь y k , y k +1 – значение y, которое
вычисляется на шагах итерации k и k + 1. Общий вид цикла, который
вычисляет выражение с заданной точностью, имеет следующий вид:
y = x;
do
{y1 = y; // В y1 засылается значение y с предыдущего шага.
…
y = f(y); // На текущем шаге y определяется по формуле.
} while (fabs(y - y1) > ep); // Выполнять цикл до заданной точности.
Здесь x – начальное значение переменной y; y1 – значение переменной y,

которое определено на шаге k; y – значение переменной, которое
вычисляется на шаге k + 1; ep – заданная точность вычисления по
итерационной формуле.
Программа 12. Вычисляет корень степени m из действительного числа
1⎛ x ⎞
x по итерационной формуле yk +1 = ⎜ (m − 1) yk + m−1 ⎟
m⎝ yk ⎠
void main()
{
double x, ep, r, r1, rm;
double yn, yn1, m;
int i;
clrscr();
cout << "Введи показатель корня и основание степени m, x = ";
cin >> m >> x;
cout << " \n Введи точность вычисления ep = ";
cin >> ep;
yn1 = x;
rm = (m - 1) / m;
r1 = x / m;
do { r = r1;

yn = yn1;
for (i = 1; i < m; i++) // В цикле
r = r / yn; // вычисляется значение корня степени m
// из числа x.
yn1 = rm * yn + r ; // Вычисляется значение y n+1 .
}
while ( fabs(yn1 - yn) > ep );
cout << "Корень " << m << "-й cтепени из " << x
<< "= " << yn1 << "\n";
cout << "\n\n Проверка:\n ";
yn = 1;
for (i=1; i<=m; i++)
yn = yn1* yn;
cout << yn1 << " в степени " << m << "= " << yn << "\n";
getch();
}

ЛЕКЦИЯ 9. МАССИВЫ. НЕКОТОРЫЕ
ПРОСТЕЙШИЕ ЗАДАЧИ. МАТРИЦЫ
План
1. Массивы.
2. Некоторые простейшие задачи.
3. Матрицы.
4. Перебор элементов матрицы.
1. Массивы
Массив есть множество элементов одного типа. Общий формат

объявления массива имеет следующий вид:
<тип> <имя> [<размер>]
Например, код int x[10]; объявляет массив с именем x, который состоит

из 10 элементов. Этот оператор выделяет 10 ячеек памяти размером в два
байта каждая для целых чисел. Области памяти элементов массива имеют
имена x[0], x[1], x[2], …, x[9], т. е. код доступа к любому элементу массива
имеет формат x[k], k < n, где n – размер массива. Индексы массива в языке С
начинаются с нуля!!!
Замечание 1. <размер> – это константа. Размер может быть задан либо
в виде числа, либо в виде выражения. Например, возможна следующая форма
объявления массива:
const n = 10, m= 15;

float mas[n * m + 10];
Замечание 2. В языке С можно присваивать значения элементам массива,

для которых не зарезервирована память. Транслятор пропускает такую
ошибку. Например, можно написать int x[10]; x[25] = 10; Код x[25] = 1000;
является ошибкой, которую транслятор не выявляет.
Цикл предоставляет возможность перебора индексов, а значит, и
перебора элементов массива.
Программа 1. Выводит значения элементов массива на экран.

void main(void)
{ const n = 4; // Определяется размер массива.
int a[n], i; // Объявляется массив a[n].
clrscr();
cout << "Вывод элементов массива на экран \n";

ЛЕКЦИЯ 9. МАССИВЫ. НЕКОТОРЫЕ ПРОСТЕЙШИЕ ЗАДАЧИ. МАТРИЦЫ
1. Массивы
for(i = 0; i < n; i++) // Перебор индексов массива.
cout << “a(“ << i << “)= “ << a[i] << "\n"; // Вывод на экран
// значения элемента массива a[i].
cout << "\n";
getch(); }
Программа выдаст на экран монитора следующую информацию:
a(0) = X0
a(1) = X1
a(2) = X2
a(3) = X3
Здесь X0, X1, X2, X3 – какие-то случайные числа. Данная программа демон-
стрирует, что задание начальных значений (инициализация) элементов
массива должна быть предусмотрена в программе. Инициализировать
элементы массива можно при его объявлении, например, используя код int
x[6] = {n1, n2, n3, n4, n5, n6}, здесь n1, n2, …, n6 некоторые числа. Если при
объявлении массива определить его первый элемент (int x[6] = {n1}), то
остальные элементы массива автоматически заполняются нулями.
Программа 2. Выводит адреса памяти элементов массива в десятичной

и шестнадцатеричной системе.
void main(void)
{ const n = 5;
int i, a[n] ;
clrscr();
cout << “Программа выводит адреса элементов массива. \n\n”;
cout << “Шестнадцатеричная система”
<< “Десятичная система: \n”;
for(i = 0; i < n; i++) // Перебор индексов массива.
{ cout << &a[i] << " "; // Вывод адреса i-го элемента
cout << (unsigned long int) &a[i] << " \n"; } // массива.
cout << "\n"; getch(); }
Результат работы программы на экране будет выглядеть так:
Программа выводит адреса элементов массива.
Шестнадцатеричная система Десятичная система

0x1a0a0ff2 436867058
0x1a0a0ff4 436867060
0x1a0a0ff6 436867062
0x1a0a0ff8 436867064
0x1a0a0ffa 436867066

1. Массивы
Программа 3. Ввод значений элементов массива с клавиатуры. Вывод
значений элементов массива на экран.
void main(void)
{ const n = 6 ;
int i, a[n] ;
clrscr();
cout << "Введи элементы массива с клавиатуры \n";
for (i = 0; i <= n-1; i++) // Начало цикла.
{ printf("a[ %d ]= ", i); // Подсказка для пользователя.
scanf( "%d", &a[i] ); // Ввода элемента массива с клавиатуры.
}
// Вывод массива на экран.
for (i = 0; i <= n-1; i++)
printf("%d ", a[i]); // Вывода элемента массива на экран.
getch(); }
Анализ результата работы программы приводит к выводу, что

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

Задача mas1. Определить, есть ли в массиве элемент, значение
которого равно заданному числу.
Приведем некоторые соображения, позволяющие составить алгоритм
решения данной задачи. Перебирать элементы массива, сравнивать числа мы
умеем. Для того чтобы решить задачу mas1, нужно проверить, найден или
нет элемент массива, равный заданному числу. Это можно установить,
использовав следующие приемы:
Определить некоторый параметр состояния – (флаг). Начальное
значение этого параметра задать равным нулю. Как только элемент массива,
равный заданному числу, найден, присваиваем этому параметру любое
значение, отличное от нуля. Тем самым фиксируем факт, что элемент с
заданным свойством в массиве найден.
Данный подход можно модифицировать: при каждом совпадении
элемента массива с заданным числом увеличивать значение параметра
состояния на единицу. Тогда фиксируется не только факт совпадения, но и
количество таких совпадений.
В предлагаемой ниже программе реализован второй подход к решению
задачи mas1.
void main(void)
{ const n = 4 ;
int i, a[n], r; // r – переменная для числа поиска.

2. Некоторые простейшие задачи
int ps = 0; // ps – параметр состояния.
clrscr();
cout << "Введи элементы массива с клавиатуры: \n";
for (i = 0; i <= n - 1; i++ )
{ printf("a[ %d ]= ", i); // Вывод поясняющей информации.
scanf( " %d", &a[i]); // Ввод числа с клавиатуры.
} clrscr();
cout << "Введен массив: \n";
for (i = 0; i <= n - 1; i++)
printf("%d ", a[i]); // Вывод элементов массива на экран.
cout << "\n\nВведи число для поиска его в массиве: ";
scanf("%d", &r); // Ввод числа для поиска.
for (i = 0; i <= n - 1; i++)
if (a[i] == r) ps++; // Подсчет совпадений элементов массива a[i]
// с числом r.
if (ps == 0)
cout << "\n\n Элемент массива со значением "
<< r << " не найден. \n";
else
cout << "\n\n Число элементов в массиве, совпадающих с числом "
<< r << " равно " << ps << "\n";
getch(); }
Следует акцентировать внимание слушателей на приеме ввода

параметра состояния (флага) для того, чтобы зафиксировать те моменты при
обработке информации, которые определяются условием задачи.
Задача mas2. Найти k-й отрицательный элемент массива.
Программа 5. Поиск k-го отрицательного элемента массива.

void main()
{ const n = 10;
int i, b, a[n], in = -1, k, kt = 0 ;
clrscr();
cout << "Введи порядковый номер для поиска “
<< “ отрицательного элемента k = ";
cin >> k;
cout << "Введи элементы массива с клавиатуры \n";
for (i = 0; i <= n-1; i++)
{ cout << "a(" << i << ")= ";
scanf( "%d", &a[i] ); } // Ввод элемента массива.
for (i = 0; i <= n - 1; i++)
cout << a[i] << " "; // Вывод элемента массива a[i] на экран.
for (i = 0; i < n; i++)
if ( (a[i] < 0) && (kt < k)) // Определяет знак элемента массива

2. Некотор�

Язык

Языки Программирования. Язык C. Конспект лекций

Загружено:

Сведения о документе

Авторское право

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Языки Программирования. Язык C. Конспект лекций

Загружено:

Авторское право:

ЯЗЫКИ

Учебная программа дисциплины

Методические указания по лабораторным работам

© Сибирский федеральный университет, 2008

Подп. к использованию 01.10.2008

 Языки программирования. Язык С. Конспект лекций -3-

ЛЕКЦИЯ 6. АРИФМЕТИЧЕСКИЕ ОПЕРАЦИИ.

 Языки программирования. Язык С. Конспект лекций -4-

ЛЕКЦИЯ 13. СТРУКТУРЫ И УКАЗАТЕЛИ

 Языки программирования. Язык С. Конспект лекций -5-

ЛЕКЦИЯ 19. ГЕНЕРАТОР КОДА/ПРИЛОЖЕНИЙ ... 172

 Языки программирования. Язык С. Конспект лекций -6-

3. Сортировка обменом (методом пузырька) ........................................................... 289

 Языки программирования. Язык С. Конспект лекций -7-

Курс лекций «Языки программирования» соответствует государствен-

 Языки программирования. Язык С. Конспект лекций -8-

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

 Языки программирования. Язык С. Конспект лекций -9-

ческих функций. Проведение таких вычислений без особых устройств было

2. Основные устройства ЭВМ и их назначение

Основными устройствами ЭВМ (в том числе и современного

 Языки программирования. Язык С. Конспект лекций -10-

запоминающие устройства (ЗУ),

3. История развития языков

Управляет работой компьютера программа. Программа – это

 Языки программирования. Язык С. Конспект лекций -11-

В дальнейшем слова директива, код, команда, оператор, указание будут

001 0345 0363 0211.

В представленном коде наборы чисел означают следующее:

 Языки программирования. Язык С. Конспект лекций -12-

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

 Языки программирования. Язык С. Конспект лекций -13-

широкого распространения. Считается, что это произошло потому, что он

 Языки программирования. Язык С. Конспект лекций -14-

1. Общие принципы построения языков программирования.

1. Общие принципы построения языков программирования

При проектировании языка программирования необходимы критерии

 Языки программирования. Язык С. Конспект лекций -15-

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

 Языки программирования. Язык С. Конспект лекций -16-

совершенно разные люди. А успех языка зависит от ясности его описания.

 Языки программирования. Язык С. Конспект лекций -17-

Препроцессор – инструмент языка C++, при помощи которого

 Языки программирования. Язык С. Конспект лекций -18-

В языке C++ многие возможности директив препроцессора можно

3. Этапы решения задач на компьютере

Решение любой задачи на компьютере состоит из нескольких этапов:

Распределения трудностей этапов 3 и 4

Этап 3 т т н/т н/т

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

 Языки программирования. Язык С. Конспект лекций -19-

начальной информации от источника задачи. Программист сам решает

 Языки программирования. Язык С. Конспект лекций -20-

1. Современные интегрированные среды.

1. Современные интегрированные среды

Интегрированная среда (IDE – Integrated Development Environment)

 Языки программирования. Язык С. Конспект лекций -21-

Здесь мы специально не идентифицируем имена команд меню, которые

Отладка программы, то есть устранение возможных ошибок либо в

 Языки программирования. Язык С. Конспект лекций -22-

выполнять другую программу по одной команде;

3. Библиотеки программ и классов

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

 Языки программирования. Язык С. Конспект лекций -23-

инструменты, которые содержат готовые библиотеки. Современная

 Языки программирования. Язык С. Конспект лекций -24-

Языки программирования. Язык С. Конспект лекций -3-

Языки программирования. Язык С. Конспект лекций -4-

Языки программирования. Язык С. Конспект лекций -5-

Языки программирования. Язык С. Конспект лекций -6-

Языки программирования. Язык С. Конспект лекций -7-

Языки программирования. Язык С. Конспект лекций -8-

Языки программирования. Язык С. Конспект лекций -9-

Языки программирования. Язык С. Конспект лекций -10-

Языки программирования. Язык С. Конспект лекций -11-

Языки программирования. Язык С. Конспект лекций -12-

Языки программирования. Язык С. Конспект лекций -13-

Языки программирования. Язык С. Конспект лекций -14-

Языки программирования. Язык С. Конспект лекций -15-

Языки программирования. Язык С. Конспект лекций -16-

Языки программирования. Язык С. Конспект лекций -17-

Языки программирования. Язык С. Конспект лекций -18-

Языки программирования. Язык С. Конспект лекций -19-

Языки программирования. Язык С. Конспект лекций -20-

Языки программирования. Язык С. Конспект лекций -21-

Языки программирования. Язык С. Конспект лекций -22-

Языки программирования. Язык С. Конспект лекций -23-

Языки программирования. Язык С. Конспект лекций -24-

Языки программирования. Язык С. Конспект лекций -25-

Языки программирования. Язык С. Конспект лекций -26-

Языки программирования. Язык С. Конспект лекций -27-

Языки программирования. Язык С. Конспект лекций -28-

Языки программирования. Язык С. Конспект лекций -29-

Языки программирования. Язык С. Конспект лекций -30-

Языки программирования. Язык С. Конспект лекций -31-

Языки программирования. Язык С. Конспект лекций -32-

Языки программирования. Язык С. Конспект лекций -33-

Языки программирования. Язык С. Конспект лекций -34-

Языки программирования. Язык С. Конспект лекций -35-

Языки программирования. Язык С. Конспект лекций -36-

Языки программирования. Язык С. Конспект лекций -37-

Языки программирования. Язык С. Конспект лекций -38-

Языки программирования. Язык С. Конспект лекций -39-

Языки программирования. Язык С. Конспект лекций -40-