Методические указания к лабораторным работамe.lib.vlsu.ru/bitstream/123456789/2779/1/00284.pdfПОДГОТОВКА К ЛАБОРАТОРНЫМ

Министерство образования и науки Российской Федерации

Федеральное государственное бюджетное образовательное учреждение высшего профессионального образования

«Владимирский государственный университет имени Александра Григорьевича и Николая Григорьевича Столетовых»

Кафедра вычислительной техники

С + +

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

Составители И. А. КОЛОМИЕЦ

С. С. ГЛАДЬО

Владимир 2012

1

УДК 621.396 ББК 32.988-5я7 С11

Рецензент Кандидат технических наук,

доцент кафедры радиотехники и радиосистем Владимирского государственного университета

имени Александра Григорьевича и Николая Григорьевича Столетовых В.А. Ефимов

Печатается по решению редакционно-издательского совета ВлГУ

С + + : метод. указания к лаборатор. работам / Владим. гос. ун-т имени Александра Григорьевича и Николая Григорьевича Столето-вых ; сост. : И. А. Коломиец, С. С. Гладьо. – Владимир : Изд-во ВлГУ, 2012. – 39 с.

Рассмотрены вопросы решения практических задач на ЭВМ, создания про-грамм на языке высокого уровня С++ для вычислительных процессов различных струк-тур, для задач обработки различных типов данных. Особое внимание уделено струк-турному подходу, модульности. Раскрыты приемы программирования, приведены при-меры выполнения каждого задания, требования к содержанию отчета и таблица номе-ров задач для каждой работы по указанному в списке литературы задачнику.

Предназначены для студентов 1-го курса направления 230100 – информатика и вычислительная техника всех форм обучения, но могут быть полезны для всех, начи-нающих изучать язык С++.

Рекомендованы для формирования профессиональных компетенций в соответ-ствии с ФГОС 3-го поколения.

Библиогр.: 8 назв.

УДК 621.396 ББК 32.988-5я7

С11

2

ВВЕДЕНИЕ

Лабораторные работы посвящены изучению основ алгоритмизации

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

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

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

СОДЕРЖАНИЕ ОТЧЕТОВ

Каждая лабораторная работа включает в себя оформление соответ-

ствующей документации. В документации обязательно должны быть пред-ставлены следующие пункты:

1) текст индивидуального задания по варианту;

3

2) схема алгоритма решения задачи; 3) спецификации всех разработанных процедур и/или функций; 4) текст программы решения задачи на языке высокого уровня С++; 5) тесты и результаты тестирования. Тесты должны включать вход-

ные и выходные данные и содержать все возможные варианты входных данных. Тесты должны покрывать все ветви алгоритма;

6) выводы по работе. Все представленные пункты должны быть отражены в отчете по

каждой лабораторной работе.

ВАРИАНТЫ ИНДИВИДУАЛЬНЫХ ЗАДАНИЙ

Индивидуальным заданием к каждой лабораторной работе является соответствующая задача из задачника [5], номер которой определяется по таблице (прил. 1). Столбцы таблицы соответствуют номерам лабораторных работ, а строки - вариантам. Если преподавателем не оговорено другое, то номер варианта есть номер студента в списке группы.

Особое внимание следует обратить на требования к алгоритму, ко-торые представлены в порядке выполнения к каждой работе. Известно, что одну задачу можно решить разными способами, использовать разные приемы и структуры. Начинающему изучать основы алгоритмизации за-частую сложно рационально оценивать применяемые структуры алгорит-мов. Настоящие методические указания как раз направлены на формиро-вание этих знаний и умений. Для того чтобы студенты в полной мере по-лучили те навыки и знания, на которые направлена та или иная лаборатор-ная работа, они должны очень точно выполнить указанные требования по использованию операторов, структур блоков, приемов и подходов. Невы-полнение этих требований повлечет за собой возврат работы на доработку. Такой подход прививает дисциплинированность и учит грамотно анализи-ровать полученное задание.

Творческий подход к выполнению задания заключается в выборе методов решения задач, структурировании алгоритмов и объединении структурных блоков в единый проект, комментировании текста программ.

4

ПОДГОТОВКА К ЛАБОРАТОРНЫМ РАБОТАМ

Для выполнения лабораторных работ потребуется среда разработки,

поддерживающая язык С++. В данных методических указаниях будем ориен-тироваться на Microsoft Visual Studio, версии не ниже 8.0.

Все лабораторные работы данного цикла ориентированы на созда-ние консольных приложений, поскольку студенты изучают средства ви-зуализации на старших курсах.

Для создания проекта в среде Microsoft Visual Studio выполните следующее:

1. Запустите Microsoft Visual Studio. 2. Выберите в меню создание нового проекта: File-> New ->

Project... 3. В открывшемся окне:

а) выберите Visual C++ ; б) выберите Win32 Consol Application (Visual C++); в) в строке ввода Name введите имя проекта, в строке

Location укажите место расположения будущего проекта на диске (рабочая директория проекта), в строке Solution name будет то же самое имя проекта, что и в Name.

4. Нажмите кнопку ОК. В результате открывается совокупность окон редактора текста, де-

рева файлов проекта, отладчика и других, в которых располагается шаблон приложения. В редакторе видим текст созданного файла с именем, как у проекта, и расширением .срр, а в нем - заготовку функции main.

Для компиляции приложения выберите в меню Build->Build Solu-tion (или нажмите F7). Если компиляция выполнилась без ошибок, то в ра-бочей директории проекта будет создан исполняемый файл с именем про-екта и расширением .exe. Если компилятор обнаружил ошибки, то их спи-сок будет располагаться в окне Output, там же появляется сообщение об успешной («Build succeeded»), либо неуспешной («Build FAILED») компи-ляции.

Для отладки программы можно выполнять ее по шагам, для этого выберите в меню Debug-> Step Over (или Step Into) или нажмите F10 (F11).

5

Лабораторная работа № 1

АЛГОРИТМИЗАЦИЯ ЛИНЕЙНЫХ ВЫЧИСЛИТЕЛЬНЫХ ПРОЦЕССОВ

1. Цель работы Изучение принципов алгоритмизации линейных вычислительных

процессов, способов записи алгоритмов. Исследование структуры про-грамм, типов данных, стандартных библиотек. Получение навыков отладки программ.

2. Порядок выполнения работы 2.1. Изучить структуру программы на языке С++, структуру проек-

та Visual Studio (VS). 2.2. Изучить простые типы данных, объявление переменных и констант,

процедуры и операторы ввода-вывода (printf и scanf, cin и cout). 2.3. Изучить порядок использования библиотечных ресурсов, ди-

рективу #include, библиотеку iostream, файл stdafx. 2.4. Создать проект в VS (см. подготовку к лабораторным работам), в

