МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ РОССИЙСКОЙ ФЕДЕРАЦИИ Министерство образования Российской Федерации УФИМСКИЙ

МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ РОССИЙСКОЙ
ФЕДЕРАЦИИ
Министерство образования Российской Федерации
Федеральное государственное образовательное учреждение
среднего профессионального образования
УФИМСКИЙ
ГОСУДАРСТВЕННЫЙ КОЛЛЕДЖ РАДИОЭЛЕКТРОНИКИ
УТВЕРЖДАЮ
Зам. директора по УВР
_______________Л.Р.Туктарова
«____»_______________2011 г
Методические указания
по выполнению курсовой работы
для студентов специальности 230105
”Программное обеспечение вычислительной техники
и автоматизированных систем”
по дисциплине
”Технология разработки программных продуктов”
Согласовано
Методист УГКР
_______________ Горцева Т.Н.
Рассмотрено
на
заседании
кафедры
программирования и ИТ
Зав. кафедрой
Бронштейн М.Е.
Разработала
к.т.н., преподаватель
Полюдова Г.Р.
Уфа 2011
Методические указания по выполнению курсовой работы
для студентов специальности
230105”Программное обеспечение вычислительной техники
и автоматизированных систем”
по дисциплине
«Технология разработки программных продуктов»
Составитель:
Полюдова Г.Р.
к.т.н. преподаватель УГКР
Рецензент:
______М.Е._Бронштейн____ зав. кафедрой программирования
и ИТ, преподаватель УГКР
Содержание
стр
Введение
3
1. Цели и задачи курсовой работы
4
2. Основные этапы выполнения курсовой работы
5
3. Постановка задачи
5
4. Краткие теоретические сведения
6
4.1 Динамические массивы структур
6
4.2 Классы. Класс массивов структур
11
4.3 Классы. Класс динамических массивов структур
15
4.4 Списки. Класс списка структур
22
4.5 Работа с графическими примитивами
30
5. Правила оформления пояснительной записки
36
6. Программные средства обеспечения выполнения курсовой работы
36
7. Литература
37
Приложение А
38
Введение
Технологии программирования играет разную роль этапах развития
программирования. По мере повышения мощности компьютеров и развития
средств и методологии программирования росла и сложность решаемых на
компьютерах задач, что привело к повышенному вниманию к технологии
программирования.
Понятие технологии в русском языке имеет ясное определение, понятие
технологии программирования требует некоторого уточнения прежде всего из-за
необходимости определения, что следует считать продуктом этой технологии.
Кроме того, появление этого термина в русскоязычной научной литературе
вызвано в значительной степени не всегда адекватным переводом иноязычной
литературы по программированию, что привело к различным определениям
(толкованиям) этого понятия.
Одним из основных видов самостоятельной
выполнение
принципов
деятельности
является
курсовой работы. Работа затрагивает вопросы изучения основных
разработки
программных
продуктов,
технологии
и
стили
программирования. Написание и защита курсовой работы является одним из
возможных вариантов завершения изучения дисциплины «Технология разработки
программных продуктов».
Приступая
к
выполнению
курсовой
работы
студенту
необходимо
ознакомиться с основными этапами его выполнения: разработка алгоритма,
написание программного кода, оформление пояснительной записки.
Настоящие
методические
указания
предназначены
для
студентов
специальности 230105 «Программное обеспечение вычислительной техники и
автоматизированных систем».
1. Цели и задачи курсовой работы
Целью курсовой работы является закрепление и углубление знаний,
полученных студентами по дисциплине «Технология разработки программных
продуктов», развитие навыков при выборе представления исходных данных,
использовании различных стилей программирования при написании программ на
языке Си++, тестировании и отладки программ, оформление документации на
программные разработки.
Задачами курсовой работы являются:
 -
закрепление,
углубление,
расширение
и
систематизация
знаний,
полученных при изучении дисциплины «Основы алгоритмизации и
программирования», а также приобретение практических навыков решения
комплексных задач;
 - приобретение опыта аналитической работы, развитие умений работы со
специальной литературой и иными информационными источниками;
 - применять на практике методы, языки и технологии разработки
программных продуктов,
 - пользоваться методами и средствами анализа описания и проектирования
человеко-машинного
взаимодействия,
инструментальными
средствами
разработки пользовательского интерфейса;
 - формирование умений формулировать логически обоснованные выводы,
предложения и рекомендации по результатам выполненной работы;
 - формирование умения выступать перед аудиторией с докладом при защите
курсовой
работы,
компетентно
отвечать
на
вопросы,
вести
профессиональную дискуссию;
 - развитие у студента системного мышления, а также профессиональной
устной и письменной речи.
В результате выполнения курсовой работы студент должен уметь:
 - создавать программу в среде Си++ в соответствии с основными этапами ее
разработки;
 - строить блок-схему алгоритма работы программы в соответствии с
требованиями стандарта;
 - грамотно тестировать, отлаживать и сопровождать программу;
 - анализировать результаты работы программы и делать выводы.
2. Основные этапы выполнения курсовой работы
В ходе выполнения курсовой работы, как правило, выделяются три этапа.
Первый этап - подготовительный, определяющий начальные позиции и
разработку программы исследовательской деятельности и имеющий цели:
-ознакомление с методическими рекомендациями по выполнению курсовой
работы,
-составление плана курсовой работы,
-обсуждение плана курсовой работы с руководителем.
Второй этап - основной - включает:
-написание теоретической части курсовой работы,
-написание практической части курсовой работы.
Третий этап - итоговый, предполагающий защиту курсовой работы.
3. Постановка задачи
Разработать программу на языке высокого уровня С++ в соответствии с
вариантом (см. Приложение А).
Разработать базу данных в соответствии с вариантом среде С++ с
использованием классов динамических и статических массивов структур,
конструкторов, деструкторов, линейных списков, файловых потоков, графических
примитивов.
База данных состоит из пяти полей, в каждом из которых должно
содержаться не менее 20 записей.
Обработка данных должна включать
следующие функции:
 создание новой базы данных (с возможностью задания имени файла)
 просмотр существующей базы данных (чтение данных осуществить из
файла);
 редактирование базы данных (с сохранением изменений в файле и
выводом на экран);
 дополнение базы данных новыми записями (с сохранением в файле и
выводом на экран);
 удаление записей из базы данных (с сохранением в файле и выводом на
экран);
 поиск в базе данных (по одному и двум поисковым признакам) с
