Реферат Моделирование структуры книги
Работа добавлена на сайт bukvasha.net: 2015-10-28Поможем написать учебную работу
Если у вас возникли сложности с курсовой, контрольной, дипломной, рефератом, отчетом по практике, научно-исследовательской и любой другой работой - мы готовы помочь.
Предоплата всего
от 25%
Подписываем
договор
ОглавлениеВведение 3
Анализ и описание предметной области проекта 4
Разработка объектной модели 5
Определение объектов и классов 5
Подготовка словаря данных 5
Определение атрибутов объектов 6
Определение методов классов 7
Упрощение классов при использовании наследования и графическое изображение объектной модели 7
Реализация объектной модели на языке программирования C++ 9
Реализация класса книги 9
Порождение объектов
19
Вызов операций 20
Использование наследования
21
Реализация зависимостей 22
Анализ полученных результатов и выводы 23
Снимок экрана программы 24
Литература 25
Введение
Темой данной курсовой работы является изучение объектно-ориентированных возможностей языка C++ (номер варианта 34). Предметная область курсовой работы согласно варианту – моделирование структуры книги.
В методическом приложении были приведены особенности предметной области, рассмотренной в данной работе, – в книге выделяются компоненты: страница, глава, раздел. По условию задачи необходимо реализовать объектную модель книги и написать программу с использованием класса C++, который отражает структуру книги и наглядно демонстрирует эффективность использования объектно-ориентированной технологии разработки программ.
Для повышения эффективности создания программных комплексов и сокращения времени, отводимого на проектирование и реализацию конечного продукта, фирма Microsoft рекомендует использовать разработанную ею библиотеку классов MFC (Microsoft Foundation Classes), поставляемую в составе среды разработки программ Microsoft Visual C++ 6. Поэтому приложение, созданное в ходе написания данной курсовой работы, является приложением, использующем библиотеку MFC, и разработано в визуальной среде Microsoft Visual C++ 6. Предназначение данного приложения – наглядное представление в визуальной форме структуры книги.
Анализ и описание предметной области проекта
Предметная область данной курсовой работы была выбрана в методическом приложении: моделирование структуры книги (вариант №34).
Книга содержит текстовую информацию (в простейшем случае) и имеет древовидную структуру – книга состоит из нескольких разделов, раздел состоит из нескольких глав, глава, в свою очередь, состоит из страниц. Особый компонент книги, облегчающий ее использование, – оглавление, имеющее также древовидную структуру. Недостаток бумажной книги – необходимость часто открывать страницы, содержащие оглавление, для определения номеров нужных страниц, далее необходимо осуществлять поиск этих страниц по известным номерам, на что снова уходит некоторое время. В электронных книгах (например, созданных для просмотра с помощью программы Adobe Acrobat Reader) оглавление всегда находится перед глазами читателя и переход на нужную страницу осуществляется простым щелчком мыши по элементу, соответствующему некоторой странице. Кроме того, в таких оглавлениях показываются все страницы, а не только первые страницы глав, что также упрощает навигацию по книге. И в бумажных, и в электронных книгах всегда присутствует возможность перевернуть одну страницу вперед или назад. Для упрощения задачи и осуществления совместимости с книгами, созданными для просмотра на ПК, ориентированных на текстовые операционные системы (типа DOS), страницу мы будем рассматривать как объект, содержащий исключительно текстовую информацию, отображаемую единым шрифтом и не содержащую никакого форматирования. Таким образом, можно представить страницу как массив с константным количеством расположенных вертикально сверху вниз горизонтальных строк, содержащих константное количество символов (в случае использования немоноширинных шрифтов строки имеют постоянную длину, выраженную в физических единицах: сантиметрах, дюймах, пикселях и т.п.).
Разработка объектной модели
Определение объектов и классов
Согласно модели приложения, используемой библиотекой MFC, любое SDI-приложение должно иметь определения следующих классов: класс приложения, порожденный от CWinApp, класс окна, порожденный от CFrameWnd, класс документа, порожденный от CDocument, и класс представления, порожденный от CView. Т.к. приложение для просмотра книг выполнено в стиле “Explorer”, то также определен класс представления оглавления книги, порожденный от CTreeView. Кроме того, класс представления страницы книги порожден не непосредственно от класса CView, а от наследуемого от CView класса – класса CListView. Т.е. страница книги имеет представление в виде списка ее строк.
Класс, отражающий структуру книги, имеет название CBookClass. Определены классы коллекций разделов, глав и страниц – класс CRazdels, класс CGlavas и класс CPages соответственно; а также классы собственно раздела, главы и страницы – класс CRazdel, класс CGlava и класс CPage соответственно.
Подготовка словаря данных
Приложение – глобальный объект класса приложения, используемый для согласования работы объектов других стандартных классов MFC и для разрешения ссылок внутри одних объектов на другие объекты.
Окно приложения – объект визуального представления приложения, организовывающий взаимное расположение визуальных компонентов программы на экране и реализующий стандартный интерфейс взаимодействия пользователя с программой.
Документ – информация, которую пользователь может сохранять в процессе работы с приложением и затем считывать.
Представление – средства представления документа пользователю в процессе выполнения приложения.
Положенная в основу MFC концепция документ/представление позволяет отделить данные от средств, с помощью которых пользователь имеет возможность просмотреть эти данные и манипулировать ими. Объекты-документы ответственны за хранение, загрузку и выгрузку данных, а объекты-представления, которые представляют собой те же окна, позволяют пользователю просматривать данные на экране и редактировать их соответственно логике работы приложения. Объект класса представления содержит указатель на объект класса документа, который используется для доступа к членам-переменным этого класса, где собственно и хранятся данные.
Значения терминов книга, раздел, глава, страница, строка и оглавление очевидны и не подлежат объяснению.
Определение атрибутов объектов
В классе документа определен открытый атрибут – объект класса CBookClass:
class CBookDoc : public CDocument
{
public:
CBookClass m_Book;
};
В класс документа включен открытый член с тем, чтобы не затруднять доступ к нему из объектов классов представления. Определения атрибутов других классов соответствуют классическому объектно-ориентированному подходу, который требует включать в класс закрытые или защищенные члены-переменные и открытые члены-функции считывания и модификации этих переменных.
Классы книги, раздела, главы и страницы имеют закрытую член-переменную m_Name класса CString. Т.к. книга имеет древовидную структуру, то классы книги, раздела и главы соответствуют ветвям дерева, а класс страницы – листу этого дерева. Поэтому классы-ветви содержат член-переменную класса коллекции более мелких объектов (книга содержит коллекцию разделов, глава – коллекцию страниц), а страница содержит член-переменную – массив объектов класса CString (строки этой страницы). Классы раздела и главы содержат члены-переменные типа WORD – номера первой и последней страниц, принадлежащих данному разделу или главе. Класс раздела содержит также номера первой и последней глав, принадлежащих этому разделу.
В классе книги определен закрытый атрибут типа WORD, хранящий номер страницы, которая в данный момент времени просматривается пользователем. Кроме того, в классе книги определены члены-указатели на элементы управления CTreeCtrl и CListCtrl, позволяющие осуществлять при чтении книги переход от одной страницы к другой. Для этой же цели в классе страницы определена член-переменная – указатель на элемент дерева – типа HTREEITEM.
Для перебора всех страниц книги удобно пользоваться не деревом, а массивом страниц. Поэтому в классе книги определена член-переменная – массив указателей на страницы книги – MFC-класса CPtrArray.
Определение методов классов
Помимо открытых членов-функций, осуществляющих чтение и модификацию закрытых членов-переменных, в классах, используемых в программе, определены и другие члены-функции.
В классе книги определены открытые члены-функции, осуществляющие переход при чтении книги к предыдущей и последующей страницам. Кроме того, в этом классе определена закрытая член-функция RenewCtrls(), которая вызывается вышеупомянутыми функциями при переходе к другой странице. Данная функция вызывает глобальные функции RenewTree() и RenewList(), которые обновляют визуальное содержание представлений оглавления и страницы соответственно.
Классы коллекций разделов, глав и страниц (CRazdels, CGlavas и CPages) имеют открытые члены-функции DeleteRazdels(), DeleteGlavas() и DeletePages() соответственно. Данные члены-функции осуществляют освобождение памяти, выделенной под хранение книги, при открытии другой книги или завершении работы программы.
В классе книги перегружены конструктор и деструктор по умолчанию. Конструктор обнуляет номер текущей страницы для того, чтобы при открытии новой книги автоматически отображалась первая страница. Деструктор запускает механизм освобождения памяти.
Упрощение классов при использовании наследования и графическое изображение объектной модели
Объектно-ориентированный подход в программировании имеет одну очень привлекательную черту – возможность повторного использования уже разработанного кода. Во-первых, можно использовать классы, созданные другими разработчиками, не заботясь о деталях реализации методов внутри класса. Примером могут служить сотни классов из библиотеки MFC. Но более существенные преимущества дает повторное использование кода, реализуемое через механизм наследования.
Класс, использующий код другого класса, называется производным или подклассом. Класс, который предоставляет свой код другому классу, называется базовым или суперклассом. Если есть необходимость предоставить методам порожденного класса возможность прямого доступа к члену-переменной базового класса, вместо квалификатора доступа private можно использовать квалификатор protected. Может оказаться, что методы базового класса, унаследованные порожденным классом, не совсем соответствуют специфике последнего и нуждаются в определенной модификации. Для этого потребуется разработать отдельный метод Имя_Класса::Метод(). Это и есть перегрузка методов базового класса. Если желательно, чтобы метод Имя_Класса::Метод() выполнял то же, что и метод базового класса, а затем и еще нечто, то наилучшим способом достичь такого результата будет вызов Имя_Базового_Класса::Метод() внутри Имя_Класса::Метод(). Но при этом нужно использовать полное имя метода базового класса, т.е. именно Имя_Базового_Класса::Метод().
В приложении классы книги, раздела, главы и страницы унаследованы от CObject. Это необходимо для реализации механизма загрузки документа из файла – метод Serialize() в этих классах перегружается также, как и в классе документа:
void CBookDoc::Serialize(CArchive& ar)
{
m_Book.Serialize(ar);
}
Классы CRazdels, CGlavas и CPages унаследованы от класса CObArray. Поэтому для объектов этих классов можно вызывать все члены-функции, присущие классу массива объектов.
Объектная модель книги
Реализация объектной модели на языке программирования C++
Реализация класса книги
BookClass.
h:
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "Razdels.h"
class CBookClass;
extern void RenewTree(CTreeCtrl*,CBookClass*);
extern void RenewList(CListCtrl*,CBookClass*);
class CBookClass : public CObject
{
DECLARE_SERIAL(CBookClass)
private:
CRazdels m_Razdels;
CPtrArray m_pPages;
CTreeCtrl* pTreeCtrl;
CListCtrl* pListCtrl;
CString m_Name;
WORD m_ActivePage;
void RenewCtrls()
{
RenewTree(pTreeCtrl,this);
RenewList(pListCtrl,this);
}
public:
CRazdels* GetRazdels()
{
return &m_Razdels;
}
CPtrArray* GetPages()
{
return &m_pPages;
}
void SetTreeCtrl(CTreeCtrl* TreeCtrl)
{
pTreeCtrl=TreeCtrl; }
void SetListCtrl(CListCtrl* ListCtrl)
{
pListCtrl=ListCtrl;
}
CString* GetName()
{
return &m_Name;
}
WORD GetActivePage()
{
return m_ActivePage;
}
void SetActivePage(WORD Page)
{
m_ActivePage=Page;
RenewList(pListCtrl,this);
}
void SetPreviousActivePage()
{
if (m_ActivePage>0)
{
m_ActivePage--;
RenewCtrls();
}
}
void SetNextActivePage()
{
if (m_ActivePage+1<m_pPages.GetSize())
{
m_ActivePage++;
RenewCtrls();
}
}
CBookClass();
~CBookClass();
void Serialize(CArchive&);
};
BookClass.cpp:
#include "stdafx.h"
#include "BookClass.h"
IMPLEMENT_SERIAL(CBookClass,CObject,0)
CBookClass::CBookClass()
{
m_ActivePage=0;
}
CBookClass::~CBookClass()
{
m_Razdels.DeleteRazdels();
}
void CBookClass::Serialize(CArchive& ar)
{
m_Razdels.DeleteRazdels();
m_pPages.RemoveAll();
m_ActivePage=0;
CObject::Serialize(ar);
if (ar.IsLoading())
{
ar>>m_Name;
WORD Count,Counter;
ar>>Count;
for(Counter=0;Counter<Count;Counter++)
{
CRazdel* Razdel=new CRazdel;
Razdel->Serialize(ar);
m_Razdels.Add(Razdel);
}
for(Counter=0;Counter<m_Razdels.GetSize();Counter++)
{
CRazdel* Razdel=(CRazdel*)m_Razdels.GetAt(Counter);
for(WORD Counter2=0;Counter2<Razdel->GetGlavas()->GetSize();Counter2++)
{
CGlava* Glava=(CGlava*)Razdel->GetGlavas()->GetAt(Counter2);
for(WORD Counter3=0;Counter3<Glava->GetPages()->GetSize();Counter3++)
m_pPages.Add(Glava->GetPages()->GetAt(Counter3));
}
}
}
}
Razdels.h:
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "Razdel.h"
class CRazdels : public CObArray
{
public:
void DeleteRazdels();
};
Razdels.cpp:
#include "stdafx.h"
#include "Razdels.h"
void CRazdels::DeleteRazdels()
{
WORD Counter;
for(Counter=0;Counter<GetSize();Counter++)
{
CRazdel* Razdel=(CRazdel*)GetAt(Counter);
Razdel->GetGlavas()->DeleteGlavas();
delete Razdel;
}
RemoveAll();
}
Razdel.h:
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "Glavas.h"
class CRazdel : public CObject
{
DECLARE_SERIAL(CRazdel)
private:
CGlavas m_Glavas;
CString m_Name;
WORD m_FirstGlava;
WORD m_LastGlava;
WORD m_FirstPage;
WORD m_LastPage;
public:
CGlavas* GetGlavas()
{
return &m_Glavas;
}
CString* GetName()
{
return &m_Name;
}
WORD GetFirstGlava()
{
return m_FirstGlava;
}
void SetFirstGlava(WORD FirstGlava)
{
m_FirstGlava=FirstGlava;
}
WORD GetLastGlava()
{
return m_LastGlava;
}
void SetLastGlava(WORD LastGlava)
{
m_LastGlava=LastGlava;
}
WORD GetFirstPage()
{
return m_FirstPage;
}
void SetFirstPage(WORD FirstPage)
{
m_FirstPage=FirstPage;
}
WORD GetLastPage()
{
return m_LastPage;
}
void SetLastPage(WORD LastPage)
{
m_LastPage=LastPage;
}
CRazdel(){};
void Serialize(CArchive&);
};
Razdel.cpp:
#include "stdafx.h"
#include "Razdel.h"
IMPLEMENT_SERIAL(CRazdel,CObject,0)
void CRazdel::Serialize(CArchive& ar)
{
CObject::Serialize(ar);
if (ar.IsLoading())
{
ar>>m_Name>>m_FirstGlava>>m_LastGlava>>m_FirstPage>>
m_LastPage;
WORD Count,Counter;
ar>>Count;
for(Counter=0;Counter<Count;Counter++)
{
CGlava* Glava=new CGlava;
Glava->Serialize(ar);
m_Glavas.Add(Glava);
}
}
}
Glavas.h:
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "Glava.h"
class CGlavas : public CObArray
{
public:
void DeleteGlavas();
};
Glavas.cpp:
#include "stdafx.h"
#include "Glavas.h"
void CGlavas::DeleteGlavas()
{
WORD Counter;
for(Counter=0;Counter<GetSize();Counter++)
{
CGlava* Glava=(CGlava*)GetAt(Counter);
Glava->GetPages()->DeletePages();
delete Glava;
}
RemoveAll();
}
Glava.h:
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "Pages.h"
class CGlava : public CObject
{
DECLARE_SERIAL(CGlava)
private:
CPages m_Pages;
CString m_Name;
WORD m_FirstPage;
WORD m_LastPage;
public:
CPages* GetPages()
{
return &m_Pages;
}
CString* GetName()
{
return &m_Name;
}
WORD GetFirstPage()
{
return m_FirstPage; }
void SetFirstPage(WORD FirstPage)
{
m_FirstPage=FirstPage;
}
WORD GetLastPage()
{
return m_LastPage;
}
void SetLastPage(WORD LastPage)
{
m_LastPage=LastPage;
}
CGlava(){};
void Serialize(CArchive&);
};
Glava.cpp:
#include "stdafx.h"
#include "Glava.h"
IMPLEMENT_SERIAL(CGlava,CObject,0)
void CGlava::Serialize(CArchive& ar)
{
CObject::Serialize(ar);
if (ar.IsLoading())
{
ar>>m_Name>>m_FirstPage>>m_LastPage;
WORD Count,Counter;
ar>>Count;
for(Counter=0;Counter<Count;Counter++)
{
CPage* Page=new CPage;
Page->Serialize(ar);
m_Pages.Add(Page);
}
}
}
Pages.h:
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "Page.h"
class CPages : public CObArray
{
public:
void DeletePages();
};
Pages.cpp:
#include "stdafx.h"
#include "Pages.h"
void CPages::DeletePages()
{
WORD Counter;
for(Counter=0;Counter<GetSize();Counter++)
{
CPage* Page=(CPage*)GetAt(Counter);
delete Page;
}
RemoveAll();
}
Page.h:
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#define CountOfStrings 37
class CPage : public CObject
{
DECLARE_SERIAL(CPage)
private:
CString m_Strings[CountOfStrings];
CString m_Name;
HTREEITEM m_TreeItem;
public:
CString* GetString(BYTE Index)
{
return &m_Strings[Index];
}
CString* GetName()
{
return &m_Name;
}
HTREEITEM GetTreeItem()
{
return m_TreeItem;
}
void SetTreeItem(HTREEITEM TreeItem)
{
m_TreeItem=TreeItem;
}
CPage(){};
void Serialize(CArchive&);
};
Page.cpp:
#include "stdafx.h"
#include "Page.h"
IMPLEMENT_SERIAL(CPage,CObject,0)
void CPage::Serialize(CArchive& ar)
{
CObject::Serialize(ar);
if (ar.IsLoading())
{
ar>>m_Name;
BYTE Counter;
for(Counter=0;Counter<CountOfStrings;Counter++)
ar>>m_Strings[Counter];
}
}
Порождение объектов
В файле Book.cpp объявляется глобальная переменная – объект класса приложения CBookApp:
CBookApp theApp;
В перегруженной функции-члене InitInstance() класса CBookApp создаются объекты классов документа, окна и представления оглавления:
BOOL CBookApp::InitInstance()
{
CSingleDocTemplate* pDocTemplate;
pDocTemplate = new CSingleDocTemplate(
IDR_MAINFRAME,
RUNTIME_CLASS(CBookDoc),
RUNTIME_CLASS(CMainFrame),
RUNTIME_CLASS(CLeftView));
AddDocTemplate(pDocTemplate);
return TRUE;
}
Класс окна CMainFrame содержит защищенный атрибут класса CSplitterWnd, предоставляющий доступ к представлению страницы посредством вызова открытой член-функции класса CMainFrame:
class CMainFrame : public CFrameWnd
{
protected:
CSplitterWnd m_wndSplitter;
public:
CBookView* GetRightPane();
};
Объект класса книги является открытым атрибутом класса документа:
class CBookDoc : public CDocument
{
public:
CBookClass m_Book;
};
Все структурные элементы книги (разделы, главы и страницы) создаются в момент загрузки файла книги с диска через оператор new:
CRazdel* Razdel=new CRazdel;
m_Razdels.Add(Razdel);
Вызов операций
Вызов операций для объектов в C++ может быть организован двумя способами:
1) Если требуется вызвать операцию для переменной, являющейся объектом какого-либо класса, то используется оператор .*:
Object.MemberFunc();
2) Если переменная является указателем на объект класса, то доступ к методам, поддерживаемым данным классом, организовывается через оператор ->*:
pObject->MemberFunc();
Т.к. объект класса книги является открытым атрибутом класса документа, то доступ к членам класса книги осуществляется через указатель на объект класса документа. Т.о., чтобы вызвать функцию-член класса CBookClass, необходимо получить вначале указатель на объект класса CBookDoc:
CBookDoc* pDoc = GetDocument();
pDoc->m_Book.SetTreeCtrl(&refCtrl);
Если члены-функции вызываются внутри их класса, то вызов этих функций осуществляется напрямую без указания имени класса. Например, внутри функции CRazdels::DeleteRazdels() осуществляется вызов членов-функций, наследуемых от базового класса CObArray:
void CRazdels::DeleteRazdels()
{
WORD Counter;
for(Counter=0;Counter<GetSize();Counter++)
{
CRazdel* Razdel=(CRazdel*)GetAt(Counter);
Razdel->GetGlavas()->DeleteGlavas();
delete Razdel;
}
RemoveAll();
}
Использование наследования
Согласно концепции объектно-ориентированного программирования функция загрузки файла книги с диска должна быть инкапсулирована в самом классе CBookClass. Основные этапы создания класса, который может самостоятельно организовать сохранение-восстановление (в документации на MFC применяется термин serialize
-сериализация) собственных членов-переменных перечислены ниже:
1.Объявить класс как производный от CObject.
2.В объявление класса включить макрос DECLARE_SERIAL.
3.В реализацию класса включить макрос IMPLEMENT_SERIAL.
4.Перегрузить метод Serialize(), унаследованный от базового класса.
5.Перегрузить для нового класса среди прочих конструктор по умолчанию.
Т.о. в нашем случае неизбежно приходится применять механизм наследования классов. Как только мы объявили класс книги производным от CObject, нам разрешается использовать сериализацию данных.
Кроме выполнения вышеуказанных пяти пунктов необходимо также перегрузить метод Serialize() и для класса документа:
void CBookDoc::Serialize(CArchive& ar)
{
m_Book.Serialize(ar);
}
Также как и метод Serialize() класса документа перегруженный метод Serialize() класса книги не выполняет непосредственное чтение текста книги из файла. Этот метод извлекает из файла только лишь служебную информацию, определяя название книги и количество ее разделов. Далее в цикле создаются объекты класса раздела, им делегируется загрузка из файла разделов, затем происходит добавление разделов в коллекцию разделов книги. Аналогично раздел, загрузив служебную информацию раздела, делегирует загрузку глав классу главы; глава, в свою очередь, делегирует загрузку страниц классу страницы; а уже страница вызывает оператор загрузки из архива, определенный в MFC-классе CString.
Реализация зависимостей
Здесь подробно остановимся на механизме «перелистывания» страниц, т.е. на переходе к предыдущей и последующей страницам. При работе с определенными элементами меню, кнопками панели инструментов или при нажатии специальных виртуальных клавиш в программе осуществляется «перелистывание» одной страницы вперед или назад. При этом управление передается членам-функциям класса документа OnPagedown() и OnPageup(). Эти функции вызывают члены-функции класса книги SetNextActivePage() и SetPreviousActivePage(), которые после обновления номера активной страницы вызывают закрытую член-функцию класса книги RenewCtrls(). Эта функция вызывает глобальные функции RenewTree() и RenewList(), передавая им в качестве аргументов указатели на элементы управления, отвечающие за отображение книги на экране, и указатель на объект книги. Данные глобальные функции, получив доступ к активной странице через указатель на объект книги, обновляют отображения оглавления и страницы в соответствии с номером активной страницы.
Для реализации зависимости между элементом просмотрового окна дерева оглавления и класса книги в классе страницы определен атрибут – указатель на элемент дерева:
class CPage : public CObject
{
private:
HTREEITEM m_TreeItem;
};
Данный указатель позволяет при щелчке мыши по номеру страницы в оглавлении отображать страницу с этим номером, а при «перелистывании» страниц – выделять в оглавлении номер активной страницы. Последнее осуществляется через вызов вышеупомянутой функции RenewTree():
void RenewTree(CTreeCtrl* TreeCtrl,CBookClass* Book)
{
CPage* Page=(CPage*)Book->GetPages()->GetAt(Book->
GetActivePage());
TreeCtrl->Select(Page->GetTreeItem(),TVGN_CARET);
}
Анализ полученных результатов и выводы
В ходе изучения объектно-ориентированных возможностей языка C++ была разработана программа, активно использующая объектно-ориентированные технологии создания программных комплексов, включая Microsoft Foundation Classes. Данные технологии позволяют в короткий срок за счет экономии времени на этапах проектирования и реализации объектной модели создавать довольно сложные программные продукты с богатыми функциональными возможностями. Это обусловлено двумя причинами:
1)Нет необходимости «изобретать велосипед», т.е. реализовывать стандартные функции, присущие любому приложению для Windows. Все внимание программист уделяет непосредственно реализации особенностей данной программы и созданию объектной модели данных, с которой приходится работать разрабатываемому приложению.
2)Библиотека Microsoft Foundation Classes предлагает программисту использовать некоторые стандартные для этой библиотеки концепции программирования, такие как документ/представление, сериализация данных и т.д. Т.о. среда Visual C++ является не только инструментальной средой разработки программ, но также эта среда во многом может помочь и на этапе проектирования, предоставляя программисту в использование некоторые полезные мастера.
Объектно-ориентированный подход позволяет не только эффективно и наглядно описать на языке C++ структуру книги, но также легко создать удобную для использования программу. Такая модель книги достаточна для организации всех действий, которые необходимы программе просмотра электронных книг.
Снимок экрана программы
Литература
1.К. Грегори. Использование Visual C++ 6. Специальное издание. – М.;СПб.;К.: Издательский дом «Вильямс», 2003
2.К. Джамса. Учимся программировать на языке C++. – М.: Мир, 2001.
3.Сабуров С. Языки программирования C и C++. – М.: Познавательная книга плюс, 2001.
4.Страуструп Б. Дизайн и эволюция языка C++. – М.: ДМК-Пресс, 2000.
5.Фридман А. C/C++. Архивы программ. – СПб.: БИНОМ, 2001.