функцию main внести текст представленного примера. В тексте примера наме-ренно допущен ряд типичных для начинающих ошибок.

2.5. Выполнить компиляцию получившейся программы и получить список ошибок.

2.6. Исправить все указанные ошибки и скомпилировать еще раз. 2.7. Если компиляция неудачная, снова выполнить п. 2.6. 2.8. Разработать алгоритм решения задачи индивидуального задания

в виде схемы алгоритма, предусмотреть ввод и вывод необходимых данных. 2.9. Записать алгоритм п. 2.8 на языке С++. 2.10. Добавить созданный текст п. 2.9 к тексту функции main и до-

биться успешной компиляции всего проекта. 2.11. Подготовить набор тестов (см. содержание отчетов, п. 5) и вы-

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

6

б) оставшиеся тесты выполнить, запуская исполняемый файл; если в результате тестирования будут получены неверные результаты, повторить п. 2.11а, используя наборы данных, с которыми был получен неверный результат.

3. Пример выполнения задания Найти скалярное произведение двух векторов; считать, что размер-

ность векторов равна 3, угол между векторами 60º. Метод решения: скалярное произведение равно произведению длин

двух векторов на косинус угла между ними.

Текст программы на С++

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

//модуль lab1.cpp #include "stdafx.h" #include <cmath> #define int M_PI 3.14 const level = 2; int main() { //добавление возможности писать на русском языке setlocale(LC_ALL, "RUS"); int x1, x2; //координаты первого вектора int y1, y2; //координаты второго вектора double a = 60; //угол между векторами int p; //скалярное произведение printf("Введите координаты первого вектора: x1, x2, x3 = \n"); scanf("%%%i", x1, x2, x3); printf("x1 = %s\n", x1); printf("x2 = %s\n", x2); printf("x3 = %s\n", x3); printf("Введите координаты второго вектора: y1, y2, y3 = \n"); scanf("%%%i", y1, y2, y3); printf("y1 = %s\n", y1); printf("y2 = %s\n", y2); printf("y3 = %s\n", y3); d1 = sqrt((double)(x1*x1 + pow((double)x2, level) + pow((double)x3,

7

28 29 30 31 32 33 34 35 36 37 38

(double)level))); d2 = sqrt((double)(y1*y1 + pow((double)y2, (int)2) + pow((double)y3, level))); radians = a * M_PI / 180 p = d1*d2 * cos(radians); printf("Длина первого вектора = 5.2i\n", d1); printf("Длина второго вектора = 5.2i\n", d2); printf("Скалярное произведение = 5.2i\n"); system("pause"); //Для продолжения нажмите любую клавишу... //(чтобы окошко не закрывалось) return 0; }

4. Контрольные вопросы 1. Какие существуют способы записи алгоритма? 2. Метод нисходящего проектирования: в чем его особенности? 3. Линейные операторы языка С++. 4. Простые типы данных языка С++. 5. Структура программы на языке С++. 6. Стандартные библиотеки и их подключение. 7. Что такое идентификатор, переменная, константа? 8. Что такое совместимость типов? 9. Явное и неявное преобразование типов.


АЛГОРИТМИЗАЦИЯ РАЗВЕТВЛЯЮЩИХСЯ ВЫЧИСЛИТЕЛЬНЫХ ПРОЦЕССОВ

1. Цель работы Изучение принципов алгоритмизации и структуры алгоритмов раз-

ветвляющихся вычислительных процессов. 2. Порядок выполнения работы 2.1. Изучить структуры алгоритмов разветвляющихся вычисли-

тельных процессов. Изучить отличия структурного алгоритма от неструк-турного.

8

2.2. Изучить синтаксис и работу операторов ветвления if и switch. 2.3. Изучить пример выполнения задания. Обратите внимание, что

здесь и далее библиотечные модули, используемые в работе, подключают-ся в файле stdafx.h, а сам файл stdafx.h подключается в основном модуле, содержащем точку входа консольного приложения – функцию main.

2.4. Разработать алгоритм решения индивидуального задания, удовлетворяющий требованиям п. 2.5.

2.5. Требования к алгоритму. Алгоритм должен соответствовать требованиям структурного подхода. Необходимо организовать ввод и вы-вод всех требуемых данных через диалог ЭВМ с человеком (интерфейс ввода-вывода), организовать проверку входных данных на допустимые значения. Запрещается использование неструктурного оператора goto. Возможно использование досрочного выхода из процедуры с помощью оператора return.

2.6. Разработать программу на языке С++ для алгоритма п. 2.4. 2.7. Выполнить отладку и компиляцию программы, получить ис-

полняемый файл. 2.8. Выполнить тестирование программы несколькими наборами

входных данных. 3. Пример выполнения задания Даны действительные числа a, b, c, d. Если a ≤ b ≤ c ≤ d, то каждое число заменить наибольшим из них;

если a > b > c> d, то оставить без изменений; в противном случае все чис-ла заменяются их квадратами.


1 2 3 4 5 6 7 8 9 10 11

// модуль lab2.cpp #include "stdafx.h" const int level = 2; int main() { setlocale(LC_ALL, "RUS"); //диалог и ввод данных-------------------------------------------------------------------------- int lm = 0; //для меню

9

12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

