Программирование
Выбери формат для чтения
Загружаем конспект в формате pdf
Это займет всего пару минут! А пока ты можешь прочитать работу в формате Word 👇
Министерство образования Нижегородской области
Государственное бюджетное образовательное учреждение
высшего образования
«Нижегородский государственный инженерно-экономический университет»
Факультет «Информационных технологий и систем связи»
Кафедра информационных систем и технологий
УТВЕРЖДЕНЫ
на заседании кафедры
«___»__________20__ г., протокол
№___
Заведующий кафедрой
___________________________________
(подпись)
КУРС ЛЕКЦИЙ
по дисциплине:
ПРОГРАММИРОВАНИЕ
Квалификация (степень): бакалавр
по направлению 38.03.05 «Бизнес-информатика»
профиль «Электронный бизнес»
Форма обучения очная, заочная
г. Княгинино
2015 год
(ФИО)
Модульная единица 1.
«Технологии и языки программирования».
Цель: изучить возможности языков программирования и технологий программирования.
1)
2)
3)
4)
5)
Понятие о структурном программировании.
Модульный принцип программирования. Подпрограммы.
Принципы проектирования программ "сверху-вниз" и "снизу-вверх".
Объектно-ориентированное программирование
общие сведения о BASIC
Модульное программирование
Согласно принципу модульности программа разбивается на отдельные смысловые части (модули).
Модуль – это функционально законченная часть программы. Например, модуль вычисления
определителя матрицы; модуль нахождения суммы элементов ряда.
Каждый модуль программируется отдельно, а затем модули объединяются в единую программу.
Модуль на языке программирования – это функция или процедура.
Структурное программирование
Является дальнейшим развитием модульного программирования.
Основой технологии метода структурного программирования являются:
1) Принцип модульной разработки программ
2) Использование при разработке модуля композиции трех базовых структур (элементов):
А) линейной (структуры следования)
Действия выполняются последовательно друг за другом
Б) ветвления (структуры «если-то-иначе»)
В)циклической (структуры «цикл пока»)
Структурное программирование делает текст программы более понятным – алгоритм решения ясно виден из исходного
текста. Структурное программирование называют программированием без GOTO. Его методология основана на использовании
подпрограмм и независимых структур данных, объединяющих связанные между собой совокупности данных.
Подпрограммы позволяют заменять в тексте программ упорядоченные блоки команд, отчего
программный код становится более компактным. Структурный подход обеспечивает создание более понятных и легко
читаемых программ, упрощает их тестирование и отладку.
Программирование сверху вниз
Программирование сверху вниз, когда задача делится на простые, самостоятельно решаемые подзадачи.
Затем на основе решенных подзадач выстраивается решение исходной задачи полностью — сверху вниз.
Объектно-ориентированное программирование
Основой объектно-ориентированного программирования (ООП) является понятие объект. Его суть состоит в том, что
объект объединяет в себе структуры данных и характерные только для него процедуры (методы) их обработки. Такой подход
полностью меняет стиль программирования, он заключается в отображении физических объектов реального мира на
программную среду. Работать с объектами удобнее и естественнее, чем с традиционными конструкциями процедур
преобразования данных.
Объект ООП – это совокупность переменных состояния и связанных с ними методов (операций), которые определяют, как
объект взаимодействует с окружающим миром. Объект состоит из следующих трех частей: имя объекта, состояние (переменные
состояния), методы (операции).
Другим фундаментальным понятием ООП является класс. Класс есть шаблон, на основе которого может быть создан
конкретный программный объект, он описывает свойства и методы, определяющие поведение объектов этого класса. В ООП
класс представляет собой абстрактный тип данных и является механизмом для создания объектов. Объявление класса есть
логическая абстракция, определяющая новый тип объекта, а определение объекта как экземпляра класса создает этот объект
физически, т.е. размещает объект в памяти.
ООП является более естественным, так как предоставляет возможность выбрать имеющиеся или создать новые объекты и
организовать взаимодействия между ними.
Следовательно, объектно-ориентированные языки по сравнению с процедурными являются языками более высокого
уровня.
Основные принципы ООП:
1) Инкапсуляция - объединение данных и свойственных им процедур обработки в одном объекте, детальная реализация
которых остается скрытой для пользователей.
2) Наследование предусматривает создание новых классов на базе существующих и позволяет классу-потомку иметь
(наследовать) все свойства класса-родителя.
3) Полиморфизм - при работе с объектами иерархии «родители — дети — и т.д.» разрешается задавать одинаковые имена
различным по реализации методам, для обработки объектов разных ступеней иерархии.
Благодаря полиморфизму в ООП обработка объектов упрощается, так как одинаковым действиям объектов соответствуют
одноименные методы. Полиморфизм (от греч. «многоликость») означает, что рожденные объекты обладают информацией о
том, какие методы они должны использовать в зависимости от того, в каком месте цепочки наследования они находятся.
4) Модульность — объекты заключают в себе полное определение их характеристик, никакие определения методов и
свойств объекта не должны располагаться вне его, это делает возможным свободное копирование и внедрение одного объекта в
другие.
К языкам ООП относятся:
- C++,
- Java,
Объектно-ориентированные системы визуального проектирования:
- Visual Basic,
- Delphi,
- C++ Builder,
- Visual C++,
- Turbo Vision.
Среда программирования
Среды программирования (или как их еще называют, среды разработки) - это программы, в которых программисты пишут
свои программы. Иными словами, среда программирования служит для разработки (написания) программ и обычно
ориентируется на конкретный язык или несколько языков программирования (в этом случае языки, обычно, принадлежат одной
языковой группе, например, Си-подобные). Интегрированная среда программирования содержит в себе все необходимое для
разработки программ:
редактор с подсветкой синтаксиса конкретного языка программирования. В нем программист пишет текст программы, так
называемый программный код;
компилятор. Он, как мы уже с вами знаем, транслирует программу, написанную на высокоуровневом языке
программирования в машинный язык (машинный код), непосредственно понятный компьютеру. Язык С++ относится к
компилируемым языкам, поэтому для обработки текстов его программ служит компилятор, иногда вместо компилятора (либо
вместе с ним) используется интерпретатор, для программ, написанных на интерпретируемых языках программирования;
отладчик. Служит для отладки программ. Как мы все знаем, ошибки в программах допускают абсолютно все: и новички, и
профессионалы - они могут быть синтаксическими (обычно они выявляются еще на стадии компиляции) и логическими. Для
тестирования программы и выявления в ней логических ошибок служит отладчик.
Мы рассмотрели базовую комплектацию среды программирования, но иногда в них присутствуют еще и такие
компоненты, как система управления версиями, различные инструменты для конструирования графического интерфейса
программы, браузер классов, инспектор объектов и другие.
Введение в язык программирования Basic.
Для представления алгоритма в виде, понятном компьютеру, служат языки программирования. Сначала разрабатывается
алгоритм действий, а потом он записывается на одном из таких языков. В итоге получается текст программы - полное,
законченное и детальное описание алгоритма на языке программирования. Затем этот текст программы специальными
служебными приложениями, которые называются трансляторами, либо переводится в машинный код (язык нулей и единиц),
либо исполняется.
Языки программирования - искусственные языки. От естественных они отличаются ограниченным числом "слов", значение
которых понятно транслятору, и очень строгими правилами записи команд (операторов).
Для написания текста программы можно использовать обычный текстовый редактор (например, Блокнот), а затем с
помощью компилятора перевести её в машинный код, т.е. получить исполняемую программу. Но проще и удобнее пользоваться
специальными интегрированными средами программирования.
Общие сведения о BASIC
Язык программирования BASIC& – Bginner's All purpose Symbolic Instruction Code (универсальный символьный
программный код для начинающих) был разработан сотрудниками Дартмутского колледжа (США) в 1964 г. Первоначальная его
версия включала всего 14 служебных слов и предназначалась для обучения программированию. С тех пор было создано более
100 версий этого языка, реализованных на различных ЭВМ.
Первый персональный компьютер IBM PC имел 16-разрядный BASIC, разработанный корпорацией IBM. Позже его сменил
GW-BASIC и QUICK-BASIC, разработанный корпорацией Microsoft. В QUICK-BASIC была убрана нумерация строк и добавлен
компилятор, превращающий BASIC-программу в полноценный исполняемый (.exe) файл. Неоставила без внимания язык BASIC
и корпорация Borland, азработавшая в 1987 году интегрированную среду программирования Turbo-Basic.
Интегрированная среда разработки приложений Visual Basic
Visual Basic развился из первоначального языка Basic и в настоящее время содержит несколько сотен команд, функций и
ключевых слов, многие из которых связаны непосредственно с графическим интерфейсом пользователя GUI (Graphical User
Interface) операционной системы Windows. Используя Visual Basic даже начинающие программисты могут создавать полезные
программы, зная лишь несколько ключевых слов. При этом профессиональные программисты имеют все необходимые средства
для разработки сложных приложений, функционирующих под управлением Windows.
В 1992 г. корпорацией Microsoft был разработан и выпущен Visual Basic 1.0 - относительно простой язык программирования для
Windows 3.1. Затем были выпущены Visual Basic 3.0, 4.0, 5.0 и наконец Visual Basic 6.0. Версии 5.0 и 6.0 отличаются
незначительно: в шестой версии улучшено ядро и добавлен ряд новых функций. ПомимоVisual Basic существует еще язык
макросов для приложений Microsoft Office (Word, Excel и т.п.). Он называется VBA (Visual Basic for Application). С его помощью
можно разрабатывать макрокоманды для автоматизации работы с приложениями Microsoft Office.
Интегрированная среда разработки приложений Microsoft Visual Basic (в дальнейшем изложении Visual Basic), обладая простыми
в обращении средствами визуального проектирования, позволяет в полной мере использовать преимущества графической среды
Windows и быстро конструировать эффективные приложения. Помимо Visual Basic существуют и другие языки визуального
программирования с аналогичными возможностями: Borland Delphi, Borland C++ Builder.
Visual Basic – один из первых языков, поддерживающих событийно-управляемое программирование (event-driven programming).
Этот стиль хорошо согласуется со стандартом графического пользовательского интерфейса. Традиционно программирование
ориентировалось на поэтапное описание конкретного процесса. Однако современные компьютерные приложения слишком
сложны и данный стиль программирования для них не подходит.
Основная идея событийно-управляемого программирования заключается в том, что вместо скрупулезного описания каждого шага
работы приложения достаточно лишь указать, как необходимо реагировать на различные события (действия пользователя): выбор
команды, щелчок или перемещение мыши, нажатие клавиш и др. В результате программист создает не одну большую программу,
а приложение, состоящее из набора взаимодействующих процедур, управляемых пользователем.
Программы, или как принято говорить - приложения, разрабатываемые для Windows, имеют, как правило, стандартный
пользовательский интерфейс: окна-формы, на которых располагаются окна для текстов или рисунков, меню, кнопки управления
и другие элементы. Каждый из этих объектов обладает определенными свойствами: цвет, размеры, надписи и другие. Кроме этого,
каждое конкретное приложение в режиме взаимодействия с пользователем посредством вышеупомянутых объектов, выполняет
те или иные действия, приводящие к получению определенного результата. Для получения какого-либо конкретного действия
должна быть написана соответствующая команда в тексте программы на языке Visual Basic.
Разработка приложения в системах визуального объектно-ориентированного программирования.
1. Cоздание интерфейса пользователя с использованием средств визуального программирования, в процессе которого на формах
размещаются необходимые объекты из набора стандартных элементов интерфейса Windows.
2. Установка свойств для формы и размещенных на ней объектов (размеры, цвет, надписи и др.).
3. Написание текста программы, определяющей выполнение приложением необходимых действий.
Разработанная корпорацией Microsoft интегрированная среда разработки приложений Visual Basic объединяет в себе множество
функций, позволяющих выполнять визуальное проектирование интерфейса приложения, ввод и редактирование исходного текста
программы, компиляцию и отладку приложений.
Приложения, создаваемые в среде Visual Basic принято называть проектами.
Программы Visual Basic хранятся в программных модулях, которые бывают трех видов: модуль формы, стандартный модуль и
модуль класса.
Модуль формы.
содержит основной текст оригинальной программы. В нем могут содержаться объявления переменных, констант, типов данных,
внешних процедур, используемых на уровне модуля, процедур обработки событий. Модули формы хранятся в файлах, имеющих
расширение frm. В модуле можно также ссылаться на другие формы и объекты данного приложения.
Стандартный модуль.
Стандартный модуль содержит повторяющиеся функции, выполняемые с нескольких модулей формы. Они будет являться общим
для целого ряда модулей и могут содержать объявления глобальных и локальных переменных, констант, типов, внешних
процедур и процедур общего характера, доступных для других модулей данного приложения. Они хранятся в файлах с
расширением bas.
Модуль классов.
Модуль классов содержит новые объекты с разработанными для них свойствами и методами. Они хранятся в файлах с
расширением els.
Перечень вопросов для закрепления материала:
1)
Опишите основные виды алгоритмов.
2)
Какие этапы развития языка программирования BASIC вы знаете?
3)
Какие языки программирования существуют?
1.
2.
3.
Рекомендуемая литература:
Ашарина И.В. Объектно-ориентированное программирование в С++ [Электронный ресурс]: учебное пособие/ Ашарина
И.В.— Электрон. текстовые данные. — М.: Горячая линия - Телеком, 2012. — 320 c.— Режим доступа:
http://www.iprbookshop.ru/12008. — ЭБС «IPRbooks», по паролю
Сафронов И.К., Visual Basic в задачах и примерах, БХВ-Петербург, 2008.
Борис Пахомов - C/C++ и MS Visual С++ 2010 для начинающих, БХВ-Петербург, 2011г. - 726с.
Модульная единица 2.
«Язык программирования BASIC: данные и их описание»
Цель: изучить синтаксис С++, синтаксис языка, простые конструкции языка, функции, возможности языка.
1) Типы данных BASIC
2) Массивы
Типом данных называется способ хранения и представления данных в компьютерной системе. В языке Visual Basic могут
храниться и обрабатываться данные следующих типов.
Byte — целое неотрицательное число. Принимает значения от 0 до 255, занимает 1 байт.
Boolean — логическая величина. Принимает одно из двух значений True и False, занимает 2 байта.
Currency — десятичное протяженное число. Используется для проведения денежных вычислений с фиксированным
количеством знаков после десятичной запятой, занимает 8 байт. (До 15 знаков слева от десятичной точки и до 4 знаков справа
от десятичной точки).
Date — дата. Используется для хранения дат/времени, занимает 8 байт.
Double — десятичное число двойной точности, занимает 8 байт.
Integer — короткое целое числовое значение, занимает 2 байта. Используется для представления целых чисел в диапазоне от 32768 до 32767.
Long — длинное целое число, занимает 4 байта. Используется для представления целых чисел в диапазоне от -2147483648 до
2147483647.
Single — десятичное число обычной точности, занимает 4 байта. Используется для представления отрицательных чисел в
диапазоне от -3.402823Е 38 до -1.401298Е-45 и для представления положительных чисел в диапазоне от 1.401298Е-45 до
3.402823Е 38.
String — строка переменной длины. Занимаемая память линейно зависит от числа символов в строке.
String * длина — строка постоянной длины.
Variant — произвольное значение. Используется для хранения данных любых типов. Занимает 16 байтов плюс по одному байту
на каждый символ, если значением является строка.
Object — объект. Используется только для хранения ссылок на объекты, занимает 4 байта.
Переменная — это именованная область памяти, предназначенная для хранения данных, изменяющихся в процессе выполнения
программы. Для доступа к содержимому этой области памяти достаточно знать имя переменной.
Имя переменной (идентификатор) — это строка символов, которая отличает эту переменную от других объектов программы
(идентифицирует переменную в программе).
При задании имен переменным нужно соблюдать следующие правила:
первым символом имени должна быть буква. Остальные символы — буквы и цифры (прописные и строчные буквы
различаются). Можно использовать символ «_»;
в имени нельзя использовать символ «.»;
число символов в имени не должно превышать 255;
имя переменной не должно совпадать с зарезервированными (служебными) словами языка.
В Visual Basic существуют следующие возможности объявления типа переменной.
Переменная может вообще не объявляться. В этом случае будет установлен по умолчанию тип Variant. Однако это может
привести к медленной неэффективной работе программы и нерациональному использованию памяти.
Переменная может объявляться явно с помощью оператора определения переменной:
Dim имяПеременной [ As типПеременной],
например: Dim d as Long.
Чтобы переменные всегда объявлялись явно, нужно использовать опцию Option Explicit в секции (General) (Declarations)
существующих форм, модулей или классов. После установки этой опции Visual Basic требует явного описания переменных и
при использовании в коде необъявленной переменной выдаст сообщение об ошибке.
Переменная может объявляться неявно:
• с помощью оператора объявления типа:
DеfТип Начальная буква [— Конечная буква];
• вместо ОегТип указывается одно из ключевых слов, обозначающих тип:
— Deflnt (для типа Integer);
— DefLng (для типа Long);
— DefSng (для типа Single);
— DefStr (для типа String) и так далее;
• о типе переменной можно иногда судить по суффиксу, приписываемому к имени переменной. Суффиксы могут быть только у
шести типов переменных:
— % — тип Integer;
— & — тип Long;
— ! — тип Single;
— # — тип Double;
— $ — тип String;
— @ — тип Currency.
Если переменная, тип которой указан неявно с помощью суффикса, встречается в программе многократно, то суффикс можно
указывать только один раз при первом использовании этой переменной в программе.
Константы — величины, значения которых не могут меняться. Как и переменные, константы объявляются в начале текста
программного кода оператором:
Const ИмяКонстанты [As Тип] = Значение, например: Const Pi = 3.14159
В качестве значения допускается использовать только постоянные значения и их комбинации, включая арифметические и/или
логические операторы.
Массив — это набор элементов определенного типа, каждый из которых имеет свой порядковый номер, называемый индексом.
Определение массива выполняется оператором:
Dim ИмяПеременной ([НижнийПредел То]
ВерхнийПредел) [As тип].
Например: Dim b (a to 15) — объявление массива b, состоящего из 15 элементов.
Visual Basic по умолчанию индексирует элементы массива, начиная с нуля, т. е. индекс 0 обозначает первый элемент массива,
индекс 1 — второй и так далее. Оператор Option Base 1 позволяет задать индексацию массива с 1. Этот оператор должен
находиться в секции (General) (Declarations).
Перечень вопросов для закрепления материала:
1) Какие операторы языка программирования BASIC вы знаете?
2) Что представляет из себя массив
Рекомендуемая литература:
1.
2.
3.
Ашарина И.В. Объектно-ориентированное программирование в С++ [Электронный ресурс]: учебное пособие/ Ашарина
И.В.— Электрон. текстовые данные. — М.: Горячая линия - Телеком, 2012. — 320 c.— Режим доступа:
http://www.iprbookshop.ru/12008. — ЭБС «IPRbooks», по паролю
Сафронов И.К., Visual Basic в задачах и примерах, БХВ-Петербург, 2008.
Борис Пахомов - C/C++ и MS Visual С++ 2010 для начинающих, БХВ-Петербург, 2011г. - 726с.
Модульная единица 3.
«Операторы языка
Цель: изучить основные операторы языка BASIC
1) Оператор присваивания
2) Оператор выбора
3) Операторы цикла.
Правила записи операторов
При записи операторов необходимо придерживаться следующих правил:
Каждый новый оператор записывается с новой строки.
Чтобы записать несколько операторов на одной строке, их разделяют между собой двоеточием (:).
Если оператор не помещается в одной строке, то необходимо поставить в конце строки пробел и знак подчеркивания ( _), а
затем продолжить не поместившуюся часть на следующей строке.
Оператор присваивания
Оператор присваивания используется, если какой-то переменной нужно присвоить новое значение. Он имеет следующий
синтаксис:
ИМЯ_ПЕРЕМЕННОЙ = ВЫРАЖЕНИЕ
Сначала вычисляется выражение в правой части, а затем результат присваивается переменной, стоящей в левой части.
Например. Записать с помощью оператора присваивания следующее математическое выражение:
На VВА это выражение можно записать в виде следующего оператора:
Y = a^(1/3)+(a^2+Exp(-b))/(Sin(a)^2-Log(b))
Условный оператор IF
Для реализации разветвляющегося вычислительного процесса используется оператор If…Then…Else, который представляет
собой простейшую форму проверки условий. Он имеет следующий синтаксис:
If УСЛОВИЕ Then ОПЕРАТОР_1 Else ОПЕРАТОР_2
ОПЕРАТОР_1 выполняется, если УСЛОВИЕ истинно, в противном случае выполняется ОПЕРАТОР_2. При этом оператор
If…Then…Else записывается в одну строку.
УСЛОВИЕ – это выражение логического типа. Результат выражения всегда имеет булевский тип. Выражение может быть
простым и сложным.
Таблица 1 Логические отношения
Операция
Название
Выражение
Результат
=
Равно
A=В
True, если А равно В
<>
Не равно
A<>В
True, если А не равно В
>
Больше
А>B
True, если А ,больше В
<
Меньше
A=
Больше или равно
A>=B
True, если А больше или равно В
<=
Меньше или равно
A<=B
True, если А меньше или равно В
Сложные условия образуются из простых путем применения логических операций и круглых скобок.
Таблица 2 Логические операции
Not
And
Or
Название
Выражение
А
Логическое
отрицание
Not A
False
True
A And B
True
True
False
False
True
False
True
False
True
False
False
False
A Or B
True
True
False
False
True
False
True
False
True
True
True
False
Логическое И
Логическое ИЛИ
В
Результат
True
False
В условном операторе допустимо использование блока операторов вместо любого из операторов. В этом случае условный
оператор имеет вид:
If УСЛОВИЕ Then
БЛОК_ОПЕРАТОРОВ_1
Else
БЛОК_ОПЕРАТОРОВ_2
End If
В условном операторе может проверяться несколько условий. В этом случае условный оператор имеет вид:
If УСЛОВИЕ_1 Then
БЛОК_ОПЕРАТОРОВ_1
ElseIf УСЛОВИЕ_2 Then
БЛОК_ОПЕРАТОРОВ_2
Else
….
End If
Оператор выбора Select Case
Оператор Select Case удобно использовать, когда в зависимости от значения некоторого выражения, имеющего конечное
множество допустимых значений, необходимо выполнить разные действия. Он также относится к условным операторам, но
имеет другой вид:
Select Case ПРОВЕРЯЕМОЕ_ВЫРАЖЕНИЕ
Case ЗНАЧЕНИЯ_1
ОПЕРАТОРЫ_1
Case ЗНАЧЕНИЯ_2
ОПЕРАТОРЫ_2
. . .
Case ЗНАЧЕНИЯ_N
ОПЕРАТОРЫ_N
[Case Else
ИНАЧЕ_ОПЕРАТОРЫ]
End Select
ПРОВЕРЯЕМОЕ_ВЫРАЖЕНИЕ может иметь любой скалярный тип, кроме вещественного. ЗНАЧЕНИЯ состоят из
произвольного количества значений или диапазонов, отделенных друг от друга запятыми.
Тип ЗНАЧЕНИЙ должен совпадать с типом ПРОВЕРЯЕМОГО_ВЫРАЖЕНИЯ.
Сначала вычисляется ПРОВЕРЯЕМОЕ_ВЫРАЖЕНИЕ. Если его значение совпадает с одним из значений ЗНАЧЕНИЯ_I, то
выполнятся ОПЕРАТОРЫ_I и управление передается оператору, стоящему после End Select. Если его значение не совпадает ни
с одним из значений ЗНАЧЕНИЯ_I, то выполнятся ИНАЧЕ_ОПЕРАТОРЫ и управление передается оператору, стоящему
после End Select
Операторы цикла
Для реализации циклического вычислительного процесса, т. е. многократного выполнения одного или нескольких операторов,
служит оператор цикла For…Next, который имеет следующий синтаксис:
For СЧЕТЧИК=НАЧ_ЗНАЧЕНИЕ Тo КОН_ЗНАЧЕНИЕ Step ШАГ
БЛОК_ОПЕРАТОРОВ
[Exit For]
БЛОК_ОПЕРАТОРОВ
Next СЧЕТЧИК
Цикл For…Next перебирает значения переменной СЧЕТЧИК, которая является параметром цикла, от начального до конечного
значения с указанным шагом изменения. При этом обеспечивается выполнение блока операторов тела цикла при каждом новом
значении счетчика. Если Step ШАГ в конструкции отсутствует, то по умолчанию считается, что шаг равен 1. По оператору Exit
Forможно выйти из оператора цикла до того, как СЧЕТЧИК достигнет последнего значения.*
Для перебора объектов из группы подобных объектов, например, ячеек из диапазона или элементов массива, удобно
использовать оператор цикла For… Each…Next.
For Each Элемент In Группа
БЛОК_ОПЕРАТОРОВ
[Exit For]
БЛОК_ОПЕРАТОРОВ
Next Элемент
В VBA для организации циклов с неизвестным заранее числом повторений используются и другие операторы цикла:
циклы с предусловием –
Do While … Loop,
Do Until … Loop;
циклы с постусловием –
Do … Loop While,
Do … Loop Until.
Ниже приведен синтаксис этих операторов цикла:
' Цикл с предусловием Do While … Loop
Do While УСЛОВИЕ
БЛОК_ОПЕРАТОРОВ
[Exit Do]
БЛОК_ОПЕРАТОРОВ
Loop
Примечание. Не рекомендуется принудительно изменять значения параметра цикла, его начального и конечного значения в
теле цикла For…Next.
' Цикл с предусловием Do Until … Loop
Do Until УСЛОВИЕ
БЛОК_ОПЕРАТОРОВ
[Exit Do]
БЛОК_ОПЕРАТОРОВ
Loop
' Цикл с постусловием Do … Loop While
Do
БЛОК_ОПЕРАТОРОВ
[Exit Do]
БЛОК_ОПЕРАТОРОВ
Loop While УСЛОВИЕ
' Цикл с постусловием Do … Loop Until
Do
БЛОК_ОПЕРАТОРОВ
[Exit For]
БЛОК_ОПЕРАТОРОВ
Loop Until УСЛОВИЕ
Оператор Do While…Loop обеспечивает многократное повторение блока операторов до тех пор, пока УСЛОВИЕ соблюдается,
а оператор Do Until…Loop пока УСЛОВИЕ не соблюдается. Операторы Do…Loop While, Do…Loop Until отличаются от
перечисленных выше операторов тем, что сначала блок операторов выполняется по крайней мере один раз, а потом
проверяется УСЛОВИЕ.
Для избежания зацикливания в теле цикла должен быть хотя бы один оператор, который изменяет значения переменных,
стоящих в УСЛОВИИ.
Перечень вопросов для закрепления материала:
1) Опишите оператор присваивания и способ его записи?
2) Опишите оператор выбора и способ его записи.
3) Какие виды операторов цикла вы знаете?
Рекомендуемая литература:
1.
2.
3.
Ашарина И.В. Объектно-ориентированное программирование в С++ [Электронный ресурс]: учебное пособие/ Ашарина
И.В.— Электрон. текстовые данные. — М.: Горячая линия - Телеком, 2012. — 320 c.— Режим доступа:
http://www.iprbookshop.ru/12008. — ЭБС «IPRbooks», по паролю
Сафронов И.К., Visual Basic в задачах и примерах, БХВ-Петербург, 2008.
Борис Пахомов - C/C++ и MS Visual С++ 2010 для начинающих, БХВ-Петербург, 2011г. - 726с.
Модульная единица 4. «Обработка данных, организованных в виде массивов».
Цель: Изучить возможности типов данных организованных в виде массивов для создания программ
1) Массивы данных
2) Динамические массивы.
3) Двумерные массивы.
4) Основные процедуры обработки данных, организованных в виде массива.
Массивы
Их ещё называют списками. Итак, что же такое массивы? Массив (вектор) - это набор однотипных переменных,
объединенных одним именем и доступных через это имя и порядковый номер переменной в наборе. Количество элементов
массива теоретически может быть бесконечным, ограничения накладываются конкретными языком программирования и
операционной системой. Элементы массива обладают непрерывной нумерацией определённого диапазона.
В программировании массивы используются довольно часто. Например, вам нужно загрузить в программу содержимое
какого-нибудь файла. Если этот файл строковый, то можно использовать строку и обойтись без массива. А вот если файл
бинарный (двоичный), то тут без массива просто не обойтись!
В Visual Basic массивы определяются следующим образом:
Dim myArray (10) As Long
Как вы могли заметить, определение массива отличается от определения обычной переменной только индексом,
указанным в скобках. Этот индекс указывает размерность массива. В данной случае массив myArray будет содержать 11
элементов. Почему 11? Потому что нижняя граница массива начинается с нуля. [0,1,2.....9,10]. Чтобы задать определённую
размерность можно использовать зарезервированное слово To:
Dim myArray (5 To 10) As Long
Здесь определяется массив, размерность которого 6 элементов (5,6,7,8,9,10).
Общий синтаксис определения массива следующий:
Dim ИмяМассива{НомПерв1 То НомПосл1, НомПерв2
То НомПосл2, ...) [As [New] ИмяТипа]
Многомерные массивы
Массивы можно делать многомерными. Например, объявим массив - таблицу поля шахматной доски:
Dim chessTable (1 To 8, 1 To 8) As String
Этот массив представляет собой таблицу с восьми ячейками по вертикали и горизонтали.
Итак, массив определён. Теперь необходимо узнать - как же можно добраться к элементам этого массива. Очень просто! К
элементам массива нужно обращаться по индексу, к примеру, чтобы изменить нулевой элемент массива myArray нужно
написать:
myArray(0) = 1234
Или, например:
chessTable (2,3) = "Пешка"
Массивы переменной размерности (динамические)
Динамические массивы - это такие массивы, размерность которых может меняться в ходе работы программы. Пожалуй
динамические массивы используются даже чаще статических. Рассмотрим характерный пример использования такого массива.
Пусть у нас есть процедура, которая загружает содержимое двоичного файла в массив. Массив мы можем определить так:
Dim fileContent (119) As Byte
Но это если файл имеет длину 120 байт. А что делать, если мы не знаем длину загружаемого файла? Определять очень
большой массив, чтобы уж наверняка туда мог поместиться большой файл? Нет. Так делать нельзя. Вот здесь как раз и нужно
использовать динамический массив.
Visual Basic предоставляет довольно мощные средства для работы с такими массивами. Опеределяется такой массив
следующим образом:
Dim myArray () As Byte
В отличие от массивов статичных размеров, когда обращаться к элементам можно сразу после его объявления, к элементам
динамического массива сразу обращаться нельзя, т.к. они ещё не инициализированы. Для начала нужно указать его новую
размерность. Для это в VB есть оператор ReDim. Работает он следующим образом:
ReDim myArray (4)
Теперь массив myArray имеет одну размерность с индексами от 0 до 4 (т.е. всего 5 элементов). Теперь к такому массиву
можно обращаться точно так же, как и к статичному. Если в дальнейшем возникнет необходимость снова изменить размерность
массива, можно ещё раз использовать ReDim.
Но! Здесь есть подводный камень! Давайте рассмотрим маленький примерчик:
Dim myLong As Long
Dim myArray() As Long ' объявляем массив
ReDim myArray (2) ' одна размерность [0,1,2]
myArray (1) = 234 ' присваиваем второму элементу чило 234
myLong = myArray (1) ' сохраняем его в переменной myLong
ReDim myArray (3) ' снова меняем размерность-теперь [0,1,2,3]
myLong = myArray (1) ' снова пытаемся сохранить второй элемент
На последней строке, переменной myLong присвоится 0 вместо 234! Это происходит потому, что оператор ReDim заново
инициализирует (сбрасывает) все элементы массива к значению по умолчанию (как помните, для чисел - это 0, для строк ""). Но
как же быть, если мы хотим изменить размеры массива, сохранив все старые элементы? Для этого нужно после оператора
ReDim поставить слово Preserve. Примерно так:
ReDim Preserve myArray (3) ' сохраняем старые элементы
myLong = myArray (1) ' всё в порядке
Перечень вопросов для закрепления материала:
1) Какие виды массивов вы знаете?
2) Опишите способы обработки массивов
Рекомендуемая литература:
1.
2.
3.
Ашарина И.В. Объектно-ориентированное программирование в С++ [Электронный ресурс]: учебное пособие/ Ашарина
И.В.— Электрон. текстовые данные. — М.: Горячая линия - Телеком, 2012. — 320 c.— Режим доступа:
http://www.iprbookshop.ru/12008. — ЭБС «IPRbooks», по паролю
Сафронов И.К., Visual Basic в задачах и примерах, БХВ-Петербург, 2008.
Борис Пахомов - C/C++ и MS Visual С++ 2010 для начинающих, БХВ-Петербург, 2011г. - 726с.
Модульная единица 5.
«Основные определения»
Цель: освоить лексику языка С++, освоить использование переменных и констант. Изучить типы данных
1) Лексика языка С++.
2) Переменные и константы.
3) Типы данных.
4) Выражения и операции.
Концепция типа данных
Основная цель любой программы состоит в обработке данных. Данные различного типа хранятся и обрабатываются поразному. В любом алгоритмическом языке каждая константа, переменная, результат вычисления выражения или функции
должны иметь определенный тип.
Тип данных определяет:
внутреннее представление данных в памяти компьютера;
множество значений, которые могут принимать величины этого типа;
операции и функции, которые можно применять к величинам этого типа.
Исходя из этих характеристик, программист выбирает тип каждой величины, используемой в программе для
представления реальных объектов. Обязательное описание типа позволяет компилятору производить проверку допустимости
различных конструкций программы. От выбора типа величины зависит последовательность машинных команд, построенная
компилятором.
Все типы языка С++ можно разделить на простые (скалярные), составные (агрегатные) и функциональные. Простые
типы могут быть стандартными и определенными программистом.
В языке С++ определено шесть стандартных простых типов данных для представления целых, вещественных,
символьных и логических величин. На основе этих типов, а также массивов и указателей (указатель не является
самостоятельным типом, он всегда связан с каким-либо другим конкретным типом), программист может вводить описание
собственных простых или структурированных типов. К структурированным типам относятся перечисления, функции,
структуры, объединения и классы.
Простые типы данных
Простые типы делятся на целочисленные типы и типы с плавающей точкой. Для описания стандартных типов
определены следующие ключевые слова:
int (целый);
char (символьный);
wchar_t (расширенный символьный);
bool (логический);
float (вещественный);
double (вещественный с двойной точностью).
Существует четыре спецификатора типа, уточняющих внутреннее представление и диапазон значений стандартных
типов:
short (короткий);
long (длинный);
signed (со знаком);
unsigned (без знака).
Целый тип (int)
Размер типа int стандартом ANSI не определяется. Он зависит от реализации. Для 16-разрядного процессора под
величины этого типа отводится 2 байта, для 32-разрядного — 4 байта.
Спецификатор short перед именем типа указывает компилятору, что под число требуется отвести 2 байта. Спецификатор
long означает, что целая величина будет занимать 4 байта.
Внутреннее представление величины целого типа — целое число в двоичном коде. При использовании спецификатора
signed старший бит числа интерпретируется как знаковый ( 0 — положительное число, 1 — отрицательное). Спецификатор
unsigned позволяет представлять только положительные числа. Диапазоны значений величин целого типа с различными
спецификаторами для IBM PC-совместимых компьютеров приведены в таблице 1.4.
По умолчанию все целочисленные типы считаются знаковыми.
Константам, встречающимся в программе, приписывается тип в соответствии с их видом. Программист может явно
указать требуемый тип с помощью суффиксов L, l (long) и U, u (unsigned). Например, константа 32L имеет тип long и занимает 4
байта.
ПРИМЕЧАНИЕ
Типы shortint,longint,signedint иunsignedint можно сокращать до short,long, signed иunsignedсоответственно.
Символьный тип (char)
Под величину символьного типа отводится количество байт, достаточное для размещения любого символа из набора
символов для данного компьютера. Как правило, это 1 байт.
Тип char, как и другие целые типы, может быть со знаком или без знака.
В величинах со знаком можно хранить значения в диапазоне от –128 до 127. При использовании спецификатора
unsignedзначения могут находиться в пределах от 0 до 255. Величины типа char применяются также для хранения целых чисел,
не превышающих границы указанных диапазонов.
Расширенный символьный тип (wchar_t)
Тип wchar_t предназначен для работы с набором символов, для кодировки которых недостаточно 1 байта, например,
Unicode. Размер этого типа зависит от реализации; как правило, он соответствует типу short.
Логический тип (bool)
Величины логического типа могут принимать только значения true и false. Внутренняя форма представления значения
false — 0 (нуль). Любое другое значение интерпретируется как true. При преобразовании к целому типу true имеет значение 1.
Типы с плавающей точкой (float, double и longdouble)
Стандарт С++ определяет три типа данных для хранения вещественных значений: float, double и longdouble.
Внутреннее представление вещественного числа состоит из мантиссы и порядка. Длина мантиссы определяет точность
числа, а длина порядка — его диапазон.
Константы с плавающей точкой имеют по умолчанию тип double. Можно явно указать тип константы с помощью
суффиксов F, f (float) и L, l (long). Например, константа 2E+6L будет иметь типlongdouble.
Таблица 1.3. Диапазоны значений простых типов данных для IBM PC
Тип
Диапазон значений
Размер (байт)
Bool
true и false
1
signed char
–128 … 127
1
Unsigned char
0 … 255
1
signed short int
–32 768 … 32 767
2
Unsigned short int
0 … 65 535
2
signed long int
–2 147 483 648 … 2 147 483 647
4
Unsigned long int
0 … 4 294 967 295
4
Float
3.4e–38 … 3.4e+38
4
Double
1.7e–308 … 1.7e+308
8
long double
3.4e–4932 … 3.4e+4932
10
Для вещественных типов в таблице приведены абсолютные величины минимальных и максимальных значений.
Тип void
Тип void используется для определения функций, которые не возвращают значения, для указания пустого списка
аргументов функции, как базовый тип для указателей и в операции приведения типов.
Операции и выражения
унарная_операция: одна из * & ! ~ ++ -Выражения с унарными операциями группируют справа налево.
Унарная операция * означает косвенное обращение: выражение должно быть указателем и результатом будет ссылка на
объект, на который указывает выражение. Если выражение имеет тип "указатель на ...", то тип результата есть "...".
Результатом унарной операции & является указатель на объект, на который ссылается операнд. Операнд должен быть
ссылкой. Если выражение имеет тип "...", то тип результата есть "указатель на ...".
Результатом унарной операции ++ является значение ее операнда после выполнения обычных арифметических
преобразований. Операнд должен быть арифметического типа.
Результатом унарной операции -- является отрицательное значение ее операнда. Операнд должен иметь целый тип.
Выполняются обычные арифметические преобразования.
Результатом операции логического отрицания ! является 1, если значение операнда 0, и 0, если значение операнда не 0.
Результат имеет тип int. Применима к любому арифметическому типу или к указателям.
-
#include
int main(int argc, char* argv[])
{
int x;
int i;
int y;
x = 100;
i = 0;
while (i < 10)
{
y =!x;
cout << !y << endl;
i = i+1;
}
return 0;
}
Операция ~ дает дополнение значения операнда до единицы. Выполняются обычные арифметические преобразования.
Операнд должен иметь интегральный тип.
#include
int main(int argc, char* argv[])
{
int x;
int i;
int y;
x = 100;
y = 100;
i = 0;
while (i < 10)
{
cout << ~(x--) << endl;
i = i+1;
}
return 0;
}
Мультипликативные операции *, / и % группируют слева направо. Выполняются обычные арифметические
преобразования.
мультипликативное_выражение:
выражение * выражение
выражение / выражение
выражение % выражение
Бинарная операция * определяет умножение.
Бинарная операция / определяет деление. При делении положительных целых округление осуществляется в сторону 0, но
если какой-либо из операндов отрицателен, то форма округления является машинно-зависимой. Всегда истинно, что (a/b)*b +
a%b равно a (если b не 0).
#include
int main(int argc, char* argv[])
{
int x;
int i;
int y;
x = 100;
y = 50;
i = 0;
while (i < 10)
{
cout << (x/y)*y+x%y << endl;
--x;
++y;
i = i+1;
}
return 0;
}
Бинарная операция % дает остаток от деления первого выражения на второе. Выполняются обычные арифметические
преобразования. Операнды не должны быть числами с плавающей точкой.
Аддитивные операции + и - группируют слева направо. Выполняются обычные арифметические преобразования. Каждая
операция имеет некоторые дополнительные возможности, связанные с типами.
аддитивное_выражение:
выражение + выражение
выражение - выражение
Результатом операции + является сумма операндов.
Результатом операции - является разность операндов. Выполняются обычные арифметические преобразования. Кроме
того, значение любого целого типа может вычитаться из указателя, в этом случае применяются те же преобразования, что и к
сложению.
Операции отношения (сравнения) группируют слева направо, но этот факт не очень-то полезен: a < b < c не означает то,
чем кажется.
выражение_отношения:
выражение
<
выражение
выражение
>
выражение
выражение
<=
выражение
выражение
>=
выражение
Операции < (меньше чем), > (больше чем), <= и >= все дают 0, если заданное соотношение ложно, и 1, если оно истинно.
Тип результата int. Выполняются обычные арифметические преобразования.
выражение_равенства:
выражение
==
выражение
выражение
!=
выражение
Операции == и != в точности аналогичны операциям сравнения за исключением их низкого приоритета.
логическое_И_выражение:
выражение && выражение
Операция && группирует слева направо. Она возвращает 1, если оба операнда ненулевые, и 0 в противном случае.
Операция && гарантирует вычисление слева направо; более того, второй операнд не вычисляется, если первый операнд есть 0.
Операнды не обязаны иметь один и тот же тип, но каждый из них должен иметь один из основных типов или быть
указателем. Результат всегда имеет тип int.
#include
int main(int argc, char* argv[])
{
int x;
int i;
int y;
int z;
x = 100;
y = 0;
i = 0;
while (i < 10)
{
z = x && y;
cout << z << endl;
--x;
++y;
i = i+1;
}
return 0;
}
логическое_ИЛИ_выражение:
выражение || выражение
Операция || группирует слева направо. Она возвращает 1, если хотя бы один из ее операндов ненулевой, и 0 в противном
случае. Операция || гарантирует вычисление слева направо; более того, второй операнд не вычисляется, если первый операнд не
есть 0.
Операнды не обязаны иметь один и тот же тип, но каждый из них должен иметь один из основных типов или быть
указателем. Результат всегда имеет тип int.
Операция_присваивания: одна из
= += -= *= /= %=
#include
int main(int argc, char* argv[])
{
int x;
int i;
int y;
int z;
x = 100;
y = 50;
i = 3;
z = x;
cout << z << endl;
z += x;
cout << z << endl;
z -= y;
cout << z << endl;
z *= i;
cout << z << endl;
z /= y;
cout << z << endl;
z %= 5;
cout << z << endl;
return 0;
}
//Программа рассчитывающая количество сантиметров в заданном количестве дюймов
#include
main()
{
int inch = 0;
// inch - дюйм
cout << "inches: ";
cin >> inch;
cout << inch;
cout << " in = ";
cout << inch*2.54;
cout << " cm\n";
}
Оператор
cin >> inch;
Использует объект входного потока cin и операцию взять из потока >>, чтобы получить от пользователя значение. Объект
cin забирает вводимую информацию из стандартного потока ввода, которым обычно является клавиатура.
cout << "Insert two integers: " << endl;
cin >> x >> y;
Первый оператор использует сцепленные операции взять из потока для ввода двух целых чисел. Сначала читается
значение переменной х, а затем – переменной у.
-
Управляющие структуры
Структура выбора if (ЕСЛИ)
#include
int main(int argc, char* argv[])
{
int x;
int y;
cout << "Insert two integers: " << endl;
cin >> x >> y;
if (x> y)
cout << 1 << endl;
return 0;
}
Структура if является структурой с одним входом и одним выходом.
-
Структура выбора if/else (ЕСЛИ/ИНАЧЕ)
#include
int main(int argc, char* argv[])
{
int x;
int y;
cout << "Insert two integers: " << endl;
cin >> x >> y;
if (x> y)
cout << 1 << endl;
else
cout << 0 << endl;
return 0;
}
С++ имеет еще условную операцию (?:), которая близка к структуре if/else. Условная операция – единственная
трехчленная операция в С++, имеющая три операнда. Первый операнд является условием, второй операнд содержит значение
условного выражения в случае, если условие истинно, а третий операнд равен значению условного выражения, если условие
ложно.
cout << (x>y ? 1 : 0) << endl;
x>y ? cout << 1 << "\n" : cout << 0 << "\n";
Для множественного выбора можно использовать вложенные структуры if/else, помещая одну структуру if/else внутрь
другой:
if (x>y)
cout << 1 << endl;
else
if (x>z)
cout << 2 << endl;
else
if (y>z)
cout << 3 << endl;
else
cout << 4 << endl;
if (x>y)
cout << 1 << endl;
else if (x>z)
cout << 2 << endl;
else if (y>z)
cout << 3 << endl;
else
cout << 4 << endl;
Обе формы записи эквивалентны. Последняя форма популярна, поскольку она позволяет избежать сдвига кода далеко
вправо.
Структуры выбора if обычно предполагает наличие в своем теле только одного оператора. Чтобы включить несколько
операторов в тело структуры, заключите их в фигурные скобки {}
-
Структура повторения while (ПОКА)
#include
int main(int argc, char* argv[])
{
int counter, grade, total, average;
total = 0;
counter = 1;
while (counter <=5)
{
cout << "Enter the grade: ";
cin >> grade;
total = total + grade;
counter++;
}
average = total /5;
cout << "The average grade is " << average << endl;
return 0;
}
#include
#include
int main(int argc, char* argv[])
{
int counter, grade, total;
float average;
total = 0;
counter = 0;
cout << "Enter the grade or -1 for stopping: ";
cin >> grade;
while (grade != -1)
{
total = total + grade;
counter++;
cout << "Enter the grade or -1 for stopping: ";
cin >> grade;
}
average = (float)total / counter;
cout << "The average grade is " << setprecision(2) << setiosflags(ios::fixed|ios::showpoint) << average << endl;
return 0;
}
Целые значения не всегда выражаются целыми числами. Часто среднее значение имеет величину типа 7,2 или -93,5.
Подобные числа записываются как числа с плавающей точкой и представляются типом данных float. Переменная average
объявлена как переменная типа float, чтобы учесть дробную часть результатов вычислений. Однако результат вычисления
total/counter является целым числом, поскольку и total и counter – переменные целого типа. Деление двух целых чисел
осуществляется как целочисленное деление, при котором любая дробная часть результат теряется. Поскольку сначала
осуществляется деление, дробная часть потеряется прежде, чем результат будет записан в переменную average. Чтобы
осуществлять над целыми числами вычисления с плавающей запятой, надо создавать для вычислений временные величины с
плавающей запятой. В С++ для решения этой задачи вводится унарная операция приведения к типу. Оператор
average = (float)total / counter;
включает операцию приведения к типу , которая создает временную копию с плавающей запятой своего оператора total.
Подобное использование операции приведения к типу называется явным преобразованием. Величина, сохраняемая в total,
остается целой. А вычисления теперь сводятся к делению величины с плавающей запятой на целую величину.
-
Структура повторения do/while (ВЫПОЛНЯТЬ/ПОКА)
#include
int main(int argc, char* argv[])
{int counter = 1;
do
{
cout <
int main(int argc, char* argv[])
{
for (int counter = 1; counter <=10; counter++)
cout << counter << endl;
return 0;
}
Структура множественного выбора switch
Программа в следующем примере осуществляет преобразование дюймов в сантиметры и сантиметров в дюймы;
предполагается, что вы укажете единицы измерения вводимых данных, добавляя i для дюймов и c для сантиметров (через пробел):
#include
main()
-
{
const float fac = 2.54;
float x, in, cm;
char ch = 0;
cout << "введите длину: ";
cin >> x >> ch;
switch (ch) {
case 'i':
in = x;
cm = x*fac;
break;
case 'c':
in = x/fac;
cm = x;
break;
default:
in = cm = 0;
break;
}
Оператор break вызывает передачу программного управления на первый оператор после структуры switch. Если не
использовать break, тогда каждый раз, когда одно из условий case удовлетворяется, будут выполняться операторы всех
последующих меток case. Если ни одно условие не выполнено, то выполняются действия после метки default.
Структура switch отличается от всех других структур тем, что при нескольких действиях после case не требуется
заключать их в фигурные скобки.
Операторы break и continue
Операторы break и continue изменяют поток управления. Когда оператор break выполняется в структурах while, for, do /
while или switch, происходит немедленный выход из структуры. Программа продолжает выполнение с первого оператора после
структуры. Обычное назначение оператора break – досрочно прерывать цикл или пропустить оставшуюся часть структуры switch.
for (int counter = 1; counter <=10; counter++)
{if (counter == 5)
break;
cout << counter << " ";}
cout << endl << counter << endl;
Оператор continue в структурах while, for или do/while вызывает пропуск оставшейся части тела структуры и начинается
выполнение последующей итерации цикла. В структурах while и do/while немедленно после выполнения оператора continue
производится проверка условия продолжения цикла. В структуре for выполняется выражение приращения, а затем
осуществляется проверка условия продолжения.
В большинстве случаев структура while может использоваться вместо for. Единственным исключением является случай,
когда выражение приращения в структуре while следует за оператором continue. В этом случае приращение не выполняется до
проверки условия продолжения цикла, и структура while работает не так, как for.
for (int counter = 1; counter <=10; counter++)
{
if (counter == 5)
continue;
cout << counter << " ";
}
cout << endl << counter << endl;
-
int counter = 1;
while (counter <=10)
{
if (counter == 5)
{
counter ++; // без этой строчки программа входит в бесконечный цикл
continue;
}
cout << counter << " ";
counter ++;
}
cout << endl << counter << endl;
Перечень вопросов для закрепления материала:
1) Расскажите об операциях и выражениях, использующихся в языке программирования
2) Расскажите об основных управляющих структурах
3) Расскажите о синтаксисе оператора switch.
Рекомендуемая литература:
1.
2.
3.
Ашарина И.В. Объектно-ориентированное программирование в С++ [Электронный ресурс]: учебное пособие/ Ашарина
И.В.— Электрон. текстовые данные. — М.: Горячая линия - Телеком, 2012. — 320 c.— Режим доступа:
http://www.iprbookshop.ru/12008. — ЭБС «IPRbooks», по паролю
Сафронов И.К., Visual Basic в задачах и примерах, БХВ-Петербург, 2008.
Борис Пахомов - C/C++ и MS Visual С++ 2010 для начинающих, БХВ-Петербург, 2011г. - 726с.
Модульная единица 6.
«Процедуры и функции»
Цель: освоить разработку процедур и функций.
1) Программные модули в С++
2) Заголовочные файлы
Программные модули в С++
Большинство компьютерных программ, решающих реальные практические задачи, намного превышают те программы,
которые были представлены выше. Экспериментально доказано, что наилучшим способом создания и поддержки больших
программ является их конструирование из маленьких фрагментов или модулей, каждый из которых более управляем, чем сложная
программа. Эта техника называется «разделяй и властвуй».
Модули в С++ называются функциями и классами. Обычно программы на С++ пишутся путем объединения новых
функций, которые пишет сам программист, с функциями, уже имеющимися в стандартной библиотеке С, и путем объединения
новых классов, которые пишет сам программист, с классами, уже имеющимися в различных библиотеках классов.
Стандартная библиотека С обеспечивает широкий набор функций для выполнения типовых математических расчетов,
операций со строками, с символами, ввода-вывода, проверки ошибок и многих других полезных операций. Не нужно изобретать
колесо. Если возможно, нужно использовать стандартную библиотеку ANSI С вместо того, чтобы писать новые функции..
Программист может написать функции, чтобы определить, какие-то специфические задачи, которые можно использовать
в разных местах программы. Эти функции называют функции, определенные пользователем. Операторы, реализующие данную
функцию, пишутся только один раз и скрыты от других функций.
Функция активизируется (т.е. начинает выполнять запроектированную для нее задачу) путем вызова функции. В
вызове функции указывается ее имя и дается информация (в виде аргументов), необходимая вызываемой функции для ее работы.
main
Function1
Function4
Function2
Function3
Function5
Начальник (вызывающая функция или вызывающий оператор) просит подчиненного (вызываемую функцию)
выполнить задание и возвратить (т.е. сообщить) результаты после того, как задание выполнено. Функция-начальник не знает,
как функция-подчиненный выполняет порученное ей задание.
Математические библиотечные функции
Математические библиотечные функции позволяют программисту выполнять определенные типовые математические
вычисления. Для использования функций математической библиотеки необходимо включить соответствующий файл с помощью
директивы препроцессора #include
Обычно функция вызывается путем записи имени функции, после которого записывается левая круглая скобка, затем
аргумент функции (или список аргументов, разделенных запятыми), а завершает запись правая круглая скобка.
Например:
cout << sqrt (900.0);
cout << sqrt(c1+d*f)
Функция sqrt вычисляет квадратный корень. Она получает аргумент типа double и возвращает результат типа double.
-
Определения функций
Рассмотрим программу, которая использует функцию square для вычисления квадратов целых чисел от 1 до 10.
Функция создает копию значения х в параметре у. Затем square вычисляет у*у. Результат передает в ту точку main, из
которой была вызвана square, и затее этот результат выводится на экран.
Описание square показывает, что эта функция ожидает передачи в нее целого параметра у. Ключевое слово INT,
предшествующее имени функции указывает, что square возвращает целый результат. Оператор return в square передает результат
вычислений обратно в вызывающую функцию.
Функция не может быть объявлена внутри другой функции.
-
#include
int square (int);
int main(int argc, char* argv[])
{
for (int x = 1; x<=10; x++)
cout << square (x) << " ";
cout << endl;
return 0;
}
int square (int y)
{
return y*y;
}
Строка
int square (int);
является прототипом функции. Прототип функции указывает компилятору тип данных, возвращаемых функцией,
количество параметров, которое ожидает функция, тип параметров и ожидаемый порядок их следования. Компилятор использует
прототип функции для проверки правильности вызовов функции. Вызов функции, который не соответствует прототипу функции,
ведет к синтаксической ошибке.
Другой важной особенностью прототипов функций является приведение типов аргументов, т.е. задание аргументам
подходящего типа. Например оператор
cout << sqrt (4);
правильно вычисляет и печатает значение квадратного корня 4. Прототип функции заставляет компилятор преобразовать
целое значение 4 в значение 4,0 типа double, прежде чем значение будет передано в sqrt.
Преобразования типов могут привести к неверным результатам, если не руководствоваться правилами приведения
типов С++. Правила приведения определяют как типы могут быть преобразованы в другие типы без потерь.
Правила приведения типов применяются к выражениям, содержащим значения двух или более типов данных; такие
выражения относятся к выражениям смешанного типа. Тип каждого значения в выражениях смешанного типа приводится к
«наивысшему» типу, имеющемуся в выражении (на самом деле создается и используется временная копия выражения – истинные
значения остаются неизменными).
Типы данных в порядке следования от высших типов к низшим:
long double
double
float
unsigned long int
long int
unsigned int
int
unsigned short int
short int
unsigned char
char
Функция определяет и возвращает наибольшее из трех целых чисел.
#include
int maximum (int, int, int);
int main(int argc, char* argv[])
{
int a,b,c;
cout << "Enter 3 integers: ";
cin >> a >> b >>c;
cout << "Maximum is: " << maximum(a,b,c) << endl;
return 0;
}
int maximum (int x, int y, int z)
{
int max = x;
if (y > max)
max = y;
if (z>max)
max = z;
return max;
}
#include
#include
int main(int argc, char* argv[])
{
int n; cout <<”Enter n: “; cin >> n;
srand(n);
for (int i = 1; i <=20; i++)
{
cout << 1+ rand() % 6 << endl;
return 0;
}
}
Заголовочные файлы
-
Каждая стандартная библиотека имеет соответствующий заголовочный файл, содержащий
прототипы всех функций библиотеки и объявления различных типов данных и констант, которые
используются этими функциями.
Программист может сам создавать требующиеся ему заголовочные файлы. Заголовочные файлы
должны иметь расширение .h. Включаются в программу точно так же директивой препроцессора
#include “square.h”
Перечень вопросов для закрепления материала:
1) Что такое прототип функции?
2) Что такое заголовочный файл функции?
3) Для чего нужна подпрограмма?
Рекомендуемая литература:
1.
2.
3.
Ашарина И.В. Объектно-ориентированное программирование в С++ [Электронный ресурс]: учебное пособие/ Ашарина
И.В.— Электрон. текстовые данные. — М.: Горячая линия - Телеком, 2012. — 320 c.— Режим доступа:
http://www.iprbookshop.ru/12008. — ЭБС «IPRbooks», по паролю
Сафронов И.К., Visual Basic в задачах и примерах, БХВ-Петербург, 2008.
Борис Пахомов - C/C++ и MS Visual С++ 2010 для начинающих, БХВ-Петербург, 2011г. - 726с.
Модульная единица 7.
«Структурированные типы данных. Массивы, строки, множества»
Цель: освоить отличия и сходства языков программирования Java и С++, историю языка, его развитие и возможности.
1) Декларация массивов
2) Способы заполнения массивов
3) Обработка массивов
Массивы
Массив – это последовательная группа ячеек памяти, имеющих одинаковое имя и одинаковый тип. Чтобы сослаться на
элемент массива, мы указываем имя массива и номер позиции отдельного элемента массива.
На любой элемент массива можно сослаться, указывая имя массива и номер позиции элемента, заключенный в
квадратные скобки. Первый элемент каждого массива – нулевой элемент. Например, есть массив целый чисел, названный с. Этот
массив содержит 12 элементов. Первый элемент массива указывают с[0], второй - c[1], третий - c[2] и т.д. i-тый элемент массива
указывают как c[i-1]. Имена массивов должны удовлетворять тем же требованиям, которые предъявляют к другим именам
переменных.
Номер позиции, указанный в квадратных скобках называют индексом. Индекс должен быть целым числом или целым
выражением. Если программа использует выражение в качестве индекса, то выражение вычисляется с целью определения
индекса.
Важно понимать различие между «седьмым элементом массива» и «элементом массива семь». Седьмой элемент массива
имеет индекс 6, тогда как элемент массива семь имеет индекс 7.
Чтобы разделить значение седьмого элемента массива с на 2 и записать результат в переменную х, надо записать:
x = c[6] / 2;
Объявления массивов
Массивы занимают область в памяти. Программист указывает тип каждого элемента, количество элементов, требуемое
каждым массивом, и компилятор может зарезервировать соответствующий объем памяти.
int c[12];
int b[100], x[27];
Элементам массива должны быть заданы какие-то начальные значения:
int n[10];
for (int I = 0; i<10; i++) n[i] = 0;
Элементам массива можно присваивать начальные значения (инициализировать их) в объявлении массива с помощью
следующего за объявлением списка (заключенного в фигурные скобки):
int n[5] = {5,4,3,2};
Если начальных значений меньше чем элементов в массиве, оставшиеся элементы автоматически получают нулевые
значения.
Если размер массива не указан в объявлении со списком инициализации, то количество элементов массива будет равно
количеству элементов в списке начальных значений:
int n[ ] = {5,4,3,2,1};
const int arraySize = 10;
int s[arraySize];
Строка const int arraySize = 10; использует спецификацию const для объявления так называемой постоянной переменной
arraySize. Постоянные значения при объявлении должны получать в качестве постоянных значений постоянные выражения,
которые после того не могут быть модифицированы. При объявлении массивов можно использовать только константы.
Символьному массиву можно также задать в качестве начального значения список отдельных символьных констант,
указанных в списке инициализации. Например,
char string1 [ ] = “first”;
char string2 [ ] ={‘f’, ‘i’, ‘r’, ‘s’, ‘t’, ‘\0’}
Эти объявления эквивалентны. Оба массива содержат ШЕСТЬ символов, потому что последним символом в строке всегда
является нулевой символ – признак завершения строки.
char string3[20];
cin >> string3;
cout << string3<< endl;
#include
int main(int argc, char* argv[])
{
char string1[20], string2[] = "áóêâà";
cout << "Enter the string: ";
cin >> string1;
cout << "String1 is: " << string1<
void modifyArray(int [], int);
void modifyElement(int);
int main(int argc, char* argv[])
{
const int arraySize = 5;
int a[arraySize] = {0,1,2,3,4};
cout << "Array By Reference"<
#include
#include
#pragma hdrstop
//--------------------------------------------------------------------------#pragma argsused
int main(int argc, char* argv[])
{
const int arraySize = 10;
int a[arraySize] = {2,6,4,8,10,12,89,68,45,37};
int hold;
cout << "In natural order" << endl;
for (int i = 0; i< arraySize; i ++)
cout << a[i] << " ";
cout << endl;
//Bubbble-sort
int pass = arraySize-1;
for( int pass = arraySize-1; pass >0; pass --)
{
for ( int i = 0; i < pass; i++)
if (a[i] > a[i+1])
{
hold = a[i];
a[i] = a[i+1];
a[i+1] = hold;
}
}
cout << "In right order" << endl;
for (int i = 0; i< arraySize; i ++)
cout << a[i] << " ";
cout << endl;
getch();
return 0;
}
//---------------------------------------------------------------------------
Данная сортировка получила название пузырьковая сортировка или сортировка погружением, потому что наименьшее
значение постепенно «всплывает», продвигаясь к вершине (началу) массива, подобно пузырьку воздуха в воде, тогда как
наибольшее значение погружается на дно (конец массива).
Сортировка выполняется с помощью вложенного цикла for. Перестановка выполняется тремя присваиваниями, с
помощью переменной hold. Двумя присваиваниями сортировку выполнить НЕЛЬЗЯ, потому что после первого присваивания
одно из значений будет утеряно, а обе переменные будут иметь одинаковое значение.
Сортировка вставками
main()
{
const int arraySize = 10;
int a[arraySize] = {2,6,4,8,10,12,89,68,45,37};
int b[arraySize];
cout << "In natural order" << endl;
for (int i = 0; i< arraySize; i ++)
cout << a[i] << "\t";
cout << endl;
//Insert sorting
for (i = 0; i< arraySize; i ++)
{
int j = i;
while ((j>0) && (b[j-1]>a[i]))
{
b[j]=b[j-1];
j=j-1;
}
b[j] = a[i];
}
//*******************************************
cout << "In right order" << endl;
for (i = 0; i< arraySize; i ++)
cout << b[i] << "\t";
cout << endl;
}
Вставка происходит следующим образом: в конце нового массива выделяется свободная ячейка, далее анализируется
элемент, стоящий перед пустой ячейкой (если, конечно, пустая ячейка не стоит на первом месте), и если этот элемент больше
вставляемого, то подвигаем элемент в свободную ячейку (при этом на том месте, где он стоял, образуется пустая ячейка) и
сравниваем следующий элемент. Так мы перейдем к ситуации, когда элемент перед пустой ячейкой меньше вставляемого, или
пустая ячейка стоит в начале массива. Помещаем вставляемый элемент в пустую ячейку. Таким образом, по очереди вставляем
все элементы исходного массива.
-
Поиск в массивах
Линейный поиск
Линейный поиск сравнивает каждый элемент массива с ключом поиска. Поскольку массив может быть неупорядочен,
вполне вероятно, что отыскиваемое значение окажется первым же элементом массива. Но в среднем программа должна сравнить
с ключом поиска половину элементов массива.
main()
{
const int arraySize = 10;
int a[arraySize] = {13,6,4,8,10,12,89,68,45,37};
int searchKey, element;
cout << "Enter search key: ";
cin >> searchKey;
element = -1;
for (i = 0; i< arraySize; i ++)
if(a[i]==searchKey)
element = i;
if (element != -1)
cout << "Number is " << element << endl;
else
cout << "No such element" << endl;
}
Метод линейного поиска хорошо работает для небольших или для несортированных массивов. Однако для больших
массивов линейный поиск неэффективен. Если массив отсортирован, можно использовать высокоэффективный метод двоичного
поиска.
Двоичный поиск
Алгоритм двоичного поиска исключает половину еще непроверенных элементов массива после каждого сравнения.
Алгоритм определяет местоположение среднего элемента массива и сравнивает его с ключом поиска. Если они равны, то ключ
поиска найден, и выдается индекс этого элемента. В противном случае задача сокращается на половину элементов массива.
Если ключ поиска меньше, чем средний элемент массива, то дальнейший поиск осуществляется в первой половине массива, а
если больше, то во второй половине.
Многомерные массивы
Массивы в С++ могут иметь много индексов. Обычным представлением многомерных массивов являются таблицы
значений, содержащие информацию в строках и столбцах. Чтобы определить отдельный табличный элемент, нужно указать два
индекса: первый (по соглашению) указывает номер строки, а второй (по соглашению) указывает номер столбца. Таблицы или
массивы, которые требуют двух индексов для указания отдельного элемента, называются двумерными.
Каждый элемент в двумерном массиве а определяется именем элемента в форме a[i][j]; а – это имя массива, а i и j –
индексы, которые однозначно определяют каждый элемент в a. Имена элементов первой строки имеют первый индекс 0, имена
элементов четвертого столбца имеют второй индекс 3.
Многомерные массивы могут получать начальные значения в своих объявления точно так же, как массивы с
единственным индексом. Значения группируются в строки, заключенные в фигурные скобки:
int b [2][3] = {{1,2,3,}, {4,5,6}};
Если начальных значений в данной строке не хватает для их присвоения всем элементам строки, то остающимся
элементам строки присваиваются нулевые значения
int b [2][3] = {{1,}, {4,5,6}};
int c [2][3] = {{1,2,3,4,5};
Объявление массива с содержит пять начальных значений. Начальные значения присваиваются первой строке, затем
второй строке. Любые элементы, которые не имеют явно заданных начальных значений, автоматически получают нулевые
значения.
#include
void printArray (int [] [3]);
int main(int argc, char* argv[])
{
int a [2][3] = {{1,2,3},{4,5,6}};
int b [2][3] = {1,2,3,4,5};
int c [2][3] = {{1,2},{4}};
cout << "a" << endl; printArray(a);
cout << "b" << endl; printArray(b);
cout << "c" << endl; printArray(c);
return 0;
}
void printArray (int d [] [3])
{
for (int i = 0; i< 2; i++)
for (int j = 0; j <3; j++)
cout << d[i][j] << ' ';
cout << endl;
}
Программа вызывает функцию printArray для вывода элементов каждого массива. Описание функции указывает параметр
– массив int a[][3]. Когда мы задаем как аргумент функции одномерный массив, скобки в списке параметров функции пусты.
Размерность первого индекса многомерного массива также не требуется, но все последующие размерности необходимы.
Компилятор использует размерности этих индексов для определения ячеек в памяти элементов многомерных массивов. В памяти
все элементы массива хранятся последовательно, независимо от количества индексов. В двумерном массиве первая строка
хранится в памяти перед второй строкой.
Перечень вопросов для закрепления материала:
1) Какие этапы развития языка вы знаете?
2) В чем существенные отличия языка Java от других языков?
Рекомендуемая литература:
1.
2.
3.
Ашарина И.В. Объектно-ориентированное программирование в С++ [Электронный ресурс]: учебное пособие/ Ашарина
И.В.— Электрон. текстовые данные. — М.: Горячая линия - Телеком, 2012. — 320 c.— Режим доступа:
http://www.iprbookshop.ru/12008. — ЭБС «IPRbooks», по паролю
Сафронов И.К., Visual Basic в задачах и примерах, БХВ-Петербург, 2008.
Борис Пахомов - C/C++ и MS Visual С++ 2010 для начинающих, БХВ-Петербург, 2011г. - 726с.
Модульная единица 8.
«Работа с файлами»
Цель: Освоить принципы работы с файлами последовательного доступа
1) Виды файлов
2) Способы работы с различными видами файлов
Последовательные файлы — файлы, хранящие информацию в неструктурированном (для поиска и обращения) виде. Поиск в
таких файлах осуществляется последовательным считыванием файла с начала и сравнением «всего» с искомым. Так же и
обращение к определённому участку файла каждый раз требует «чтения с начала».
Примером последовательных файлов являются текстовые файлы (*.txt)
EOF
- отрицательное целое число типа int, используемое для обозначения конца файла.
Библиотека stdio.h
stdio.h (от англ. standard input/output header — стандартный заголовочный файл ввода/вывода) заголовочный файл стандартной
библиотеки языка Си, содержащий определения макросов, константы и объявления функций и типов, используемых для
различных операций стандартного ввода и вывода при работе с файлами.
Стандарт определяет такое понятие, как поток — последовательный набор информации, который может быть входным или
выходным. Поток может быть текстовым или бинарным. Текстовый поток — поток символов, разделённых строками. Каждая
строка заканчивается символом новой строки. Бинарный поток — поток байтов, которые могут прозрачно представлять любую
информацию.
Для начала работы с файлом его необходимо открыть!
Делает это функция fopen библиотеки stdio.h
fopen(имя физического файла, режим доступа)
Режим доступа — строка, указывающая режим открытия файла файла и тип файла
Типы файла: бинарный (b); текстовый (t)
Например: fopen("D:\\file1.txt","rt")
Режим
описание
r
Открывает файл для чтения из него (файл должен существовать)
w
Создает файл для записи (по умолчанию файл открывается как текстовый).
а
Дописывает информацию к концу файла (по умолчанию файл открывается как текстовый).
rt
Открывает текстовый файл для чтения.
wt
Открывает текстовый файл для записи.
fclose - закрывает файл, ассоциированный с переданным ей значением FILE *
fopen - открывают файл для определённых типов чтения и записи
fgetc - возвращает один символ из файла
fgets - получает строку из файла (оканчивающуюся символом перевода строки или конца файла)
fputc - записывает один символ в файл
fputs - записывает строку в файл
feof - проверяет, установлен ли индикатор EOF для данного потока
Ввод / вывод при прямом доступе: функция fseek()
При прямом доступе можно выполнять операции ввода/вывода, используя систему ввода/вывода языка С и функцию fseek(),
которая устанавливает указатель текущей позиции в файле. Вот прототип этой функции:
int fseek(FILE *уф, long int колич_байт, int начало_отсчета);
Здесь уф — это указатель файла, возвращаемый в результате вызова функции fopen(), колич_байт — количество байтов, считая
от начало_отсчета, оно определяет новое значение указателя текущей позиции, а начало отсчёта — это один из следующих
макросов:
Начало отсчета
Макрос
Начало файла
SEEK_SET
Текущая позиция SEEK_CUR
Конец файла
SEEK_END
Поэтому, чтобы получить в файле доступ на расстоянии колич_байт байтов от начала файла, начало_отсчета должно равняться
SEEK_SET. Чтобы при доступе расстояние отсчитывалось от текущей позиции, используйте макрос SEEK_CUR, а чтобы при
доступе расстояние отсчитывалось от конца файла, нужно указывать макрос SEEK_END. При успешном завершении своей
работы функция fseek() возвращает нуль, а в случае ошибки — ненулевое значение.
В следующей программе показано, как используется fseek(). Данная программа в определенном файле отыскивает некоторый
байт, а затем отображает его. В командной строке нужно указать имя файла, а затем нужный байт, то есть его расстояние в байтах
от начала файла.
#include
#include
int main(int argc, char *argv[])
{
FILE *fp;
if(argc!=3) {
printf("Синтаксис: SEEK <имя_файла> <байт>\n");
exit(1);
}
if((fp = fopen(argv[1], "rb"))==NULL) {
printf("Ошибка при открытии файла.\n");
exit(1);
}
if(fseek(fp, atol(argv[2]), SEEK_SET)) {
printf("Seek error.\n");
exit(1);
}
printf("В %ld-м байте содержится %c.\n", atol(argv[2]), getc(fp));
fclose(fp);
return 0;
}
Функцию fseek() можно использовать для доступа внутри многих значений одного типа, просто умножая размер данных на номер
элемента, который вам нужен. Например, предположим, имеется список рассылки, который состоит из структур типа addr
(определенных ранее). Чтобы получить доступ к десятому адресу в файле, в котором хранятся адреса, используйте следующий
оператор:
fseek(fp, 9*sizeof(struct addr), SEEK_SET);
Текущее значение указателя текущей позиции в файле можно определить с помощью функции ftell(). Вот ее прототип:
long int ftell(FILE *уф);
Функция возвращает текущее значение указателя текущей позиции в файле, связанном с указателем файла уф. При неудачном
исходе она возвращает -1.
Обычно прямой доступ может потребоваться лишь для двоичных файлов. Причина тут простая — так как в текстовых файлах
могут выполняться преобразования символов, то может и не быть прямого соответствия между тем, что находится в файле и тем
байтом, к которому нужен доступ. Единственный случай, когда надо использовать fseek() для текстового файла — это доступ к
той позиции, которая была уже найдена с помощью ftell(); такой доступ выполняется с помощью макроса SEEK_SET,
используемого в качестве начала отсчета.
Хорошо помните следующее: даже если в файле находится один только текст, все равно этот файл при необходимости можно
открыть и в двоичном режиме. Никакие ограничения, связанные с тем, что файлы содержат текст, к операциям прямого доступа
не относятся. Эти ограничения относятся только к файлам, открытым в текстовом режиме.
Перечень вопросов для закрепления материала:
1) Какие типы файлов вы знаете?
2) Опишите способы работы с разными типами файлов.
Рекомендуемая литература:
1.
2.
3.
Ашарина И.В. Объектно-ориентированное программирование в С++ [Электронный ресурс]: учебное пособие/ Ашарина
И.В.— Электрон. текстовые данные. — М.: Горячая линия - Телеком, 2012. — 320 c.— Режим доступа:
http://www.iprbookshop.ru/12008. — ЭБС «IPRbooks», по паролю
Сафронов И.К., Visual Basic в задачах и примерах, БХВ-Петербург, 2008.
Борис Пахомов - C/C++ и MS Visual С++ 2010 для начинающих, БХВ-Петербург, 2011г. - 726с.
Модульная единица 9.
«Программирование модулей и форм»
Цель: получить теоретические знания о основных интегрированных средах разработки на языке Java.
1) Модуль
2) Элементы управления при создании форм
Модуль — функционально законченный фрагмент программы, оформленный в виде отдельного файла с исходным
кодом или поименованной непрерывной её части (например, Активный Оберон), предназначенный для использования в других
программах. Модули позволяют разбивать сложные задачи на более мелкие в соответствии с принципом модульности. Обычно
проектируются таким образом, чтобы предоставлять программистам удобную для многократного использования
функциональность (интерфейс) в виде набора функций, классов, констант. Модули могут объединяться в пакеты и, далее, в
библиотеки. Удобство использования модульной архитектуры заключается в возможности обновления (замены) модуля, без
необходимости изменения остальной системы. В большинстве случаев различные модули могут запускаться как на одном
сервере, так и на разных, для распределения нагрузки и создания распределенной архитектуры.
Модульное программирование — это организация программы как совокупности небольших независимых блоков,
называемых модулями, структура и поведение которых подчиняются определенным правилам. Использование модульного
программирования позволяет упростить тестирование программы и обнаружение ошибок. Аппаратно-зависимые подзадачи
могут быть строго отделены от других подзадач, что улучшает мобильность создаваемых программ.
Элемент управления - это объект, имеющий свои свойства, методы, события.
1.
Надпись
Label - служит для добавления текста на форму. Этот текст не может быть изменен пользователем, но
может быть изменен программой.
Свойства:
o Caption - текст надписи.
o Font - шрифт, его размер, начертание.
o Alignment - выравнивание текста: Left (влево), Right (вправо), Center (по центру).
o ToolTipText - подсказка, появляющаяся при наведении указателя мыши на элемент управления.
o Свойства размещения и размера элемента:
o
o
ForeColor - цвет текста.
BackColor - цвет фона.
Примечание: Можно выбирать системные цвета, соответствующие оформлению Windows или любые из палитры.
2.
Текстовое поле
- TextBox
Служит для того, чтобы пользователь мог ввести текст во время работы программы.
Свойства:
Text - содержит символы, которые ввел пользователь. Другие свойства аналогичны элементу "Надпись".
3.
Рамка
- Frame - используется для оформления, а также для группировки переключателей. Сверху на рамке можно
сделать надпись с помощью свойстваCaption. Если нужно создать элемент внутри рамки, то перед их рисованием
рамку выделяют, тогда рамка может служить контейнером для группы переключателей.
Кнопка
Button.
Свойства:
o Caption - надпись на кнопке.
o Enabled - доступность элемента. С помощью этого свойства блокируются элементы, которые пользователю
нельзя использовать в данный момент. Заблокированные элементы отображаются серым цветом. В
заблокированное текстовое поле не получится ввести текст, а заблокированную кнопку нельзя нажать.
Выбирают из двух значений:
True (Да) - элемент управления доступен пользователю.
False (Нет) - элемент управления не доступен.
o Visible - видимость элемента управления:
True (Да) - виден.
False (Нет) - не виден.
5. Флажок - Check Box
Используется, когда пользователь должен ввести Да (флажок установлен ) или Нет (флажок снят )
Свойства:
Value - содержит значение элемента управления. Имеются следующие значения:
- нет, флажок снят;
- есть, флажок установлен;
- флажок недоступен.
4.
1.
2.
3.
6.
Переключатель
- Option Button
Позволяет пользователю выбрать один вариант из нескольких.
Свойства:
Value - показывает выбрана опция (1) или нет (0).
7.
Поле со списком
ComboBox
В это поле пользователь может вводить текст так же, как и в TextBox, а кроме этого, если нажать
, то откроется
список, из которого можно выбрать нужную строку.
Свойства:
o Text - содержимое строки, введенное пользователем или выбранное из списка.
o List - строки списка (многострочное свойство).
o ListIndex - номер выбранной пользователем строки (нумерация начинается с нуля, если никакая строка не была
выбрана, то свойство равно -1).
8.
Список
ListBox
Cодержит список строк, в котором пользователь может выбрать одну или несколько строк.
Свойства элемента аналогичны элементу ComboBox, за исключением свойстваText, которое здесь отсутствует.
9.
Рамка для рисунка
PictureBox
Содержит рисунок. Рисунок выбирается с помощью свойства Picture, в которое вводится имя файла или выбирается с
помощью кнопки .
Перечень вопросов для закрепления материала:
1. Классификация алгоритмов и их виды.
2. Что такое структурное программирование?
3. Модульный принцип программирования. Подпрограммы. Принципы проектирования программ
сверху-вниз и снизу-вверх.
4. Объектно-ориентированное программирование. В чем его отличие от структурного?
5. Какие языки программирования вы знаете?
6. Основные понятия языков программирования.
7. Опишите типы процедур и функций, их определение.
8. Создание функций пользователя в C++.
9. Какие элементы управления вы знаете? Опишите их основные свойства.
10. Операторы языка. Операторы цикла, выбора и т.д.
11. Опишите основные типы данных.
12. Переменные. Объявление переменных.
13. Константы и их типы. Объявление констант.
14. Области видимости переменных и констант.
15. Опишите способы создания и обработки массивов
16. Двумерные массивы и их обработка.
17. Опишите принципы работы с файлами последовательного и прямого доступа.
Рекомендуемая литература:
1.
2.
3.
Ашарина И.В. Объектно-ориентированное программирование в С++ [Электронный ресурс]: учебное пособие/ Ашарина
И.В.— Электрон. текстовые данные. — М.: Горячая линия - Телеком, 2012. — 320 c.— Режим доступа:
http://www.iprbookshop.ru/12008. — ЭБС «IPRbooks», по паролю
Сафронов И.К., Visual Basic в задачах и примерах, БХВ-Петербург, 2008.
Борис Пахомов - C/C++ и MS Visual С++ 2010 для начинающих, БХВ-Петербург, 2011г. - 726с.
Глоссарий
АЛФАВИТ (alphabet) – упорядоченный определённым образом набор символов, из которых можно составлять слова и фразы
данного языка
АТРИБУТ (attribute) – признак, содержащий одну из характеристик данной величины.
БЕЗУСЛОВНЫЙ ПЕРЕХОД – конструкция, при которой выполнение команд определяется вне зависимости от каких–либо
условий.
БИБЛИОТЕКА (library) – совокупность программ, организованная определенным образом.
ВЫРАЖЕНИЕ – конструкция на языке программирования, предназначенная для выполнения вычислений.
ИНКАПСУЛЯЦИЯ – сокрытие внутренней структуры данных и реализации методов объекта от остальной программы.
ИНТЕРЛИНЬЯЖ – расстояние между базовыми линиями двух соседних строк.
ИНТЕРПРЕТАТОР (interpreter) – транслятор, последовательно (по одной команде) переводящий команды программы,
написанной на языке высокого уровня, в команды машинного языка и выполняющий каждую команду сразу после перевода.
КЛАСС ОБЪЕКТОВ – совокупность объектов, обладающих одинаковыми свойствами и поведением.
КОМАНДА (command) – мнемонический набор символов, задающий тип операции, подлежащей выполнению процессором, а
также участвующие в операции данные.
КОММЕНТАРИИ – пояснительный текст, который можно записывать в любом месте программы.
КОМПИЛЯТОР (compiler) – транслятор, преобразующий целиком программу, написанную на языке высокого уровня в
эквивалентную программу на машинном языке.
КОНКАТЕНАЦИЯ (concatenation) – объединение двух и более значений строковых переменных или текстов в одно значение или
текст без нарушения порядка следования символов в каждом из них.
КОНСТАНТА (constant) – величина, которая не изменяет своё значение в процессе выполнения алгоритма или программы.
ЛИСТИНГ (listing) – совокупность всей последовательности команд программы.
МАКРОС – программный объект, который во время вычисления заменяется на новый объект, создаваемый определением макроса
на основе его аргументов, затем выражается обычным образом.
МАССИВ (file) – данные, объединённые по какому-то признаку.
МЕТОДЫ – это действия, выполняемые над объектом.
ОБЪЕКТ (в программировании) – это инкапсуляция данных вместе с кодом, предназначенным для их обработки.
ОБЪЕКТНО-ОРИЕНТИРОВАННОЕ ПРОГРАММИРОВАНИЕ – технология программирования, при которой программа
рассматривается как набор дискретных объектов, содержащих, в свою очередь, наборы структур данных и процедур,
взаимодействующих с другими объектами.
ОПЕРАТОР (operator) – законченное выражение на языке высокого уровня, предписывающее процессору выполнение некоторого
действия.
ОПЕРАТОР ВЫБОРА – является обобщением условного оператора и позволяет сделать выбор из произвольного числа
имеющихся вариантов.
ОТЛАДКА ПРОГРАММЫ – устранение в программе синтаксических, семантических и алгоритмических ошибок.
ОТЛАДЧИК – программа, предназначенная для поиска, обнаружения и исправления ошибок в других программах, позволяющая
программистам выполнять программы по шагам, испытывать данные и контролировать значения переменных.
ПЕРЕМЕННАЯ (variable) – величина, которая изменяет своё значение в процессе выполнения алгоритма или программы.
ПОВЕДЕНИЕ ОБЪЕКТА – действия, которые могут выполняться над объектом или которые может выполнять сам объект.
ПОДПРОГРАММА (subroutine) – вызываемая основной программой последовательность операторов, оформленная в виде
отдельной программы.
ПОЛИМОРФИЗМ – способность объекта выбирать правильный метод в зависимости от типа данных, полученных в сообщении.
ПРОГРАММА (program) – алгоритм, записанный на языке программирования, понятном для ЭВМ.
ПРОГРАММНЫЙ МОДУЛЬ – «контейнер» для размещения текстов процедур и функций, вызываемых системой во время
исполнения в определенные моменты времени.
ПРОГРАММИРОВАНИЕ – запись решающего алгоритма на языке программирования и последующая трансляция на машинный
язык.
ПРОЦЕДУРА – часть программы, предназначенная для выполнения некоторых стандартных действий, зависящих, в общем
случае, от входных параметров.
СВОЙСТВА ОБЪЕКТОВ – атрибут объекта, определяющий его характеристики: размер, цвет, положение на экране или
состояние (доступность, видимость)
СИСТЕМА КОМАНД (system of commands) – совокупность всех команд, которые может выполнить данный исполнитель.
СОБЫТИЯ ОБЪЕКТОВ – действия, распознаваемые объектом.
СОСТАВНОЙ ОПЕРАТОР – группа из произвольного числа операторов, заключенная в операторные скобки.
СПИСОК – список констант выбора состоит из произвольного количества значений и диапазонов, разделенных запятыми.
СТРУКТУРИРОВАННЫЕ ОПЕРАТОРЫ – структуры, построенные из других операторов по определенным правилам.
ТРАНСЛЯТОР (translator) – программа, осуществляющая перевод команд программы, написанной на исходном языке
программирования, в команды машинного языка.
УСЛОВНЫЙ ОПЕРАТОР – структура, позволяющая в зависимости от истинности условия выполнить один или другой оператор.
ФУНКЦИЯ (в программировании) – это именованная часть программы, к которой можно обращаться из других частей программы
столько раз, сколько потребуется.
ЦИКЛ – оператор языка программирования, позволяющий многократно повторять одну и ту же последовательность команд (тело
цикла).
ЭЛЕМЕНТ МАССИВА (element of a file) – пронумерованная переменная.
ЯЗЫК ВЫСОКОГО УРОВНЯ (language of a high level) – язык программирования, содержащий элементы естественного языка.
С (в русском варианте – Си) – язык программирования общего назначения, хорошо известный своей эффективностью,
экономичностью и переносимостью.