Управление информацией в автобусном парке
Министерство образования республики Беларусь
Учреждение образования
Белорусский государственный
университет информатики и
Кафедра: электронных вычислительных машин
Факультет: компьютерных сетей и систем
Пояснительная записка к курсовой работе по курсу КПиЯП
на тему:
«Управление информацией в автобусном парке»
Выполнил:
Студент группы 050504 Насуро Е.В.
Козак С.С.
Минск 2012
Содержание
- Содержание____________________
______________________________ _________2 - Введение______________________
______________________________ _________ 3 - Постановка задачи________________________
_____________________________4
Условие задачи________________________
Обзор методов________________
- Структура входных и выходных данных ______________________________
____5 - Диаграмма классов_______________________
______________________________ 6 - Описание классов_______________________
______________________________ _7 6.1 CityBus_______________________ ______________________________ _______7
6.2 ComfortBus____________________
6.3 List__________________________
6.4 mylist ______________________________
6.8 ListNotFree___________________
7. Описание алгоритмов___________
7.1 Блок схемы алгоритмов
программы_____________________
- Алгоритмы по шагам_________________________
______________________12
8.Текст программы_____________________
8.1 CityBus.h ______________________________
8.2 CityBus.cpp ______________________________
8.3 ComfortBus.h__________________
8.5 mylist.h ______________________________
8.7 Iterator.cpp ______________________________
8.9 database.cpp ______________________________
8.10 Form1.h ______________________________
9. Результат
работы программы_____________________
10.Заключение_________________
11.Литература_________________
Введение
С++ - это универсальный язык
Ключевым понятием С++ является
класс. Класс - это тип, определяемый
пользователем. Классы обеспечивают сокрытие
данных, гарантированную инициализацию
данных, неявное преобразование типов
для типов, определенных пользователем,
динамическое задание типа, контролируемое
пользователем управление памятью
и механизмы перегрузки операций.
С++ предоставляет гораздо лучшие,
чем в C, средства выражения модульности
программы и проверки типов. В
языке есть также усовершенствования,
не связанные непосредственно с
классами, включающие в себя символические
константы, inline-подстановку функций,
параметры функции по умолчанию,
перегруженные имена функций, операции
управления свободной памятью и
ссылочный тип. В С++ сохранены
возможности языка C по работе с основными
объектами аппаратного
С++ и его стандартные библиотеки спроектированы так, чтобы обеспечивать переносимость. Имеющаяся на текущий момент реализация языка будет идти в большинстве систем, поддерживающих C. Из С++ программ можно использовать C библиотеки, и с С++ можно использовать большую часть инструментальных средств, поддерживающих программирование на C.
Язык С++ предназначен для разработки высокопроизводительного программного обеспечения и чрезвычайно популярен среди программистов. При этом он обеспечивает концептуальный фундамент (синтаксис и стиль), на который опираются другие языки программирования. Не случайно ведь потомками С++ стали такие почитаемые языки , как С# и Java. Более того, С++ можно назвать универсальным языком программирования, поскольку практически все профессиональные программисты на том или ином уровне знакомы с С++.
Постановка задач
Условие задачи:
Написать программу учёта наличия транспортных средств (автобусы) в автопарке. Программа должна иметь удобный пользовательский интерфейс с необходимыми пунктами меню. Работа с информацией должна проводиться в окнах. Информация организуется в виде структур и хранится в файле. Структура содержит следующие поля:
- Марка автобуса.
- Тип автобуса.
- Состояние (на базе, в рейсе, на ремонте, списан).
- Количество мест.
- Государственный номер.
- Водители.
По запросу выдавать информацию о свободных автобусах, автобусах в рейсе, ремонтируемых, списанных. Выдаваемая информация должна быть отсортирована по разным признакам. При реализации операции редактирования, добавления, удаления информации предусмотреть операцию отмены последних действий.
Обзор методов:
- Для решения поставленной задачи можно подключить к нашей программе базу данных, созданную в Microsoft Access. В таком случае можно создать объект DataGridView и работать напрямую с файлом, используя SQL-запросы.
Минус данного
метода заключается в том, что
таким способом не реализуется
- Можно использовать структуру классов для связи с файлами, в которых будет храниться та или иная информация.
Выбранный метод – 2.
Данный метод даёт больше «свободы» в работе с данными, позволяет использовать всю мощь языка, позволяет создавать новые методы для работы с файлами, позволяет реализовать основные принципы объектно-ориентированного программирования.
Структура входных и выходных данных
Входные данные:
- Файл с расширением .cbd, содержащий список городских автобусов и их характеристик. Элементами файла являются объекты класса CityBus.
class CityBus
{
public:
----//----
private:
char RegNumber[10]; // Уникальный регистрационный номер
char BusState[6]; // Состояние автобуса
char Mark[10]; // Марка автобуса
int Seats; // Количество сидений
char Driver1[40]; // Имя первого водителя
char Driver2[40]; // Имя второго водителя
char ST[4]; // Тип сидений
};
- Файл с расширением .mbd, содержащий номера комфортабельных автобусов и их характеристики. Элементами файла являются объекты класса ComfortBus.
class ComfortBus
{
public:
---//---
private:
char RegNumber[10]; // Уникальный регистрационный номер
char BusState[6]; // Состояние автобуса
char Mark[10]; // Марка автобуса
int Seats; // Количество сидений
char Driver1[40]; // Имя первого водителя
char Driver2[40] // Имя второго водителя
bool wc; // Наличие отхожего места
bool tv; // Наличме телевизора
};
Выходные данные имеют тот же формат, что и входные.
Диаграмма классов
Рисунок 1 – Диаграмма классов
Описание классов
class CityBus //Информация о городском автобусе
{
private:
char RegNumber[10]; //Регистрационный номер автобуса
char BusState[6]; //Состояние автобуса
char Mark[10]; //Марка автобуса
int Seats; //Количество мест для сидения
char Driver1[40]; //Первый водитель
char Driver2[40]; //Второй водитель
char ST[4]; //Тип сидений
public:
CityBus(void); //Консруктор по умолчанию
CityBus(int a7, System::String ^a1 , System::String ^ a2, System::String ^ a3, System::String ^ a4, System::String ^ a5, System::String ^ a6) ; //Конструктор c параметрами
CityBus (CityBus &tmp) ; //Конструктор копирования
~CityBus(void); //Деструктор
const CityBus& CityBus::operator = (const CityBus &tmp) ; //Перегрузка «=»
bool CityBus::operator < (const CityBus &ptr) const; // Перегрузка «<»
char* getST(); //Получить тип сидений
char* getRegNumber(); //Получить регистрационный номер автобуса
char* getMark(); // Получить марку автобуса
int getSeats(); // Получить количество мест для сидения
char* getState(); // Получить состояние автобуса
char* getDriver1(); // Получить первого водителя
char* getDriver2(); // Получить второго водителя
void setRegNumber(char *) ; //Задать регистрационный номер автобуса
void setMark(char * tmp) ; // Задать марку автобуса
void setSeats(int tmp) ; // Задать количество мест для сидения
void setState(char * tmp) ; // Задать состояние автобуса
void setDriver1(char * tmp) ; // Задать первого водителя
void setDriver2(char * tmp) ; // Задать второго водителя
void setST(char * tmp) ; // Задать тип сидений
};
class ComfortBus //Информация о комфортабельном автобусе
{
private:
char RegNumber[10]; //Регистрационный номер автобуса
char BusState[6]; //Состояние автобуса
char Mark[10]; //Марка автобуса
int Seats; //Количество мест для сидения
char Driver1[40]; //Первый водитель
char Driver2[40]; //Второй водитель
bool wc; //Наличие туалета
bool tv; //Наличие телевизора
public:
ComfortBus (void); //Консруктор по умолчанию
ComfortBus (int a7, System::String ^a1 , System::String ^ a2, System::String ^ a3, System::String ^ a4, System::String ^ a5, System::String ^ a6, bool a8, bool a9) ; //Конструктор с параметрами
ComfortBus (ComfortBus &tmp) ; //Конструктор копирования
~ ComfortBus (void); //Деструктор
const ComfortBus & CityBus::operator = (const ComfortBus &tmp) ; //Перегрузка «=»
bool ComfortBus::operator < (const ComfortBus &ptr) const; // Перегрузка «<»
char* getST(); //Получить тип сидений
char* getRegNumber(); //Получить регистрационный номер автобуса
char* getMark(); // Получить марку автобуса
int getSeats(); // Получить количество мест для сидения
char* getState(); // Получить состояние автобуса
char* getDriver1(); // Получить первого водителя
char* getDriver2(); // Получить второго водителя
bool getbwc(); // Получить наличие туалета
bool gettv(); // Получить наличие телевизора
void setRegNumber(char *) ; //Задать регистрационный номер автобуса
void setMark(char * tmp) ; // Задать марку автобуса
void setSeats(int tmp) ; // Задать количество мест для сидения
void setState(char * tmp) ; // Задать состояние автобуса
void setDriver1(char * tmp) ; // Задать первого водителя
void setDriver2(char * tmp) ; // Задать второго водителя
void setwc(bool tmp); // Задать наличие туалета
void settv(bool tmp); // наличие телевизора
};
template <typename T> class List // класс – контейнер (список)
{
friend class listIter<T>;
friend class Algoritm<T>;
public:
List(): top(NULL), end(NULL) {} // конструктор по умолчанию
List(const List<T> &p): top(p.top), end(p.end) {} // конструктор
void push_front(T); // добавить элемент в начало
void push_back(T); // добавить элемент в конец
T pop_front(); // достать первый элемент
T pop_back(); // достать последний элемент
void Delete(listIter<T> *); // удалить произвольный элемент
void Add(listIter<T> *, T); // добавить элемент по месту итератора
void SendToFile(char*); // поместить все элементы в бинарный файл
void PopFromFile(char*); // загрузить список из бинарного файла
bool getweight(); // показывает наличие хотя бы одного элемента
mylist<T>* front() const { return top;} // возвращает указатель на первый
mylist<T>* back() const { return end;} // возвращает указатель на
последний элемент
private:
mylist<T> *top, *end; // указатели на начало и конец списка
};
template <typename T> class mylist
{
friend class listIter <T>;
friend class List <T>;
friend class Algoritm<T>;
public:
mylist(T a): data(a), prv(NULL), next(NULL) {} // конструктор по
умолчанию
mylist<T>* getprv(); // возвращает указатель на предыдущий
элемент в списке
mylist<T>* getnext(); // возвращает указатель на следующай элемент
в списке
private:
T data; // элемент пользовательского типа
mylist<T> *prv, *next; // указатели на пр. и след. элемент
};
Описание алгоритмов
Блок-схемы алгоритмов:
нет да
да нет
нет да
да нет
да нет
да нет
Алгоритмы по шагам
Реализация алгоритма private:System::
- Начало.
- Выполняется проверка на наличие элементов в контейнере List
(if(mainlist.getweight()). Если контейнер пуст, обработчик завершается.
- Выполняется получение индекса выделенной строки (Selectpos1 = this->dataGridView->CurrentCel
lAdress). - Устанавливается итератор на начало списка (mainptr = mainlist)
- Ставим итератор в контейнере на элемент, соответствущий выбранному полю в dataGridView (for(int i = 0; i < Selectpos1; i++) mainptr++).
- Выводим на экран имена водителей.
- Конец.
Реализация алгоритма
private:System::Void button2_Click(System::Object^
- Начало.
- Выполняется проверка на наличие элементов в контейнере List и на выделение определенной dataGridView(if(this->
tabControl1->SelectedTab == tabPage2 && maincomlist.getweight())). - Устанавливается итератор на начало списка (maincomptr = maincomlist).
- Ставим итератор в контейнере на элемент, соответствущий выбранному полю в dataGridView (for(int i = 0; i < Selectpos2; i++) maincomptr++).
- Удаляем выделенный элемент из контейнера (maincomlist.Delete( &maincomptr)).
- Удаляем выделенный элемент из dataGridView (this->dataGridView2->Rows->
RemoveAt(selectpos2)). - Очистка полей с именами водителей.
- Конец.
Текст программы
Файл «CityBus.h»
#pragma once
#include <iostream>
class CityBus //Информация о городском автобусе
{
private:
char RegNumber[10]; //Регистрационный номер автобуса
char BusState[6]; //Состояние автобуса
char Mark[10]; //Марка автобуса
int Seats; //Количество мест для сидения
char Driver1[40]; //Первый водитель
char Driver2[40]; //Второй водитель
char ST[4]; //Тип сидений
public:
CityBus(void); //Консруктор по умолчанию
CityBus(int a7, System::String ^a1 , System::String ^ a2, System::String ^ a3, System::String ^ a4, System::String ^ a5, System::String ^ a6) ; //Конструктор c параметрами
CityBus (CityBus &tmp) ; //Конструктор копирования
~CityBus(void); //Деструктор
const CityBus& CityBus::operator = (const CityBus &tmp) ; //Перегрузка «=»
bool CityBus::operator < (const CityBus &ptr) const; // Перегрузка «<»
char* getST(); //Получить тип сидений
char* getRegNumber(); //Получить регистрационный номер автобуса
char* getMark(); // Получить марку автобуса
int getSeats(); // Получить количество мест для сидения
char* getState(); // Получить состояние автобуса
char* getDriver1(); // Получить первого водителя
char* getDriver2(); // Получить второго водителя
void setRegNumber(char *) ; //Задать регистрационный номер автобуса
void setMark(char * tmp) ; // Задать марку автобуса
void setSeats(int tmp) ; // Задать количество мест для сидения
void setState(char * tmp) ; // Задать состояние автобуса
void setDriver1(char * tmp) ; // Задать первого водителя
void setDriver2(char * tmp) ; // Задать второго водителя
void setST(char * tmp) ; // Задать тип сидений
};
Файл «CityBus.cpp»
#include "StdAfx.h"
#include "CityBus.h"
#include <iostream>
int strtoi (System::String ^ );
char * SysStringToChar(System::
CityBus(void){};
//CityBus(int, System::String ^ , System::String ^, System::String ^, System::String ^, System::String ^, bool, bool );
CityBus(int a7, System::String ^a1 , System::String ^ a2, System::String ^ a3, System::String ^ a4, System::String ^ a5, System::String ^ a6, bool a8, bool a9)
{
Seats=a7;
strcpy(RegNumber, SysStringToChar(a1));
strcpy(BusState, SysStringToChar(a2));
strcpy(Mark, SysStringToChar(a3));
strcpy(Driver1, SysStringToChar(a4));
strcpy(Driver2, SysStringToChar(a5));
wc=a8;
tv=a9;
strcpy(ST, SysStringToChar(a6));
}
CityBus (CityBus &tmp)
{
strcpy(Mark,tmp.Mark);
strcpy(Driver1,tmp.Driver1);
strcpy(Driver2,tmp.Driver2);
strcpy(BusState,tmp.BusState);
strcpy(RegNumber,tmp.
Seats=tmp.Seats;
wc=tmp.wc;
tv=tmp.tv;
strcpy(ST, tmp.ST);
}
~CityBus(void){};
const CityBus& CityBus::operator = (const CityBus &tmp)
{
if ( &tmp != this )
{
strcpy(Mark,tmp.Mark);
strcpy(Driver1,tmp.Driver1);
strcpy(Driver2,tmp.Driver2);
strcpy(BusState,tmp.BusState);
strcpy(RegNumber,tmp.
Seats=tmp.Seats;
tv=tmp.tv;
wc=tmp.wc;
strcpy(ST, tmp.ST);
}
return *this;
}
bool CityBus::operator < (const CityBus &ptr) const
{
if (strcmp(RegNumber, ptr.RegNumber) < 0) return true;
else return false;
}
char* getST()
{
return ST;
}
char* getRegNumber()
{
return RegNumber;
}
char* getMark()
{
return Mark;
}
int getSeats()
{
return Seats;
}
char* getState()
{
return BusState;
}
char* getDriver1()
{
return Driver1;
}
char* getDriver2()
{
return Driver2;
}
void setRegNumber(char * tmp)
{
strcpy(RegNumber,tmp);
}
void setMark(char * tmp)
{
strcpy(Mark,tmp);
}
void setSeats(int tmp)
{
Seats = tmp;
}
void setState(char * tmp)
{
strcpy(BusState,tmp);
}
void setDriver1(char * tmp)
{
strcpy(Driver1,tmp);
}
void setDriver2(char * tmp)
{
strcpy(Driver2,tmp);
}
void setST(char * tmp)
{
strcpy(ST,tmp);
}
};
Файл «ComfortBus.h»
#pragma once
#include <iostream>
using namespace std;
class ComfortBus //Информация о комфортабельном автобусе
{
private:
char RegNumber[10]; //Регистрационный номер автобуса
char BusState[6]; //Состояние автобуса
char Mark[10]; //Марка автобуса
int Seats; //Количество мест для сидения
char Driver1[40]; //Первый водитель
char Driver2[40]; //Второй водитель
bool wc; //Наличие туалета
bool tv; //Наличие телевизора
public:
ComfortBus (void); //Консруктор по умолчанию
ComfortBus (int a7, System::String ^a1 , System::String ^ a2, System::String ^ a3, System::String ^ a4, System::String ^ a5, System::String ^ a6, bool a8, bool a9) ; //Конструктор с параметрами
ComfortBus (ComfortBus &tmp) ; //Конструктор копирования
~ ComfortBus (void); //Деструктор
const ComfortBus & CityBus::operator = (const ComfortBus &tmp) ; //Перегрузка «=»
bool ComfortBus::operator < (const ComfortBus &ptr) const; // Перегрузка «<»
char* getST(); //Получить тип сидений
char* getRegNumber(); //Получить регистрационный номер автобуса
char* getMark(); // Получить марку автобуса
int getSeats(); // Получить количество мест для сидения
char* getState(); // Получить состояние автобуса
char* getDriver1(); // Получить первого водителя
char* getDriver2(); // Получить второго водителя
bool getbwc(); // Получить наличие туалета
bool gettv(); // Получить наличие телевизора
void setRegNumber(char *) ; //Задать регистрационный номер автобуса
void setMark(char * tmp) ; // Задать марку автобуса
void setSeats(int tmp) ; // Задать количество мест для сидения
void setState(char * tmp) ; // Задать состояние автобуса
void setDriver1(char * tmp) ; // Задать первого водителя
void setDriver2(char * tmp) ; // Задать второго водителя
void setwc(bool tmp); // Задать наличие туалета
void settv(bool tmp); // наличие телевизора
};
Файл «ComfortBus.cpp»
#include "StdAfx.h"
#include "ComfortBus.h"
ComfortBus(void){};
ComfortBus(int a7, System::String ^a1 , System::String ^ a2, System::String ^ a3, System::String ^ a4, System::String ^ a5, bool a8, bool a9)
{
Seats=a7;
strcpy(RegNumber, SysStringToChar(a1));
strcpy(BusState, SysStringToChar(a2));
strcpy(Mark, SysStringToChar(a3));
strcpy(Driver1, SysStringToChar(a4));
strcpy(Driver2, SysStringToChar(a5));
wc=a8;
tv=a9;
}
ComfortBus (ComfortBus &tmp)
{
strcpy(Mark,tmp.Mark);
strcpy(Driver1,tmp.Driver1);
strcpy(Driver2,tmp.Driver2);
strcpy(BusState,tmp.BusState);
strcpy(RegNumber,tmp.
Seats=tmp.Seats;
wc=tmp.wc;
tv=tmp.tv;
}
~ComfortBus(void){};
const ComfortBus& ComfortBus::operator = (const ComfortBus &tmp)
{
if ( &tmp != this )
{
strcpy(Mark,tmp.Mark);
strcpy(Driver1,tmp.Driver1);
strcpy(Driver2,tmp.Driver2);
strcpy(BusState,tmp.BusState);
strcpy(RegNumber,tmp.
Seats=tmp.Seats;
tv=tmp.tv;
wc=tmp.wc;
}
return *this;
}
bool ComfortBus::operator < (const ComfortBus &ptr) const
{
if (strcmp(RegNumber, ptr.RegNumber) < 0) return true;
else return false;
}
bool getbwc()
{
return wc;
}
bool gettv()
{
return tv;
}
char* getRegNumber()
{
return RegNumber;
}
char* getMark()
{
return Mark;
}
int getSeats()
{
return Seats;
}
char* getState()
{
return BusState;
}
char* getDriver1()
{
return Driver1;
}
char* getDriver2()
{
return Driver2;
}
void setwc(bool tmp)
{
wc = tmp;
}
void settv(bool tmp)
{
tv = tmp;
}
void setRegNumber(char * tmp)
{
strcpy(RegNumber,tmp);
}
void setMark(char * tmp)
{
strcpy(Mark,tmp);
}
void setSeats(int tmp)
{
Seats = tmp;
}
void setState(char * tmp)
{
strcpy(BusState,tmp);
}
void setDriver1(char * tmp)
{
strcpy(Driver1,tmp);
}
void setDriver2(char * tmp)
{
strcpy(Driver2,tmp);
}
};
Файл «mylist.h»
#ifndef MYLIST_H
#define MYLIST_H
#include "iterator.h"
#include <fstream>
template <typename T> class Algoritm;
template <typename T> class Iterator;
template <typename T> class List
{
friend class Iterator<T>;
friend class Algoritm<T>;
public:
List(): top(NULL), end(NULL) {}
List(const List<T> &p): top(p.top), end(p.end) {}
void push_front(T);
void push_back(T);
T pop_front();
T pop_back();
void Delete(Iterator<T> *);
void Add(Iterator<T> *, T);
void SendToFile(char*);
void PopFromFile(char*);
bool getweight();
mylist<T>* front() const { return top;}
mylist<T>* back() const { return end;}
private:
mylist<T> *top, *end;
};
template <typename T> class mylist
{
friend class Iterator <T>;
friend class List <T>;
friend class Algoritm<T>;
public:
mylist(T a): data(a), prv(NULL), next(NULL) {}
mylist<T>* getprv();
mylist<T>* getnext();
private:
T data;
mylist<T> *prv, *next;
};
template <typename T>
class Algoritm
{
public:
Algoritm() {};
void Sort(const List<T> *);
};
#endif
Файл «mylist.cpp»
#include "stdafx.h"
#include "mylist.h"
#include "iterator.h"
#include "exceptions.h"
#include <fstream>
template <typename T>
void List<T>::push_front(T a) //Добавление в начало листа
{
mylist<T> *p;
p=new mylist<T> (a);
if (top == NULL) top = end = p;
else
{
p->next = top;
top->prv = p;
top = p;
}
}
template <typename T>
void List<T>::push_back(T a) //Добавление в конец листа
{
mylist<T> *p;
p = new mylist<T> (a);
if (top == NULL) top = end = p;
else
{
p->prv = end;
end->next = p;
end = p;
}
}
template <typename T>
T List<T>::pop_front() //
{
if (top == NULL)
{
exit (0) ;
}
if (top == end)
{
T temp;
temp = top->data;
top = end = NULL;
return temp;
}
T temp;
temp = top->data;
top = top->next;
top->prv = NULL;
return temp;
}
template <typename T>
T List<T>::pop_back() //Извлечение из листа с конца
{
if (end == NULL)
{
exit(1);
}
if (top == end)
{
T temp;
temp = end->data;
top = end = NULL;
return temp;
}
T temp;
temp = end->data;
end = end->prv;
end->next = NULL;
return temp;
}
template <typename T>
void List<T>::Delete(Iterator<T> *p) //Удаление элемента из листа
{
mylist<T> *temp;
if (top == end || top == NULL)
{
if (top != NULL)
{
delete p->ptr;
top = end = NULL;
}
}
else
{
if (top == p->ptr) {top = p->ptr->next; top->prv = NULL;}
else p->ptr->prv->next = p->ptr->next;
if (end == p->ptr) {end = p->ptr->prv; end->next = NULL;}
else p->ptr->next->prv = p->ptr->prv;
temp = p->ptr;
p->ptr = p->ptr->next;
temp->next = temp->prv = NULL;
delete temp;
}
}
template <typename T>
void List<T>::Add(Iterator<T> *p, T temp) //Добавление элемента
{
if (top == NULL) {top = end = new mylist<T>(temp); }
else
{
if (p->ptr == top)
{
mylist<T> *pointer = new mylist<T> (temp);
top->prv = pointer;
pointer->next = top;
top = pointer;
p->ptr = p->ptr->prv;
}
else
{
mylist<T> *pointer = new mylist<T> (temp);
if (p->ptr == end) end = pointer;
else
{
p->ptr->next->prv = pointer;
pointer->next = p->ptr->next;
}
p->ptr->next = pointer;
pointer->prv = p->ptr;
p->ptr = p->ptr->next;
}
}
}
template <typename T>
void List<T>::SendToFile(char *s) //Запись листа в файл
{
Iterator<T> p;
T* temp;
ofstream File(s,ios::binary);
if (!File)
{
exit (1);
}
p = *this;
if (top != NULL)
{
while (1)
{
temp = new T (*p);
File.write((char*) temp, sizeof T);
if (p.ptr->next != NULL) p++;
else { File.close() ; break;}
}
}
else
{
File.close();
}
}
template <typename T>
void List<T>::PopFromFile(char *s) //Чтение листа из файла
{
T temp;
ifstream File(s, ios::binary);
if (!File) ofstream File(s, ios::binary);
else
{
if (top != NULL) throw ListNotFree();
while (File.read ((char*) &temp, sizeof T))
{
push_back(temp);
}
}
File.close();
}
template <typename T>
bool List<T>::getweight() //
{
if (top == NULL) return false;
else return true;
}
template <typename T>
void Algoritm<T>::Sort (const List<T> *point) //Сортировка
{
listIter<T> ptr1, ptr2, ptr3;
T min;
ptr1=*point;
for( int i=0; ptr1.ptr->next != NULL ; i++,ptr1++)
{
min = ptr1.ptr->data;
ptr3 = ptr1;
for(ptr2 = ptr1, ptr2++ ; 1 ; ptr2++)
{
if (ptr2.ptr->data < min)
{
min = ptr2.ptr->data;
ptr3 = ptr2;
}
if (ptr2.ptr->next == NULL) break;
}
if (ptr3 != ptr1)
{
ptr3.ptr->data = ptr1.ptr->data;
ptr1.ptr->data = min;
}
}
}
template <typename T>
mylist<T>* mylist<T>::getprv()
{
return(prv);
}
template <typename T>
mylist<T>* mylist<T>::getnext()
{
return(next);
}
Файл «Iterator.h»
#ifndef ITERATOR_H
#define ITERATOR_H
#include "mylist.h"
template <typename T> class mylist;
template <typename T> class List;
template <typename T> class Algoritm;
template <typename T> class Iterator
{
friend class List<T>;
friend class Algoritm<T>;
public:
Iterator(const Iterator<T> &p): ptr(p.ptr) {} //Перегрузки операторов
Iterator(): ptr(0) {}
void Reset () ;
const Iterator<T> & operator= (const List<T> &p) ;
const Iterator<T> & operator= (const mylist<T> &p) ;
bool operator== (const Iterator &p2) ;