cout << "Выберите желаемое действие: " << endl; cout << "1: Решить задачу: " << endl; cout << "2: Выйти из приложения (без решения задачи)" << endl; cout << "Введите желаемое действие: "; cin >> lm; switch(lm){ //switch case 1: float a, b, c, d; printf("Введите число a = "); scanf("%f", &a); printf("Введите число b = "); scanf("%f", &b); printf("Введите число c = "); scanf("%f", &c); printf("Введите число d = "); scanf("%f", &d); //решение задачи--------------------------------------------------------------------------------- if ((a <= b) & (b <= c) & (c <= d)) { a = d; //a = b = c = d; b = d; c = d; } else if ((a > b) & (b > c) & (c > d)) // если написать противоположное условие, то операторы будут в блоке "true" ; //пустой оператор else { // различные способы возведения в квадрат a *= a; b = b*b; c = pow(c, 2); d = pow(d, level); } //вывод результатов----------------------------------------------------------------------------- printf("\nЧисло a = %3.2f", a); printf("\nЧисло b = %3.2f", b); printf("\nЧисло c = %3.2f", c); printf("\nЧисло d = %3.2f\n\n", d); break; default: break; }// конец switch std::system("pause"); return 0; }

10

4. Контрольные вопросы 1. Какие управляющие структуры используются в языке C++ для

организации разветвляющихся алгоритмов? 2. Поясните порядок выполнения оператора if…else и его сокра-

щенной формы. 3. Поясните порядок выполнения оператора switch. Каково здесь на-

значение оператора break? 4. Сколько операторов можно написать после ключевых слов if и else? 5. Что такое составной оператор? 6. Как разрешается неоднозначность, которая может возникнуть при

использовании вложенных операторов if?


АЛГОРИТМИЗАЦИЯ ЦИКЛИЧЕСКИХ ВЫЧИСЛИТЕЛЬНЫХ ПРОЦЕССОВ

1. Цель работы Изучение принципов алгоритмизации и структуры алгоритмов цик-

лических вычислительных процессов и задач, связанных с обработкой мас-сивов. Изучение структурированного типа данных – массива. Освоение методики пошаговой детализации задачи.

2. Порядок выполнения работы 2.1. Изучить структуры алгоритмов циклических вычислительных

процессов. Изучить общие принципы работы с массивами. 2.2. Изучить синтаксис и работу операторов for, while и do-while,

директиву #define. 2.3. Изучить пример выполнения задания. Обратите внимание, что

имя массива фактически есть адрес первого элемента массива в памяти. 2.4. Разработать алгоритм решения индивидуального задания, удов-

летворяющий требованиям п. 2.5, используя метод пошаговой детализации. 2.5. Требования к алгоритму. Алгоритм должен соответствовать

требованиям структурного подхода. Необходимо организовать интерфейс ввода-вывода всех требуемых данных, организовать проверку входных

11

данных на допустимые значения. Для решения задачи использовать одно-мерный массив. Необходимо предусмотреть именованную константу для за-дания размерности массива, величина константы должна быть не менее 20. Фактический рабочий размер массива должен определяться переменной, задаваемой в качестве исходных данных. Предусмотреть инициализацию массива на выбор пользователя ручным способом или с помощью генера-тора случайных чисел. Необходимо использовать все три оператора цикла: либо разные части алгоритма выполнить, используя разные операторы цикла, либо одну и ту же часть выполнить тремя способами.



входных данных. 3. Пример выполнения задания Даны натуральное число n, действительное число x.

Вычислить: ⎟⎠⎞

⎜⎝⎛ −

+Π = x

kk kn

k cos11 .


1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// модуль lab3.cpp #include "stdafx.h" #define MAX_SIZE 100; //константа – максимальный размер массива int main() { setlocale(LC_ALL, "RUS"); unsigned int n = 0; //фактический рабочий размер массива float x = 0; float mas[MAX_SIZE] = {0}; //объявление массива максимального размера //диалог и ввод данных------------------------------------------------------------------------- printf("Введите количество элементов в массиве (натуральное число) = "); scanf("%i", &n); printf("Введите действительное число x = "); cin >> x; //решение задачи--------------------------------------------------------------------------------- //первый вариант реализация цикла (for) float p = 1; //произведение for(unsigned int k = 0; k < n; k++) { //-----------------------------счетный цикл

12

21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

mas[k] = (k/(k+1))-pow(cos(abs(x)), (int)k); p *= (mas+k)[0]; //mas – есть адрес массива в памяти } printf("\n\nПроизведение равно (первый способ) = %3.5f\n\n", p); //второй вариант реализация цикла (while) unsigned int k = 0; //счетчик p = 1; while (k < n) { //--------------------------------------------цикл с предусловием mas[k] = (k/(k+1))-pow(cos(abs(x)), (int)k); p *= *(mas+k); k = k + 1; } cout << "Произведение равно (второй способ) = " << p << endl << endl; //третий вариант реализации цикла (do-while) k = 0; p = 1; do { //----------------------------------------------------------цикл с постусловием mas[k] = (k/(k+1))-pow(cos(abs(x)), (int)k); p *= mas[k]; k++; }while(k < n); printf("Произведение равно (третий способ) = %3.5f\n\n\n", p); system("pause"); return 0; }

4. Контрольные вопросы 1. Функциональная схема цикла и назначение ее отдельных частей. 2. Какие виды циклов существуют, в чем их принципиальные отличия? 3. Назначение цикла for и его отдельных компонентов. 4. Укажите, сколько операторов можно разместить в теле цикла? 5. Можно ли в теле цикла изменять значение параметра цикла? 6. Можно ли вне тела цикла использовать значение параметра

цикла? 7. Как работают операторы while и do-while? 8. Какими способами можно инициализировать массив? 9. Какими способами можно обращаться к элементам массива?

10. Какова общая схема работы с массивом?

13


ПРОГРАММИРОВАНИЕ ВЛОЖЕННЫХ ЦИКЛОВ И МАТРИЧНЫХ ЗАДАЧ

1. Цель работы Изучение принципов алгоритмизации и структуры алгоритмов, со-

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

2. Порядок выполнения работы 2.1. Изучить особенности организации вложенных циклов, прин-

ципы работы с многомерными массивами. 2.2. Изучить работу оператора break и принципы его применения. 2.3. Изучить пример выполнения задания. 2.4. Разработать алгоритм решения индивидуального задания, удов-

летворяющий требованиям п. 2.5, используя метод пошаговой детализации. 2.5. Требования к алгоритму. Алгоритм должен соответствовать

требованиям структурного подхода. Необходимо организовать интерфейс ввода-вывода всех требуемых данных, проверку входных данных на до-пустимые значения. Для решения задачи использовать многомерный мас-сив. Необходимо предусмотреть именованную константу для задания раз-мерности массива, величина константы должна быть не менее 20. Факти-ческий рабочий размер массива должен определяться переменными, зада-ваемыми в качестве исходных данных. Предусмотреть инициализацию массива на выбор пользователя ручным способом или с помощью генера-тора случайных чисел.



входных данных. 3. Пример выполнения задания Даны натуральные числа n и z, определяющие количество фактиче-

ских строк и столбцов в матрице соответственно, действительные числа

14

1,1x , … , zx ,2 . Получить в порядке следования все kix , , удовлетворяющие

неравенствам 1,,2,1,1,1, ,...,,, −>>> kikikiki xxxxxx . Метод решения: для каждого элемента матрицы xi,k (начиная с x0,1)

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

Текст программы на С++ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

// модуль lab4.cpp. #include "stdafx.h" #define MAX_SIZE 100; int main() { setlocale(LC_ALL, "RUS"); //фактическое количество элементов в строке - n, в столбце – z unsigned int n = 0, z = 0; float x[MAX_SIZE][ MAX_SIZE]; // диалог и ввод данных … (см. пример лаб. раб. № 3)---------------------------------- // инициализация массива псевдослучайными числами--------------------------------- for(unsigned int i = 0; i < n; i++) //внешний цикл – по строкам for(unsigned int j = 0; j < z; j++) //вложенный цикл – по столбцам { //генерация псевдослучайного числа x[i][j] = ((float)rand()/RAND_MAX+rand()%100 - rand()%50); } //вывод матрицы на экран--------------------------------------------------------------------- printf("\n\n"); for(unsigned int i = 0; i < n; i++) for(unsigned int j = 0; j < z; j++) printf("[%i][%i] элемент матрицы = %3.2f\n", i, j, x[i][j]); printf("\n\n"); // решение задачи--------------------------------------------------------------------------------- unsigned int stroka; //строка матрицы, в которой находится найденный //k-й элемент, подходящий по условию задачи for(unsigned int i = 0; i < n; i++) for(unsigned int k = 0; k < z; k++) { //обход матрицы до i строки, в которой находится k-й элемент bool flag = true; //флаг выполнения условия задачи for(unsigned int temp_i = 0; temp_i <= i; temp_i++) { if (flag == false) break; // выход из ближайшего цикла unsigned int temp_j = 0; //обнуляем счетчики unsigned int temp_k = 0; //обход матрицы (i строки) до k-го элемента (включительно)

15

36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

while(temp_j <= temp_k) { //анализируем, на какой строке находится k-й элемент if (i != temp_i) //если k элемент находится на отличной от i строки temp_k = z-1; else temp_k = k; //если k-й элемент находится на i строке if (x[i][k] >= x[temp_i][temp_j]) stroka = temp_i; else { flag = false; //нарушение условия задачи break; } temp_j++; //увеличиваем счетчик (столбцы) }//while }//for if (flag) //анализируем флаг выполнения заданного условия printf("x[%i][%i] = %3.2f\n", stroka, k, x[stroka][k]); }//for printf("\n\n"); system("pause"); return 0; }

4. Контрольные вопросы 1. Какова общая схема работы с многомерным массивом? 2. Каковы правила организации вложенных циклов? 3. Какие существуют способы объявления массива? 4. Назовите алгоритм работы и правила использования неструк-

турного оператора break.


АЛГОРИТМИЗАЦИЯ ЗАДАЧ ОБРАБОТКИ СИМВОЛЬНОЙ ИНФОРМАЦИИ

1. Цель работы Изучение строкового типа данных и принципов его обработки. Изу-

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

16

2. Порядок выполнения работы 2.1. Изучить особенности объявления, обработки и представления в

памяти ЭВМ символьного типа данных. Изучить определение пользова-тельского типа данных (typedef).

2.2. Изучить типы char и string, особенности их использования, изучить отличия символьной и строковой константы (к последней всегда добавляется нулевой байт).

2.3. Изучить работу с функциями библиотеки string.h: strlen, strupr, strchr, strlwr, strcat, strcpy, strcmp memset; библиотеки ctype.h: isdigit, isal-num, isalpha, tolower, toupper.

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

2.5. Разработать алгоритм решения индивидуального задания, удов-летворяющий требованиям п. 2.6, используя метод пошаговой детализации.

2.6. Требования к алгоритму. Алгоритм должен соответствовать требованиям структурного подхода. Необходимо организовать интерфейс ввода-вывода всех требуемых данных, организовать проверку входных данных на допустимые значения. Для решения задачи использовать сим-вольный массив и указатель на строку. Предусмотреть инициализацию массива и строк на выбор пользователя ручным способом или с помощью строковых констант. Использовать объявление символьного массива с предварительным заданием типа.



входных данных.

3. Пример выполнения задания Даны символы s1, s2 … . Известно, что символ s1 отличен от пробела

и что среди s2, s3 … имеется хотя бы один пробел. Рассматриваются s1, … , sn - символы, предшествующие первому пробелу (n заранее неизвестно). Преобразовать последовательность s1, … , sn, удалив все символы, не яв-ляющиеся буквами или цифрами, и заменив каждую большую букву одно-именной малой.

17

Текст программы на С++ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

// модуль lab5.cpp #include "stdafx.h" #include <Windows.h> typedef char string_user[100]; //пользовательский тип строка из 99 символов //(в последний компилятор записывает 0, для обозначения конца строки) using namespace std; //область видимости для встроенного типа //string из библиотеки string.h int main() { setlocale(LC_ALL, "RUS"); //char st1[100]; // вариант объявления символьного массива из 99 символов // инициализация строковой константой---------------------------------------------- string_user st1("Ис2х!од)(ны:й тЕКСт 2: abcDF1+2=3!!!"); //или ввод исходной строки пользователем----------------------------------------------- printf("Введите последовательность символов - строку: \n"); std::cin.getline(st1, 99); printf("\n"); //проверка на допустимость входных данных while ((strlen(st1)==0) || (st1[0]==' ') || strchr(st1, ' ')==NULL) //strchr(st1, ' '); { printf("Повторите ввод, первый символ не должен быть пробелом\n"); std::cin.getline(st1, 99); printf("\n"); } OemToAnsi(st1, st1); //преобразует введенные данные в символьный набор cout << "#Исходная последовательность символов" << endl; cout << st1 <<endl; //поиск первого пробела----------------------------------------------------------------------- int n = 0; //переменная для сохранения позиции пробела char buf[100] = ""; for (n = 0; st1[n] != ' '; n++); //удаляем все символы, кроме букв и цифр---------------------------------------------- memset (buf, 0, 100); //очищаем строку, заполняя все символы нулями j = 0; for (int i = 0; i < n; i++) // для русского алфавита (маленькие и большие буквы) if (((int(st1[i]) >= -64)&&(int(st1[i]) <= -1)) || //добавляем английский алфавит ((int(st1[i]) >= 65 &&int(st1[i]) <= 90)||(int(st1[i]) >= 97 && st1[i] <= 122)) //добавляем цифры ||((int(st1[i]) >= 48 && int(st1[i]) <= 57)))

18

44 45 46 47 48 49 50 51 52 53

buf[j++] = st1[i]; strcpy(st1, buf); //преобразуем большие буквы в маленькие (приводим к нижнему регистру)----- char * pst3 = strlwr(buf); cout << "#Преобразованная последовательность символов " << endl; cout << pst3 << endl; system("pause"); return 0; }

4. Контрольные вопросы 1. Какие существуют способы организации символьных данных? 2. Объявление и инициализация символьных массивов. 3. В чем отличие символьной и строковой констант? 4. Как хранится строковое значение в памяти ЭВМ? 5. Общие принципы работы с символьными данными. 6. Библиотеки и функции для работы со строками. 7. Какие возможны операции над строками?


ПРОЦЕДУРЫ И ФУНКЦИИ

1. Цель работы Изучение принципов структурного программирования и модульно-

го подхода, программирование процедур и функций. Изучение способов передачи параметров в подпрограммы. Приобретение навыков формирова-ния блочной структуры программы.

2. Порядок выполнения работы 2.1. Изучить принципы организации модульности в С++ (заголо-

вочные файлы с расширением .h и файлы реализации с расширением .cpp), изучить организацию подпрограмм в С++, особенности связей по управле-нию и по данным.

19

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

2.3. Изучить работу оператора return, тип void, операторов *, &. 2.4. Изучить пример выполнения задания. Обратите внимание на

содержимое модулей func.h и func.cpp, их взаимосвязь с модулем lab6.cpp. Обратите внимание на список параметров каждой из функций и соответст-вующий вызов, на возвращаемые значения. Пример диаграммы модулей и спецификация одной из разработанных функций представлены в прил. 2.


2.6. Требования к алгоритму. Алгоритм должен соответствовать требованиям структурного подхода. Необходимо организовать интерфейс ввода-вывода всех требуемых данных, проверку входных данных на до-пустимые значения. Алгоритм решения задачи разбить на функциональные блоки, оформить блоки в виде функций, обязательно со списком парамет-ров (каждый из способов передачи параметров должен быть использован в работе хотя бы один раз). Должна быть хотя бы одна функция, возвра-щающая значение (не void).

2.7. Разработать программу на языке С++ для алгоритма п. 2.5, удовлетворяющую требованиям п. 2.8, используя модульный подход.

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

2.9. Выполнить отладку и компиляцию программы, получить ис-полняемый файл.

2.10. Выполнить тестирование программы несколькими наборами входных данных.

2.11. Составить диаграмму модулей, дерево вызова функций и спе-цификации функций (включить в отчет по лабораторной работе).

3. Пример выполнения задания Даны целые числа a1, … , an, b1, …, bm, k. Если в последовательно-

сти a1, … , an нет ни одного члена со значением k, то первый по порядку

20

член этой последовательности, не меньший всех остальных членов, заме-нить на значение k. По такому же правилу преобразовать последователь-ность b1, …, bm применительно к 10.

Текст программы на С++ (часть) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

// модуль lab6.cpp #include "stdafx.h" #include "func.h" int arr_a[100], arr_b[100]; //объявление массивов int main() { setlocale(LC_ALL, "RUS"); int a_size = 0, b_size = 0; //количество элементов в массиве a и b cout << "Данные для первого массива a" << endl; menu(a_size, arr_a); out(a_size, arr_a); cout << "Данные для второго массива b" << endl; menu(b_size, arr_b); out(b_size, arr_b); int k = 8; //число для сравнения (исходные данные) cout << "Обработка первого массива a" << endl; mission(a_size, arr_a, k); cout << "Обработка второго массива b" << endl; mission(b_size, arr_b, k); system("pause"); return 0; }//========================================================= //модуль func.h //в этом файле описаны все интерфейсы подпрограмм #pragma once; // директива – «включать один раз» #include "stdafx.h" void enter (int, int *); //функция ввода элементов массива (ввод с клавиатуры)void genm (int size, int * arr); //функция инициализации массива случайными числами void out (int size, int * arr); //функция вывода массива на экран void menu (int &size, int * arr); //функция отображения меню на экране bool InMas(int size, int * arr, int y); //функция проверки вхождения элемента в массива void task(int size, int arr[], int y); //функция преобразования массива по заданию void mission(int size, int * arr, int &y);//функция вызова преобразования массива

21

37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

//============================================================ //модуль func.cpp (представлена только часть функций) //функция проверки вхождения элемента в массив bool InMas(int size, int * arr, int y) { for(unsigned int i = 0; i < size; i++) if (arr[i] == y) return false; return true; }//-------------------------------------------------------------------------------------------------- //функция преобразования массива по заданию void task(int size, int arr[], int y) { int i = 0; //счетчик while(arr[i+1] > arr [i]) i++; arr[i] = y; }//------------------------------------------------------------------------------------------------- //функция вызова преобразования массива void mission(int size, int * arr, int &y) { cout << "Введите число для сравнения: "; cin >> y; if (mas(size, arr, y)) { cout << "В последовательности нет элемента со значением k" << endl; cout << "Преобразованный массив:" << endl; task(size, arr, y); out(size, arr); } else cout << "В последовательности есть элемент со значением k" << endl << "Массив не преобразуется" << endl; }

4. Контрольные вопросы 1. Что такое подпрограмма? Каково ее назначение? 2. Назовите основные принципы модульности и как они реализова-

ны в С++. 3. Что такое область видимости и время жизни объекта программы? 4. Глобальные и локальные переменные. 5. Формальные и фактические параметры. 6. Назовите основные принципы структурного программирования.

22

7. Как происходит передача параметров в подпрограмму, какие ап-паратные и программные средства для этого используются?

8. В чем принципиальное отличие передачи параметра по значению и по ссылке, в каких случаях используется одно и другое?

9. Что такое синоним переменной, чем он отличается от указателя? 10. Для чего нужно предварительное объявление функции? 11. Покажите в своей работе предварительное объявление, реализа-

цию (тело) и вызов функции.


ФАЙЛЫ И СТРУКТУРЫ

1. Цель работы Изучение описания и принципов работы с пользовательскими ти-

пами данных: перечисляемый тип, записи. Изучение принципов алгорит-мизации задач, связанных с обработкой файлов разного типа. Изучение пе-регрузки функций.

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

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

2.2. Изучить возможности и правила перегрузки функций. 2.3. Изучить синтаксические конструкции enum и struct, объявле-

ние файловой переменной FILE *. 2.4. Изучить функции для работы с бинарными и текстовыми фай-

лами: fopen, fclose, fwrite, fread, ferror, eof, fgets, fputs. 2.5. Изучить пример выполнения задания. 2.6. Разработать алгоритм решения индивидуального задания,

удовлетворяющий требованиям п. 2.7, используя метод пошаговой детали-зации.

2.7. Требования к алгоритму. Алгоритм должен соответствовать требованиям структурного подхода. Необходимо организовать интерфейс

23

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

2.8. Разработать программу на языке С++ для алгоритма п. 2.6, ис-пользуя модульный подход (см. п. 2.8 лаб. работы № 6).




3. Пример выполнения задания Дан файл, содержащий сведения об учениках школы и их оценках.

Определить, имеются ли в школе однофамильцы и подсчитать количество учеников, имеющих отметки не ниже «хорошо».

Текст программы на С++ (часть)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

//модуль type_menu.h //файл содержит интерфейсы функций для "типизированного" файла (функции //верхнего уровня, вызываемые из меню) #pragma once #include "type_func.h" //перегружаемые функции void WriteFile(int n, rec &wrec);//открытие "типизированного" файла для записи void ReadFile(int n, rec &wrec);//открытие "типизированного" файла для чтения void CheckNameDuplicated(int n, rec &nrec); //проверка однофамильцев void NumberOfBPupil(rec &urec);//поиск количества учеников с отметками не //ниже “хорошо” в типизированном файле //============================================================ //модуль text_menu.h //файл содержит интерфейсы функций для текстового файла (функции верхнего //уровня, вызываемые из меню)

24

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

#pragma once #include "text_func.h" //перегружаемые функции void WriteFile(int n, string_user &st); //открытие текстового файла для записи void ReadFile(int n, string_user &st); //открытие текстового файла для чтения void CheckNameDuplicated(int n, string_user &st); //проверка однофамильцев void NumberOfBPupil(string_user &st); //поиск количества учеников с отметками //не ниже “хорошо” в текстовом файле //============================================================ //модуль type_menu.срр (представлена одна функция) //файл содержит реализации функций для "типизированного" файла (для меню) #include "stdafx.h" #include "type_menu.h" //открытие "типизированного" файла для записи void WriteFile(int n, rec &wrec) { FILE * fo; fo = fopen("type.txt","wb"); //открываем (создаем) файл для записи if (fo == NULL) { cout << "Ошибка открытия файла для записи" << endl; exit(EXIT_FAILURE); } for(int i = 0; i < n; i++) { int temp=0; //временная переменная для оценок cout << "Введите имя ученика: "; cin >> wrec.name; cout << "Введите фамилию ученика: "; cin >> wrec.subname; cout << "Введите класс, где обучается ученик: "; cin >> wrec.clas; cout << "Введите оценки ученика (4 штуки от 1 до 5)" << endl; for(int j = 0; j < 4; j++) { cout << "Введите " << j+1 << " оценку: "; cin >> temp; wrec.marks[j] = (mark)temp; } WriteElement(wrec, fo); //запись одной структуры в файл cout << endl; } fclose(fo); //закрываем файл cout << endl; }//============================================================ //модуль text_menu.cpp (представлена одна функция) //файл содержит реализации функций для текстового файла (функции для меню) #include "stdafx.h" #include "text_menu.h" //проверка однофамильцев в текстовом файле void CheckNameDuplicated(int n, string_user &st) { FILE * ft; ft = fopen("text.txt","r"); //открываем существующий файл для чтения if (ft == NULL) { cout << "Ошибка открытия файла для чтения" << endl;

25

63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109

exit(EXIT_FAILURE); } if(HasDuplicatedName(n, st, ft)) cout << "В школе есть однофамильцы" << endl; else cout << "В школе нет однофамильцев" << endl; fclose(ft); cout << endl; }//============================================================ //модуль type_func.h //файл содержит интерфейсы функций для "типизированного" файла (функции //преобразования - функции нижнего уровня) #pragma once //перечисляемый тип с оценками enum mark {very_bad = 1, bad = 2, satisfactory = 3, good = 4, excellent = 5}; struct rec //структура данных { char name[10]; char subname[15]; int clas; mark marks[4]; }; //перегружаемые функции void WriteElement(rec &wrec, FILE * f1); //запись структуры в файл void ReadElement (rec &rrec, FILE * f1); //чтение структуры из файла bool HasDuplicatedName(int n, rec &nrec, FILE * f1); //есть ли однофамильцы int GetNumberOfBPupil(rec &urec, FILE * f1); // количество учеников с оценками //не ниже “хорошо” //============================================================ //модуль type_func.срр (представлена только часть функций) //файл содержит реализации функций преобразования для "типизированного" файла #include "stdafx.h" #include "type_func.h" //------------------------------------------------------------------------------------------------- //запись структуры в файл void WriteElement(rec &wrec, FILE * f1) { fwrite(&wrec,sizeof(rec),1,f1); //записываем одну структуру }//------------------------------------------------------------------------------------------------- //чтение структуры из файла void ReadElement(rec & rrec, FILE * f1) { fread(&rrec, sizeof(rec), 1, f1); //читаем одну структуру }//------------------------------------------------------------------------------------------------- //поиск однофамильцев в школе bool HasDuplicatedName (int n, rec &nrec, FILE * f1) { char str[100][15]; //массив для фамилий for(int i = 0; i < n; i++) { fread(&nrec, sizeof(rec), 1, f1); strncpy(str[i], nrec.subname, 15); //записываем только фамилии в

