В этой курсовой работе я делал модель электронного справочника.
ОГЛАВЛЕНИЕ
2.1.Наименование и область применения. 4
2.2.Основания для разработки. 4
2.4.Технические требования к программе или программному обеспечению. 4
3.ВЫБОР СПОСОБА, МЕТОДА РЕШЕНИЯ ПОСТАВЛЕННОЙ ЗАДАЧИ.. 5
4.3. Класс CObjectListItem.. 7
4.1.2.Поиск элемента в списке. 9
4.1.2 Вставка элемента в список. 9
4.1.3 Удаление элемента из списка. 10
4.2.Указатель на базовый класс. 10
1.ВВЕДЕНИЕ
Фундаментальная концепция ООП состоит в передаче сообщений объектам. Для этого необходимо, чтобы объекты определялись вместе с сообщениями, на которые они будут реагировать. Это и есть главное отличие ООП от императивного (процедурного) программирования, в котором сначала определяются структуры данных, а затем передаются соответствующим процедурам (функциям) как параметры.
Существует пять основных компонент объектно-ориентированной парадигмы: объект, сообщение, класс, наследование, метод. Объектно-ориентированный язык программирования должен обладать свойствами абстракции, инкапсуляции, наследования и полиморфизма. Кроме этих обязательных свойств объектно-ориентированному языку желательно иметь возможности расширения за счет введения новых классов, повторного использования программных компонент, параметризации, а также некоторые формы коллекций.
Суть основных компонент можно раскрыть следующим образом:
- Объект (Object). Вот несколько определений объекта.
* В наиболее широком смысле это совокупность данных, существующих в машинном представлении как единое целое, допускающее обращение по имени, указателю или ссылке.
* В смысле ООП объект – это сущность, обладающая состоянием и поведением.
* Объект – это инкапсулированная абстракция, которая включает информацию о состоянии и четко определенное множество протоколов доступа.
- Сообщение (Message) – это специальный символ, идентификатор или ключевое слово с параметром или без, которое представляет выполняемое объектом действие.
- Класс (Class). Представляет тип данных, определяемых программистом, который специфицирует как представление объектов этого класса, так и операции, которые можно выполнять с объектами. Во многих случаях класс следует понимать как абстрактный тип данных.
- Экземпляр (Instance) – объект, принадлежащий конкретному классу.
- Метод (Method) – функция, вызываемая в ответ на запрос к объекту некоторого класса совершить какое-либо действие. Можно сказать, что метод определяет реакцию объекта на сообщение. Совокупность методов класса определяет поведение объектов данного класса.
Несколько слов об основных свойствах ООП.
- Инкапсуляция (Encapsulation) – сокрытие информации или определение пользователем новых типов данных. Каждый такой тип содержит определение набора значений и операций, которые могут быть выполнены над этими значениями, и образует так называемый абстрактный тип данных.
- Наследование (Inheritance) – это механизм, позволяющий строить иерархию типов. Механизм наследования предполагает определение базового типа, а затем использование его для построения производных типов. Причем каждый из производных типов наследует все свойства базового типа, включая характеристики (данные) и набор операций (методов, функций).
- Полиморфизм (Polymorphism) – свойство объекта отвечать на направленный к нему запрос сообразно своему типу.
Новизна ООП позволяет отбросить старые способы мышления и привычки, которые в течение многих лет были присущи в традиционным языкам программирования.
Целью курсовой работы является углубление и закрепление теоретических знаний, навыков практического применения основных принципов объектно-риентированных систем: наследования, инкапсуляции, полиморфизма, а также формирование новых взглядов на процессы программирования с учетом абстракции данных.
2.ПОСТАНОВКА ЗАДАЧИ
По заданию необходимо создать модель электронного справочника. Поскольку задание не имеет никаких уточнений о виде справочника (для библиотеки, для аэропорта…) то будет проектироваться универсальный справочник. В этом справочнике будет содержаться информация о названии объекта, его описании и изображении.
2.1.Наименование и область применения
Электронный справочник применяется для хранения информации об объектах. Например, может храниться следующая информация: название предмета, описание предмета, изображение предмета.
Основанием для разработки модели электронного справочника является выданное в соответствии с вариантом задание на курсовую работу по дисциплине «Объектно-ориентированное программирование».
2.3.Назначение разработки.
Разработка предназначена для хранения и модификации данных о предметах: название, описание, изображение, поиска информации по справочнику.
2.4.Технические требования к программе или программному обеспечению.
3.1.Требования к функциональным характеристикам.
Программа должна иметь возможности добавления новых объектов, изменения уже существующих объектов и удаления объектов. Также программа должна осуществлять поиск объектов по заданным критериям.
3.2.Требования к надёжности.
В случае возникновения ошибок программа должна выдавать соответствующее сообщение.
3.3.Условия эксплуатации.
Заданные характеристики в пункте 3.2 характеристики должны обеспечиваться при температурно-климатических условиях, приемлемых для ЭВМ, на которой запущена программа.
Программа должная быть рассчитана на опытного пользователя Microsoft Windows 2000.
3.4.Требования к составу и параметрам технических средств. Программа должна корректно работать на IBM-совместимой ЭВМ. Наличие манипулятора «мышь» и sVGA монитора обязательно.
3.5. Требования к информационной и программной совместимости.
Программа должна быть разработана с использованием среды разработки Microsoft Visual C++ 6.0.
3.6.Требования к маркировке и упаковке.
Диски с копиями программы должны быть маркированы товарными знаками Заказчика.
3.7.Требования к транспортированию и хранению. Данные требования соответствую таковым для каждого из носителей, на которых будет храниться программа.
3.ВЫБОР СПОСОБА, МЕТОДА РЕШЕНИЯ ПОСТАВЛЕННОЙ ЗАДАЧИ
3.1.Выбор структуры данных
Существует множество способов решения поставленной задачи. Все они основываются на способе хранения данных. Для хранения данных могут использоваться следующие структуры:
- Список[6]
- Массив[1][4][5]
- Дерево[6]
Естественно самой критической операцией для работы с данными является время. С помощью деревьев можно добиться очень высокой производительности, используя различный методы поиска, которые сильно зависят от структуры дерева.
Можно использовать цифровой поиск, поиск в АВЛ деревьях, в красно-чёрных деревьях.
Представление с помощью деревьев имеет высокую производительность при поиске и не имеет ограничения на количество данных (ограниченно только ресурсами вычислительной машины)
Отрицательная сторона — сложность реализации по сравнению с остальными методами.
Массив в данном случае не подходит из-за ограниченности его размеров. Однако существует у него и положительные стороны.
- Простота реализации
- быстрота поиска, особенно при использовании хеширования. при использовании других методов поиска (бинарный в упорядоченной таблице, поиск Фибоначчи) быстрота несколько ниже, но также остаётся достаточно высокой
Список достаточно прост в реализации и у него нет ограничения на количество данных. Его слабая сторона – время поиска. Но поскольку по заданию требуется построить модель электронного справочника, а не реальный электронный справочник то будет реализован этот вариант. Благодаря быстродействию современный компьютеров он будет работать достаточно быстро и на сравнительно больших объёмах данных.
Вообще можно взять готовый стандартный шаблон для работы со списком list, также в используемой графической библиотеке wxWidgets[3] есть класс wxList[3]. Легче всего было бы использовать один из них. Но тогда непонятно: куда применить классы и наследование в программе. Поэтому класс список будет реализован самостоятельно.
Будет реализован самый простой список, но упорядоченный. Хотя вообще-то можно было бы использовать некоторые методы для ускорения операций со списком. Например, можно было хранить указатели на объект, который является первым в списке, с этой первой буквой:
Но как уже говорилось выше будет реализован самый простой список.
Схема классов, реализованных для данной программы:
4.2.Класс CObject
4.2.1.Описание
Класс CObject представляет собой единичный объект базы данных (одну запись). Сама база данных справочника состоит из множества экземпляров класса CObject.
4.2.2.Поля
Как видно из схемы существует класс CObject, содержащий поля с данными. На основе него построен класс CObjectListItem, в котором присутствуют методы для вставки элементов перед и после объекта и соответствующие поля.
Класс CObject имеет следующий поля для хранения названия предмета, описания предмета, изображения предмета. Таким образом достигается практически универсальность справочника. Можно в справочнике хранить список книг (Записывая в название предмета название книги, а в описании — о чём та книга, в изображении привести, например, обложку), телефоны (название – ФИО, описание – телефое, изображение — фотография) и т. д.
4.2.3.Методы
Какие методы необходимы для класса CObject? Поскольку используется инкапсуляция, то естественно необходимы методы для доступа к полям.
Далее необходимо иметь возможность присвоить один объект другому и сравнить объекты на равенство.
4.3. Класс CObjectListItem
4.3.1.Описание
Класс CObjectLstItem представляет собой один объект базы данных с информацией о других объектах. То есть с помощью одного объекта этого класса можно получить информацию о других объектах.
4.3.2.Поля
Построен на основе CObject и наследует от него все поля и методы. Добавляются поля-указатели на предыдущий и следующий элемент
4.3.3.Методы
Добавляются методы доступа к полям-указателям на предыдущий и следующий элементы. Также методы для вставки нового элемента после и перед ним. Более подробно вставка описана в разделе 4.
4.4.Класс CObjectList
4.4.1.Описание
Класс CObjectList представляет собой прообраз базы данных. он содержит в себе информацию о всех объектах базы данных модели электронного справочника.
По сути он представляет собой реализацию списка объектов.
4.4.2.Поля
Класс CObjectList имеет в своём составе указатели на голову и хвост списка, поле для хранения количества элементов и методы для работы со списком: вставка, удаление, поиск.
Также было бы полезным знать количество объектов, находящихся в данный момент в списке. Для этого есть два пути:
- Написать метод подсчёта количества объектов в списке;
- Иметь переменную в которой будет постоянно хранится и корректироваться при выполнении операций удаления в вставки количество объектов
Понятно, что второй метод предпочтительнее, так как в первом методе при подсчёте будет проходить время пропорциональное n, где n — количество объектов в списке.
4.4.3.Методы
Для работы со списком нужны стандартные методы вставки, удаления, поиска и т. д. Эти методы более подробно описаны в теоретическом разделе.
4.5.Класс CHandbook
4.5.1.Описание
Класс CHandbook построен на основе CObjectList и имеет все методы, необходимые для работы модели электронного справочника. Он осуществляет связь пользовательского интерфейса и остальной программы. То есть он является чем-то средним между классом интерфейса и внутренней программы.
4.5.2.Поля
Добавляются поля для хранения информации о поиске объекта. То есть о признаках, по которым необходимо найти объект. Для этого используется класс CObject. Подразумевается, что соответствующее поле соответствует нулю типа этого поля (для строк им является строка “”, то есть пустая строка). В противном случае там хранится информация, которая должная содержатся в этом поле в найденном объекте. Это сделано для того, чтобы после осуществления первого поиска элемента, для поиска следующего элемента необходимо было нажать только одну кнопку FindNext.
Поскольку в один определённый момент просматривается только одно поле, то есть указатель на текущий объект, а также номер его позициив списке.
4.5.3.Методы
Добавляется методы для поиска первого элемента и поиска следующего элемента.
Также методы для получения указателя на текущий просматриваемый элемент. Однако, его нужно использовать с осторожностью, поскольку он даёт прямой доступ к объекту (элементу списка CObjectList) и можно случайно нарушить целостность базы данных.
Есть метод установки текущего элемента и номера текущего элемента (тоже нужно использовать с осторожностью).
Для перемещения по записям методы перехода к предыдущему элементу и следующему элементу.
Также перегружаются методы добавления и удаления объекта, которые после (или перед) вызова метода базового класса CObjectList корректируют добавленные в этом классе поля.
4.6.Строки
Этот вопрос является актуальным при программировании на С++. Поскольку в С++ есть много способов для хранения строк.
Массив символов, обычно используемый для элит целей не очень удобен, так как программисту самому приходится следить за размерами памяти.
К счастью в стандартной библиотеке С++ есть класс string, который заметно облегчает работу со строками. Но в используемой графической библиотеке wxWidgets[3] есть ещё один класс wxString[3]. Во избежании проблем с графической оболочкой будет использоваться именно он.
4.ТЕОРЕТИЧЕСКИЙ РАЗДЕЛ
4.1.Список
4.1.1.Список
Список строится на основе структуры, в которой имеется поле с данными и поле, указывающее на следующий элемент списка (Next).
Можно также добавить и указатель на предыдущий элемент списка (Previous) (так и сделано в этой курсовой работе).
4.1.2.Поиск элемента в списке
Поиск будет осуществляться последовательно от начального элемента списка к последнему (имеющему в поле указателя на следующий элемент NIL) так как в любом случае проверить нужно все объекты (так как ищется подстрока в описании или названии предмета).
4.1.2 Вставка элемента в список
Вставка элемента. Для вставки элемента сначала необходимо найти позицию вставки. Объекты в списке хранятся не беспорядочно. В данном случае они упорядочены по имени. Список начинает просматриваться с начала. Когда находится место для вставки то происходит корректировка указателей.
Список перед вставкой нового элемента:
Пусть P (от слова Previous, предыдущий) — предыдущий элемент списка, то есть элемент, после которого необходимо вставить новый. Пусть N (от слова Next, следующий) — следующий элемент списка, то есть элемент, перед которым необходимо вставить новый. C (Current) —вставляемый элемент списка.
Корректировка указателей происходит по следующему алгоритмы:
P.Next:=C;
C.Previous=P;
N.Previous=C;
C.Next=C;
Список после вставки нового элемента:
Описанный случай происходит при вставке в середину списка. В случае вставки в начало списка, то есть когда С становится первым элементом списка полю С.Previous присваивается NIL и убираются все операции с P. А в случае вставки в конец списка убираются все действия с N и полю C.Next:=NIL.
Также в случае вставки в конец и начало списка необходимо скорректировать указатели на голову и хвост списка.
4.1.3 Удаление элемента из списка
При удалении элемента из списка происходит следующая коррекция указателей:
Если существует следующий за С элемент N, то N.Previous:=C.Previous
Если существует предыдущий для С элемент P, то P.Next=C.Next
Только после этого освобождается память из-под элемента С.
Список перед удалением элемента:
Список после удаления элемента:
4.2.Указатель на базовый класс
Указателю на базовый класс можно присвоить значение адреса объекта любого произвольного класса, вызывать методы любого объекта произвольного класса. Если метод определён в базовом классе, как виртуальный, то он наследуется и в произвольном классе, и переопределять его требуется только при необходимости задать отличающиеся действия. Если метод определён в базовом классе, как виртуальный, то решение, о том, метод какого класса нужно вызвать при совпадении имён, будет приниматься в зависимости от типа объекта, на который ссылается указатель.
В программе, написанной при выполнении данной работы, указатель на базовый класс ссылается лишь на объекты произвольных классов, причём попеременно.
4.3.Инкапсуляция
Класс содержит не только данные, но и методы для их обработки. Для каждого класса требуется реализовать все действия над его данными, могущие понадобиться при работе с экземпляром данного класса. Инкапсуляция[1] подразумевает запрет на прямой доступ к данным класса. Обработка информационных полей экземпляра класса в таком случае может быть осуществлена лишь с помощью методов данного класса. Подразумевается, что методы класса предоставляют возможность производить над экземпляром класса все необходимые действия.
Инкапсуляция позволяет рассматривать экземпляр класс не как совокупность информационных полей, а как нечто целое – объект, над которым можно совершать лишь предусмотренные, заведомо корректные действия. Это улучшает понятность и структурированность программы, уменьшает число ошибок.
При инкапсуляции любое действие над объектом предусматривает вызов функции, что отрицательно сказывается на быстродействии программы, особенно при обработке больших объёмов данных. В некоторых случаях возможно объявлять другие классы, как дружественные данному, что позволяет осуществить прямой доступ к его элементам
4.4.Наследование
Наследование[1] — возможность создания иерархии классов, когда потомки наследуют все свойства своих предков, могут их изменять и добавлять новые. Свойства при наследовании повторно не описываются, что сокращает объём программы. Выделение общих черт различных классов в один класс-предок является мощным механизмом абстракции — ведь и любая наука начинается с абстрагирования и классификации, которые помогают справиться со сложностью рассматриваемой предметной области.
Иерархия классов представляется в виде древовидной структуры, в которой более общие классы располагаются ближе к корню, а более специализированные — на ветвях и листьях. Иногда предки называются надклассами или суперклассами, а потомки – подклассами или субклассами.
4.5.Полиморфизм
Третьим китом, на котором стоит ООП, является полиморфизм[1] — возможность использовать в различных классах иерархии одно и то же имя для обозначения сходных по смыслу действий и гибко выбирать требуемое действие во время выполнения программы.
Простым примером полиморфизма является перегрузка функций.
5.ВЫВОДЫ ПО РАБОТЕ
Объектно-ориентированное программирование является мощным средством для построения сложных программ, поскольку они позволяют строить программу на основе объектов и их взаимодействий.
Объектно-ориентированное программирование позволяет в значительной степени абстрагироваться от того, в каком формате хранятся данные в памяти ЭВМ, рассматривать данные и те операции, что возможно произвести над этими данными, как единое целое, не отвлекаясь на несущественные в деле достижения поставленной цели – создания работающей программы, решающей конкретную задачу, детали, сокрытые внутри методов класса. Реализованный в языке С++ механизм наследования позволяет создавать множество объектов различных классов на основе исходного класса, дополняя производные классы новыми свойствами и методами и сохраняя за ними, в той или иное мере, прежние, унаследованные у базового класса.
Данный механизм позволяет моделировать в программе объекты реального мира и связи между ними, производить обобщение и конкретизацию. Наследование и полиморфизм позволяют одним и тем же именем вызывать метода для произведения сходных действий для различных объектов, не отвлекаясь на то, что фактически в каждом случае выполняются различные участки кода.
Использование объектно-ориентированного программирования удобно, а в ряде случаев практически необходимо создании больших программных продуктов.
Созданная в данной работе программа показала эффективность объектно-ориентированного программирования при создании модели электронного справочника.
6.СПИСОК ЛИТЕРАТУРЫ
- Павловская Т. А. C/C++. Программирования на языке высокого уровня – СПб.: Питер, 2004. – 461с. ил.
- MSDN Library Visual Studio 6.0
- wxWidgets Manual
- Ишкова Э. А. С++. Начала программирования. Изд. 3-е перераб. и доп. — М.: ООО «Бином-Пресс», 2004. —368 с.: ил.
- Глушаков С. В., Коваль А. В., Смирнов С. В. Язык программирования С++: Учебник курс / Худож. – оформитель А. С. Юхьман. — Харьков: Фолио; М.: ООО «Издательство АСТ», 2001. — 500 с. — (Домашняя б-ка).
- Структуры данных и алгоритмы. :Пер. с англ. : Уч. пос. — М. : Издательский дом «Вильямс», 2000. —384 с. : ил. — Парал. Тит. англ.
7. ПРИЛОЖЕНИЯ
Тексты основных файлов:
Файл «object.h»:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 |
/////////////////////////////////////////////////////////////////////////////// // // Проект : Handbook // Модуль : object.h // Дата : 6/03/07 // // Описание : В этом модуле описан класс CObject, описывающийся один // объект, хранящийся в электронном справочнике // /////////////////////////////////////////////////////////////////////////////// // // COPYRIGHT (c) 2007. Урванов Фёдор Владиславович // /////////////////////////////////////////////////////////////////////////////// #ifndef _COBJECT_FHOW384S98EGHSO98E4HYSOEB4TGO9S4E #define _COBJECT_FHOW384S98EGHSO98E4HYSOEB4TGO9S4E #include <wx/wx.h> #include <ostream.h> #include <istream.h> class CObjectListItem ; class CObject{ private: wxString m_wxstrName; wxString m_wxstrDescription; wxString m_wxstrImageFileName; public: CObject():m_wxstrName(""),m_wxstrDescription(""),m_wxstrImageFileName("") {} CObject(const CObject & p_rco); virtual ~CObject() {}; //Функции доступа к полям wxString GetName(void){return m_wxstrName;} void inline SetName(wxString p_wxstrName) {m_wxstrName=p_wxstrName;} wxString GetDescription(void){return m_wxstrDescription;} void inline SetDescription(wxString p_wxstrDescription) {m_wxstrDescription=p_wxstrDescription;} wxString GetImageFileName(void){return m_wxstrImageFileName;} void inline SetImageFileName(wxString p_wxstrImageFileName) {m_wxstrImageFileName=p_wxstrImageFileName;} ///////////////////////////////////////////////////////////////////////////// //перегрузка операций virtual BOOL operator ==(const CObject & p_rco); virtual BOOL operator !=(const CObject & p_rco); friend ostream & operator << (ostream & out, CObject & p_rco); friend istream & operator >> (istream & in, CObject & p_rco); }; ostream & operator << (ostream & out, CObject & p_rco); istream & operator >> (istream & in, CObject & p_rco); #endif |
Файл «object.cpp»:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 |
/////////////////////////////////////////////////////////////////////////////// // // Проект : Handbook // Модуль : object.cpp // Дата : 6/03/2007 // // Описание : Реализация класса object. // /////////////////////////////////////////////////////////////////////////////// // // COPYRIGHT (c) 2007. Урванов Фёдор Владиславович // /////////////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include "object.h" #include "objectlistitem.h" /////////////////////////////////////////////////////////////////////////////// // // Метод : Конструктор // Автор : Урванов Фёдор Владиславович // Дата : 6/03/2007 // //----------------------------------------------------------------------------- // // Параметры : const CObject& p_rco // // Описание : Конструктор копирования // // Выход : нет // /////////////////////////////////////////////////////////////////////////////// CObject::CObject(const CObject & p_rco) { memcpy((void*)this, (const void*)&p_rco,sizeof(p_rco)); } /////////////////////////////////////////////////////////////////////////////// // // Метод : ostream & operator << // Автор : Урванов Фёдор Владиславович // Дата : 6/03/2007 // //----------------------------------------------------------------------------- // // Параметры : ostream & out, CObject& p_rco // // Описание : Для записи в файл // // Выход : нет // /////////////////////////////////////////////////////////////////////////////// ostream & operator << (ostream & out, CObject & p_rco) { out<<p_rco.m_wxstrName<<'\0'; out<<p_rco.m_wxstrDescription<<'\0'; out<<p_rco.m_wxstrImageFileName<<'\0'; return out; } /////////////////////////////////////////////////////////////////////////////// // // Метод : istream& operator >> // Автор : Урванов Фёдор Владиславович // Дата : 6/03/2007 // //----------------------------------------------------------------------------- // // Параметры : istream & in, CObject & p_rco // // Описание : Стандартная операция потокового ввода. // // Выход : нет // /////////////////////////////////////////////////////////////////////////////// istream & operator >> (istream & in, CObject & p_rco) { ReadString(in,p_rco.m_wxstrName); ReadString(in,p_rco.m_wxstrDescription); ReadString(in,p_rco.m_wxstrImageFileName); return in; } /////////////////////////////////////////////////////////////////////////////// // // Метод : operator == // Автор : Урванов Фёдор Владиславович // Дата : 6/03/2007 // //----------------------------------------------------------------------------- // // Параметры : const CObject& p_rco // // Описание : Операция сравнения // // Выход : нет // /////////////////////////////////////////////////////////////////////////////// BOOL CObject::operator ==(const CObject & p_rco) { if (m_wxstrName!=p_rco.m_wxstrName) return FALSE; if (m_wxstrDescription!=p_rco.m_wxstrDescription) return FALSE; if (m_wxstrImageFileName!=p_rco.m_wxstrImageFileName) return FALSE; return TRUE; } /////////////////////////////////////////////////////////////////////////////// // // Метод : operator != // Автор : Урванов Фёдор Владиславович // Дата : 6/03/2007 // //----------------------------------------------------------------------------- // // Параметры : const CObject& p_rco // // Описание : Операция не равно // // Выход : нет // /////////////////////////////////////////////////////////////////////////////// BOOL CObject::operator !=(const CObject & p_rco) { if (m_wxstrName!=p_rco.m_wxstrName) return TRUE; if (m_wxstrDescription!=p_rco.m_wxstrDescription) return TRUE; if (m_wxstrImageFileName!=p_rco.m_wxstrImageFileName) return TRUE; return FALSE; } |
Файл «objectlist.h»:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
/////////////////////////////////////////////////////////////////////////////// // // Проект : Handbook // Модуль : objectlist.h // Дата : 14/03/07 // // Описание : В этом модуле описан класс CObjectList, описывающий // список // /////////////////////////////////////////////////////////////////////////////// // // COPYRIGHT (c) 2007. Урванов Фёдор Владиславович // /////////////////////////////////////////////////////////////////////////////// #include "objectlistitem.h" #ifndef _OBJECTLIST_HGWOHHGPPOIV3657FDFGHW54Y_INCLUDED_ #define _OBJECTLIST_HGWOHHGPPOIV3657FDFGHW54Y_INCLUDED_ class CObjectList{ CObjectListItem * m_pcoliHead; CObjectListItem * m_pcoliTail; int m_unCountObjects; public: CObjectList():m_pcoliHead(NULL),m_pcoliTail(NULL),m_unCountObjects(0){} virtual ~CObjectList() ; BOOL Add(CObject & p_rco,unsigned &p_rnPosition,CObjectListItem * & p_pcoliNewObject); BOOL Remove(CObjectListItem& p_rcoli); BOOL RemoveAll(void); CObjectListItem* Find(CObjectListItem *p_pcoliFirst,CObject& p_rcoFind,unsigned& p_runPosition); //Методы доступа к элементам списка CObjectListItem * GetFirstObject() {return m_pcoliHead;} CObjectListItem * GetLastObject() {return m_pcoliTail;} unsigned int GetCountObjects(){return m_unCountObjects;} }; #endif |
Файл «objectlist.cpp»:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 |
/////////////////////////////////////////////////////////////////////////////// // // Project : Handbook // Module : objectlist.cpp // Date : 11/05/2007 // // Content : Класс списка объектов, на основе которого построена вся // база данных // /////////////////////////////////////////////////////////////////////////////// // // COPYRIGHT (c) 2007 Урванов Фёдор Владиславович // /////////////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include "objectlist.h" /////////////////////////////////////////////////////////////////////////////// // // Метод : Деструктор // Автор : Урванов Фёдор Владиславович // Дата : 6/03/2007 // //----------------------------------------------------------------------------- // // Параметры : нет // // Описание : Уничтожает все объекты. // // Выход : нет // /////////////////////////////////////////////////////////////////////////////// CObjectList::~CObjectList() { RemoveAll(); }; /////////////////////////////////////////////////////////////////////////////// // // Метод : Add // Автор : Урванов Фёдор Владиславович // Дата : 6/03/2007 // //----------------------------------------------------------------------------- // // Параметры : CObject& p_rco входной параметр. Объект для // добавления. // unsigned & p_runPosition. Входной и выходной // параметр. Вход - текущий номер // позиции. Выход - номер позиции // добавленного оьбъекта // CObjectListItem* & p_pcoliNewObject - выходной // параметр. Добавленный элемент. // // // Описание : Операция добавления нового элемента // // Выход : TRUE в случае успеха, FALSE - в противном случае. // /////////////////////////////////////////////////////////////////////////////// BOOL CObjectList::Add(CObject & p_rco,unsigned &p_runPosition,CObjectListItem * & p_pcoliNewObject) { unsigned un=0; if (!m_pcoliHead) { m_pcoliTail=new CObjectListItem(p_rco); if (!m_pcoliTail) return FALSE; m_pcoliHead=m_pcoliTail; p_pcoliNewObject=m_pcoliHead; } else { CObjectListItem *coli=m_pcoliHead; while (coli) { if (coli->GetName()>p_rco.GetName()) break; coli=coli->GetNext (); un++; } if (coli) { if (!coli->AddBefore(p_rco)) return FALSE; if (coli==m_pcoliHead) { m_pcoliHead=coli->GetPrevious(); } p_pcoliNewObject=coli->GetPrevious(); } else { if (!m_pcoliTail->AddAfter(p_rco)) return FALSE; m_pcoliTail=m_pcoliTail->GetNext(); p_pcoliNewObject=m_pcoliTail; } } p_runPosition=un; m_unCountObjects++; return TRUE; } /////////////////////////////////////////////////////////////////////////////// // // Метод : Remove // Автор : Урванов Фёдор Владиславович // Дата : 6/03/2007 // //----------------------------------------------------------------------------- // // Параметры : CObjectListItem& p_rcoli - объект, который нужно // удалить. Должен входить в состав списка!!! // // Описание : Операция удаления. // // Выход : TRUE в случае успеха, FALSE - в противном случае. // /////////////////////////////////////////////////////////////////////////////// BOOL CObjectList::Remove(CObjectListItem& p_rcoli) { if (m_pcoliHead==&p_rcoli) m_pcoliHead=p_rcoli.GetNext(); if (m_pcoliTail==&p_rcoli) m_pcoliTail=p_rcoli.GetPrevious(); p_rcoli.~CObjectListItem(); m_unCountObjects--; return TRUE; } /////////////////////////////////////////////////////////////////////////////// // // Метод : Find // Автор : Урванов Фёдор Владиславович // Дата : 6/03/2007 // //----------------------------------------------------------------------------- // // Параметры : CObjectListItem * p_pcoliFirst - объект, с которого // начинается поиск (включительно). // CObject & p_rcoFind - объект, хранящий условия // поиска. // unsigned& p_runPosition - выходной параметр. // Смещение позиции найденного элемента, относительно // p_pcoliFirst. // // Описание : Ищет объект, содержащий необходимый текст. // Ищется объект, у котого в имени содержится строка, // находящаяся в поле имени у p_pcoFind. Или в описании // которого содержится строка, находящаяся в поле имени // p_pcoFind. Выходной параметр p_runPosition указывает // смещение в объектах найденного объекта, относительно // начала поиска. Например, элемент p_pcoliFirst имеет // смещение 0. // // Выход : CObjectListItem * - указатель на найденный элемент. // /////////////////////////////////////////////////////////////////////////////// CObjectListItem * CObjectList::Find(CObjectListItem *p_pcoliFirst, CObject& p_rcoFind, unsigned& p_runPosition) { CObjectListItem *coli=p_pcoliFirst; unsigned unPos=0; while (coli) { if ((coli->GetName()).Find(p_rcoFind.GetName())!=-1) break; if ((coli->GetDescription()).Find(p_rcoFind.GetDescription())!=-1) break; coli=coli->GetNext(); unPos++; } p_runPosition=unPos; return coli; } /////////////////////////////////////////////////////////////////////////////// // // Метод : RemoveAll // Автор : Урванов Фёдор Владиславович // Дата : 6/03/2007 // //----------------------------------------------------------------------------- // // Параметры : нет // // Описание : Удаляет все элементы. // // Выход : TRUE - в случае успеха // /////////////////////////////////////////////////////////////////////////////// BOOL CObjectList::RemoveAll(void) { CObjectListItem * pcoli=m_pcoliHead; if (pcoli) { while (pcoli->GetNext()) { pcoli=pcoli->GetNext(); if (!Remove(*pcoli->GetPrevious())) return FALSE; } } m_pcoliHead=NULL; m_pcoliTail=NULL; m_unCountObjects=0; return TRUE; } |
Файл «handbook.h»:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 |
/////////////////////////////////////////////////////////////////////////////// // // Проект : Handbook // Модуль : Handbook.h // Дата : 11/04/2007 // // Описание : Модуль с классом всей базы данных // /////////////////////////////////////////////////////////////////////////////// // // COPYRIGHT (c) 2007 Урванов Фёдор Владиславович // /////////////////////////////////////////////////////////////////////////////// #ifndef _HANDBOOK #define _HANDBOOK #include "objectlist.h" #include <ostream.h> class CHandbook:public CObjectList { CObjectListItem *m_pcoliCurrent; CObject m_coFind; unsigned m_unPosition; public: CHandbook(); virtual ~CHandbook(); BOOL Add(CObject& p_rcoli); BOOL Remove(); BOOL RemoveAll(); const CObjectListItem * GetCurrent(); unsigned GetCurrentPosition(); void SetCurrent(CObjectListItem* p_pcoliCurrent,unsigned p_unPosition); wxString GetName(void); wxString GetDescription(void); wxString GetImageFileName(void); BOOL SetName(wxString p_wxstrName); BOOL SetDescription(wxString p_wxstrDescription); BOOL SetImageFileName(wxString p_wxstrImageFileName); BOOL IsFree(){if (!m_pcoliCurrent) return TRUE; else return FALSE;} void Previous(void); void Next(void); void FindFirst(const wxString& p_rwxstrFindText,BOOL p_bFindInName, BOOL p_bFindInDescription); void FindNext(); friend ostream & operator << (ostream & out, CHandbook& p_chb); friend istream & operator >> (istream & in, CHandbook& p_chb); }; extern ostream & operator << (ostream & out, CHandbook& p_chb); extern istream & operator >> (istream & in, CHandbook& p_chb); inline wxString CHandbook::GetName(void ) { if (m_pcoliCurrent) return m_pcoliCurrent->GetName(); return wxString(""); } inline wxString CHandbook::GetDescription() { if (m_pcoliCurrent) return m_pcoliCurrent->GetDescription(); else return wxString(""); } inline BOOL CHandbook::SetName(wxString p_wxstrName) { if (m_pcoliCurrent) { m_pcoliCurrent->SetName(p_wxstrName); return TRUE; } return FALSE; } inline BOOL CHandbook::SetDescription(wxString p_wxstrDescription) { if (m_pcoliCurrent) { m_pcoliCurrent->SetDescription(p_wxstrDescription); return TRUE; } else return FALSE; } inline const CObjectListItem * CHandbook::GetCurrent() { return m_pcoliCurrent; } inline wxString CHandbook::GetImageFileName(void) { if (m_pcoliCurrent) return m_pcoliCurrent->GetImageFileName(); else return wxString(""); } inline BOOL CHandbook::SetImageFileName(wxString p_wxstrImageFileName) { if (m_pcoliCurrent) { m_pcoliCurrent->SetImageFileName(p_wxstrImageFileName); return TRUE; } else return FALSE; } #endif |
Файл «handbook.cpp»:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 |
/////////////////////////////////////////////////////////////////////////////// // // Проект : Handbook // Модуль : Handbook.cpp // Дата : 11/04/2007 // // Описание : Модуль с реализацией класса всей базы данных // /////////////////////////////////////////////////////////////////////////////// // // COPYRIGHT (c) 2007 Урванов Фёдор Владиславович // /////////////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include "Handbook.h" /////////////////////////////////////////////////////////////////////////////// // // Метод : Конструктор // Автор : Урванов Фёдор Владиславович // Дата : 23/04/2007 // //----------------------------------------------------------------------------- // // Параметры : нет // // Описание : Начальная инициализация класса справочника // // Выход : нет // /////////////////////////////////////////////////////////////////////////////// CHandbook::CHandbook():CObjectList() { m_pcoliCurrent=NULL; } /////////////////////////////////////////////////////////////////////////////// // // Метод : Деструктор // Автор : Урванов Фёдор Владиславович // Дата : 23/04/2007 // //----------------------------------------------------------------------------- // // Параметры : нет // // Описание : не используется // // Выход : нет // /////////////////////////////////////////////////////////////////////////////// CHandbook::~CHandbook() { } /////////////////////////////////////////////////////////////////////////////// // // Метод : Previous // Автор : Урванов Фёдор Владиславович // Дата : 23/04/2007 // //----------------------------------------------------------------------------- // // Параметры : нет // // Описание : Перевод указателя на предыдущий элемент списка // если таковой есть // // Выход : нет // /////////////////////////////////////////////////////////////////////////////// void CHandbook::Previous(void) { if (m_pcoliCurrent) { if (m_pcoliCurrent->GetPrevious()) { m_pcoliCurrent=m_pcoliCurrent->GetPrevious(); m_unPosition--; } } } /////////////////////////////////////////////////////////////////////////////// // // Метод : Next // Автор : Урванов Фёдор Владиславович // Дата : 23/04/2007 // //----------------------------------------------------------------------------- // // Параметры : нет // // Описание : Перевод указателя на следующий элемент списка // если таковой есть // // Выход : нет // /////////////////////////////////////////////////////////////////////////////// void CHandbook::Next(void) { if (m_pcoliCurrent) { if (m_pcoliCurrent->GetNext()) { m_pcoliCurrent=m_pcoliCurrent->GetNext(); m_unPosition++; } } } /////////////////////////////////////////////////////////////////////////////// // // Метод : Add // Автор : Урванов Фёдор Владиславович // Дата : 23/04/2007 // //----------------------------------------------------------------------------- // // Параметры : CObject& p_rcoli - добавляемый объект // // Описание : Добавление элемента // // Выход : TRUE - в случае успеха, иначе FALSE // /////////////////////////////////////////////////////////////////////////////// BOOL CHandbook::Add(CObject& p_rcoli) { CObjectListItem *pcoli; unsigned unPosition; if (!(CObjectList::Add(p_rcoli,unPosition,pcoli))) return FALSE; m_pcoliCurrent=pcoli; m_unPosition=unPosition; return TRUE; } /////////////////////////////////////////////////////////////////////////////// // // Метод : Remove // Автор : Урванов Фёдор Владиславович // Дата : 23/04/2007 // //----------------------------------------------------------------------------- // // Параметры : нет // // Описание : Удаление текущего элемента. // // Выход : TRUE - в случае успеха, иначе FALSE // /////////////////////////////////////////////////////////////////////////////// BOOL CHandbook::Remove(void) { if (m_pcoliCurrent) { CObjectListItem *coli=NULL; if (m_pcoliCurrent->GetNext()) { coli=m_pcoliCurrent->GetNext(); } else { if (m_pcoliCurrent->GetPrevious()) { coli=m_pcoliCurrent->GetPrevious(); m_unPosition--; } } if (!this->CObjectList::Remove(*m_pcoliCurrent)) return FALSE; m_pcoliCurrent=coli; } return TRUE; } /////////////////////////////////////////////////////////////////////////////// // // Метод : RemoveAll // Автор : Урванов Фёдор Владиславович // Дата : 23/04/2007 // //----------------------------------------------------------------------------- // // Параметры : нет // // Описание : Удаление всех объектов из справочника // // Выход : TRUE - в случае успеха, иначе FALSE // /////////////////////////////////////////////////////////////////////////////// BOOL CHandbook::RemoveAll(void) { if (!this->CObjectList::RemoveAll()) return FALSE; m_pcoliCurrent=NULL; m_unPosition=0; return TRUE; } /////////////////////////////////////////////////////////////////////////////// // // Метод : FindFirst // Автор : Урванов Фёдор Владиславович // Дата : 23/04/2007 // //----------------------------------------------------------------------------- // // Параметры : const wxString& p_rwxstrFindText - текст для // поиска // BOOL p_bFindInName - Если TRUE, то текст // ищется в именах // BOOL p_bFindInDescription - Если TRUE, то текст // ищется в описании // // Описание : Поиск первого вхождения объекта, который содержит // искомый текст в имени (если p_bFindInName=TRUE), // и/или в описании (Если p_bFindInDescription=TRUE) // // Выход : нет // /////////////////////////////////////////////////////////////////////////////// void CHandbook::FindFirst(const wxString& p_rwxstrFindText,BOOL p_bFindInName,BOOL p_bFindInDescription) { unsigned unPosition; if (p_bFindInName) { m_coFind.SetName(p_rwxstrFindText); } else { m_coFind.SetName(""); } if (p_bFindInDescription) { m_coFind.SetDescription(p_rwxstrFindText); } else { m_coFind.SetDescription(""); } m_pcoliCurrent=this->CObjectList::Find(m_pcoliCurrent,m_coFind,unPosition); m_unPosition+=unPosition; if (!m_pcoliCurrent) { m_pcoliCurrent=GetFirstObject(); m_unPosition=0; wxMessageBox(_("Cannot find this string"),_("NO"),wxOK); } } /////////////////////////////////////////////////////////////////////////////// // // Метод : FindNext // Автор : Урванов Фёдор Владиславович // Дата : 23/04/2007 // //----------------------------------------------------------------------------- // // Параметры : нет // // Описание : Ищет следующий элемент, удовлетворяющий // условиям поиска, заданным в последнем вызове // функции FindFirst. // // Выход : нет // /////////////////////////////////////////////////////////////////////////////// void CHandbook::FindNext() { m_pcoliCurrent=m_pcoliCurrent->GetNext(); unsigned unPosition=0; if (m_pcoliCurrent) { m_pcoliCurrent=this->CObjectList::Find(m_pcoliCurrent,m_coFind,unPosition); } if (!m_pcoliCurrent) { m_pcoliCurrent=GetFirstObject(); m_unPosition=0; } else { m_unPosition+=unPosition+1; } } /////////////////////////////////////////////////////////////////////////////// // // Метод : ostream & operator << // Автор : Урванов Фёдор Владиславович // Дата : 23/04/2007 // //----------------------------------------------------------------------------- // // Параметры : ostream & out // CHandbook& p_chb - справочник // // Описание : Для сохранения справочника в файле // // Выход : в завимости от ситуации // /////////////////////////////////////////////////////////////////////////////// ostream & operator << (ostream & out, CHandbook& p_chb) { CObjectListItem* pcoliHead=(CObjectListItem* )(p_chb.GetFirstObject()); out<<p_chb.GetCountObjects()<<'\0'; while (pcoliHead) { out<<(*pcoliHead); pcoliHead=pcoliHead->GetNext(); } return out; } /////////////////////////////////////////////////////////////////////////////// // // Метод : ostream & operator >> // Автор : Урванов Фёдор Владиславович // Дата : 23/04/2007 // //----------------------------------------------------------------------------- // // Параметры : ostream & in // CHandbook& p_chb - справочник // // Описание : Для чтения справочника из файла // // Выход : в завимости от ситуации // /////////////////////////////////////////////////////////////////////////////// istream & operator >>(istream & in, CHandbook& p_chb) { CObject coBuffer; p_chb.RemoveAll(); unsigned unCount; char c; in>>unCount>>c; for (unsigned n=0; n<unCount;n++) { in>>coBuffer; p_chb.Add(coBuffer); } p_chb.m_pcoliCurrent=p_chb.GetFirstObject(); p_chb.m_unPosition=0; return in; } /////////////////////////////////////////////////////////////////////////////// // // Метод : SetCurrent // Автор : Урванов Фёдор Владиславович // Дата : 23/04/2007 // //----------------------------------------------------------------------------- // // Параметры : CObjectListItem* p_pcoliCurrent Элемент который // нужно сделать текущим // unsigned p_unPosituon - новая позиция // // Описание : Устанавливает указатель текущего элемента // и позицию. Использовать с осторожностью, чтобы // не испортить текущее состояние справочника. // // Выход : в завимости от ситуации // /////////////////////////////////////////////////////////////////////////////// void CHandbook::SetCurrent(CObjectListItem* p_pcoliCurrent, unsigned p_unPosition) { m_pcoliCurrent=p_pcoliCurrent; m_unPosition=p_unPosition; } /////////////////////////////////////////////////////////////////////////////// // // Метод : GetCurrentPosition // Автор : Урванов Фёдор Владиславович // Дата : 23/04/2007 // //----------------------------------------------------------------------------- // // Параметры : нет // // Описание : Возвращает номер текущей позиции // // Выход : в завимости от ситуации // /////////////////////////////////////////////////////////////////////////////// unsigned CHandbook::GetCurrentPosition(void) { return m_unPosition; } |