Список основной литературы
4
1. Методика преподавания информатики: Учеб. Пособие для студ.
Пед. вузов / М.П. Лапчик, И.Г. Семакин. Е.К. Хеннер; Под общей ред.
М.П. Лапчик. — М.:-Издательский центр «Академия», 2001.
2. Попов В.Б. Turbo Pascal для школьников: Учеб. Пособие.- 3-е доп.
изд. — М.: Финансы и статистика, 2002.
3. Информатика. Задачник — практикум в 2т. / Под ред. И.Г. Семакина,
Е.К. Хеннера: Том 1. — М.: Бином. Лаборатория Знаний, 2002.
4. Культин Н. Б. Turbo Pascal в задачах и примерах. — СПб.: БХВПетербург, 2002.
5. Рапаков Г.Г., Ржеуцкая С.Ю. Turbo Pascal для студентов и
школьников. — СПб.: БХВ-Петербург, 2004.
6. Фигурнов В.Э. IBM PC для пользователя. Изд. 6-е, М., 1995 г.
7. Фаронов В. В., Турбо Паскаль 7.0., Учебное пособие. — М.:
Пакеты в Python. Файл __init__, переменная __all__
«Нолидж», 1999 г.
8. Острейковский В.А. Информатика. -М.: «Высшая школа», 2000 г.
5.
Список
дополнительной литературы
• Фигурнов В.Э. «IBM PC для пользователя».
• www.allbest.ru.
• www.wikipedia.org.
• www.profi-info.ru.
• www.5fan.ru.
• www.shatalov.su.
• www.bibliofond.ru.
• www.books.dore.ru.
5
6.
Модуль – это автономно компилируемая программная единица, включающая в себя
различные компоненты раздела описаний (типы, константы, переменные, процедуры
и функции) и, возможно, некоторые исполняемые операторы инициирующей части
По своей организации и характеру использования в программе модули Паскаля близки к
модулям-пакетам (PACKAGE) языка программирования Ада. В них так же, как и в пакетах
Ады, явным образом выделяется некоторая «видимая» интерфейсная часть, в которой
сконцентрированы описания глобальных типов, констант, переменных, а также приводятся
заголовки процедур и функций. Появление объектов в интерфейсной части делает их
доступными для других модулей и основной программы. Тела процедур и функций
располагаются в исполняемой части модуля, которая может быть скрыта от пользователя.
Значение модулей для технологии разработки
программного
проекта
может
быть
продемонстрировано диаграммой на рис. 2.
Модули представляют собой прекрасный
инструмент
для
разработки
библиотек
прикладных программ и мощное средство
модульного
программирования.
Важная
особенность модулей заключается в том, что
компилятор размещает их программный код в
отдельном сегменте памяти.
6
7.
Длина сегмента не может превышать 64 Кбайт, однако количество
одновременно используемых модулей ограничивается лишь доступной
памятью, что позволяет создавать большие программы.
Модули / Введение в программирование, урок 14 (JavaScript ES6)
Структура модулей
Всякий модуль имеет следующую структуру:
Unit ;
interface
;
implementation
;
begin
;
end.
Здесь UNIT – зарезервированное слово (единица); начинает заголовок модуля;
— имя модуля (правильный идентификатор);
INTERFACE – зарезервированное слово (интерфейс); начинает интерфейсную часть
модуля;
IMPLEMENTATION – зарезервированное слово (выполнение); начинает исполняемую
часть модуля;
BEGIN – зарезервированное слово; начинает инициирующую часть модуля; причем
конструкция begin необязательна;
END – зарезервированное слово – признак конца модуля.
Таким образом, модуль состоит из заголовка и трех составных частей, любая из которых
7
может
быть пустой.
8.
9.
10.
Исполняемая часть
Исполняемая часть начинается зарезервированным словом IMPLEMENTATION и
содержит описания подпрограмм, объявленных в интерфейсной части. В ней могут
объявляться локальные для модуля объекты – вспомогательные типы, константы,
переменные и блоки, а также метки.
Unit complexn;
Interface
Type
Complex= record
Re, im: real;
End;
Procedure AddC(x,y: complex, var
z: complex);
Implementation
Procedure AddC;
z.re:= x.re + y.re;
z.im:= x.im + y.im;
end;
end.
10
11.
Инициирующая часть
Инициирующая часть завершает модуль. Она может отсутствовать вместе с начинающим
ее словом BEGIN или быть пустой – тогда вслед за BEGIN сразу следует признак конца
модуля.
Unit fileText;
Interface
Procedure print(s: string);
implementation
var f: text;
const
name= ‘output.txt’;
procedure print;
begin
writeln(f, s)
end;
begin
assign(f, name);
rewrite(f);
11
end.
12.
Компиляция модулей
В среде Паскаль имеются средства, управляющие способом компиляции модулей и
облегчающие разработку больших программ. Определены три режима компиляции:
COMPILE, MAKE, BUILD.
Unit A;
Unit B;
interface
interface
uses B;
Uses A;
…….
……
implementation
implementation
……..
……
end.
end.
Это ограничение можно обойти, если «спрятать»
предложение USES в исполняемые части зависимых
модулей:
Unit A;
Unit B;
interface
interface
…….
……
implementation
implementation
uses B;
Uses A;
……..
……
end.
end.
12
13.
Доступ к объявленным в модуле объектам
Пусть, например, мы создаем модуль, реализующий сложение и вычитание комплексных
чисел с помощью процедур:
Unit complexn;
Interface
type
complex= record
re, im: real;
end;
procedure AddC (x, y: complex; var z: complex);
procedure SubC (x, y: complex; var z: complex);
const
c: complex= (re: 0.1; im: -1);
implementation
procedure AddC;
begin
z.re:= x.re + y.re;
z.im:= x.im + y.im;
end;
procedure SubC;
begin
z.re:= x.re — y.re;
z.im:= x.im — y.im;
13end;
end.
14.
Стандартные модули
В Паскале имеется 8 стандартных модулей, в которых содержится множество различных
типов, констант, процедур и функций. Этими модулями являются SYSTEM, DOS, CRT,
GRAPH, OVERLAY, TURBO3, GRAPH3. Модули GRAPH, TURBO3, GRAPH3 выделены в
отдельные TPU-файлы, а остальные входят в состав библиотечного файла TURBO.TPL.
Лишь один модуль SYSTEM подключается к любой программе автоматически, все
остальные становятся доступны только после указания их имен в списке подключаемых
модулей.
14
Источник: ppt-online.org
Лекция 1. Лекция Функции и модули в языке программирования C
Единственный в мире Музей Смайликов
Самая яркая достопримечательность Крыма
Скачать 57.09 Kb.
Лекция 1. Функции и модули в языке программирования C++
Программирование функций. Рекурсивные функции. Функции с переменным количеством параметров. Стандартные функции сортировки и поиска.
Определение функций.
Функция представляет собой поименованную последовательность инструкций, которая выполняет определенные действия. Функции используются для того, чтобы в теле программы не повторять одни и те же блоки инструкций несколько раз. Например, определим функцию, которая вычисляет сумму двух целых чисел.
int add ( int x, int y)
Эта же функция может быть определена более кратко:
int add ( int x, int y)
То есть после ключевого слова return можно использовать выражение.
Если функции не возвращает никакого значения, то в языке С считается, что эта функция возвращает значение типа void, то есть пустое значение. В этом случае для выхода из функции используется инструкция return без выражения. Если выход из функции, не возвращающей значения, происходит как выход из блока, то в этом случае инструкцию return можно опустить. Например, следующая функция напечатает сумму двух чисел:
void print ( int x, int y)
printf (“x + y = %dn”, x + y);
Если функция не имеет параметров, то вместо списка параметров пишется ключевое слово void, которое можно также опустить. Предпочтительнее использовать первый вариант, так как он явно указывает, что параметров нет. Например, следующая функция печатает сообщение:
Параметры функции можно рассматривать как локальные переменные, которые видны только в теле функции. Отсюда следует, что значения параметров можно изменять в теле функции. Например, можно написать следующую функцию:
которая вернет значение n+1. Заметим, что функция
вернет значение n.
Прототипы функций.
Для предварительного описания функции может использоваться её объявление или прототип. В отличие от определения функции, прототип содержит только заголовок функции и не включает её тело. Прототипы функций используются в следующих случаях:
— функция определена в другом файле,
— функция определена после обращения к ней,
— функция определена в библиотеке функций, которая подключается к программе на этапе её компоновки или выполнения.
Например, функция сложения двух чисел имеет следующий прототип:
int add ( int x, int y);
При объявлении функции в списке параметров можно указывать только типы параметров, опуская их названия. Например, функцию add можно объявить следующим образом:
int add ( int, int);
Заметим, что объявление функции заканчивается символом ‘;’
Вызов функции.
Для вызова функции в программе пишется имя функции, за которым в скобках следует список аргументов, которые являются переменными и константами, определенными в программе. При этом происходит выполнение тела функции, в котором параметры заменяются значениями аргументов. Важно отметить, что тип аргумента должен соответствовать типу соответствующего параметра или допускать приведение к типу параметра. Кроме того, заметим, что функция должна быть объявлена или определена до своего вызова.
Ниже приведена программа, в которой вызывается функция сложения двух чисел.
int add (int x, int y)
// можно вызвать функцию так
printf («1 + 2 = %dn», add(1, 2));
// можно также и так, но в этом случае непонятно зачем
Если функция не имеет параметров, то при её вызове аргументы не указываются, но круглые скобки остаются. В следующей программе показан вызов функции hello.
В заключение этого параграфа сделаем два очень важных замечания. Во-первых, аргументы передаются в функцию по значению. То есть значения аргументов переписываются в параметры функции. Так как значение аргумента копируется в тело функции, то сам аргумент изменить в теле функции невозможно. Во-вторых, функция возвращает результат также по значению.
То есть значение, вычисленное в инструкции return, копируется в переменную, которая определена в теле вызывающей программы и которой присваивается результат вычисления функции.
Рекурсивные функции.
В языке программирования С возможно определение рекурсивных функций. Например, определим рекурсивную функцию, которая вычисляет факториал натурального числа.
unsigned factorial(unsigned n)
return n * factorial(n — 1);
>
Передача аргументов через указатели.
Для того чтобы функция могла изменить значения переменных, которые определены в программе, нужно передать в функцию указатели на эти переменные. Например, в следующей программе определена функция, которая увеличивает на единицу значение переменной, определенной в программе.
Отметим, что в этом случае в функцию должен передаваться адрес переменной, а не сама переменная.
Функции с переменным количеством параметров.
В языке программирования С допускается использование функций с переменным количеством параметров. В этом случае в конце списка параметров ставится многоточие (…). При этом предполагается, что в списке параметров присутствует хотя бы один параметр. Примерами функций с переменным количеством параметров являются стандартные функции scanf и printf. Например, можно определить функцию для сложения произвольного количества целых чисел следующим образом:
int add_num ( int n, …); // n — количество слагаемых
Для обработки функций с переменным количеством параметров используется переменная типа va_list и три макрокоманды
va_start ( va_list ap, last_arg); // инициализирует ap, где last_arg – имя последнего параметра
// в списке параметров функции перед многоточием
va_arg (va_list ap, type); // возвращает следующий аргумент типа type
va_end ( va_list ap); // обеспечивает правильную работу инструкции return в функции,
// которая использует эти макрокоманды
Эта переменная и макрокоманды определены в заголовочном файле .
Например, определенная ниже функция print распечатывает переменное количество целых чисел, которые передаются ей как параметры.
// проверяем, есть ли параметры
if (n Указатели на функции.
Имя функции является адресом этой функции в памяти. Язык программирования С позволяет определять указатели на функции. Например, следующая инструкция
int (*fp)(int x, int y);
объявляет переменную fp, которая является указателем на функцию. Причем эта функция должна иметь два параметра типа int и возвращать значение также типа int. В следующей программе функции сложения и вычитания двух чисел вызываются через указатель.
int add(int x, int y)
int sub(int x, int y)
// вызываем функцию через указатель
printf(«1 + 2 = %dn», (*p)(1, 2));
// можно вызвать функцию и так
printf(«1 — 2 = %dn», p(1, 2));
Так как указателю на функцию могут присваиваться адреса различных функций при условии совпадения типа параметров и типа возвращаемого значения, то указатели на функции часто называют функторами.
Вызов стандартных функций сортировки и поиска.
На практике при работе с данными часто встречаются задачи сортировки массива и поиска элементов в отсортированном массиве. Причем массивы могут иметь разные типы. Чтобы облегчить решение таких задач, в стандартной библиотеке языка программирования С есть специальные функции qsort и bsearch, которые предназначены для решения этих задач.
Функция qsort выполняют сортировку массива, элементы которого имеют произвольный тип. Эта функция имеет следующий прототип:
void qsort ( void *base, size_t nelem, size_t size, int (*cmp) (const void *e1, const void *e2));
который описан в заголовочном файле . Кратко опишем назначение параметров этой функции:
base адрес массива,
nelem количество элементов в массиве,
size длина элемента в массиве,
comp указатель на функцию сравнения, которая возвращает:
— отрицательное число, если элемент e1 меньше элемента e2,
— 0, если элемент e1 равен элементу e2,
— положительное число, если элемент e1 больше элемента e2.
Функция qsort реализует «быстрый алгоритм» сортировки массивов.
Функция bsearch выполняет бинарный поиск элемента в отсортированном массиве. Эта функция имеет следующий прототип:
void* bsearch (const void *key, const void *base,
size_t nelem, size_t size, int (*cmp) (const void *ck, const void *ce);
который также описан в заголовочном файле . Первый параметр key этой функции является указателем на элемент, который нужно найти. Остальные параметры повторяют параметры функции qsort. В случае успешного завершения поиска функция bsearch возвращает адрес найденного элемента, а в случае неудачи NULL.
В следующей программе показан пример использования функций qsort и bsearch для сортировки целочисленного массива и дальнейшего поиска элементов в этом отсортированном массиве.
// функция для сравнения элементов массива
int comp_int(const int* e1, const int* e2)
// ищем это число в отсортированном массиве
if(!(s = (int*) bsearch(There is no such an integer.n»);
printf(«The integer index = %d.n», s-a);
>
Модули. Структура модулей. Подключение модулей.
Понятие модульности
Модульность это свойство системы, которая была разложена на внутренне связных, но слабо связанные между собой модули.
В традиционном структурном проектировании модульность — это искусство раскладывать подпрограммы за кучками так, чтобы к одной кучке попадали подпрограммы, которые используют друг друга или что изменяются вместе. В объектно-ориентированном программировании ситуация несколько другая: необходимо физически разделить классы и объекты, которые составляют логическую структуру проекта.
На основе имеющегося опыта можно перечислить приемы и правила, что позволяют составлять модули из классов и объектов наиболее эффективным чином. Бритон и Парнас считают, что «конечной целью декомпозиции программы на модуле является снижение расходов на программирование за счет независимой разработки и тестирования.
Структура модуля должна быть достаточно простою для восприятия; реализация каждого модуля не должна зависеть от реализации других модулей; должны быть приняты меры для облегчения процесса внесения изменений там, где они наиболее вероятны». Прагматичные рассуждения ставят предел этим ведущим указаниям. На практике перекомпиляция тела модуля не является трудоемкой операцией: заново компилируется лишь данный модуль, и программа перекомпонуется. Перекомпиляция интерфейсной части модуля, напротив, более трудоемкая. В строго типизирующих языках придется перекомпилировать интерфейс и тело самого измененного модуля, потом все модули, связанные из данным, модули, связанные с ними, и так далее за цепочкой.
В итоге, для очень больших программ могут понадобиться много часов на перекомпиляцию (если только среда разработки не поддерживает фрагментарную компиляцию), что явно нежелательно. Поэтому стоит стремиться к тому, чтобы интерфейсная часть модулей была возможно уже (в пределах обеспечения необходимых связей). Наш стиль программирования требует спрятать все, что только возможно, в реализации модуля. Постепенный перенос описаний из реализации в интерфейсную часть намного менее опасный, чем «вычистка» избыточного интерфейсного кода.
Таким образом, программист должен находить баланс между двумя противоположными тенденциями: стремлениям спрятать информацию и необходимостью обеспечения видимости тех или других абстракций в нескольких модулях. Парнас, Клеменс и Вейс, предложили следующее правило: «Особенности системы, которые подлежат изменениям, стоит скрывать в отдельных модулях; в качестве межмодульных можно использовать лишь те элементы, вероятность изменения которых имела. Все структуры данных должны быть обособлены в модуле; доступ к ним будет возможен для всех процедур этого модуля и закрыт для всех других. Доступ к данным из модуля должен осуществляться лишь через процедуры данного модуля». Иначе говоря, стоит стремиться построить модули так, чтобы объединить логично связаны абстракции и минимизировать взаимные связки между модулями.
В разных языках программирования модульность поддерживается по-разному. Например, в С++ модулями являются файлы, которые компилируются отдельно. Для С/с++ традиционным является размещение интерфейсной части модулей в отдельные файлы с расширением .п (так называемые файлы-заглавия).
Реализация, то есть текст модуля, сохраняется в файлах с расширением .с (в программах на С++ часто используются расширения .ее, .ср и .срр). Связь между файлами объявляется директивой макропроцессору #include. Такой подход строится исключительно на соглашении и не является строгим требованием самого языка. В языке Object Pascal принцип модульности формализированный немного строже.
В этом языке определен особенный синтаксис для интерфейсной части и реализации модуля (unit). Язык Ada идет еще на шаг дальше: модуль (что называется package) также имеет две части — спецификацию и тело. Но, в отличие от Object Pascal, допускается раздельное определение связей с модулями для спецификации и тела пакета.
Таким образом, допускается, чтобы тело модуля мало связки с модулями, невидимыми для его спецификации. Со временем при в проектировании программ акцент сместился с организации процедур на организацию структур данных. Помимо всего прочего это вызвано и ростом размеров программ. Модулем обычно называют совокупность связанных процедур и тех данных, которыми они управляют.
Парадигма программирования приобрела вид:
Определите, какие модули нужны; поделите программу так, чтобы данные были скрыты в этих модулях
Эта парадигма известна также как «принцип сокрытия данных». Если в языке нет возможности сгруппировать связанные процедуры вместе с данными, то он плохо поддерживает модульный стиль программирования. Теперь метод написания «хороших» процедур применяется для отдельных процедур модуля.
Поскольку данные есть единственная вещь, которую хотят скрывать, понятие упрятывания данных тривиально расширяется до понятия упрятывания информации, т.е. имен переменных, констант, функций и типов, которые тоже могут быть локальными в модуле. Хотя С++ и не предназначался специально для поддержки модульного программирования, классы поддерживают концепцию модульности). Помимо этого С++, естественно, имеет уже продемонстрированные возможности модульности, которые есть в С, т.е. представление модуля как отдельной единицы трансляции.
Пример модуля. Способ использования модуля.
Массивы в языке С++. Связь указателей и массивов в С++.
При использовании простых переменных каждой области памяти для хранения данных соответствует свое имя. Если с группой величин одинакового типа требуется выполнять однообразные действия, им дают одно имя, а различают по порядковому номеру. Это позволяет компактно записывать множество операций с помощью циклов. Конечная именованная последовательность однотипных величин называется массивом. Описание массива в программе отличается от описания простой переменной наличием после имени квадратных скобок, в которых задается количество элементов массива (размерность):
float а [10]; // описание массива из 10 вещественных чисел
Элементы массива нумеруются с нуля. При описании массива используются те же модификаторы (класс памяти, const и инициализатор), что и для простых переменных. Инициализирующие значения для массивов записываются в фигурных скобках. Значения элементам присваиваются по порядку. Если элементов в массиве больше, чем инициализаторов, элементы, для которых значения не указаны, обнуляются:
int b[5] = ; / / b[0]=3, b[l]=2, b[2]=l, b[3]=0, b[4]=0
Размерность массива вместе с типом его элементов определяет объем памяти, необходимый для размещения массива, которое выполняется на этапе компиляции, поэтому размерность может быть задана только целой положительной константой или константным выражением. Если при описании массива не указана размерность, должен присутствовать инициализатор, в этом случае компилятор выделит память по количеству инициализирующих значений. В дальнейшем мы увидим, что размерность может быть опущена также в списке формальных параметров.
При описании массивов квадратные скобки являются элементом синтаксиса, а не указанием на необязательность конструкции.
Для доступа к элементу массива после его имени указывается номер элемента (индекс) в квадратных скобках. В следующем примере подсчитывается сумма элементов массива.
const int n = 10;
for (i = 0, sum = 0; i ;
const int n = 20; // количество элементов массива
int b[n]; // описание массива
for (i = 0; i> b[i]; // ввод массива
for (i = 0; i *pa++; // или pb[1] = pa[1];
Модульное программирование — это организация программы как совокупности небольших независимых блоков, называемых модулями.
Модуль — функционально законченный фрагмент программы, оформленный в виде отдельного файла с исходным кодом. Модули проектируются таким образом, чтобы предоставлять программистам удобную для многократного использования функциональность (интерфейс) в виде набора функций, классов, констант. Модули могут объединяться в пакеты и, далее, в библиотеки. Удобство использования модульной архитектуры заключается в возможности обновления (замены) модуля, без необходимости изменения остальной системы.
Использование модульного программирования позволяет упростить тестирование программы и обнаружение ошибок. Модульность часто является средством упрощения задачи проектирования программы и распределения процесса разработки между группами разработчиков. При разбиении программы на модули для каждого модуля указывается реализуемая им функциональность, а также связи с другими модулями.
Выделение функций в модуль
Модуль в языке Си состоит из интерфейса (заголовочого файла .h) и реализации (файла .c).
Код, подключающий модуль, на этапе компиляции нуждается только в интерфейсе модуля, поэтому на этапе препроцессинга заголовочный файл копируется в код директивой
#include «somelib.h»
Реализация модуля должна полностью реализовывать указанный интерфейс, поэтому она также включает свой заголовочный файл.
Итого, пример проекта из основного файла и одного модуля, может выглядеть так:
#include «hello.h»
hello_world();
return EXIT_SUCCESS;
#ifndef HELLO_H
#define HELLO_H
void hello_world();
#endif //HELLO_H
#include «hello.h»
void hello_world()
printf(«Hello, World!n»);
В данном примере в файле main.c не понадобилось подключать stdio.h, хотя он и используется в модуле hello.c. Причина этого в том, что никакие типы из stdio.h не нужны для корректной обработки интерфейса hello.h, оказывающегося в main.c на этапе компиляции.
Источник: topuch.com
Презентация Разработка структуры программы. Модульное программирование
Вы можете ознакомиться и скачать презентацию на тему Разработка структуры программы. Модульное программирование. Доклад-сообщение содержит 30 слайдов. Презентации для любого класса можно скачать бесплатно. Если материал и наш сайт презентаций Mypresentation Вам понравились – поделитесь им с друзьями с помощью социальных кнопок и добавьте в закладки в своем браузере.
Слайды и текст этой презентации
Слайд 1
Описание слайда:
Разработка структуры программы. Модульное программирование. Отвагин Алексей Владимирович, доцент каф. ЭВМ, к.т.н., а. 505-5
Слайд 2
Описание слайда:
Содержание Понятие модульного программирования Основные характеристики модуля Методы разработки структуры программы Контроль структуры
Слайд 3
Описание слайда:
Цель модульного программирования Упрощение структуры ПС Отображение архитектуры ПС Повышение качества разработки Сокращение пространства поиска ошибок
Слайд 4
Описание слайда:
Понятие модульного программирования Модуль – любой фрагмент описания процесса, оформляемый как самостоятельный программный продукт Модуль может входить во многие процессы, если он должным образом документирован Модульное программирование – разработка ПС в виде совокупности модулей
Слайд 5
Описание слайда:
Процессы модульного программирования Разделение – выделение отдельных модулей на основе их характеристик (отношения между элементами, интенсивности взаимодействия и т.д.) Программирование – разработка модулей индивидуальными программистами или группами (проходит параллельно) Интеграция – проверка взаимодействия модулей в реальной среде
Источник: mypresentation.ru