26

110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149

// созданный массив } for(int i = 0; i < n-1; i++) //поиск одинаковых фамилий { for(int j = i+1; j < n; j++) if(strcmp(str[i], str[j]) == 0) //сравниваем строки (фамилии) return true; } return false; }//============================================================ //модуль text_func.h //файл содержит интерфейсы функций для текстового файла (функции нижнего //уровня) #pragma once #define MAX_LEN 25 typedef char string_user[MAX_LEN]; //перегружаемые функции void WriteElement(string_user &st, FILE * f1); //запись строки в файл void ReadElement (string_user &st, FILE * f1); //чтение строки из файла bool HasDuplicatedName (int n, string_user &st, FILE * f1); //поиск однофамильцев int GetNumberOfBPupil(string_user &st, FILE * f1); //поиск количества учеников с //оценками не ниже “хорошо” //============================================================ //модуль text_func.cpp (представлена только часть функций) //файл содержит реализации функций преобразования для текстового файла #include "stdafx.h" #include <fstream> #include "text_func.h" #include "type_func.h" //для типа оценок mark //------------------------------------------------------------------------------------------------- //запись строки в текстовый файл void WriteElement(string_user &st, FILE * f1) { fputs(st, f1); fputs("\n",f1); }//------------------------------------------------------------------------------------------------- //чтение строки из текстового файла void ReadElement(string_user &st, FILE * f1) { fgets(st, MAX_LEN, f1); OemToAnsi(st, st); }//-------------------------------------------------------------------------------------------------

