Определяет использование отступов, пропусков строк и комментариев. Обычно пропуски строк и комментариев используют для визуального разделения частей модуля. Для языков Pascal, C++, Java использование отступов позволяет прояснить структуру программы. Обычно дополнительный отступ обозначает вложение операторов языка. Сложнее обстоит дело с комментариями.
Не нужно переводить с английского языка каждый оператор программы. Комментировать следует цели выполнения действий и группы операторов, связанные общим действием, то есть комментарий должен содержать дополнительную неочевидную информацию. Для языков низкого уровня стиль, облегчающий понимание, предложить труднее. Здесь целесообразно комментировать и блоки операторов, и каждый оператор. Например, цикл суммирования элементов массива.
Этап постановки задачи. Классификация программных продуктов по функциональному признаку.
По назначению программные продукты делятся на 3 группы:
1)системные; 2) прикладные; 3)гибридные
БРЕНДБУК ЗА 5 МИНУТ | ASUS STUDIO
К системным относятся:
1)операционные системы; 2)оболочки; 3) утилиты
Прикладные ориентированы на решение конкретных пользовательских задач. Различают пользователей:
1)разработчиков программ; 2) не программисты
Для разработчиков программ:
1)case-средства; 2) системы программирования; 3) среды разработки; 4) отладочные средства
Для не программистов:
1)программы общего назначения; 2) профессиональные; 3) системы автоматизации производственных процессов; 4) обучающие, развлекающие.
1)автоматизированные системы управления; 2) системы реального времени
Этап постановки задачи. Основные эксплуатационные требования к программным продуктам.
Эксплуатационные требования определяют некоторые характеристики разрабатываемого ПО, проявляемые в процессе его функционирования.
1)правильность – функционирование в соответствии с ТЗ.
2)универсальность – обеспечение правильной работы при любых допустимых данных и защита от неправильных данных.
3)надежность (помехозащищенность) – обеспечение полной повторяемости результатов, т.е. их правильности при наличии различных сбоев.
4)проверяемость – возможность проверки получаемых результатов.
5)точность результатов – обеспечение заданной погрешности.
6)защищенность – обеспечение конфиденциальности информации.
7)программная совместимость.
8)аппаратная совместимость.
9)эффективность – использование минимально возможного количества ресурсов технических средств.
10) адаптируемость.
11)повторная входимость
12)возможность параллельного использования несколькими процессами
Сложность программных систем не позволяет сразу сформулировать четкие требования к ним. Обычно для перехода от идеи создания ПО к четкой формулировке требований (ТЗ) выполняют предпроектные исследования в области разработки.
Этап постановки задачи. Предпроектные исследования предметной области.
Их цель — преобразование общих нечетких знаний о предназначении ПО, сравнительно точные требования к нему.
ФИРМЕННЫЙ СТИЛЬ. ЭТАПЫ СОЗДАНИЯ. СКАЧАЙ ПРИМЕР ХОРОШЕГО ТЕХНИЧЕСКОГО ЗАДАНИЯ .
Существует два вида неопределенности:
1) неизвестны методы решения формулируемой задачи (при решении научно-технических задач)
2) неизвестна структура автоматизируемых информационных процессов (при построении АСУ)
В первом случае во время проектных исследований определяют возможность решения поставленной задачи и методы, позволяющие получить требуемый результат. Для этого могут понадобиться соответствующие научные исследования фундаментального и прикладного характера, разработка и исследование новых моделей объектов реального мира.
Во втором случае определяют:
1) структуры и взаимосвязи автоматизируемых информационных процессов
2) распределение функций между человеком и системой, между аппаратурой и программным обеспечением
3) функции ПО, внешние условия его функционирования, особенности интерфейса (с пользователями и при необходимости с аппаратной частью)
4) требования к программным и информационным компонентам, необходимые аппаратные ресурсы, требования к базам данных и физические характеристики программных компонентов.
Результаты предпроектных исследований предметной области используются в процессе разработки ТЗ.
Дата добавления: 2018-05-13 ; просмотров: 460 ; Мы поможем в написании вашей работы!
Поделиться с друзьями:
Источник: studopedia.net
Что включает в себя стиль оформления программы
Следование этому стилю оформления программ обязательно для всех сдаваемых программ.
1. Набор символов
1.1. В тексте программы запрещено использование любых управляющих символов, кроме символов «Перевода строки» LF (код 10) и «Возврата каретки» CR (код 13). К управляющим относятся символы с кодами от 0 до 31 и символ с кодом 127.
1.2. Этот запрет включает в себя запрет на использование символа табуляции (код 9). Все отступы в программе должны быть сделаны только с использованием символа пробела.
2. Отступы и ширина текста
2.1. Размер отступа — 4 символа. Прочие отступы не допускаются (кроме исключения в п. 2.3 и 4.5.3).
2.2. Ширина текста программы (то есть количество символов в одной строке кода) не должна превышать 100 символов.
2.3. В случаях, когда длинная конструкция программы размещается на нескольких строках, так как не помещается в одну, для продолжения длинной строки на следующих строках используется отступ 8 символов относительно отступа первой части длинной строки. Например:
if (a > b c
3. Имена
3.1. Имена глобальных переменных и функций должны быть осмысленными и отражать назначение. Слишком длинные имена, однако, не рекомендуются. В именах допускаются сокращения, которые не затрудняют понимание имени и назначения функций и переменных.
3.2. В именах должны использоваться только английские слова. Транслитерации русских слов не допускаются.
Например, имя функции f является недопустимым. Имена функций calculate_square_root и calc_sqrt допустимы, но последнее предпочтительнее, так как короче и использует общепринятые сокращения. Имя функции vychislenie_kornya недопустимо, так как использует русские слова.
3.3. Имена констант записываются полностью заглавными буквами. Если имя константы состоит из нескольких слов, для их разделения используются подчеркивания. Например, RED, POLL_INTERVAL.
3.4. Имена переменных, функций и меток записываются полностью строчными буквами. Если имя состоит из нескольких слов, для их разделения используются символы подчеркивания. Например, buf (допустимое сокращение от слова buffer), create_tree. В случаях, оговоренных преподавателями, допускаются отступления от правила именования функций.
3.5. В именах не допускается использование каких-либо префиксов или суффиксов, отражающих тип объекта (т. н. венгерская нотация), например, a_crszkvc30LastNameCol.
3.6. Имена типов и тегов начинаются с заглавной буквы. Каждое новое слово в имени начинается с заглавной буквы. Например, Node, BinaryOperation.
3.7. Имена не должны вызывать визуальные затруднения при прочтении. Например, переменная с именем l или константа с именем I недопустимы, так как могут быть спутаны с числом 1. То же правило применимо к константе O.
4. Стиль отступов
4.1. Структурные типы
Определения структурных типов оформляются следующим образом:
struct StructureType < int field1; int field2; char *field3; >;
или следующим образом:
typedef struct Node < struct Node *next; double data; >Node;
Каждое определение поля структуры записывается на отдельной строке. Не допускается объединять определение переменной и структуры, например, следующая запись недопустима:
struct Foo < int fudge; >foos[10];
(C++) Определения классов записываются следующим образом:
class Complex < double re, im; public: Complex(double re_, double im_) : re(re_), im(im_) <>>;
Не допускается именование полей классов ни с префиксом m, ни с суффиксом _, таким образом неправильно:
class Complex1 < double re_, im_; >; class Complex2 < double m_re, m_im; >;
4.2. Перечислимые типы
Определения перечислимых типов оформляются следующим образом:
enum Colours < RED, GREEN >;
или следующим образом:
typedef enum Colours < RED, GREEN >Colours;
Допускается использование анонимных перечислений:
enum < READY_BIT = 0x1, ERROR_BIT = 0x2 >;
Если определяется единственная константа, допускается запись анонимного перечисление в одной строке:
enum < BUFFER_SIZE = 1024 >;
4.3. Указатели
При объявлении переменных указательного типа знак * относится к имени переменной, а не к имени типа. Пробел между * и именем переменной не ставится.
int *p; char *str, **pstr;
int* p; int* q, r; char * * * s;
4.4. Инициализация
4.4.1.
Инициализация составных типов оформляется так, чтобы была понятна структура инициализационных данных. Например:
int matrix[3][2] = < < 4, 5 >, < 10, 2 >, < 1, 1 >>;
Не допускается пропускать фигурные скобки вложенного инициализатора, даже если они и не обязательны. Например,
int matrix[3][2] = < 4, 5, 10, 2, 1, 1 >;
4.4.2. Инициализация простых и указательных типов записывается на той же строке, что и определение, например:
double summ = 0.0;
4.4.3. Инициализация символьных строк записывается, как правило, на той же строке, что и определение переменной.
char errmsg[] = «No error»;
Если строка достаточно длинная, допускается разбивать инициализацию на несколько строк текста.
char *helpmsg = «hello: my first programn» » usage: hello worldn»;
4.4.4. Для инициализации локальных структур нулями используйте функцию memset.
Даже если некоторые поля структуры инициализируются ненулевыми значениями, предварительно вся структура должна быть обнулена.
4.4.5. Если локальная переменная инициализируется сложным выражением (то есть не константой), каждое такое определение переменной должно записываться на отдельной строке.
int var1 = some_func(params), var2 = some_other_func(params);
int var1 = some_func(params); int var2 = some_other_func(params);
4.5. Функции
4.5.1. Определение функции записывается следующим образом:
char * copy_str(const char *instr)
То есть тип возвращаемого значения, квалификаторы типа и классы памяти записываются на отдельной строке. Имя функции начинается с первой позиции, между именем функции и открывающей скобкой пробелы не ставятся. Открывающая и закрывающая фигурные скобки блока функции располагаются каждая на отдельной строке на первой позиции.
4.5.2. Если функция не принимает параметров, в списке параметров обязательно указание ключевого слова void.
int random(void)
4.5.3. Если у функции становится много параметров, определение функции записывается так, чтобы каждый параметр располагался на отдельной строке с отступом 8 символов. Открывающая фигурная скобка тела функции должна размещаться на отдельной строке. (Много параметров — это когда длина строки, содержащей имя функции, начинает превышать 70 символов.)
static void callback_handler( int param1, int param2)
4.6. Операторы
4.6.1. Оператор if без else записывается следующим образом.
if (test)
if и открывающая скобка, а также закрывающая скобка и открывающая фигурная скобка отделяются одним пробелом. Закрывающая фигурная скобка находится на отдельной строке.
4.6.2. Оператор if с else записывается следующим образом.
if (test) < statements. >else
4.6.3. Цепочка операторов if, else if, else записывается следующим образом.
if (test1) < statements. >else if (test2) < statements. >else
4.6.4. Оператор while записывается следующим образом:
while (test)
4.6.6. Оператор do while записывается следующим образом:
do < statements. >while (test);
4.6.7. Оператор for записывается следующим образом:
for (init; test; update)
4.6.8. Оператор switch записывается следующим образом:
switch (expr)
4.6.9. В операторах if, while, do-while, for тело цикла заключается в фигурные скобки (составной оператор), даже если тело — единственный оператор.
4.6.10. Операторы вычисления выражения размещаются каждый на отдельной строке. Пример:
a = b; b = c;
4.6.11. Метки записываются с первой позиции вне зависимости от текущего отступа блока. Каждая метка записывается на отдельной строке.
void func(void) < for (. ) < for (. ) < >exit1:; > >
4.6.12. Использование оператора goto настоятельно не рекомендуется. Допускается использование оператора goto при обработке ошибок и при выходе из вложенных циклов. Допускаются только переходы вперед по тексту программы.
4.6.13. (C++) Оператор try-catch записывается следующим образом:
try < >catch (ex1 e1) < >catch (ex2 e2)
Типы обрабатываемых исключений должны быть упорядочены от более специализированных к более общим. Объекты исключений пользовательских типов должны передаваться по константной ссылке.
4.7. Операции
4.7.1. Бинарные операции +, * и пр. отделяются пробелами от аргументов, например,
a + b, a != 0, d >= a
4.7.2. Операции доступа к полю . и -> бинарной операцией не считаются, поэтому пробелами не окружаются. Скобки [, ] пробелами не окружаются. Примеры:
var.field, var->field, var->do_method(), arr[i][j]
4.7.3. После запятой во всех случаях и после точки с запятой в заголовке цикла for ставится один символ пробела.
int a, b, c = 0; printf(«%dn», n); for (i = 0; i < 10; ++i)
4.7.4. Между унарной операцией и операндом пробел не ставится. Примеры:
b = *a; i++; *p++ = 0;
4.7.5. Между именем функции и открывающей скобкой пробелы не ставятся.
printf(«%dn», value); while ((c = getchar()) != EOF);
4.7.6. После открывающей скобки и перед закрывающей скобкой пробел не ставится.
4.7.7. После закрывающей скобки операции приведения типов ставится один пробел.
(unsigned char *) str
4.7.8. Конструкции *(a + i), (*p).f запрещены. Используйте a[i] и p->f соответственно.
4.7.9. В выражении не должны присутствовать заведомо лишние скобки.
if ((a > 0) (!(b)))
if (a > 0 !b)
5. Использование элементов языка и библиотек
- Константы 0 и 1 без ограничений.
- Константа 2, когда она обозначает файловый дескриптор потока ошибок.
- Константа -1 как специальное значение, сигнализирующее об ошибке.
Следующий фрагмент недопустим, так используется константа 10.
for (i = 0; i
5.2. Для определения констант целых типов не разрешается использовать ни директиву #define, ни квалификатор const. Все целые константы должны определяться с помощью ключевого слова enum и иметь осмысленные имена.
#define BUFSIZE 1024 // использование #define const int BOARD_WIDTH = 8; // использование const enum < TEN = 10 >; // бессмысленное имя
5.3. Стандартные заголовочные файлы должны подключаться с помощью директивы
#include
Пользовательские заголовочные файлы должны подключаться с помощью директивы
#include «FILE»
#include «stdio.h» // стандартный заголовочный файл #include // пользовательский заголовочный файл
5.4. Все сообщения об ошибках, предупреждения, отладочные сообщения и прочая диагностическая информация, не являющаяся результатом работы программы в предположении корректных входных данных, должна выводиться на стандартный поток ошибок stderr.
5.5. Каждое диагностическое сообщение должно заканчиваться символом перехода на новую строку.
5.6. При выводе результата работы на стандартный поток вывода или в текстовый файл вывод должен заканчиваться символом перехода на новую строку. Исключением являются программы, выполняющие посимвольную обработку потока данных.
int main(void)
int main(void)
5.7. Работа функции main должна заканчиваться выполнением оператора return с соответствующим кодом завершения. Код завершения — это число в диапазоне [0, 128).
5.8. Использование функций, не проверяющих переполнение буфера, запрещено. К таким функциям относятся: gets, sprintf, strcpy, strcat. Использование спецификатора %s функций scanf и fscanf без указания максимального количества вводимых символов запрещено. Использование функций strncpy, strncat запрещено.
5.9. Использование функции malloc не рекомендуется. Допускается использовать malloc при реализации расширяемых массивов, если предполагается выполнять realloc. Во всех остальных случаях используйте функцию calloc. Запрещается использовать malloc при выделении памяти под элементы списков, деревьев и прочих подобных структур.
5.10. Запрещается использовать конструкцию sizeof(TYPE), если ее можно заменить конструкцией sizeof(VALUE).
struct List *p = calloc(1, sizeof(struct List));
struct List *p = calloc(1, sizeof(*p));
5.11. Даже при операциях с массивами элементов типа char необходимо вычислять размер с помощью умножения количества элементов на размер одного элемента.
s = realloc(s, sz);
s = realloc(s, sz * sizeof(s[0]));
5.12. В программе не должны присутствовать закомментированные строки кода, которые использовались для отладки.
5.13. Вспомогательные функции общего назначения (такие, как getline, функции работы со списками и т. д.) не должны ничего выводить на stdout или stderr. В случае возникновения ошибки такие функции должны, как правило, возвращать специальное значение.
5.14. Глобальные переменные должны использоваться только при необходимости. Передача параметров предпочтительнее использования глобальных переменных.
5.15. Локальные массивы константного и небольшого (до 64кб) размера должны создаваться на стеке, а не в динамической памяти.
5.16. Запрещается использовать локальные массивы переменного размера.
scanf(«%d», double arr[size];
5.17. Переменные, которые хранят дескрипторы ресурсов (файловые дескрипторы, дескрипторы потоков FILE *, указатели в динамическую память и пр.) должны определяться в начале функции и инициализироваться либо корректным значением дескриптора ресурса, либо специальным значением, обозначающим, что ресурс не выделен. Все ресурсы должны освобождаться когда становятся ненужными.
void func(void)
void func(void)
5.18. (только для C) Запрещается использовать явное приведение типа результата, возвращаемого функциями malloc, calloc, realloc.
double *ptr = (double*) calloc(init_size, sizeof(*ptr));
double *ptr = calloc(init_size, sizeof(*ptr));
6. Многомодульные программы
6.1. Каждая независимо компилируемая единица программы (модуль) должна состоять из двух файлов: файла с суффиксом .h (заголовочного файла), содержащего определения типов данных, констант и прототипов функций, и файла с суффиксом .c (файла реализации), содержащего тела функций.
Головной модуль (исходный файл, содержащий функцию main) может не иметь соответствующего .h файла.
6.2. Заголовочный файл должен быть защищен от повторного включения. Например, если файл называется module.h, то защита от повторного включения может реализовываться следующим образом:
#ifndef MODULE_H_INCLUDED #define MODULE_H_INCLUDED // текст файла #endif
6.3. Заголовочный файл модуля должен обязательно включаться в файл реализации этого модуля. Другими словами, в файле module.c должна быть обязательно директива
#include «module.h»
6.4. Заголовочный файл модуля должен обязательно включаться во все файлы, которые используют сущности, определенные в этом заголовочном файле.
6.5. Заголовочный файл должен содержать минимальное количество директив #include — только те, в которых определяются сущности, используемые в этом заголовочном файле. Если сущности используются в соответствующем файле реализации, но не в данном заголовочном файле, то и включаться требуемый заголовочный файл должен в файле реализации.
6.6. Для сборки проекта в каталоге проекта должен присутствовать Makefile, содержащий правила all для сборки всего проекта и clean для очистки всех файлов, возникающих при компиляции (объектных и исполняемых файлов).
Источник: ejudge.ru
2.5. Стиль оформления программы
С точки зрения технологичности хорошим считают стиль оформления программы, облегчающий ее восприятие как самим автором, так и другими программистами, которым, возможно, придется ее проверять или модифицировать. «Помните, программы читаются людьми», призывал Д. Ван Тассел, автор одной из известных монографий, посвященной проблемам программирования [60]. Именно исходя из того, что любую программу неоднократно придется просматривать, следует придерживаться хорошего стиля написания программ.
Стиль оформления программы включает: • правила именования объектов программы (переменных, функций, типов, данных и т. п.); • правила оформления модулей; • стиль оформления текстов модулей. Правила именования объектов программы. При выборе имен программных объектов следует придерживаться следующих правил: • имя объекта должно соответствовать его содержанию, например: MaxItem — максимальный элемент; NextItem — следующий элемент; • если позволяет язык программирования, можно использовать символ «_» для визуального разделения имен, состоящих из нескольких слов, например: Max_Item, Next_Itetm; необходимо избегать близких по написанию имен, например: Index и InDec. Правила оформления модулей. Каждый модуль должен предваряться заголовком, который, как минимум, содержит: • название модуля; • краткое описание его назначения; • краткое описание входных и выходных параметров с указанием единиц измерения; • список используемых (вызываемых) модулей; • краткое описание алгоритма (метода) и/или ограничений; • ФИО автора программы; • идентифицирующую информацию (номер версии и/или дату последней корректировки). Например:
Стиль оформления текстов модулей. Стиль оформления текстов модулей определяет использование отступов, пропусков строк и комментариев, облегчающих понимание программы. Как правило, пропуски строк и комментарии используют для визуального разделения частей модуля, например: <проверка количества отрезков и выход, если отрезки не заданы>ifn S: = 0; for i: = 0 to n-l do S: = S + Len [i]; Для таких языков, как Pascal, C++ и Java, использование отступов позволяет прояснить структуру программы: обычно дополнительный отступ обозначает вложение операторов языка, например: аmах: = а[1,1]; for i: = l to n do for j: = l to т do ifa[i,j]>amax then amax: = a [i,j]; Несколько сложнее дело обстоит с комментариями. Опыт показывает, что переводить с английского языка каждый оператор программы не нужно: любой программист, знающий язык программирования, на котором написана программа, без труда прочитает тот или иной оператор. Комментировать следует цели выполнения тех или иных действий, а также группы операторов, связанные общим действием, т. е. комментарии должны содержать некоторую дополнительную (неочевидную) информацию, например: <проверка условия и выход, если условие не выполняется>ifn
; тело цикла
| cycle: | add | AX, a [BX] | ; добавляем элемент |
| add | BX, 2 | ; определяем адрес следующего | |
| loop | cycle | ; цикл на n повторений |
; выход из цикла при обнулении счетчика
2.6. Эффективность и технологичность
Традиционно эффективными считают программы, требующие минимального времени выполнения и/или минимального объема оперативной памяти. Особые требования к эффективности программного обеспечения предъявляют при наличии ограничений (на время реакции системы, на объем оперативной памяти и т. п.).
В случаях, когда обеспечение эффективности не требует серьезных временных и трудовых затрат, а также не приводит к существенному ухудшению технологических свойств, необходимо это требование иметь в виду. Разумный подход к обеспечению эффективности разрабатываемого программного обеспечения состоит в том, чтобы в первую очередь оптимизировать те фрагменты программы, которые существенно влияют на характеристики эффективности.
Для уменьшения времени выполнения некоторой программы в первую очередь следует проанализировать циклические фрагменты с большим количеством повторений: экономия времени выполнения одной итерации цикла будет умножена на количество итераций. Не следует забывать и о том, что многие способы снижения временных затрат приводят к увеличению емкостных и, наоборот, уменьшение объема памяти может потребовать дополнительного времени на обработку.
И тем более не следует «платить» за увеличение эффективности снижением технологичности разрабатываемого программного обеспечения. Исключения возможны лишь при очень жестких требованиях и наличии соответствующего контроля за качеством. Частично проблему эффективности программ решают за программиста компиляторы.
Средства оптимизации, используемые компиляторами, делят на две группы: • машинно-зависимые , т. е. ориентированные на конкретный машинный язык, выполняют оптимизацию кодов на уровне машинных команд, например, исключение лишних пересылок, использование более эффективных команд и т. п.; • машинно-независимые выполняют оптимизацию на уровне входного языка, например, вынесение вычислений константных (независящих от индекса цикла) выражений из циклов и т. п. Естественно, нельзя вмешаться в работу компилятора, но существует много возможностей оптимизации программы на уровне команд. Способы экономии памяти.
Принятие мер по экономии памяти предполагает, что в каких-то случаях эта память неэкономно использовалась. Учитывая, что анализировать имеет смысл только операции размещения данных, существенно влияющие на характеристику эффективности, следует обращать особое внимание на выделение памяти под данные структурных типов (массивов, записей, объектов и т. п.).
Прежде всего при наличии ограничений на использование памяти следует выбирать алгоритмы обработки, не требующие дублирования исходных данных структурных типов в процессе обработки. Примером могут служить алгоритмы сортировки массивов, выполняющие операцию в заданном массиве, например, хорошо известная сортировка методом «пузырька».
Если в программе необходимы большие массивы, используемые ограниченное время, то их можно размещать в динамической памяти и удалять при завершении обработки. Также следует помнить, что при передаче структурных данных в подпрограмму «по значению» копии этих данных размещаются в стеке.
Избежать копирования иногда удается, если передавать данные «по ссылке», но как неизменяемые (описанные const). В последнем случае в стеке размещается только адрес данных, например: Type Mas.4iv = array [I.. 100] of real; function Summa (Const a:Massiv; . ). Способы уменьшения времени выполнения. Как уже упоминалось выше, для уменьшения времени выполнения в первую очередь необходимо анализировать циклические участки программы с большим количеством повторений. При их написании необходимо по возможности: • выносить вычисление константных, т. е. не зависящих от параметров цикла, выражений из
циклов; • избегать «длинных» операций умножения и деления, заменяя их сложением, вычитанием и сдвигами; • минимизировать преобразования типов в выражениях; • оптимизировать запись условных выражений — исключать лишние проверки; • исключать многократные обращения к элементам массивов по индексам (особенно многомерных, так как при вычислении адреса элемента используются операции умножения на значение индексов) — первый раз прочитав из памяти элемент массива, следует запомнить его в скалярной переменной и использовать в нужных местах; • избегать использования различных типов в выражении и т. п. Рассмотрим следующие примеры. Пример 2.2. Пусть имеется цикл следующей структуры (Pascal): for y: = 0 to 99 do for x: = 0 to 99 do a [320*x+y]: = S [k,l]; В этом цикле операции умножения и обращения к элементу S[k] выполняются 10000 раз. Оптимизируем цикл, используя, что 320 = 2 8 + 2 6 :
| skl: =S [k,l]; | |
| for x: = 0 to 99 do | (меняем циклы местами> |
| begin |
i:= x shl 8 + x shl 6; for y; = 0 to 99 do a [i+y]: =skl; end; . В результате вместо 10000 операций умножения будут выполняться 200 операций сдвига, а их время приблизительно сравнимо со временем выполнения операции сложения. Обращение к элементу массива S[k] будет выполнено один раз. Пример 2.3.
Пусть имеется цикл, в теле которого реализовано сложное условие: for k: = 2 to n do begin ifx[k] > yk then S: = S+y[k]-x [k]; if (x [k]< = yk) and (y[k]yk then S:=S+y[k]-x[k] else ify[k]
Источник: studfile.net