Содержание
Задание на курсовой проект
Содержание
Введение
1. Система программирования и прикладные системы
1.1. Объявление и определение функций
2. Решение экономической задачи «Платежная ведомость предприятия»
2.1. Постановка задачи
2.2. Разработка алгоритма решения задачи
2.3. Разработка программы решения задачи
2.3.1.Описание работы программы (краткое руководство пользователя)
Заключение
Список использованной литературы
Приложение 1
Текст программы
Введение
Автором языка С++ является Бьярн Страуструп. Изначально язык С++ был разработан для того чтобы не приходилось программировать на Ассемблере, С или других современных языках высокого уровня. «С++ – это универсальный язык общего назначения, область применения которого – программирование систем в самом широком смысле» -так писал его автор.
До 1983 года язык был известен лишь автору и его группе поддержки. Практическое использование языка началось летом 1983 г. Тогда же появилось и название – С++; его придумал Рик Масситти ( ++ – операция приращения ).
Данный язык программирования базируется на языке С, который был разработан для системных программистов с тем, чтобы избавить их от работы на Ассемблере. С этой целью в С были включены многие операции низкого уровня, позволяющие работать с машинными представлениями данных (числами, символами и адресами). С другой стороны, С является языком высокого уровня (Бьярн Страуструп называет его языком относительно низкого уровня). Таковым является и С++. Основное его отличие от предшественника состоит в том, что в С++ добавлено все необходимое для поддержки объектно-ориентированного стиля программирования.
На протяжении своей сравнительно недолгой истории язык С++ постоянно совершенствовался. В структуру языка вводились новые понятия, расширялась его библиотека стандартных функций и классов, создавались все новые и новые системы программирования. Это привело к тому, что литература по С++ очень быстро устаревала. В подтверждение сказанного достаточно сравнить три издания книги Б. Страуструпа “Язык программирования С++” .
В августе 1998 г. был, наконец, принят стандарт языка (ISO/IES 14882 “Standard for the C++ Programming Language”). Однако до сих пор в нашем распоряжении нет среды программирования, которая бы полностью поддерживала стандарт. Конкретно мы будем вести разаработку в среде программирования Borland C++ версии 5.2.
Ключевым понятием С++ является понятие класса. Бьярн Страуструп определяет класс следующим образом: «Класс – это тип, определенный пользователем; это значит, что он задает поведение объектов из этого класса: как они создаются, как может осуществляться работа с ними и как они уничтожаются».
В Турбо Паскале ( до 7-ой версии включительно ) понятию класс соответствовало понятие объектный тип. В языке Object Pascal объектные типы стали называть классами.
Изучение языка Си++ позволит освоить базовые методы разработки и эксплуатации программного обеспечения ПЭВМ, а также более эффективно использовать вычислительную технику в практической деятельности будущего специалиста.
Так как язык Си++ является важным и перспективным языком структурно-модульного программирования, мы будем изучать данный язык на примере решения экономической задачи «Сведения о производительности труда». В задаче даются исходные данные такие как: наименование предприятия, объем валовой продукции и число рабочих. Нам требуется вычислить производительность труда на предприятии. Решение данной задачи программным методом позволит ускорить, упорядочить и упростить расчет и вывод анализируемой информации.
1. Система программирования и прикладные системы
1.1 Объявление и определение функций
В языке С++, как и в его предшественнике С, в отличии от языка Паскаль и др. в которых различаются программы, подпрограммы, процедуры и функции, используются только функции.
При программировании на языке С++ функция – это основное понятие, без которого невозможно обойтись. Во-первых, каждая программа обязательно должна включать единственную функцию с названием main (главная функция). Именно функция main обеспечивает создание точки входа в откомпилированную программу. Кроме главной функции, в программу может входить произвольное количество функций, выполнение которых инициируется прямо или опосредованно вызовами из функции main. Всем именам функций программы по умолчанию присваивается класс памяти extern, т.е. каждая функция имеет внешний тип компоновки и статическую продолжительность существования. Как объект с классом памяти extern, каждая функция глобальна, т.е. при определенных условиях доступна в модуле и даже во всех модулях программы. Для доступности в модуле функция должна быть в нем определена или описана до первого вызова.
Следует различать объявление функции и ее описание (определение).
В определении функции указываются последовательность действий, выполняемых при ее вызове, имя функции, тип функции (тип возвращаемого ею значения, т.е. тип результата) и совокупность формальных параметров (аргументов). Определение функции, в котором выделяются две части – заголовок и тело, имеет следующий формат:
тип_функции имя_функции (спецификация_формальных_параметров)
тело_функции
Здесь тип_функции – тип возвращаемого функцией значения, в том числе void, если функция никакого значения не возвращает. Имя_функции – идентификатор. Имена функций как имена внешние (тип extern) должны быть уникальными среди среди других имен из модулей, в которых используются функции. Спецификация формальных параметров – это либо пусто, либо void, либо список спецификаций отдельных параметров, в конце которого может быть поставлено многоточие. Неиспользуемые параметры имеют смысл в двух случаях: когда предусматривается расширение программы в будущем или, наоборот, когда программа упрощается и за счет этого появляется ” лишний ” параметр. В обоих случаях гарантируется, что не нужно будет изменять саму программу.
Например:
void search ( table *t, const char *key, const char* ) { . }
Тело-функции – это всегда блок или составной оператор, т.е. последовательность описаний и операторов, заключенная в фигурные скобки. Очень важным оператором тела функции является оператор возврата в точку вызова:
return выражение;
или
return;
Пример:
1) int Anyfunc ( void )
{ if ( условие ) return 0;
else { оператор; return 1; } }
2) int factorial ( int n )
{ if (n>1) return n*factorial(n-1);
else return 1;
}
Выражение в операторе return определяет возвращаемое функцией значение. Именно это значение будет результатом обращения к функции. Тип возвращаемого значения определяется типом функции. Если функция не возвращает никакого значения, т.е. имеет тип void, то выражение в операторе return опускается. В этом случае необязателен и сам оператор return в теле фукции. В теле функции может быть и несколько операторов return.
В том случае если функция не должна выполнять никаких действий и не должна возвращать никаких значений, тело функции буде состоять из фигурных скобок {}.
При обращении к функции, формальные параметры заменяются фактическими, причем соблюдается строгое соответствие параметров по типам. В отличие от своего предшественника – языка С, язык С++ не предусматривает автоматического преобразования в тех случаях, когда фактические параметры не совпадают по типам с соответствующими им формальными параметрами. Говорят, что язык С++ обеспечивает «строгий контроль типов». В связи с этой особенностью языка С++ проверка соответствия типов формальных и фактических параметров выполняется на этапе компиляции.
Формальные параметры функции – это обобщенное представление данных, которые нужны функции для ее работы. Их еще называют аргументами.
Фактические параметры – это те конкретные данные, которые передаются функции при каждом ее вызове.
Переменные, объявленные внутри функции, называются локальными. Под эти переменные (если только они не имеют описателя static – см. далее) память выделяется при каждом вызове функции и освобождается при ее завершении.
Формальные параметры по определению являются локальными. Формальные параметры в С++ могут иметь любой встроенный или производный тип.
Строгое согласование по типам между формальными и фактическими параметрами требует, чтобы в модуле до первого обращения к функции было помещено ее объявление (прототип), содержащее сведения о ее типе (о типе результата, т.е. возвращаемого значения) и о типах всех параметров. Именно наличие такого прототипа позволяет компилятору выполнять контроль соответствия типов параметров. Прототип функции может внешне почти полностью совпадать с заголовком ее определения:
тип_функции имя_функции (спецификация_формальных_параметров);
Основное различие – точка с запятой в конце объявления (прототипа). Второе отличие – необязательность имен формальных параметров в прототипе даже тогда, когда они есть в заголовке определения функции.
Примеры:
void f( ); // функция не имеет параметров и не возвращает значение
extern double sqrt( double ); // внешняя функция с параметром и возвращаемым значением типа double
char* strcpy( char *to, const char *from); // функция имеет два параметра и возвращает указатель на char.
2. Решение экономической задачи
«Платежная ведомость предприятия»
2.1 Постановка задачи
Цель курсового проекта – разработка программы на языке Си++ для решения экономической задачи «Платежная ведомость предприятия». Реализована эта задача должна быть двумя путями: с использованием файлов и на базе динамических структур (односвязного списка). Программа должна обеспечивать:
1. Ввод с клавиатуры исходных данных, требуемых для решения данной задачи.
2. Длительное хранение и корректировку этих данных (нужно создать файл для хранения исходных данных и предусмотреть возможность дополнения, изменения, удаления записей и их вывода на экран монитора или принтер).
3. Создание динамической структуры заданного типа (односвязный список), при этом данные должны вводиться в процессе диалога с клавиатуры.
4. Добавление новых элементов в созданную динамическую структуру или исключение существующих; корректировку элементов списка; вывод элементов динамической структуры на экран монитора или принтер в заданном порядке; сохранение структуры в файле и ее воссоздание.
Формула расчета и вид выходного документа указаны в таблице 2.1
Таблица 2.1
№
Фамилия
Зарплата, грн
Удержано, грн
Выдано, грн
1
2
.
F
Z
P
S=Z-P
Итого
S1
S2
S3
При разработке программы необходимо в максимальной степени использовать механизм функций языка С++ (действия над данными, как ввод, вывод, корректировка и другие, должны быть оформлены в виде отдельных функций). Кроме того, при разработке программы необходимо задействовать возможности модульного программирования.
2.2 Разработка алгоритма решения задачи
Разрабатывать программу мы будем в среде программирования Borland C++ версии 5.2.
Так как программа у нас будет объемная и в наши задачи входит обучение модульному программированию мы разобьем программу на модули. Обязательно должен быть головной модуль и заголовочный. В головном модуле будет выводится шапка программы и основное меню. Заголовочный модуль будет содержать работу с файлами и односвязными списками. Но так как это тоже будет большой объем, мы разобьем заголовочный модуль на два модуля: один – работа с файлами, другой – работа со списком.
Итак наша программа будет состоять из головного модуля:
– cursovoi.cpp,
и двух заголовочных:
– f1.h,
– s1.h.
Теперь определимся с данными:
Исходными данными у нас являются :
-Фамилии работников (строковый тип),
-Заработная плата (вещественный тип),
-Удержано из заработной платы (целый тип),
и расчетные данные:
-Выдано заработной платы (вещественный тип).
Фамилий будет неопределенное количество. Для хранения данной информации можно воспользоваться как массивами так и структурами (типами определяемыми пользователями). Проанализировав вышеуказанную информацию (информация по рабочих разных «типов», количество рабочих не известно) мы остановимся на структурах. Мы создадим структуру predpr, содержащую информацию о Фамилии работника, и будем обращаться к ней при помощи переменной типа predpr.
Структура predpr и переменная ved типа predpr будут объявлены как глобальные переменные.
Для структуризации программы, ее удобочитаемости и наглядности построение программы будет основываться на функциях.
Так как информация о фамилиях однотипная, и нам придется передавать ее в функции и обратно, практически все остальные переменные будут локальными, для избежания путаницы и зацикливания.
В С++ используются два типа файлов: текстовые и двоичные (бинарные). По умолчанию файлы открываются в текстовом режиме. Это означает, что при вводе из текстового файла последовательность символов “возврат каретки / перевод строки ” преобразуется в символ ‘\n’ ; при выводе – наоборот. В процессе ввода – вывода производятся, как и в Паскале, преобразования данных из внутреннего (машинного) представления в символьное и наоборот.
В данном случае мы выбрали работу с двоичными файлами, так как информация у нас в основном не текстовая, и за счет этого мы можем увеличить быстродействие, избежанием преобразований файлов текстовые двоичные и обратно.
Головной модуль будет состоять из функций:
– работа с файлом (функция fail( ));
– работа с односвязным списком (spisok( ));
Также в головном модуле будут подключаются заголовочные модули при помощи директивы #include, с указанием пути к этим файлам.
В файле f1.h будет реализовано решение задачи путем работы с файлами т.е. функция fail( ).
Так как нам предстоит работа с файловым, вводом выводом мы будем использовать понятие потока, глобальной переменной мы укажем переменную потока nab типа fstream. Класс fstream мы выбрали, так при работе с этим классом возможны как чтение, так и запись с диска.
При вызове каждой функции работу с файлом мы будем организовывать следующим образом: инициировать поток, открыть файл и связать его с потоком. То есть файл полностью в буфер мы не будем загружать, а будем читать в поток из файла по одной записи, производить над ней определенные действия, и при выходе из функции закрывать поток и файл.
Модуль состоит следующих функций, которые вызываются из функции fail( ):
1. Создание файла и ввод информации по рабочему с клавиатуры (функция sozd())
-функция типа void передает указатель на поток (fstream *q);
2. Дополнение записей в уже созданный файл (функция dopolnen())
– функция типа void передает указатель на поток (fstream *q);
3. Корректировка уже созданных записей (функция korr())
– функция типа void передает указатель на поток (fstream *q);
4. Удаление записей из файла (функция iskl());
– функция типа void передает указатель на поток (fstream *q);
5. Ввывод информации о Фамилии рабочего из файла на экран в форме таблицы (функция pech())
– функция типа void передает указатель на поток (fstream *q);
Также отдельной функцией оформлено:
6. Ввод данных по работникам и расчет выданной зарплаты по введенным данным (функция vvod()).
-функция типа void передает указатель на переменную (predpr *p).
Эта функция вызывается в таких функциях как :
-создание файла;
-дополнение записей в файл;
-корректировка записей.
В функции записывается переменная типа predpr, в которой содержится информация по одному работнику. Далее она анализируется, и с ней производятся действия указанные в конкретной функции.
В файле s1.h будет реализовано решение задачи путем работы с односвязным списком т.е. функция spisok ( ).
Однонаправленным (односвязным) списком называется структура данных, в которой каждый элемент содержит ссылку лишь на одного “соседа”. Поэтому в структуру predpr, которую мы описали ранее нам надо добавить еще одно поле, которое будет содержать указатель на соседнюю запись. Получим новую структуру predpry.
Модуль состоит следующих функций, которые вызываются из функции spisok ( ):
1. Создание списка и ввод информации по работнику с клавиатуры (функция sozd())
– функция типа void передает указатель на переменную (predpry *p);
2. Дополнение записей в уже созданный список (функция vstavka( ())
– функция типа void передает указатель на переменную (predpry *p);
3. Корректировка уже созданных записей (функция korekt())
– функция типа void передает указатель на переменную (predpry *p);
4. Удаление записей из списка (функция udalen ())
– функция типа void передает указатель на переменную (predpry *p);
5. Вывод информации о фамилиях рабочих из списка на экран в форме таблицы (функция prints ())
– функция типа void передает указатель на переменную (predpry *p);
6. Сохранение созданного списка в файле на диске (функция soxran())
– функция типа void передает указатель на переменную (predpry *p);
7. Очистка списка (функция ochistka())
– функция типа void передает указатель на переменную (predpry *p);
8. Восстановление списка из ранее сохраненного файла на диске (функция vossosdanie())
– функция типа void передает указатель на переменную (predpry *p);
В головном модуле нам потребуется подключить такие стандартные библиотеки:
-fstream.h
В этой библиотеке находятся описания потоковых классов. Ее подключение необходимо для использованияя в программе тех или иных средств ввода – вывода при работе с файлами.
-stdlib.h
Стандартная библиотека
-ctype.h
В данной библиотеке описан ряд функций, которые удобно использовать при организации ввода – вывода с целью контроля вводимых значений;
-conio.h -stdio.h -new.h
В данной библиотеке описаны функции для работы с динамической памятью и динамическими переменными, для выделения и освобождения памяти;
-string.h
В данной библиотеке находятся cтандартные функции работы со строками;
-iomanip.h
В данной библиотеке находятся описания манипуляторов, которые используются для форматирования ввода-вывода.
2.3 Разработка программы решения задачи
Итак наша программа состоит из 3-х модулей:
– cursovoi.cpp,
– f1.h,
– s1.h.
Главная функция main(), находится в модуле cursovoi.cpp. В главной функции, выводится сначала шапка курсового проекта. Затем в конструкции do{}while() выводится основное меню в котором предлагаются следующие возможности:
1. Работа с файлами
2. Работа со списками
3. Выход из программы
Первые два пункта реализуются в конструкции switch()case: если выбран пункт 1, то вызывается функция fail(); если выбран пункт 2 , то вызывается функция spisok(). При выборе пункта 3 происходит выход из конструкции do{}while(), и завершается работа программы.
Переменные в функции main() не объявляются: все глобальные переменные объявлены в функциях fail() и spisok().
Опишем глобальные переменные, используемые в программе в таблице 2.3.1.
Таблица 2.3.1
Принятое имя
Наименование
Ved
Переменная типа predpr (структура определенная пользователем), используется для промежуточного хранения информации по одному предприятию при работе с файлами.
Otv
Переменная тип char, используется для считывания запрашиваемых ответов в функциях fail() и spisok().
vibor
Переменная тип char, используется для выбора пунктов меню, как главного, так и меню в функциях fail() и spisok().
nab
Переменная типа fsrteam, используется в качестве параметра для передачи ссылки на поток в функциях работы с файлами.
buf
Переменная типа predpry (структура определенная пользователем), используется для промежуточного хранения информации по одному предприятию при сохранении списка в файл, и считывания списка из файла.
nach
Переменная содержащая указатель на начало списка
tek
Переменная содержащая указатель на текущую позицию списка
Функция fail() – выводится меню работы с файлами, реализована также в конструкции switch()case:
-выбор 1 – функция sozd();
-выбор 2 – функция dopolnen();
-выбор 3 – функция korr();
-выбор 4 – функция iskl();
-выбор 5 – функция pech();
При выборе пункта 6 происходит выход из конструкции do{}while(), и выход в головную функцию.
Локальных переменных не объявляется, используются глобальные.
В отдельную небольшую функцию выделена функция задержки экрана – функция pause(). Она будет использоваться практически во всех ниже описанных функциях.
Функция sozd() – создание нового файла.
С клавиатуры вводится название файла, проверяется есть ли уже такой файл. Если файла с таким именем нет, то файл создается, и открывается в двоичном режиме на запись.
Информация по фамилиям рабочих заносится с клавиатуры в функции vvod(), и хранится во временной переменной.
Затем проверяется существует ли фамилия с именем, указанным во временной переменной. Если уже есть, то запись не сохраняется, если нет, то сохраняется.
После этого запрашивается продолжать ли ввод по фамилиям рабочих. Если нет, то происходит выход из функции, если да, то возвращаемся на функцию ввод.
Переменные, используемые в функции, опишем в таблице 2.3.2.
Таблица 2.3.2
Принятое имя
Наименование
vedread
Переменная типа predpr (структура определенная пользователем), используется для промежуточного хранения информации по одной фамилии при работе с файлами.
fname
Переменная тип char, используется для считывания и хранения имени файла.
*name
Указатель на тип char, используется при проверке фамилии рабочих.
kol
Переменная типа int, в которой записывается кол-во записей в файле
k
Переменная типа int, счетчик. Используется при проверке фамилии рабочих.
Функция dopolnen() – дополнение записей в уже созданный файл. С клавиатуры вводится название файла, проверяется есть ли файл с таким названием. Если файл есть, то открывается в двоичном режиме на дополнение.
Информация по фамилиям рабочих заносится с клавиатуры в функции vvod(), и хранится во временной переменной.
Затем проверяется существует ли предприятие с именем, указанным во временной переменной. Если уже есть, то запись не сохраняется, если нет, то сохраняется.
После этого запрашивается продолжать ли ввод по фамилиям рабочих . Если нет, то происходит выход из функции, если да, то возвращаемся на функцию ввод.
Переменные, используемые в функции, опишем в таблице 2.3.3.
Таблица 2.3.3
Принятое имя
Наименование
vedread
Переменная типа predpr (структура определенная пользователем), используется для промежуточного хранения информации по одной фамилии при работе с файлами.
fname
Переменная тип char, используется для считывания и хранения имени файла.
*name
Указатель на тип char, используется при проверке фамилии.
kol
Переменная типа int, в которой записывается кол-во записей в файле
k
Переменная типа int, счетчик. Используется при проверке фамилии рабочих .
Функция korr () – корректировка записей в уже созданном файле.
С клавиатуры вводится название файла, проверяется есть ли файл с таким названием. Если файл есть, то открывается в двоичном режиме на чтение.
Затем вводится название корректируемой фамилии.
Поочередно просматриваются записи в файле, и сравниваются текущая фамилия рабочего с введенным с клавиатуры. Если наименования совпадают, то запоминается номер позиции записи в файле.
Новая информация по корректируемой фамилии рабочего заносится с клавиатуры в функции vvod(), записывается во временной переменной, и записывается на место корректируемой записи с
После этого запрашивается продолжать ли корректировку по фамилиям рабочих . Если нет, то происходит выход из функции, если да, то возвращаемся на ввод названия корректируемой фамилии рабочего.
Переменные, используемые в функции, опишем в таблице 2.3.4.
Таблица 2.3.4
Принятое имя
Наименование
n
Переменная тип char, используется для считывания и хранения имени корректируемой фамилии рабочего.
fname
Переменная тип char, используется для считывания и хранения имени файла.
Функция iskl () – удаление записей из уже созданного файла.
С клавиатуры вводится название файла, проверяется есть ли файл с таким названием. Если файл есть, то открывается в двоичном режиме на чтение.
Также организовывается вспомогательный поток данных на запись.
Затем вводится название корректируемой фамилии рабочего.
Поочередно просматриваются записи в файле, и сравниваются текущую фамилию рабочего с введенным с клавиатуры. Если наименования не совпадают, тогда текущая запись записывается во вспомогательный файл, если совпадают то данная запись пропускается.
Когда просмотрены все записи, и если запись с исходным наименованием существовала, то исходный файл удаляется, а вспомогательному файлу, присваивается имя исходного.
Если записи с исходным наименованием не существовало, тогда удаляется вспомогательный файл.
После этого запрашивается продолжать ли удаление фамилий рабочих. Если нет, то происходит выход из функции, если да, то возвращаемся на ввод названия корректируемой фамилии рабочего.
Переменные, используемые в функции, опишем в таблице 2.3.5.
Таблица 2.3.5
Принятое имя
Наименование
vspom
Потоковая переменная тип ofstream, используется для хранения вспомогательного файла.
isk
Переменная тип char, используется для считывания и хранения имени удаляемого фамилии рабочего.
fname
Переменная тип char, используется для считывания и хранения имени файла.
col
Переменная типа int, флажок. Используется при проверке фамилии рабочих .
Функция pech() – вывод на экран содержимое файла.
С клавиатуры вводится название файла и открывается в двоичном режиме на чтение.
Последовательно во временную переменную считывается информация по фамилиям рабочих , выводится построчно на экран, и пересчитываются накопительные суммы по зарплате, суммы удержания, и выданной заработной платы, которые выводятся в конце таблицы строкой ИТОГО.
Переменные, используемые в функции, опишем в таблице 2.3.6.
Таблица 2.3.6
Принятое имя
Наименование
kol
Переменная типа int, в которой записывается кол-во записей в файле
svalprod
Переменная типа float, для накопительной суммы заработной платы
skolrab
Переменная типа int, для накопительной суммы по удержаниям
sproizv
Переменная типа float, для накопительной суммы по выданной заработной плате.
Функция spisok() – выводится меню работы с односвязным списком, реализована также в конструкции switch()case:
-выбор 1 – функция sozd();
-выбор 2 – функция vstavka ();
-выбор 3 – функция korekt ();
-выбор 4 – функция udalen ();
-выбор 5 – функция prints ();
-выбор 6 – функция soxran ();
-выбор 7 – функция ochistka ();
-выбор 8 – функция vossosdanie ();
При выборе пункта 9 происходит выход из конструкции do{}while(), и выход в головную функцию.
В начале функции, перед циклом, мы создаем нулевой фиктивный элемент списка.
Локальных переменных не объявляется, используются глобальные.
Функция sozd() – создание односвязного списка.
Параметром в функцию передается указатель на начало списка.
В данной функции в цикле вызывается функция vstavka (), пока запрашиваемый ответ не будет ‘N’, и заполняется список.
Функция vstavka () – добавление записей в односвязный список.
Параметром в функцию передается указатель на начало списка.
Создается новая запись. С клавиатуры вводится название нового фамилии, затем проверяется существует ли запись с такой фамилией. Если такая запись уже существует, то выводится соответствующее сообщение и запись не сохраняется. Если записи с такой фамилией нет то, заполняются все поля структуры, и новая запись сохраняется как последний элемент структуры.
Переменные, используемые в функции, опишем в таблице 2.3.7.
Таблица 2.3.7
Принятое имя
Наименование
nov
Указатель на переменную типа predpry (структура определенная пользователем), используется для хранения информации по новой фамилии рабочего.
tek1
Указатель на переменную типа predpry (структура определенная пользователем), используется для хранения информации по текущей фамилии.
b
Переменная типа int, флажок. Используется при проверке фамилии.
Функция korekt () – корректировка записей в односвязном списке.
Параметром в функцию передается указатель на начало списка.
С клавиатуры вводится название корректируемой фамилии. Затем поочередно просматриваются записи в списке: если наименования совпадают то предлагается на выбор изменять или не изменять отдельные поля в записи. Если запись с исходным именем не найдена, то происходит выход из функкции.
Переменные, используемые в функции, опишем в таблице 2.3.8.
Таблица 2.3.8
Принятое имя
Наименование
k
Переменная тип char, используется для считывания и хранения имени файла.
b
Переменная типа int, флажок. Используется при проверке фамилии.
Функция udalen () – удаление записей из односвязного списка
Параметром в функцию передается указатель на начало списка.
Проверяется не пустой ли список. Если да, то выводится соответствующее сообщение, и происходит выход из функции. С клавиатуры вводится название удаляемой фамилии, затем проверяется существует ли запись с такой фамилией. Если такая запись существует, то указателю текущей записи пере присваивается указатель следующей записи. Если записи с такой фамилией нет то, заполняются все поля структуры, и последней записью становится новая запись.
Переменные, используемые в функции, опишем в таблице 2.3.9.
Таблица 2.3.9
Принятое имя
Наименование
nov
Указатель на переменную типа predpry (структура определенная пользователем), используется для хранения информации по новой фамилии.
tek1
Указатель на переменную типа predpry (структура определенная пользователем), используется для хранения информации по текущей фамилии.
b
Переменная типа int, флажок. Используется при проверке фамилии.
Функция prints () – вывод на экран односвязного списка
Параметром в функцию передается указатель на начало списка.
Проверяется не пустой ли список. Если да, то выводится соответствующее сообщение, и происходит выход из функции. Выводится шапка таблицы. Затем производится проход по списку, и построчно выводится информация о фамилиях. Параллельно производится расчет накопительных сумм по зарплате, суммам удержаний и выданной заработной плате. Действия выполняются пока не достигнут конец списка.
Переменные, используемые в функции, опишем в таблице 2.3.10.
Таблица 2.3.10
Принятое имя
Наименование
svalprod
Переменная типа float используется для хранения накопительной суммы по зарплате.
skolrab
Переменная типа int используется для хранения накопительной суммы по удержаниям.
sproizv
Переменная типа float используется для хранения накопительной суммы выданной заработной платы.
i
Переменная типа int, счетчик. Используется для подсчета количества фамилий.
Функция soxran () – сохранение односвязного списка в файле на жестком диске
Параметром в функцию передается указатель на начало списка.
С клавиатуры вводится название файла в котором будет сохранен список. Затем открывается файл с указанным именем в двоичном режиме на запись. Затем поочередно записи из списка копируются в буферную переменную, и в файл. после этого файл закрывается.
Переменные, используемые в функции, опишем в таблице 2.3.11.
Таблица 2.3.11
Принятое имя
Наименование
fname
Переменная тип char, используется для считывания и хранения имени файла.
k
Переменная типа int, счетчик. Используется для подсчете количества записей.
Функция ochistka () – очистка односвязного списка
Параметром в функцию передается указатель на начало списка.
Проверяется не пустой ли список. Если список пуст, то выводится соответствующее сообщение и происходит выход из функции. Если список не пустой, то производится проход по списку, и удаление текущего элемента, пока не будет достигнут последний элемент списка.
Переменные, используемые в функции, опишем в таблице 2.3.12.
Таблица 2.3.12
Принятое имя
Наименование
k
Переменная типа int, счетчик. Используется для подсчете количества записей.
Функция vossosdanie () – воссоздание односвязного списка из раннее сохраненного файла.
Параметром в функцию передается указатель на начало списка.
С клавиатуры вводится название файла в котором был сохранен список. Затем открывается файл с указанным именем в двоичном режиме на чтение. Файл откроется только, если он был ранее создан. Затем в цикле записи из файла копируются в буферную переменную. Каждый проход цикла создается новый элемент списка, в поля которого копируются соответствующие поля буферной переменной, и формируется поле адреса. Когда просмотрены все записи в файле, файл закрывается.
Переменные, используемые в функции, опишем в таблице 2.3.13.
Таблица 2.3.13
Принятое имя
Наименование
nov
Указатель на переменную типа predpry (структура определенная пользователем), используется для копирования информации по фамилии из файла в список.
tek1
Указатель на переменную типа predpry (структура определенная пользователем), используется для копирования информации по фамилии из файла в список. Вспомогательная переменная
fname
Переменная тип char, используется для считывания и хранения имени файла.
kol
Переменная типа int, в которой записывается кол-во записей в файле
k
Переменная типа int, счетчик. Используется для подсчете количества записей.
Ниже приведены блок схемы следующих функций:
– рисунок 1 – главная функция main();
– рисунок 2 – функция создания файла sozd();
– рисунок 3 – функция воссоздания списка vossosdanie().
Рис.1. Блок схема главной функции main()
Рис. 2. Блок схема функции создания файла sozd()
Рис. 3. Блок схема функции воссоздания списка vossosdanie ()
potok.close
Нет
Да
Закрываем поток
Закрываем поток
q->close
for (int i=0; i
k++
tek1->next=nov
Устанавливаем новое начало списка
nov->next=
tek1->next
Переходим на следующий элемент списка
nov->nazva nov->valprod
nov->kolrab
nov->proizv
nov=new predpry
Заполняем поля нового элемента данными из вспом. переменной
Создаем новый элемент списка
tek=nach->next
tek1=nach
Запоминаем адрес текущего эл-та списка
potok.read ((char*)&buf, sizeof(buf))
Считываем i-ю запись из файла во вспомогательную переменную
2.3.1.Описание работы программы (краткое руководство пользователя)
Примечание: Так как программа была разработана в среде Borland C++ версии 5.2. американская версия, которая не русифицированна и не принимает кодов ASCII, все руководства будут выводится на экран русскими словами, но латинскими буквами. Просим извинения за неудобства чтения.
Для запуска программы надо найти и запустить файл с именем cursovoi.cpp. После запуска файла в окне MS DOS выведется сначала шапка курсового проекта:
Kursovoi proekt[Курсовой проект]
Pokursu \”OP I AY\ [По курсу «ОП и АЯ»]
Na temu: Platejnaya vedomost predpriyatia [На тему «Платежная ведомость предприятия»]
Vipolnil student 1 kursa gr. 401-2 [Выполнил студент 1 курса гр. 401-2]
Borzdun Alexei Petrovich [Борздун Алексей Петрович]
После этого для продолжения работы надо нажать Enter. Далее появится главное меню:
programma reshaet takie zadachi: [программа решает такие задачи]
1)Rabota s failom [1) Работа с файлом]
2)Rabota s odnoswaznim spiskom [2) Работа с односвязным списком]
3)Exit [Выход]
Vach vibor: [Ваш выбор]
Для работы с файлом надо набрать цифру 1, для работы с односвязным списком – цифру 2, для выхода из программы – цифру 3. После этого надо нажать Enter.
При выборе работы с файлом появится подменю:
Vidy raboti s failom: [Виды работ с файлом]
1)Sozdanie faila [1) Создание файла]
2)Dopolnenie zapisei v fail [2) Дополнение записи в файл]
3)Korrektirovka zapisei [3) Корректировка записи]
4)Udalenie zapisei iz faila [4) Удаление записи]
5)Pechat faila [5) Печать файла]
6)Vozvrat v osnovnoe menu [6) Возврат в основное меню]
Vash vibor: [Ваш выбор]
Для создания файла надо набрать цифру 1, для дополнения записей в файл – цифру 2, для корректировки записей – цифру 3, для удаления записей из файла – цифру 4, для вывода записей из файла не экран – цифру 5, для возврата в основное меню – цифру 6. После этого надо нажать Enter.
При выборе работы с односвязным списком появится подменю:
Vid rabot s odnoswaznim spiskom: [Вид работ с односвязным списком]
1) Sozdanie spiska [1) Создание списка]
2) Dopolnenie spiska [2) Дополнение списка]
3) Korrektirovka zapisey [3) Корректировка записи]
4) Udalenie zapisey [4) Удаление записи]
5) Pechat’ spiska [5) Печать списка]
6) Sohranenie spiska [6) Сохранение списка]
7) Ochistka spiska [7) Очистка списка]
8) Vossozdanie spiska [8)Воссоздание списка ]
9) Vozvrat v osnovnoe menu [9) Возврат в основное меню]
Vash vibor: [Ваш выбор]
Для создания списка надо набрать цифру 1, для дополнения записей в список – цифру 2, для корректировки записей – цифру 3, для удаления записей из списка – цифру 4, для вывода записей из списка на экран – цифру 5, для сохранения записей из списка в файле – цифру 6, для очистки списка – цифру 7, для воссоздания списка из ранее сохраненного файла – цифру 8, для возврата в основное меню – цифру 9. После этого надо нажать Enter.
Заключение
В процессе выполнения данной курсовой работы была разработана программа для решения экономической задачи «Платежная ведомость предприятия» на алгоритмическом языке программирования Си ++. Был разработан алгоритм решения задачи, составлены блок-схемы для отдельных функций.
В ходе самостоятельной работы был изучен язык Си++, его три основные составляющие:
– алфавит – конечное множество различимых между собой символов;
– синтаксис – совокупность правил, определяющих допустимые конструкции данного языка;
– семантика – совокупность правил определяющих смысловое содержание отдельных конструкций.
Также изучили работу с динамическими структурами данных (односвязные, двухсвязные списки, стеки очереди) на примере работы с односвязным списком. Получили навыки по работе с файлами. Освоили методы структурно-модульного программирования, разбивая программу на модули.
В процессе работы над курсовым проектом была достигнута основная цель курсового проектирования – закрепление и улучшение фундаментальных теоретических знаний в области структурно-модульного программирования и получение навыков разработки и отладки программ решения экономических задач.
Список использованной литературы
1. Харви Дейтел, Пол Дейтел. Как программировать на С++; Третье издание. Пер. с англ. – М.:ЗАО «Издательсиво БИНОМ»,2001 г. – 1153 с.
2. Методические рекомендации к лабораторным работам по курсу «Основы программирования и алгоритмические языки» для студентов специальности 7.050401 дневной формы обучения. Часть 1. / Составители: Ю.В.Перколаб, В.В.Браткевич, Л.И.Лукашева. Изд.ГГЭУ,2001 г.
3. Браткевич В.В., Лукашева Л.И.,Перколаб Ю.В., Основы программирования и алгоритмические языки (язык программирования С++). Часть 1. Конспект лекций. Харьков: Изд.ГГЭУ,2001 г.
4. Методические рекомендации к лабораторным работам по курсу «Основы программирования и алгоритмические языки» для студентов специальности 7.080401 всех форм обучения. Часть 2. / Составители: Ю.В.Перколаб, В.В.Браткевич, Л.И.Лукашева. Изд.ГГЭУ,2002. г
5. Б.Страуструп. Язык программирования С++, 3-е изд.\Пер. с англ. – СПб.; М.: «Невский диалект» – Издательство БИНОМ», 1999 г
6. Подбельский В.В. Язык С++: Учебн.пособие. – 4-е изд. – М.: Финансы и статистика, 1999, — 560 с.
7. Фридман А.Л. Основы объектно – ориентированного программирования на языке С++.—М.: Горячая линия – Телеком, Радио и связь, 1999 г
Приложение 1
Текст программы
– Главный модуль cursovoi.cpp :
#include
#include
#include
#include
#include
#include
#include
#include
#include “a:\\f1.h”
#include “a:\\s1.h”
main ( )
{
cout cout pause();
do
{
clrscr();
cout cout cout cout cout cout cin >> vibor;
clrscr();
switch (vibor)
{
case ‘1’:
clrscr();
fail( );
break;
case ‘2’:
clrscr();
spisok( );
break;
}
} while (vibor!=’3′);
/*ochistka(nach);
delete nach; */
cout return 0;
}
– Заголовочный модуль f1.h :
// f1.h
struct predpr
{
char nazva[15];
float valprod;
int kolrab;
float proizv;
};
predpr ved;
char otv;
char vibor;
fstream nab;
void vvod(predpr *p);
void sozd(fstream *q);
void pech(fstream *q);
void dopolnen(fstream *q);
void korr(fstream *q);
void iskl(fstream *q);
void pause();
/////////////////////////////////////////////////////////////////////////
void fail()
{
do
{
clrscr();
cout cout cout cout cout cout cout cout cin >> vibor;
clrscr();
switch (vibor)
{
case ‘1’:
clrscr();
sozd(&nab);
pause();
break;
case ‘2’:
clrscr();
dopolnen(&nab);
pause();
break;
case ‘3’:
clrscr();
korr(&nab);
pause();
break;
case ‘4’:
clrscr();
iskl(&nab);
pause();
break;
case ‘5’:
clrscr();
pech(&nab);
pause();
break;
}
}
while (vibor!=’6′);
}
////////////////////////////////////////////////////////////////////////////
void sozd(fstream *q)
{
predpr vedread;
int kol,k=1;
char fname[8],*name;
clrscr();
cout cin >> fname;
q->open(fname, ios::out|ios::binary|ios::noreplace);
if (!*q) {
cout cout return; }
do {
clrscr();
vvod(&ved);
k=1;
name=ved.nazva;
q->seekp(0, ios::end);
kol=q->tellp()/sizeof(predpr);
if (*q)
{
if (kol==0)
q->write( (char*)&ved, sizeof(ved) );
else
{q->close();
q->open(fname, ios::in|ios::binary);
for (int i=0; i
{
q->read( (char*)&vedread, sizeof(vedread) );
if (strcmp(vedread.nazva,name))
k++;
}
if (k!=kol)
{
q->close();
q->open(fname, ios::app|ios::binary);
q->write( (char*)&ved, sizeof(ved) );
}
else
{
cout cout }
}
}
cout cin >> otv;
}
while ((otv!=’N’)&&(otv!=’n’));
q->close();
}
////////////////////////////////////////////////////////////////////////////
void vvod(predpr *p)
{
char name[15] ;
cout cout cin >> p->nazva;
cout cin >> p->valprod;
cout cin >> p->kolrab;
p->proizv=p->valprod/p->kolrab;
cout cout proizv }
////////////////////////////////////////////////////////////////////////////
void pech(fstream *q)
{
int kol;
float svalprod=0;
int skolrab=0;
float sproizv=0;
clrscr();
cout char fname[8];
cin >> fname;
q->open(fname, ios::app|ios::binary|ios::nocreate);
if (!*q) {
cout return; }
q->seekp(0, ios::end);
kol=q->tellp()/sizeof(predpr);
q->close();
q->open(fname, ios::in|ios::binary);
if (*q)
{ clrscr();
cout cout cout cout for (int i=0; i { q->read( (char*)&ved, sizeof(ved) );
cout cout cout.setf(ios::left);
cout cout.setf(ios::fixed);
cout.setf(ios::right);
cout cout svalprod+=ved.valprod;
cout skolrab+=ved.kolrab;
cout sproizv+=ved.proizv;
}
cout cout cout cout cout cout }
q->close();
// cout.unsetf();
}
///////////////////////////////////////////////////////////////////////////
void pause()
{
cout while ( getch() != 13) ;
}
////////////////////////////////////////////////////////////////////////////
void dopolnen(fstream *q)
{ char otv;
predpr vedread;
int kol,k=1;
clrscr();
cout char fname[8],*name;
cin>>fname;
q->open(fname, ios::app|ios::binary|ios::nocreate);
if (!*q) {
cout return; }
do
{ vvod(&ved);
k=1;
name=ved.nazva;
q->seekp(0, ios::end);
kol=q->tellp()/sizeof(predpr);
if (*q)
{
q->close();
q->open(fname, ios::in|ios::binary);
for (int i=0; i {
q->read( (char*)&vedread, sizeof(vedread) );
if (strcmp(vedread.nazva,name))
k++;
}
if (k!=kol)
{
q->close();
q->open(fname, ios::app|ios::binary);
q->write( (char*)&ved, sizeof(ved) );
}
else
{
cout cout }
}
cout cin >> otv;
} while ((otv!=’N’)&&(otv!=’n’));
q->close();
}
////////////////////////////////////////////////////////////////////////////
void korr(fstream *q)
{
char n[15];
clrscr();
cout char fname[8];
cin >> fname;
q->open(fname, ios::in|ios::out|ios::binary|ios::nocreate);
if (!*q) {
cout return; }
do
{clrscr();
cout cin>>n;
do
{
q->read( (char*)&ved, sizeof(ved) );
} while (*q && strcmp(ved.nazva,n) );
if (!strcmp(ved.nazva,n))
{ vvod(&ved);
q->seekp(-streamoff(sizeof(predpr)),ios::cur);
q->write( (char*)&ved, sizeof(ved) );
}
else
cout q->seekp(0);
cout cin >> otv;
} while ((otv!=’N’)&&(otv!=’n’));
q->close();
}
////////////////////////////////////////////////////////////////////////////
void iskl(fstream *q)
{
ofstream vspom;
char isk[15];
int col=0;
char fname[8];
cout cin >> fname;
clrscr();
do
{
q->open(fname, ios::in|ios::binary);
vspom.open(“vsp”,ios::out|ios::binary);
if ( *q && vspom )
{
cout cin >> isk;
do
{
q->read( (char*)&ved, sizeof(ved) );
if (q->eof()) break;
if (!strcmp(ved.nazva,isk))
col=1;
else
vspom.write( (char*)&ved, sizeof(ved) );
} while ( *q );
q->close();
vspom.close();
if (col)
{
remove(fname);
rename(“vsp”, fname);
cout }
else
{ cout remove(“vsp”); }
}
else
{
cout break; }
cout cin >> otv;
} while ((otv!=’N’)&&(otv!=’n’));
}
///////////////////////////////////////////////////////////////////////////
– заголовочный модуль s1.h :
// s1.h
struct predpry
{
char nazva[15];
float valprod;
int kolrab;
float proizv;
predpry* next;
};
predpry buf;
predpry* nach;
predpry* tek;
void sozd(predpry* );
void prints(predpry* );
void vstavka(predpry* );
void udalen(predpry*);
void korekt(predpry*);
void soxran (predpry*);
void ochistka(predpry*);
void vossosdanie(predpry* );
void pause();
///////////////////////////////////////////////////////////////////////////////
void spisok()
{
nach=new predpry;
nach->next=0;
strcpy(nach->nazva,”fik”);
nach->valprod =0;
nach->kolrab =0;
do
{
clrscr();
cout cout cout cout cout cout cout cout cout cout cout cin >> vibor;
clrscr();
switch (vibor)
{
case ‘1’:
clrscr();
sozd(nach);
pause();
break;
case ‘2’:
clrscr();
vstavka(nach);
pause();
break;
case ‘3’:
clrscr();
korekt(nach);
pause();
break;
case ‘4’:
clrscr();
udalen(nach);
pause();
break;
case ‘5’:
clrscr();
prints(nach);
pause();
break;
case ‘6’:
clrscr();
soxran(nach);
pause();
break;
case ‘7’:
clrscr();
ochistka(nach);
pause();
break;
case ‘8’:
clrscr();
vossosdanie(nach);
pause();
break;
}
} while (vibor!=’9′);
}
////////////////////////////////////////////////////////////////////
void sozd(predpry* nach)
{
clrscr();
do
{
//clrscr();
vstavka(nach);
cout cin>>otv;
} while ((otv!=’N’)&&(otv!=’n’));
}
//////////////////////////////////////////////////////////////////////////////
void vstavka(predpry* nach)
{
predpry* nov; predpry* tek1;
int b;
tek=nach->next;
tek1=nach;
b=1;
nov=new predpry;
cout cout cin >> nov->nazva;
while ((tek!=0) && b)
{
if ( !strcmp(tek->nazva,nov->nazva))
{
cout b=0;
return;
}
else
{
tek1=tek;
tek=tek->next;
}
}
cout cin >> nov->valprod;
cout cin >> nov->kolrab;
nov->proizv=nov->valprod/nov->kolrab;
cout cout proizv;
nov->next=tek1->next;
tek1->next=nov;
}
////////////////////////////////////////////////////////////////////////////
void korekt(predpry* nach)
{
clrscr();
char k[15];
int b=1;
cout cin>>k;
tek=nach->next;
while ((tek!=0) && b )
{
if(!strcmp(tek->nazva,k))
b=0;
else
tek=tek->next;
}
if (b==0)
{
if (!strcmp(tek->nazva,k) )
{
cout cout cin >> tek->nazva;
cout cout valprod;
cout cin >> otv;
if ((otv!=’N’)&&(otv!=’n’))
{
cout cin >> tek->valprod;
}
cout cout kolrab;
cout cin >> otv;
if ((otv!=’N’)&&(otv!=’n’))
{
cout cin >> tek->kolrab;
}
tek->proizv=tek->valprod/tek->kolrab;
cout cout proizv;
cout }
}
else
{
cout return;
}
}
//////////////////////////////////////////////////////////////////////////////////
void udalen(predpry* nach)
{
predpry* tek1;
clrscr();
int b=1;
char isk[15];
cout cin>>isk;
tek=nach->next;
tek1=nach;
if(tek==0)
{
cout return;
}
while ((tek!=0) && b )
{
if(!strcmp(tek->nazva,isk))
{
tek1=tek;
b=0;
}
else tek=tek->next;
}
if (b==0)
{if (!strcmp(tek->nazva,isk) )
{
tek1->next=tek->next;
delete tek;
}
}
else
cout return;
}
///////////////////////////////////////////////////////////////////////////////////
void prints(predpry* nach)
{
float svalprod=0;
int skolrab=0;
float sproizv=0;
int i=1;
tek=nach->next;
if (tek==0)
{
cout return;
}
cout cout cout cout while (tek!=0)
{
cout cout
cout.setf(ios::left);
coutnazva cout.setf(ios::fixed);
cout.setf(ios::right);
cout
coutvalprod svalprod+=tek->valprod;
coutkolrab skolrab+=tek->kolrab;
coutproizv sproizv+=tek->proizv;
tek=tek->next;
}
cout cout cout cout cout cout}
/////////////////////////////////////////////////////////////////////
void soxran(predpry* nach)
{
tek=nach->next;
if (tek==0)
{
cout return;
}
int k=0;
char fname[8];
cout cin >> fname;
ofstream potok;
potok.open(fname,ios::out|ios::binary);
if(!potok)
{
cout return;
}
while (tek!=0)
{
strcpy(buf.nazva,tek->nazva);
buf.valprod = tek->valprod;
buf.kolrab = tek->kolrab;
buf.proizv = tek->proizv;
potok.write((char*)&buf, sizeof(buf));
tek=tek->next;
k++;
}
cout potok.close();
}
//////////////////////////////////////////////////////////////////////////////////
void vossosdanie(predpry* nach)
{
long kol;
int k=0;
char fname[8];
cout cin >> fname;
fstream potok;
potok.open(fname,ios::app|ios::binary|ios::nocreate);
if(!potok)
{
cout return;
}
potok.seekp(0,ios::end);
kol = potok.tellp( ) / sizeof(predpry);
potok.close();
cout potok.open(fname,ios::in|ios::binary);
nach->next = 0;
predpry* nov;
predpry* tek1;
for(int i=0; i {
potok.read((char*)&buf, sizeof(buf));
tek=nach->next;
tek1=nach;
nov=new predpry;
strcpy(nov->nazva,buf.nazva);
nov->valprod = buf.valprod;
nov->kolrab = buf.kolrab;
nov->proizv = buf.proizv;
nov->next=tek1->next;
tek1->next=nov;
k++;
}
cout potok.close();
}
////////////////////////////////////////////////////////////////////////////
void ochistka(predpry *nach)
{
int k=0;
tek=nach->next;
if (tek==0)
{
cout return ;
}
while (tek!=0)
{
delete tek;
tek=tek->next;
k++;
}
nach->next=0;
cout }