4. Контрольные вопросы 1. Что такое файл? Общая схема работы с файлом. 2. Что содержит файловая переменная? 3. Как работают функции fopen и fclose?

27

4. Что такое структура? Как обращаться к полям структуры? 5. Как выглядит объявление структуры? Как в памяти хранится пе-

ременная структурного типа? 6. В чем отличие обработки текстового и бинарного файлов?


АЛГОРИТМИЗАЦИЯ ЗАДАЧ ОБРАБОТКИ ДИНАМИЧЕСКИХ МАССИВОВ

1. Цель работы Изучение средств языка программирования для управления дина-

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

2. Порядок выполнения работы 2.1. Изучить классификацию видов памяти, их использование. Изу-

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

2.2. Изучить построение и параметризацию шаблонов функций. 2.3. Изучить работу операторов new и delete, операции над указате-

лями. Изучить синтаксис описания шаблона функции (template…). 2.4. Изучить пример выполнения задания. Обратите внимание на

описание шаблонов функций и их параметризацию в точках вызова факти-ческими типами, а также на тип формального параметра в шаблоне функ-ции creat (модуль func.h).


2.6. Требования к алгоритму. Алгоритм должен соответствовать требованиям структурного подхода. Необходимо организовать интерфейс ввода-вывода всех требуемых данных, проверку входных данных на до-пустимые значения. Считать максимальное количество элементов массива