выводом на экран найденных записей или сообщения о неуспешном
поиске;
 сортировка данных по заданному полю (с сохранением в файле и
выводом на экран).
4. Краткие теоретические сведения
4.1 Динамические массивы структур
Для глобальных переменных отводится фиксированное место в памяти на
все время работы программы. Локальные переменные хранятся в стеке. Между
ними находится область свободной памяти для динамического распределения.
Наиболее важными операциями для динамического распределения памяти
являются new, new [], delete, delete []. Они используются для динамического
распределения свободной памяти. Операции new и new [] выделяют память, а
операции delete и delete [] освобождает ее.
Две операции new предназначены для выделения участков свободной памяти
и
размещения
в
них
переменных,
а
в
случае
new
[]
–
массивов.
Продолжительность существования созданных таким образом (динамических)
переменных – от точки создания до конца программы или до явного
освобождения соответствующего участка памяти применением операций delete (
delete [] – для удаления массивов).
Первая из рассмотренных операций предназначена для размещения в
динамической памяти переменной заданного аргументом типа (кроме типов
массивов) и имеет следующий вид:
new имя_типа или new имя_типа ( выражение)
Вторая форма вызова помимо выделения памяти осуществляет ее
инициализацию значением выражения. В обоих случаях результат операции
имеет тип указателя того же типа, что и аргумент, т.е. имя_типа*, и значение
адреса размещенной динамической переменной. Это значение нужно сохранить в
какой-либо переменной-указателе, что обеспечит в дальнейшем доступ к
динамической переменной по адресу.
Операции new возвращают адрес выделенного участка памяти или, если
запрашиваемой памяти нет, NULL.
Приведем пример создания и использования динамических массивов
структур: по результатам сессии в деканате имеется список задолжников, т.е.
студентов, имеющих неудовлетворительные оценки по экзаменам, зачетам,
курсовым проектам и работам.
Список представляет собой таблицу
№
Фамилия и инициалы
Курс
Группа
1
2
.
Иванов А.А.
Сидоров Б.Б.
…
1
1
…
ИСТ – 101
АСУ – 120
…
Каждая строка содержит информацию об одном студенте. Таблица содержит
n строк. Предположим, что n не превышает 200 и ее значение вводится в процессе
работы программы. Требуется написать программу, которая печатает перечень
групп, имеющих задолжников с указанием их количества в группе.
# include <iostream.h>
# include <fstream.h>
# include <string.h>
# include <iomanip.h>
# include <stdlib.h>
const int N=200;
struct student
{
char name[30];
int kurs;
char gr[7];
};
struct group
{
char gr[7];
int ng;
};
// Прототипы функций
student *inputstudentfile ( int &nn);
void outputstudent ( student st[], int nn);
group *perechengroup ( student st[], int nn, int &kk);
void outputgroup (group z[], int kk);
void outputgroupfile (group z[], int kk);
// Ввод исходного массива задолжников из файла
student *inputstudentfile ( int &nn)
{
ifstream fin;
char file[10];
char iniz[7];
// рабочая переменная для инициалов
student t;
// рабочая переменная для подсчета записей в файле
student *ps;
int i;
cout << ”Имя файла:” ;
cin >> file;
fin.open(file);
if( fin==NULL) {cout<<”Файл не открыт.\n”; exit(1);}
// подсчет записей в файле
nn =0;
do {
fin >> t.name >> iniz >> t.kurs >> t.gr ;
nn++;
}while (fin.good());
nn--;
fin.close();
// выделение памяти для динамического массива
ps= new student [nn];
if( ps=NULL ) { cout<<”Нет динамической памяти.”; getch(); exit(1);}
// ввод массива задолжников из файла
fin.open(file);
if( fin==NULL) {cout<<”Файл не открыт.\n”; exit(1);}
for (i=0; i< nn; i++)
{
fin >> ps[i].name >> iniz >> ps[i].kurs >> ps[i].gr ;
strcat( ps[i].name, “ “);
// добавление инициалов через
strcat( ps[i].name, iniz); //
пробел к фамилии
}
fin.close();
return ps;
}
// Вывод массива задолжников на экран
void outputstudent ( student st[], int nn)
{
cout<< “Фамилия и инициалы Курс Группа \n”;
for (i=0; i<nn; i++)
cout << setw(16)<< st[i].name << setw(7)<< st[i].kurs << setw(8)
st[i].gr << endl ;
}
// Формирование перечня групп, имеющих задолжников
group *perechengroup ( student st[], int nn, int &kk)
{
int i,j,fl;
group *p;
// выделение памяти для динамического массива (перечня)
p= new group [nn];
if( p==NULL ) { cout<<”Нет динамической памяти.”; getch(); exit(1);}
kk=0;
for ( i=0; i<nn; i++)
{
<<
fl=1;
for ( j=0; j<kk; j++)
if (strcmp(st[i].gr, p[j].gr) == 0) { fl=1; p[j].ng++; }
if (fl==1) { strcpy(p[k].gr, st[i].gr); p[k].ng =1; kk++; }
}
return p;
}
// Вывод перечня групп, имеющих задолжников, на экран
void outputgroup (group z[], int kk)
{
cout<< “ Группа Кол-во \n”;
for (i=0; i< kk; i++)
cout << setw(8)<< z[i].gr << setw(8)<< z[i].ng << << endl ;
}
// Вывод перечня групп, имеющих задолжников, в файл
void outputgroupfile (group z[], int kk)
{
оfstream fout;
char file[10];
int i;
cout << ”Имя файла:” ;
cin >> file;
fout.open(file);
if( !fout.good()) {cout<<”Файл не открыт.\n”; exit(1);}
for (i=0; i< kk; i++)
fout << setw(8)<< z[i].gr << setw(8)<< z[i].ng << << endl ;
fout.close();
}
/*основная функция программы */
void main()
{
student *pst;
int n;
group *pz;
int k;
//
//
//
//
указатель на исходную таблицу задолжников
n – число строк в исходной таблице
указатель на перечень групп, имеющих задолжников
к – число групп в перечне
pst=inputstudentfile ( n);
cout << ” Исходный массив структур. \n” ;
outputstudent ( pst, n);
pz=perechengroup ( pst, n, k);
cout << ” Перечень групп, имеющих задолжников. \n” ;
outputgroup ( pz, k);
outputgroupfile ( pz, k);
delete [] pst;
delete [] pz;
}
4.2 Классы. Класс массивов структур
Класс - фундаментальное понятие С++ и лежит в основе многих свойств
С++. Класс предоставляет механизм для создания объектов. С точки зрения
синтаксиса класс в С++ - это структурированный тип, образованный на основе
уже существующих типов.
В простейшем случае класс можно определить с помощью конструкции:
тип_класса имя_класса {список_членов_класса}; где
тип_класса – служебное слово class;
имя_класса – идентификатор;
список_членов_класса – определения и описания типизированных данных и
принадлежащих классу функций.
Функции – это методы класса, определяющие операции над объектом.
Данные – это поля объекта, образующие его структуру. Значения полей
определяет состояние объекта.
Будем называть члены класса компонентами класса, различая компонентные
данные и компонентные функции. Компоненты-функции предназначены для
выполнения операций над объектным данным, их часто называют методами
класса.
Для каждого компонента класса устанавливается уровень доступа либо явно,
указанием уровня доступа одним из ключевых слов public или private с
двоеточием, либо неявно, по умолчанию. Указание уровня доступа относится ко
всем последующим компонентам класса, пока не встретится указание другого
уровня доступа. Уровень доступа public разрешает доступ к компонентам класса
из любого места программы, в котором известна переменная этого класса.
Уровень доступа private разрешает доступ к компонентам класса только из
методов этого класса. Уровень доступа к компонентам класса типа class по
умолчанию private, явно можно определять и другие уровни.
Общедоступные (public) компоненты доступны в любой части программы.
Они могут использовать любой функцией как внутри класса, так и вне его. Доступ
извне осуществляется через имя объекта:
имя_объекта.имя_члена_класса;
ссылка_на_объект.имя_члена_класса;
указатель_на_объект->имя_члена_класса;
Собственные (private) компоненты локализованы в классе и не доступны
извне. Они могут использоваться функциями-членами данного класса.
Описание тела компоненты-функции может быть включено в описание
класса, как это сделано в примере для функций getx и gety, или помещено вне
описания класса. Компоненты-функции при их вызове неявно получают
дополнительный аргумент - указатель на переменную объектного типа, для
которой вызвана функция и в теле функции можно обращаться ко всем
компонентам класса. В связи с этим при описании тела компоненты-функции вне
описания класса нужно использовать операцию разрешения контекста, чтобы
информировать компилятор о принаждлежности функции к классу.
Приведем пример: по результатам сессии в деканате имеется список
задолжников, т.е. студентов, имеющих неудовлетворительные оценки по
экзаменам, зачетам, курсовым проектам и работам.
Список представляет собой таблицу
№
Курс
Фамилия и инициалы
1
2
.
Иванов А.А.
Сидоров Б.Б.
…
1
1
…
Группа
ИСТ – 101
АСУ – 120
…
Каждая строка содержит информацию об одном студенте. Таблица содержит
n строк. Предположим, что n не превышает 200 и ее значение вводится в процессе
работы программы. Требуется написать программу, которая печатает перечень
групп, имеющих задолжников с указанием их количества в группе.
# include <iostream.h>
# include <fstream.h>
# include <string.h>
# include <iomanip.h>
# include <stdlib.h>
const int N=200;
struct student
{
char name[30];
int kurs;
char gr[7];
};
struct group
{
char gr[7];
int ng;
};
class massiv
{
private:
student st[N];
int n;
group z[N];
int k;
public:
void inputstudentfile ();
void outputstudent ();
void outputgroup ();
void outputgroupfile ();
void perechengroup ();
};
// класс массив структур
// исходная таблица задолжников
// n – число строк в исходной таблице
// перечень групп, имеющих задолжников
// к – число групп в перечне
// ввод массива задолжников из файла
// вывод массива задолжников на экран
// вывод перечня групп задолжников на экран
// вывод перечня групп задолжников в файл
// формирование перечня групп задолжников
// Ввод исходного массива задолжников из файла
void massiv::inputstudentfile ()
{
ifstream fin;
char file[10];
char iniz[7];
// рабочая переменная для инициалов
cout << ”Имя файла:” ;
cin >> file;
fin.open(file);
if( fin==NULL) {cout<<”Файл не открыт.\n”; exit(1);}
n=0;
do {
fin >> st[i].name >> iniz >> st[i].kurs >> st[i].gr ;
strcat( st[i].name, “ “);
// добавление инициалов через
strcat( st[i].name, iniz); //
пробел к фамилии
n++;
}while (fin.good());
n--;
fin.close();
}
// Вывод массива задолжников на экран
void massiv::outputstudent ()
{
cout<< “Фамилия и инициалы Курс Группа \n”;
for (i=0; i<n; i++)
cout << setw(16)<< st[i].name << setw(7)<< st[i].kurs << setw(8)
st[i].gr << endl ;
}
// Формирование перечня групп, имеющих задолжников
void massiv::perechengroup ()
{
int i,j,fl;
k=0;
for ( i=0; i<n; i++)
{
fl=1;
for ( j=0; j<k; j++)
if (strcmp(st[i].gr, z[j].gr) == 0) { fl=1; z[j].ng++; }
if (fl==1) { strcpy(z[k].gr, st[i].gr); z[k].ng =1; k++; }
}
}
// Вывод перечня групп, имеющих задолжников, на экран
void massiv::outputgroup ()
{
cout<< “ Группа Кол-во \n”;
for (i=0; i<k; i++)
cout << setw(8)<< z[i].gr << setw(8)<< z[i].ng << << endl ;
}
// Вывод перечня групп, имеющих задолжников, в файл
void massiv::outputgroupfile ()
<<
{
оfstream fout;
char file[10];
int i;
cout << ”Имя файла:” ;
cin >> file;
fout.open(file);
if( !fout.good()) {cout<<”Файл не открыт.\n”; exit(1);}
for (i=0; i<k; i++)
fout << setw(8)<< z[i].gr << setw(8)<< z[i].ng << << endl ;
fout.close();
}
/*основная функция программы */
void main()
{
massiv a;
// Объект класса massiv
a.inputstudentfile ();
cout << ” Исходный массив структур. \n” ;
a.outputstudent ();
a.perechengroup ();
cout << ” Перечень групп, имеющих задолжников. \n” ;
a.outputgroup ();
a.outputgroupfile ();
}
4.3 Классы. Класс динамического массива структур
Для инициализации объектов класса в его определение можно явно
включить специальную компонентную функцию, называемую конструктором.
Формат
определения
конструктора
следующий
-
имя_класса(список_форм_параметров).
Имя этой компонентной функции по правилам языка С++ должно совпадать
с именем класса. Такая функция автоматически вызывается при определении или
размещении в памяти с помощью оператора new каждого объекта класса.
Конструктор выделяет память для объекта и инициализирует данные-члены
класса. Конструктор имеет ряд особенностей. Для конструктора не определяется
тип возвращаемого значения. Даже тип void не допустим.
Указатель на
конструктор не может быть определен и соответственно нельзя получить адрес
конструктора.
Конструктор всегда существует для любого класса, причем, если он не
определен явно, он создается автоматически. По умолчанию создается
конструктор без параметров и конструктор копирования. Если конструктор
описан явно, то конструктор по умолчанию не создается. По умолчанию
конструкторы создаются общедоступными (public).
Динамическое выделение памяти для объекта создает необходимость
освобождения этой памяти при уничтожении объекта. Например, если объект
формируется как локальный внутри блока, то целесообразно, чтобы при выходе
из блока, когда уже объект перестает существовать, выделенная для него память
была возвращена. Желательно чтобы освобождение памяти происходило
автоматически.
Такую возможность обеспечивает специальный компонент класса –
деструктор класса. Его формат:
~имя_класса () { операторы_тела_деструктора };
Имя деструктора совпадает с именем его класса, но предваряется символом "~"
(тильда).
Деструктор не имеет параметров и возвращаемого значения. Вызов
деструктора выполняется не явно (автоматически), как только объект класса
уничтожается. Например, при выходе за область определения или при вызове
оператора delete для указателя на объект.
Если в классе деструктор не определен явно, то компилятор генерирует
деструктор по умолчанию, который просто освобождает память занятую данными
объекта. В тех случаях, когда данными объекта являются указатели, появляется
необходимость выполнить освобождение и памяти, на которую ссылаются эти
указатели. В этом случае пользователю необходимо самому определить
деструктор, который будет выполнять действия по освобождению этой памяти.
Также как и для конструктора, не может быть определен указатель на
деструктор.
Приведем пример: по результатам сессии в деканате имеется список
задолжников, т.е. студентов, имеющих неудовлетворительные оценки по
экзаменам, зачетам, курсовым проектам и работам.
Каждая строка содержит информацию об одном студенте. Таблица
содержит n строк. Требуется написать программу, которая печатает перечень
групп, имеющих задолжников с указанием их количества в группе.
# include <iostream.h>
# include <fstream.h>
# include <string.h>
# include <iomanip.h>
# include <stdlib.h>
# include <conio.h>
struct student
{
char name[30];
int kurs;
char gr[7];
};
struct group
{
char gr[7];
int ng;
};
class dmassiv
// класс динамический массив структур
{
private:
student *pst; // указатель на исходную таблицу задолжников
int n;
// n – число строк в исходной таблице
group *pz; // указатель на перечень групп, имеющих задолжников
int k;
// к – число групп в перечне
public:
dmassiv() { n=0; pst=NULL; k=0; pz=NULL;} // конструктор
~dmassiv();
// деструктор
void inputstudentfile (); // ввод массива задолжников из файла
void outputstudent (); // вывод массива задолжников на экран
void outputgroup (); // вывод перечня групп задолжников на экран
void outputgroupfile ();
void perechengroup ();
void add ();
void deletename ();
// вывод перечня групп задолжников в файл
// формирование перечня групп задолжников
// добавление записи в массив задолжников
// удаление записи из массива задолжников
};
// Ввод исходного массива задолжников из файла
void dmassiv::inputstudentfile ()
{
ifstream fin;
char file[10];
char iniz[7];
// рабочая переменная для инициалов
student t;
// рабочая переменная для подсчета записей в файле
int i;
// очистка рабочих областей (массива задолжников и перечня)
if(pst!=NULL) { delete[] pst; n=0; pst=NULL;}
if(pz!=NULL) { delete[] pz; k=0; pz=NULL;}
cout << ”Имя файла:” ;
cin >> file;
fin.open(file);
if( fin==NULL) {cout<<”Файл не открыт.\n”; exit(1);}
// подсчет записей в файле
n=0;
do {
fin >> t.name >> iniz >> t.kurs >> t.gr ;
n++;
}while (fin.good());
n--;
fin.close();
// выделение памяти для динамического массива
pst= new student [n];
if( pst==NULL ) { cout<<”Нет динамической памяти.”; getch(); exit(1);}
// ввод массива задолжников из файла
fin.open(file);
if( fin==NULL) {cout<<”Файл не открыт.\n”; exit(1);}
for (i=0; i<n; i++)
{
fin >> pst[i].name >> iniz >> pst[i].kurs >> pst[i].gr ;
strcat( pst[i].name, “ “);
// добавление инициалов через
strcat( pst[i].name, iniz); //
пробел к фамилии
}
fin.close();
}
// Вывод массива задолжников на экран
void dmassiv::outputstudent ()
{
cout << ”
Исходный массив структур. \n” ;
cout<< “Фамилия и инициалы Курс Группа \n”;
for (i=0; i<n; i++)
cout << setw(16)<< pst[i].name << setw(7)<< pst[i].kurs << setw(8)
<< pst[i].gr << endl ;
}
// Формирование перечня групп, имеющих задолжников
void dmassiv::perechengroup ()
{
int i,j,fl;
// выделение памяти для динамического массива (перечня)
pz= new group [n];
if( pz==NULL ) { cout<<”Нет динамической памяти.”; getch(); exit(1);}
// очистка рабочей области (перечня)
if(pz!=NULL) { delete[] pz; k=0; pz=NULL;}
// формирование перечня групп
for ( i=0; i<n; i++)
{
fl=1;
for ( j=0; j<k; j++)
if (strcmp( pst[i].gr, pz[j].gr) == 0) { fl=1; pz[j].ng++; }
if (fl==1) { strcpy( pz[k].gr, pst[i].gr); pz[k].ng =1; k++; }
}
}
// Вывод перечня групп, имеющих задолжников, на экран
void massiv::outputgroup ()
{
cout << ” Перечень групп, имеющих задолжников. \n” ;
cout<< “ Группа Кол-во \n”;
for (i=0; i<k; i++)
cout << setw(8)<< pz[i].gr << setw(8)<< pz[i].ng << << endl ;
}
// Вывод перечня групп, имеющих задолжников, в файл
void dmassiv::outputgroupfile ()
{
оfstream fout;
char file[10];
int i;
cout << ”Имя файла:” ;
cin >> file;
fout.open(file);
if( !fout.good()) {cout<<”Файл не открыт.\n”; exit(1);}
for (i=0; i<k; i++)
fout << setw(8)<< pz[i].gr << setw(8)<< pz[i].ng << << endl ;
fout.close();
}
// Добавление записи в массив задолжников
void dmassiv::add ()
{
int i;
student t,
// рабочая переменная для информации о добавляемом
*p;
// указатель для сохранения адреса исходного массива
char iniz[7];
// рабочая переменная для инициалов
// ввод информации о добавляемом
cout << “Введите фамилию: ”;
cin >> t.name >> iniz;
strcat( t.name, “ “);
// добавление инициалов через
strcat( t.name, iniz); //
пробел к фамилии
cout << “Курс: ”;
cin >> t.kurs;
cout << “Группа: ”;
cin >> t.gr;
p=pst;
// сохранение адреса исходного массива
// выделение памяти для массива и добавление введенной записи в него
pst= new student [n+1];
if( pst==NULL ) { cout<<”Нет динамической памяти.”; getch(); exit(1);}
for (i=0; i<n; i++)
pst[i]=p[i];
pst[n]=t;
// добавление записи в массив
n++;
delete[] p;
// удаление предыдущего массива
}
// Удаление записи по фамилии и группе из массива задолжников
void dmassiv::deletename ()
{
int i,j;
student t;
// рабочая переменная для информации об удаляемом
char iniz[7];
// рабочая переменная для инициалов
// ввод фамилии и группы удаляемого
cout << “Введите фамилию: ”;
cin >> t.name >> iniz;
strcat( t.name, “ “);
// добавление инициалов через
strcat( t.name, iniz); //
пробел к фамилии
cout << “Группа: ”;
cin >> t.gr;
// поиск и удаление записи
for ( i=0; i<n; i++)
if( strcmp(t.name, pst[i].name)==0 && strcmp(t.gr, pst[i].gr)==0) break;
if(i==n) {cout<<t.name<” не найден. \n“; getch(); exit(1);}
else { for ( j=i+1; j<n; j++)
pst[j-1]=pst[j];
n--;
}
}
// Определение деструктора
dmassiv::~dmassiv()
{
// очистка рабочих областей (массива задолжников и перечня)
if(pst!=NULL) { delete[] pst; n=0; pst=NULL;}
if(pz!=NULL) { delete[] pz; k=0; pz=NULL;}
}
/*основная функция программы */
void main()
{
dmassiv a;
int j;
// Объект класса
while (1)
{
clrscr();
cout << “1. Ввод таблицы из файла. \n”;
cout << “2. Вывод таблицы на экран. \n”;
cout << “3. Добавление записи в таблицу. \n”;
cout << “4. Удаление записи из таблицы. \n”;
cout << “5. Формирование перечня групп. \n”;
cout << “6. Вывод перечня групп на экран. \n”;
cout << “7. Вывод перечня групп в файл. \n”;
cout << “8. Выход из программы. \n”;
cout << “\n Ваш выбор (1-8) :”;
cin >> j;
dmassiv
switch(j)
{
case 1: a.inputstudentfile(); break;
case 2: a.outputstudent(); getch(); break;
case 3: a.add(); break;
case 4: a.deletename(); break;
case 5: a.perechengroup(); break;
case 6: a.outputgroup(); getch(); break;
case 7: a.outputgroupfile(); break;
case 8: cout << “Завершение рабоы.”; getch(); return;
default: cout << “ Ошибка в выборе пункта меню. Повторите.”; getch();
}
}
}
4.4 Списки. Класс списка структур
Если до начала работы с данными невозможно определить, сколько памяти
потребуется
для
хранения,
память
выделяется
по
мере
необходимости
отдельными блоками, связанными друг с другом с помощью указателей. Такой
способ организации данных называется динамическими данными, поскольку их
размер изменяется во время выполнения программы.
Динамические данные
могут занимать несмежные участки оперативной памяти.
Элемент динамического данного, часто называемый узлом, представляет
собой структуру, содержащую по крайней мере два поля: для хранения данных
(информационная часть узла) и для указателей (адресная часть узла). Полей
данных и указателей может быть несколько. Поля данных могут быть любого
типа. Описание простейшего элемента (узла) выглядит следующим образом:
struct Node
{ Data d;
// информационная часть узла
// тип данных Data должен быть определен ранее
Node *next;
// адресная часть узла
};
Самый простой способ связать элементы – сделать так, чтобы каждый
элемент содержал адрес следующего. Такие динамические данные называются
односвязным списком.
Над списками можно выполнять следующие операции: добавление элемента
в конец списка; удаление элемента из списка; начальное формирование списка;
просмотр (вывод) списка.
Задача: По результатам сессии в деканате имеется список (таблица)
задолжников, т.е. студентов, имеющих неудовлетворительные оценки по
экзаменам, зачетам, курсовым проектам и работам.
Фамилия и инициалы
Курс
Группа
Иванов А.А.
Сидоров Б.Б.
…
1
1
…
ИСТ – 101
АСУ – 120
…
№
1
2
.
Каждая строка содержит информацию об одном студенте. Таблица содержит
n строк. Требуется написать программу, которая печатает перечень групп,
имеющих задолжников с указанием их количества в группе.
# include <iostream.h>
# include <fstream.h>
# include <string.h>
# include <iomanip.h>
# include <stdlib.h>
# include <conio.h>
struct student
{
char name[30];
int kurs;
char gr[7];
};
struct group
{
char gr[7];
int ng;
};
struct node1
{
student s;
node1*next;
};
struct node2
// узлы первого списка
// информационная часть узла первого списка
// адресная часть узла первого списка
// узлы второго списка
{
group g;
node2*next;
};
class spisok
{
private:
node1*beg1, *end1;
int n;
node2 *beg2, *end2;
int k;
node1*findname (student t);
// информационная часть узла второго списка
// адресная часть второго узла
// класс списка структур
//указатели на начало и конец 1-го списка
//количество элементов в первом списке
//указатели на начало и конец 2-го списка
//количество элементов во втором списке
//функция для нахождения узла 1-го списка
public:
spisok() {m=k=0; beg1=end1=beg2=end2=NULL;}
//конструктор
~spisok();
//деструктор
void inputstudentfile();
// ввод из файла первого списка
void outputstudent();
// вывод на экран первого списка
void addstudent();
// добавление элемента в первый список
void deletestudent();
// удаление элемента из первого списка
void perechgroup();
//формирование второго списка (перечня групп)
void outputgroup();
// вывод на экран второго списка
void outputgroupfile();
// вывод в файл второго списка
};
// Определение деструктора
spisok::~spisok ()
{
node1 *p1;
node2 *p2;
if (beg1!=NULL)
{
while (beg1!=NULL)
{
p1=beg1;
beg1=beg1->next;
delete p1;
}
end1=NULL;
n=0;
}
if (beg2!=NULL)
{
// указатель на узлы первого списка
// указатель на узлы второго списка
// первый список не пустой
// надо вернуть память, занимаемую им
// узел удален из списка
// освобождена память, занимаемая узлом
// второй список не пустой
// надо вернуть память, занимаемую им
while (beg2!=NULL)
{
p2=beg2;
beg2=beg2->next;
delete p2;
}
end2=NULL;
k=0;
}
// узел удален из списка
// освобождена память, занимаемая узлом
}
// Нахождение узла первого списка по заданной фамилии и группе
node1 *spisok:: findname (student tt)
{
node1 *p;
p=beg1;
while (p!=NULL)
{
if( strcmp( tt.name, p->s.name)==0 && strcmp( tt.gr, p->s.gr)==0) break;
// узел найден
p=p->next;
}
return NULL;
// узел не найден
}
// Ввод 1-ого списка (исходной таблицы задолжников) из файла
void spisok:: inputstudentfile()
{
ifstream fin;
char file[10];
char iniz[7];
// рабочая переменная для инициалов
node1 *p1, *p;
// указатели на узлы первого списка
node2 *p2;
// указатель на узлы второго списка
// очистка рабочих областей ( 1-ого и 2-ого списков)
if (beg1!=NULL)
// первый список не пустой
{
// надо вернуть память, занимаемую им
while (beg1!=NULL)
{
p1=beg1;
beg1=beg1->next;
// узел удален из списка
delete p1;
// освобождена память, занимаемая узлом
}
end1=NULL;
n=0;
}
if (beg2!=NULL)
{
while (beg2!=NULL)
{
p2=beg2;
beg2=beg2->next;
delete p2;
}
end2=NULL;
k=0;
}
// второй список не пустой
// надо вернуть память, занимаемую им
// узел удален из списка
// освобождена память, занимаемая узлом
// ввод 1-ого списка (таблицы задолжников) из файла
cout << ”Имя файла:” ;
cin >> file;
fin.open(file);
if( fin==NULL) {cout<<”Файл не открыт.\n”; exit(1);}
p= new node1;
// выделение памяти для 1-ого узла
if( p==NULL ) { cout<<”Нет динамической памяти.”; getch(); exit(1);}
fin >> p->s.name >> iniz >> p->s.kurs >> p->s.gr ;
strcat( p->s.name, “ “);
// добавление инициалов через
strcat( p->s.name, iniz);
//
пробел к фамилии
p->next=NULL;
while( fin.good())
{// Добавление нового узла в список
if (beg1==NULL) beg1==p; else end1->next=p;
end1=p;
n++;
// Формирование нового узла
p= new node1;
if(p==NULL){cout<<”Нет динамической памяти.”;getch();exit(1);}
fin >> p->s.name >> iniz >> p->s.kurs >> p->s.gr ;
strcat( p->s.name, “ “);
// добавление инициалов через
strcat( p->s.name, iniz);
// пробел к фамилии
p->next=NULL;
}
delete p; // удаление последнего несформированного узла
fin.close();
}
// Вывод 1-го списка (таблицы задолжников) на экран
void spisok:: outputgroupstudent()
{
node1 *p;
cout << ”
Исходный список структур. \n” ;
cout<< “Фамилия и инициалы Курс Группа \n”;
for( p=beg1; p!=NULL; p=p->next)
cout << setw(16)<< p->s.name << setw(7)<< p->s.kurs << setw(8)
p->s.gr << endl ;
}
// Добавление записи в 1-ый список (таблицу задолжников)
void spisok:: addstudent()
{
node1 *p;
// указатель для нового узла
char iniz[7];
// рабочая переменная для инициалов
// выделение памяти для нового узла
p= new node1;
if( p==NULL ) { cout<<”Нет динамической памяти.”; getch(); exit(1);}
// ввод информации о добавляемом и формирование нового узла
cout << “Введите фамилию: ”;
cin >> p->s.name >> iniz;
strcat( p->s.name, “ “);
// добавление инициалов через
strcat( p->s.name, iniz);
// пробел к фамилии
cout << “Курс: ”;
cin >> p->s.kurs;
cout << “Группа: ”;
cin >> p->s.gr;
p->next=NULL;
// добавление нового узла в список
if (beg1==NULL) beg1==p; else end1->next=p;
end1=p;
n++;
}
// Удаление узла из первого списка
void spisok:: deletestudent()
{
node1 *p, *p0;
student t;
// рабочая переменная для информации об удаляемом
char iniz[7];
// рабочая переменная для инициалов
// ввод фамилии и группы удаляемого
cout << “Введите фамилию: ”;
cin >> t.name >> iniz;
strcat( t.name, “ “);
// добавление инициалов через
<<
strcat( t.name, iniz);
//
пробел к фамилии
cout << “Группа: ”;
cin >> t.gr;
p0=findname(t);
if (p0==NULL) {cout<<t.name<” не найден. \n“; getch(); return;}
if (p0==beg1)
//найденный узел является первым в списке
{
beg1=beg1->next;
// удаление узла из списка
if (p0==end1) end1==NULL;
// найденный узел последний в списке
}
else
{// поиск предшествующего узла
p=beg1;
while (p->next!=p0)
p=p->next;
p->next=p0->next;
// удаление узла из списка
if (p0==end1) end1=p;
// найденный узел последний в списке
}
n--;
delete p0;
}
// Формирование второго списка (перечня групп)
void spisok:: perechengroup()
{
int fl;
node1 *p1
// указатель на узлы первого списка
node2 *p2, *p;
// указатели на узлы второго списка
// очистка рабочей области ( 2-ого списка)
if (beg2!=NULL)
// второй список не пустой
{
// надо вернуть память, занимаемую им
while (beg2!=NULL)
{
p2=beg2;
beg2=beg2->next;
// узел удален из списка
delete p2;
// освобождена память, занимаемая узлом
}
end2=NULL;
k=0;
}
// формирование второго списка
for( p1=beg1; p1!=NULL; p1=p1->next)
{
fl=1;
for( p2=beg2; p2!=NULL; p2=p2->next)
{
if (strcmp (p1->s.gr, p2->g.gr)==0)
{fl=0; p2->g.ng++; break;}
}
if (fl==1)
{
p=new node2;
if (p==NULL) {cout<<”Нет памяти”; getch(); exit(1);}
p->next=NULL;
strcpy (p->g.gr, p1->s.gr);
p->g.ng=1;
// Добавление нового узла во второй список
if (beg2==NULL) beg2==p; else end2->next=p;
end2=p;
k++;
}
}
}
// Вывод 2-го списка (перечня групп, имеющих задолжников) на экран
void spisok:: outputgroup()
{
node2 *p;
cout << ” Перечень групп, имеющих задолжников. \n” ;
cout<< “ Группа Кол-во \n”;
for( p=beg2; p!=NULL; p=p->next)
cout << setw(8)<< p->g.gr << setw(8)<< p->g.ng << << endl ;
}
// Вывод 2-го списка (перечня групп, имеющих задолжников) в файл
void spisok:: outputgroupfile()
{
оfstream fout;
char file[10];
node2 *p;
cout << ”Имя файла:” ;
cin >> file;
fout.open(file);
if( !fout.good()) {cout<<”Файл не открыт.\n”; exit(1);}
for( p=beg2; p!=NULL; p=p->next)
fout << setw(8)<< p->g.gr << setw(8)<< p->g.ng << << endl ;
fout.close();
}
// Текст основной программы:
void main()
{
spisok a;
// Объект класса spisok
int j;
while (1)
{
clrscr();
cout << “1. Ввод таблицы из файла. \n”;
cout << “2. Вывод таблицы на экран. \n”;
cout << “3. Добавление записи в таблицу. \n”;
cout << “4. Удаление записи из таблицы. \n”;
cout << “5. Формирование перечня групп. \n”;
cout << “6. Вывод перечня групп на экран. \n”;
31
cout << “7. Вывод перечня групп в файл. \n”;
cout << “8. Выход из программы. \n”;
cout << “\n Ваш выбор (1-8) :”;
cin >> j;
switch(j)
{
case 1: a.inputstudentfile(); break;
case 2: a.outputstudent(); getch(); break;
case 3: a.addstudent(); break;
case 4: a.deletestudent(); break;
case 5: a.perechengroup(); break;
case 6: a.outputgroup(); getch(); break;
case 7: a.outputgroupfile(); break;
case 8: cout << “Завершение рабоы.”; getch(); return;
default: cout << “ Ошибка в выборе пункта меню. Повторите.”; getch();
}
}
}
4.5 Работа с графическими примитивами
В ТС и C++ имеется графическая библиотека, которая содержит большое
число функций, позволяющих осуществить доступ к отдельным элементам
видеопамяти, управлять цветом, создавать изображения различной формы,
выводить графические текстовые сообщения, управлять курсором. Настройка
этих функций на работу с конкретным видеоадаптером достигается за счет
подключения нужного графического драйвера. Драйвер - это специальная
программа для управления тем или иным устройством ПК.
Графические драйверы практически для всех видов адаптеров разработаны
фирмой Borland International. Они находятся в отдельных файлах с расширениями
BGI (Borland I Graphics Interface). Для подключения графического драйвера
служит
специальная
функция
inltgraph().
Многие
графические
функции
используют понятие указателя текущей позиции (это графический аналог курсора
в текстовом режиме, только он является невидимым). Указатель идентифицирует
выбранный пиксел и характеризуется парой целых чисел: номером в строке и
номером строки на экране (т.е. горизонтальной и вертикальной координатами).
Нумерация ведется слева направо и сверху вниз (с нуля).
Инициализация графической системы. Обработка ошибок.
1. Выбор драйвера и графического режима выполняет функция
detectgraph (&gd, &gm);
Происходит тестирование аппаратуры видеоадаптера, автоматический выбор
подходящего драйвера и графического режима. Целочисленные переменные,
указатели на которые передаются функции в качестве аргументов, возвращают
номер драйвера и номер режима.
2. Загрузку драйвера, инициализацию графической системы выполняет
функция
initgraph (&gd, &gm, "путь к BGI-файлам");
Значениями переменных gd и gm должны быть номер нужного драйвера и
номер желаемого графического peжима. Если файл с указанным драйвером
найден, то ему динамически выделяется необходимая память и производится его
загрузка.
Если BGI-файлы находятся в текущей директории, то в качестве третьего
параметра функции imtgraph() можно задать пустую строку
initgraph (&gd, &gm, "");
3. Обработка ошибочных ситуаций. В ТС и С++ предусмотрены средства
обработки ошибок, возникающих при работе с графикой. Функция
graphresult ();
возвращает код завершения последней используемой графической функции.
В случае успеха возвращается "0".
Обычная начальная последовательность действий при работе с графикой
выглядят таким образом:
#include <stdio.h>
#include <stdlib.h>
#include <graphics.h>
void main ( )
int gd, gm, error;
detectgraph (&gd, &gm); initgraph (&gd, &gm," ");
error = graphresult ( ) ;
if (error !=grok )
{
puts (" ошибка графики") ;
puts (grapherrormsg (error)) ;
exit (1) ;
}
// Тело программы
closegraph();
exit (0) ;
}
Цветом фона можно управлять с помощью функции
setbkcolor (цвет);
Текущее значение рисующего цвета (цвета выводимых символов и линий)
устанавливается функцией
setcolor (цвет);
В графическом режиме при выводе текстового со сообщения имеется
возможность выбора одного из нескольких шрифтов, размера выводимых
символов и направления текста. Эти параметры задаются при помощи функции
settextstyle (шрифт, направление, размер);
Допустимые значения для параметра шрифт
0
DEFAULT_FONT (стандартный)
1
TRIPLEX. FONT (типа триплекс; в файле TR1P.CHR)
2
SMALL.FONT
(уменьшенный; в файле LITT.CHR)
3
SANS_SERIF_FONT (прямой; в файле SANS.CHR)
4
GOTH1C_FON Г (готический; в файле GOTH.CHR)
Допустимые значения для параметра направление
0
HORIZ DIR (слева направо)
1
VERT DIR (снизу вверх)
Допустимые значения для параметра толщина
1
NORM_WIDTH (линия в один пиксел)
3
THICK WIDTH (линия в три пиксела)
Коды для параметра вид (только для кусочно-линейных графических
примитивов)
0
SOLID_LINE (сплошная)
1
DOTI'ED_LINE (из точек)
2
CENTER_L1NE (из точек и тире)
3
DASHED_LINE (пунктирная)
4
USERBIT_L1NE (определяемая пользователем)
Для установки стиля закраски используется функция
setftllsfyle (тип закраски, цвет);
Допустимые значения параметра тип закраски
-
EMPTY_FILL
штриховка цветом фона
-
SOLID_F1LL
сплошное заполнение указанным цветом
-
L1NE_FILL
штриховка горизонтальными линиями
Работа с окнами и координатами
1. Очистка экрана производится с помощью функции
cleardevice ();
Все установленные ранее графическими процедурами параметры сбрасываются и
приобретают значения по умолчанию.
2. Максимальные значения координат точек по горизонтали и вертикали,
допустимые в данном графическом режиме, можно получить, используя функции
getmaxx ();
(возвращает максимальную координату по горизонтали), getmaxy ();
(возвращает максимальную координату по вертикали).
3. Открытие окна на графическом экране. Внутри основного массива точек
экрана всегда можно выделить некоторый подмассив - прямоугольное окно со
своей системой координат. Делается это с помощью функции
setviewport (xl, yl, x2, y2, clip);
где
x1, y1 - координаты левого верхнего угла окна;
x2, y2 - координаты правого нижнего угла окна;
clip - отсечка.
Если параметр clip равен 1, то те элементы изображения, которые не
умещаются в окне, будут отсечены; если же он равен 0, то границы окна
проигнорируются. При успешном выполнении этой функции указатель текущей
графической позиции переместится в начало координат окна.
4. Очистку графического окна выполняет функция clearviewport ();
5. Текущие координаты указателя позиции в системе координат окна можно
получить с помощью функций getx ();
(возвращает горизонтальную координату), gety();
(возвращает вертикальную координату).
6. Переустановку указателя позиции выполняют функции
moveto (x, у);
moverel (dx, ay);
где
x, у - новые координаты в системе координат окна;
dx, dу - приращения относительно старых координат в окне.
7. Для восстановления параметров, принятых по умолчанию, служит
функция
graphdefaults ();
Восстанавливаются окно, указатель позиции, цвет, стили линий, шрифты такими, какими их делает initgraph().
8. Запись пиксела в видеопамять осуществляет фуш putpixel (x, у, цвет);
где
x, у - координаты пиксела в системе координат окна. Например, в результате
выполнения фрагмента
Два способа вычерчивания ромба.
способ 1
setwritemode (XOR_PUT); setcolor (GREEN);
moveto (100, 10); lineto (50, 90); lineto (100, 170);
setcolor (RED); lineto (150, 90); lineto (100, 10);
способ 2
setbcolor (WHITE); setcolor (GREEN);
line (100, 10, 50, 90); line (50, 90, 100, 170);
setbcolor (RED);
line (100, 170, 150. 90); line (150, 90, 100, 10);
3. Контур прямоугольника можно начертить с помощью функции
rectangle (x1, у1, x2, у2);
где
x1, y1 - координаты левого верхнего угла;
x2, у2 - координаты правого нижнего угла.
Параллелепипеды, стоящие друг на друге
setbkcolor (WHITE);
setcolor (GREEN);
bar3d (230, 50, 250, 150, 15, 1);
bar3d (220, 150, 260, 180, 15, 1);
bar3d (300, 150, 340, 180, 15, 0);
tar3d (300, 50, 340, 150, 15, 1);
8. Построить и закрасить многоугольник позволяет функция
fillpoly (п, указатель па массив целых);
где
п - количество вершин.
Координаты каждой вершины задаются двумя величинами целого типа. Эта
функция всегда соединяет первую точку списка вершин с последней, замыкает
контур и закрашивает его. Шаблон и цвет закрашивания могут быть заданы
функциями setfillstyle() и setfillpattern().
9. Закрашенный эллипс с контуром можно получить, применив функцию
fillellipse (x, у, rх, rу);
где
x, у - координаты центра;
rх, rу - длины полуосей эллипса в пикселах.
Оси эллипса параллельны осям координат. Закрашивание производится
текущим цветом.
10. Закрашенный круговой сектор с контуром рисует функция
pieslice (x, у, нач_угол, кон _угол, радиус);
После приведения углов к диапазону [0..360] сектор рисуется от меньшего
значения
угла
к
большему,
поэтому
невозможно
изобразить
сектор,
пересекающий положительное направление оси ОХ. Контур (дуга и два радиуса)
рисуется после закраски сектора, причем тип и толщина линий берутся из
установок функции sуtlinуstile(). Если нужен сектор без контура, это можно
сделать так:
setcolor (BLACK); setbkcolor (BLUE) ;
setwritemode (XOR_PUT); setfillstile (WIDE_DOT_PILL, RED) ;
pieslice (200, 100, 45, 90, 50);
5 Правила оформления пояснительной записки
Пояснительная записка оформляется с использованием ПК. Общий объем 4050 страниц. Листы формата А4 подшиваются в папку. Все таблицы и рисунки
должны
быть
пронумерованы.
При
написании
пояснительной
записки
используется шрифт Times New Roman 14 размера, межстрочный интервал
полуторный. В приложении используется шрифт 12 размера.
Материалы в пояснительной записке следует располагать в следующем
порядке: титульный лист, задание на курсовую работу, содержание, введение,
краткие теоретические сведения, связанные с выполнением курсовой работы,
блок-схемы по коду программы, экранные формы, список литературы,
приложение.
6 Программные средства обеспечения выполнения курсовой работы
Для выполнения курсовой работы по дисциплине «Технология разработки
программных продуктов» используется ЭВМ с операционной системой Windows
и трансляторы языка Си и С++.
7 Литература
1. Б.Керниган, Д.Ритчи, А.Фьюер. Язык программирования Си. Задачи по
языку Си. М.: Финансы и статистика, 2008. – 564 с.
2. М.Уэйт, С.Прата, Д.Мартин. Язык Си. Руководство для начинающих. - М.:
Мир, 2009. – 258 с.
3. М.Болски. Язык программирования Си. Справочник. - М.: Радио и связь,
2007. – 389 с.
4. Л.Хэнкок, М.Кригер. Введение в программирование на языке Си. - М.:
Радио и связь, 2008. -611 с.
5. Р.Берри, Б.Микинз. Язык Си. Введение для программистов. - М.: Финансы
и статистика, 2009. – 157 с.
6. Макогон В.С. Язык программирования Си для начинающих. - Одесса:
НПФ "АСТРОПРИНТ", 2007. - 296 с.
7. Кpячков А.В. и дp. Пpогpаммиpование на С и С++. Пpактикум. - М.: Радио
и связь, 2006. - 344 с.
8. 3. Жешке Р. Толковый словаpь стандаpта языка Си. -Санкт-Петеpбуpг:
Питеp, 2008. - 221 с.
9. Березин Б.И., Березин С. И. Начальный курс Си и С++. - М.: ДиалогМИФИ, 2011. - 288 с.
10. Керниган Б., Ритчи Д., Фьюэр А. Язык программирования Си. - М.: Ф и
статистика, 2010. - 279 с.
11. Белецкий Я. Энциклопедия языка Си. - М.: Мир. 1992. – 352 с.
Приложение А
Варианты заданий
Вариант 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. Тема: «Кинофильмы»
Название
Жанр
Дата выхода в
Количество
прокат
наград
Кассовый сбор