28

неизвестным, организовать массив в динамической памяти. Предусмотреть решение задачи для разных типов элементов массива (int, float, пользова-тельский тип и т.п.). Алгоритм решения задачи разбить на функциональ-ные блоки – функции. Определить функции, отличающиеся только типами формальных параметров, разработать шаблоны для этих функций с после-дующей параметризацией фактическими типами.

2.7. Разработать программу на языке С++ для алгоритма п. 2.5, ис-пользуя модульный подход (см. п. 2.8 лаб. работы № 6).




3. Пример выполнения задания Даны действительные числа a, b, c, d,…n. Если a ≤ b ≤ c ≤ d … ≤ n,

то каждое число заменить наибольшим из них; если a > b > c > d > … > n, то оставить без изменений; в противном случае все числа заменяются их квадратами.

Текст программы на С++ (часть) 1 2 3 4 5 6 7 8 9 10 11 12 13 14

//модуль func.h (представлена только часть шаблонов) // шаблоны функций для работы с динамическим массивом #pragma once //создание массива в динамической памяти template <typename T> void CreateMas(int n, T * &mas) { mas = new T[n]; }//------------------------------------------------------------------------------------------------- //инициализация динамического массива псевдослучайными числами template <typename T> void GenMas(int n, T * mas) { for(int i = 0; i < n; i++) *(mas+i) = ((T)rand()/RAND_MAX+rand()%50-rand()%30); }//-------------------------------------------------------------------------------------------------

29

15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

//определение: является ли массив упорядоченным по убыванию template <class T> bool IsToSmall(int n, T * mas) { bool flag = true; for(int i = 0; i < n-1; i++) if (mas[i] <= mas[i+1]) ; else { flag = false; break; } return flag; }//------------------------------------------------------------------------------------------------- //присвоение всем элементам массива значения последнего элемента массива template <class T> void ResSmall(int n, T * mas) { for(int i = 0; i < n-1; i++) *(mas+i) = *(mas+n-1); }//------------------------------------------------------------------------------------------------- //удаление массива из динамической памяти template <typename T> void DelMas(T *mas) { delete [] mas; }//=========================================================== //модуль lab8.cpp (часть) #include "stdafx.h" #include "func.h" int main() { setlocale(LC_ALL, "RUS"); int n; cout << "Введите количество элементов в массиве: "; cin >> n; cout << "Вещественные числа:" << endl; float * fmas; //параметризируем вещественными числами //… CreateMas(n, fmas); GenMas(n, fmas); OutMas(n, fmas); if (IsToSmall(n, fmas)) ResSmall(n, fmas); OutMas(n, fmas); DelMas(fmas);

30

53 54 55 56 57

//… cout << "Целые числа:" << endl; int * imas; //параметризируем целыми числами CreateMas(n, imas); //… system("pause"); return 0; }

4. Контрольные вопросы 1. Какие виды памяти вы знаете? Каково их назначение? 2. Что такое динамическая память? В чем заключается ее особен-

ность? Правила работы с динамической памятью. 3. Как работают операторы new и delete? 4. Что такое шаблон функции? Для чего он используется? 5. На каком механизме базируется реализация шаблонов функций? 6. Что такое параметризация шаблона? Чем он параметризируется? 7. В чем заключается параметризация шаблона?


АЛГОРИТМЫ И ПРОГРАММЫ СОРТИРОВКИ 1. Цель работы Изучение методов, алгоритмов, процедур поиска и сортировки мас-

сивов. Разработка алгоритма и процедуры для сортировки массива задан-ным способом.

2. Порядок выполнения работы 2.1. Изучить методы сортировки массивов: методы пузырька,

вставки, слияния, перемешивания (сортировки шейкерной), выбора, Шел-ла, быстрый метод (Хоара). Изучить алгоритмы поиска элемента в отсор-тированном массиве.

2.2. Исследовать библиотеки С++ на наличие функций сортировки, реализующих алгоритмы из списка в п. 2.1, изучить работу с найденными функциями.

2.3. Разработать алгоритм решения индивидуального задания сор-тировки, оформить его в виде функции с параметрами.

31

2.4. Разработать алгоритм для подсчета времени работы различных методов сортировки, причем для массивов разных размеров. Алгоритм должен соответствовать требованиям структурного подхода. Необходимо организовать интерфейс ввода-вывода всех требуемых данных, организо-вать проверку входных данных на допустимые значения. Алгоритм реше-ния задачи разбить на функциональные блоки, оформить их в виде функций.

2.5. Разработать программу на языке С++ для алгоритма п. 2.4, со-держащую работу и с библиотечными функциями сортировки, и с разрабо-танным индивидуально алгоритмом (п. 2.3), удовлетворяющую требовани-ям п. 2.6, используя модульный подход.

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



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


3. Контрольные вопросы 1. Что такое «метод дихотомии»? Для чего он используется? 2. Как оценить эффективность того или иного метода сортировки? 3. Для чего используется сортировка? В каких случаях затраты на

сортировку оправданы? 4. Как добавляются новые данные в отсортированный массив?

32

ПРИЛОЖЕНИЯ

Приложение 1

ИНДИВИДУАЛЬНЫЕ ЗАДАНИЯ К ЛАБОРАТОРНЫМ РАБОТАМ

Номер варианта

Номер лабораторной работы, номер задачи по [5] Работа № 1

Работа № 2

Работа № 3

Работа № 4

Работа № 5

Работа № 6

Работа № 7

Работа № 8

Работа № 9

1 7 41 189 370а 257а 445 517в 540а 650а 2 11е 46 193 376а 266 434 513б 541а 631а 3 11а 34б 197 379д 253в 441 509б 533а 656а 4 5 57а 201а 385 261а 465 510б 542 640а 5 8 59в 202б 390а 269б 429 506а 548 630б 6 4 35а 206 397б 260б 446 507в 534а 631б 7 17 60а 210 423д 256б 432 514а 544 640б 8 21 57б 214 404 258 460а 509а 550 632 9 3 40 216а 410а 257е 468 510а 531 650б 10 6 60д 178в 379г 251 444 511а 541б 633 11 9 44 215а 402б 269г 455 519б 536 634 12 10 59а 186 394в 256а 430 517б 553а 635 13 15 60б 218 381 253б 466 501а 534б 636 14 11б 33в 222а 386 269а 442 516 185 637 15 14 59д 179а 371 257д 440а 478 540б 630в 16 22 35б 220а 398 252а 460б 507ж 186 641 17 13 36 188 374в 262а 462 502а 532 643 18 23а 48 194 379в 264 457 515 553б 644 19 18 59е 178г 372 254 447 506б 537 645 20 25а 37 200 389 259 440б 482 541б 651 21 12 57в 205 395 267 467 510в 188 647 22 25б 60в 181б 373б 252б 433 517ж 533б 648 23 31а 59б 191 383 268 454 514б 540в 649 24 16 38 223д 393а 260в 443 511б 553г 652 25 32б 60е 178е 375 269ж 431 506в 534в 630г 26 19 43 232 396 255 463 513а 553в 656б 27 20 59з 184 376б 261б 453 517а 541г 654 28 11в 57г 215в 392 265 461 506г 533в 631б 29 23б 60г 182 377 257в 458 517е 540г 630а 30 11ж 59г 246а 390г 269в 440в 512 534г 655

33

Приложение 2

СПЕЦИФИКАЦИЯ ФУНКЦИЙ (к лаб. работе № 6)

Название специфи-кации

Содержание спецификации

Название void task(int size, int arr[], int y) Назначе-ние

Преобразует массив таким образом, что первый по порядку член последовательности (массива), не меньший всех остальных чле-нов, заменяется на значение y

Вход size - размерность массива (целое число); arr[] - указатель на массив целых чисел (указатель на первый элемент массива); y - целочисленное число, на которое будет заменен некоторый элемент массива, подходящий под условие задачи

Выход Нет Глобальныересурсы

Нет

Исключи-тельные ситуации

Нет

Метод решения

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

Алгоритм работы

1. Объявление и инициализация начального значения счетчика i нулем. 2. Сравниваем следующий элемент массива с текущим: пока следующий элемент массива arr[i+1] больше текущего arr[i], выполняем п. 2.1 – 2.2, иначе - переход к п. 3:

2.1. Инкрементируем значение счетчика i ; 2.2. Сравниваем увеличенное на 1 значение счетчика i с раз-мерностью массива size (контролируем, чтобы массив не вы-шел за свои границы), если (i + 1) равно size, то переходим к п. 2.2.1, иначе – к п. 3;

2.2.1. Остановка (прерывание) цикла while командой break. 3. Присвоение найденному элементу массива arr[i] значения y. 4. Конец

34

Рис. П1. Схема алгоритма

35

Рис. П2. Диаграмма модулей (к лаб. работе № 7)

type_func.h

type_menu.h

text_menu.h

text_func.h

type_menu.cpp

type_func.cpp

text_menu.cpp text_func.cpp

lab7.cpp

stdafx.h

36

БИБЛИОГРАФИЧЕСКИЙ СПИСОК

1. Шилдт, Г. С++: базовый курс / Г. Шилдт. – М. : Вильямс, 2008. – 614 с. – ISBN 5-8459-0768-3. – ISBN 0-07-222897-0.

2. Макконелл, Дж. Анализ алгоритмов. Вводный курс / Дж. Макко-нелл. – М.: Техносфера, 2004. – 368 с. – ISBN 5-94836-005-9.

3. Кнут, Д. Искусство программирования. Т 1. Основные алгоритмы / Д. Кнут. – 3-е изд. – М. : Вильямс, 2006. – 720 с. – ISBN 978-5-8459-0080-7. – ISBN 0-201-89683-4.

4. Он же. Искусство программирования. Т. 3. Сортировка и поиск, 2-е изд. – М. : Вильямс, 2007. – 824 с. – ISBN 978-5-8459-0082-1. – ISBN 5-8459-0082-4.

5. Задачи по программированию / С.А. Абрамов [и др.]. – М. : Наука, 1988. – 224 с.

6. Иванова, Г. С. Основы программирования: учеб. для вузов / Г. С. Ива-нова. – 2-е изд., перераб. и доп. – М. : Изд-во МГТУ им. Н. Э. Баумана, 2002. – 416 с. – ISBN 5-7038-1957-1.

7. Либерти, Дж. Освой самостоятельно С++ за 21 день / Дж. Либер-ти. – М. : Вильямс, 2000. – 816 с. – ISBN 5-8459-0056-5. – ISBN 0-672-31515-7.

8. Седжвик, Р. Фундаментальные алгоритмы на C++. Анализ. Струк-туры данных. Сортировка. Поиск Р. Седжвик. – СПб. : ДиаСофт, 2001. – 688 с. – ISBN 966-7393-89-5. – ISBN 0-201-35088-2.

37

ОГЛАВЛЕНИЕ

ВВЕДЕНИЕ ...................................................................................................... 3

СОДЕРЖАНИЕ ОТЧЕТОВ ............................................................................ 3

ВАРИАНТЫ ИНДИВИДУАЛЬНЫХ ЗАДАНИЙ ....................................... 4

ПОДГОТОВКА К ЛАБОРАТОРНЫМ РАБОТАМ ..................................... 5

Лабораторная работа № 1. АЛГОРИТМИЗАЦИЯ ЛИНЕЙНЫХ ВЫЧИСЛИТЕЛЬНЫХ ПРОЦЕССОВ. ................................................. 6

Лабораторная работа № 2. АЛГОРИТМИЗАЦИЯ РАЗВЕТВЛЯЮ-ЩИХСЯ ВЫЧИСЛИТЕЛЬНЫХ ПРОЦЕССОВ. ................................ 8

Лабораторная работа № 3. АЛГОРИТМИЗАЦИЯ ЦИКЛИЧЕСКИХ ВЫЧИСЛИТЕЛЬНЫХ ПРОЦЕССОВ. ............................................... 11

Лабораторная работа № 4. ПРОГРАММИРОВАНИЕ ВЛОЖЕННЫХ ЦИКЛОВ И МАТРИЧНЫХ ЗАДАЧ .................................................. 14

Лабораторная работа № 5. АЛГОРИТМИЗАЦИЯ ЗАДАЧ ОБРАБОТКИ СИМВОЛЬНОЙ ИНФОРМАЦИИ ............................ 16

Лабораторная работа № 6. ПРОЦЕДУРЫ И ФУНКЦИИ ......................... 19

Лабораторная работа № 7. ФАЙЛЫ И СТРУКТУРЫ ............................... 23

Лабораторная работа № 8. АЛГОРИТМИЗАЦИЯ ЗАДАЧ ОБРАБОТКИ ДИНАМИЧЕСКИХ МАССИВОВ ............................. 28

Лабораторная работа № 9. АЛГОРИТМЫ И ПРОГРАММЫ СОРТИРОВКИ ...................................................................................... 31

ПРИЛОЖЕНИЯ ............................................................................................. 33

БИБЛИОГРАФИЧЕСКИЙ СПИСОК ......................................................... 37

38

С + +

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

Составители: КОЛОМИЕЦ Ирина Александровна

ГЛАДЬО Светлана Сергеевна

Ответственный за выпуск – зав. кафедрой профессор В.Н. Ланцов

Подписано в печать 14.06.12. Формат 60×84/16. Усл. печ. л. 2,32. Тираж 100 экз.

Заказ Издательство

Владимирского государственного университета имени Александра Григорьевича и Николая Григорьевича Столетовых.

600000, Владимир, ул. Горького, 87.

39

Documents

Методические указания к лабораторным работамe.lib.vlsu.ru/bitstream/123456789/2779/1/00284.pdfПОДГОТОВКА К ЛАБОРАТОРНЫМ