GeoSELECT.ru



Программирование / Реферат: Моделирование структуры книги (Программирование)

Космонавтика
Уфология
Авиация
Административное право
Арбитражный процесс
Архитектура
Астрология
Астрономия
Аудит
Банковское дело
Безопасность жизнедеятельности
Биология
Биржевое дело
Ботаника
Бухгалтерский учет
Валютные отношения
Ветеринария
Военная кафедра
География
Геодезия
Геология
Геополитика
Государство и право
Гражданское право и процесс
Делопроизводство
Деньги и кредит
Естествознание
Журналистика
Зоология
Инвестиции
Иностранные языки
Информатика
Искусство и культура
Исторические личности
История
Кибернетика
Коммуникации и связь
Компьютеры
Косметология
Криминалистика
Криминология
Криптология
Кулинария
Культурология
Литература
Литература : зарубежная
Литература : русская
Логика
Логистика
Маркетинг
Масс-медиа и реклама
Математика
Международное публичное право
Международное частное право
Международные отношения
Менеджмент
Металлургия
Мифология
Москвоведение
Музыка
Муниципальное право
Налоги
Начертательная геометрия
Оккультизм
Педагогика
Полиграфия
Политология
Право
Предпринимательство
Программирование
Психология
Радиоэлектроника
Религия
Риторика
Сельское хозяйство
Социология
Спорт
Статистика
Страхование
Строительство
Схемотехника
Таможенная система
Теория государства и права
Теория организации
Теплотехника
Технология
Товароведение
Транспорт
Трудовое право
Туризм
Уголовное право и процесс
Управление
Физика
Физкультура
Философия
Финансы
Фотография
Химия
Хозяйственное право
Цифровые устройства
Экологическое право
   

Реферат: Моделирование структуры книги (Программирование)



Оглавление


Введение
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.
Поэтому для объектов этих классов можно вызывать все члены-функции,
присущие классу массива объектов.



Объектная модель книги


[pic]
[pic]
[pic]
[pic]

Реализация объектной модели на языке программирования 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_Name;
WORD Count,Counter;
ar>>Count;
for(Counter=0;CounterSerialize(ar);
m_Razdels.Add(Razdel);
}
for(Counter=0;CounterGetSize();Counter2++)
{
CGlava* Glava=(CGlava*)Razdel->GetGlavas()-
>GetAt(Counter2);
for(WORD Counter3=0;Counter3GetPages()-
>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;CounterGetGlavas()->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;CounterSerialize(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;CounterGetPages()->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;CounterSerialize(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 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>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;CounterGetGlavas()->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++ структуру книги, но также легко создать
удобную для использования программу. Такая модель книги достаточна для
организации всех действий, которые необходимы программе просмотра
электронных книг.
Снимок экрана программы



[pic]

Литература


1.К. Грегори. Использование Visual C++ 6. Специальное издание. –
М.;СПб.;К.: Издательский дом «Вильямс», 2003
2.К. Джамса. Учимся программировать на языке C++. – М.: Мир, 2001.
3.Сабуров С. Языки программирования C и C++. – М.: Познавательная
книга плюс, 2001.
4.Страуструп Б. Дизайн и эволюция языка C++. – М.: ДМК-Пресс, 2000.
5.Фридман А. C/C++. Архивы программ. – СПб.: БИНОМ, 2001.





Реферат на тему: Моделирование схемы "Жизнь"

КРАСНОЯРСКИЙ ГОСУДАРСТВЕННЫЙ ТЕХНИЧЕСКИЙ УНИВЕРСИТЕТ



Кафедра ВТ



Утенков Валентин

Владимирович
Специальность 2201
Шифр .448597



Курсовая работа за первый курс по предмету «Алгоритмические языки и
программирование»



Тема: моделирование игры “Жизнь”



1999 г.

Содержание



1. Введение 3
2. Описание программы 5
3. Заключение 11
4. Приложение 12

1. Введение

В наш век, когда космические корабли бороздят просторы Большого
Театра, применение компьютеров в различных областях народного хозяйства
становится необходимым и, как следствие, неизбежным. Компьютерные
технологии и методы обработки данных становятся применимыми в любых сферах
человеческой деятельности от расчетов графиков железнодорожных перевозок до
составления гороскопов. Конечно, не во всех вопросах компьютеры могут
выдать решение конкретной проблемы, но они могут, как минимум, существенно
облегчить накопление, систематизацию и рутинную обработку данных.
Методы решения задач с помощью компьютеров можно разделить на две
основные группы.
Во-первых, это аналитический метод, при котором все поведение
исследуемой системы описывается как ряд четких зависимостей, из которых с
учетом исходных данных вычисляется оптимальное соотношение условий для
данной задачи.
Во-вторых, это метод моделирования, при котором задается начальное
состояние и основные законы взаимодействий в исследуемой системе; после
этого система запускается «в жизнь» и наблюдатель отслеживает ее поведение
в динамике, визуально извлекая из этого процесса интересующие его аспекты.
В данной работе сделана попытка на простейшем примере, который (с
известными допущениями) применим в биологии, продемонстрировать применение
этого метода для исследования поведения колоний микроорганизмов.
Модель поведения системы предельно упрощена. Жизненное пространство
представлено как поле, состоящее из квадратных ячеек размером 50(30 ячеек;
у каждой ячейки, очевидно, есть 8 соседних. Каждая ячейка может быть пустой
или содержать клетку. Существование клетки определяется количеством
соседей. Если в соседних ячейках 2 или 3 клетки, то клетка живет, а если
соседей больше трех или меньше двух то клетка погибает (от
«перенаселенности» или то «одиночества»). Если же вокруг пустой ячейки
находятся ровно 3 клетки, то в ней появляется новая клетка.
Таким образом, заданы условия трех основных процессов у живых
существ: рождения, существования и отмирания.
Представленная программа обеспечивает проверку этих условий и
выполнение соответствующих действий. Программа, также, выполняет
схематический вывод поля и некоторой сопутствующей информации на экран.
2. Описание программы

2.1. Программа реализована на Borland Pascal 7.0.

2.2. Данные в программе хранятся в следующих глобальных переменных
стандартных типов:

2.2.1 A и B – основной и вспомогательный массивы элементов типа
Boolean размером [0..51,0..31]. В основном массиве A хранится информация о
содержании клеток в ячейках поля. Вспомогательный массив B введен для
занесения текущих изменений содержимого ячеек без изменения основного
массива. После заполнения массива B его содержимое копируется в массив A.
2.2.2. i и j – переменные типа integer. В первоначальном варианте
программы использовались как счетчики в циклах типа for. Впоследствии все
эти циклы были перемещены из тела программы в процедуры, и эти переменные
были использованы как параметры процедуры InitGraph для установки
графического режима.
2.2.3. VP – переменная типа integer. Содержит номер активной
видеостраницы. Используется процедурой FlipVP (см. далее).
2.2.4. step, live, dead и born – переменные типа integer. Содержат,
соответственно, номер шага работы программы, текущее количество живых
клеток на поле и количество погибших и появившихся за последний шаг клеток.
2.2.5. s и stri – переменные типа string. Переменная s применяется
как промежуточная при переводе чисел в строковое представление; с ее
помощью формируется переменная stri, которая и выводится на экран
процедурой OutTextXY.

2.3. Программа использует стандартные модули crt.tpu и graph.tpu а
так же модуль mono3d.tpu, написанный для других целей, из которого
используется только процедура FlipVP.

2.4. Основные блоки программы реализованы в двух функциях и пяти
процедурах, выполняющих следующие действия:

2.4.1. Функция Nears. Возвращает значение типа integer. Применяется
для подсчета клеток в соседних ячейках. Аргументами функции x и y являются
номер столбца и строки, содержащих ячейку, для которой определяется
количество соседей. При выполнении функции внутренние счетчики i и j
пробегают значения от x-1 до x+1 и от y-1 до y+1 соответственно. При этом
проверяется содержимое каждой ячейки A[i,j] и, если она не пустая, значение
суммирующей переменной s увеличивается на 1 (перед выполнением функции
переменная s обнуляется). Таким образом в переменную s заносится
количество клеток в квадрате 3х3 ячейки с исследуемой ячейкой в центре.
После этого, если исследуемая ячейка не пуста, переменная s уменьшается на
1 (поскольку нас интересует только содержимое окружающих ячеек). Далее
функция возвращает значение переменной s.
2.4.2. Функция Change выполняет основные действия программы и
возвращает значение типа boolean. Во время ее выполнения внутренние
счетчики i и j пробегают диапазоны значений, охватывающие всю
обрабатываемую площадь поля. Для каждой ячейки A[i,j] выполняется проверка
наличия в ней клетки. Если в ячейке есть клетка, то с помощью функции Nears
определяется количество ее соседей, если оно подходит под условия
отмирания, то ячейка вспомогательного массива B[i,j] опустошается, а
переменная dead увеличивается на 1. Если ячейка пуста, а функция Nears
возвращает значение, подходящее под условие возникновения, то ячейка
вспомогательного массива B[i,j] заполняется, а переменная born
увеличивается на 1. В остальных случаях изменения данных не происходит.
В начале выполнения переменные born и dead обнуляются, а функции
Change присваивается значение False. Если произошло хотя бы одно изменение
данных, функции присваивается значение True. Поскольку эта функция является
условием выполнения основного цикла программы, очевидно, что при отсутствии
изменений произойдет выход из цикла.
2.4.3. Процедура Setup случайным образом заполняет поле клетками.
Плотность заполнения определяется аргументом стандартной функции Random.
2.4.4. Процедура Copy копирует содержимое вспомогательного массива B
в основной массив A.
2.4.5. Процедура Count производит подсчет клеток, находящихся в
данный момент на поле. В начале ее выполнения переменная live обнуляется.
После этого проверяется содержимое каждой обрабатываемой ячейки основного
массива A[i,j] и, если она не пуста, переменная live увеличивается на 1.
2.4.6. Процедура Draw выводит содержимое основного массива A в виде
графического построения. Каждая ячейка массива A представлена на экране
прямоугольником 10х8 pix. В зависимости от содержимого ячейки он может
иметь ярко-зеленый цвет и сплошную заливку (клетка) или темно-синий цвет и
штриховую заливку типа 9 (пустая ячейка). Поверх заполненных
прямоугольников (оператор Bar) на том же самом месте рисуются контурные
прямоугольники (оператор Rectangle) ярко-синего цвета из которых получается
сетка.
2.4.7. Процедура Print осуществляет вывод на экран сопутствующей
информации (переменные step, live, born и dead c комментариями). Переменные
преобразуются в строковой вид с помощью процедуры Val и промежуточной
переменной s, после чего с помощью стандартных арифметических действий,
применимых к единицам данных типа string, формируется переменная stri,
которая и выводится на экран оператором OutTextXY.
2.4.8. Описание процедуры FlipVP (модуль mono3d.tpu) выглядит так:

Procedure FlipVP(var P:Integer);
Begin
{}
{} SetVisualPage(P);
{} P:=1-P;
{} SetActivePage(p);
{} ClearDevice;
{}
End;

Она предназначена для того, чтобы скрыть от пользователя процесс
прорисовки экрана. Принцип действия ее очевиден: активная видеостраница
всегда остается невидимой.

2.5. Работа программы.

2.5.1. Начало программы.
2.5.1.1. Процедура Setup заполняет основной массив A (п. 2.4.3.)
2. Переменным i и j присваиваются значения 9 и 1, что
соответствует видеорежиму EGA640х350 pix, 16 цветов.
3. Оператор InitGraph устанавливает этот видеорежим.

2.5.2. Основной цикл программы.
2.5.2.1. Оператор While открывает цикл.
2.5.2.2. Функция Change используется как условие выполнения цикла,
при этом выполняемые ею действия обрабатывают основной и вспомогательный
массивы (п. 2.4.2.)
2.5.2.3. Счетчик шагов step увеличивается на 1.
2.5.2.4. Процедура FlipVP переключает активную и видимую
видеостраницы (п. 2.4.8.).
2.5.2.5. Процедура Draw выводит на активную видеостраницу отображение
поля (массива A п.2.4.6.).
2.5.2.6. Процедура Count подсчитывает текущее количество клеток на
поле (п. 2.4.5.).
2.5.2.7. Процедура Print выводит на активную видеостраницу текущую
информацию о состоянии системы (п.п. 2.4.7. и 2.2.4.).
2.5.2.8. Оператор Delay обеспечивает задержку выполнения цикла для
удобства визуального наблюдения.
2.5.2.9. С помощью стандартных функций KeyPressed и ReadKey каскад
условных переходов обеспечивает выход из цикла по нажатию клавиши (для
этого в программе объявлена метка l).

2.5.3. Окончание программы.
2.5.3.1. После выхода из цикла по нажатию клавиши (п. 2.5.2.9) или по
условию выхода (п. 2.5.2.2.) функция ReadKey приостанавливает программу до
нажатия клавиши без изменения содержимого экрана.
2.5.3.2. Оператор CloseGraph отключает графический режим.
2.5.3.3. Оператор ClrScr очищает экран, приводя его в исходное
состояние.

5. Основные недостатки программы.

1. Для нормальной работы функции Change (а точнее Nears) в поле
имеются крайние ячейки A[0,0..31], A[51,0..31], A[0..51,0] и
A[0..51,31], которые несмотря ни на какие условия всегда
остаются пустыми, что снижает чистоту моделирования.
2. Некоторые параметры, такие как частота обновления, начальная
плотность заполнения поля и др. изменяются только
вмешательством непосредственно в текст программы.
3. Не предусмотрен выход из цикла при возникновении стабильных
циклических процессов, которые воспринимаются функцией Change
как изменения, хотя практически перестают являться таковыми.
2. Заключение.

3.1. В данной работе приведен простейший пример применения метода
моделирования системы. Усложнение и модернизация алгоритма позволит с
большей точностью отображать реальные процессы в модели.
2. В нынешней форме программа позволила выявить следующие нюансы:
3.2.1. Конечная картина представляется почти одинаковой при плотности
заполнения поля от 1/2 до 1/6. При плотности ниже 1/6 система обычно
довольно быстро приходит к полному «вымиранию».
3.2.2. Обнаружено несколько видов стабильных фигур. Например:



Циклические фигуры. Например:



Движущиеся фигуры. Например:



3.3. В ходе выполнения работы были закреплены навыки программирования на
языке Pascal: использование стандартных функций модуля crt.tpu, применение
элементов графики из модуля graph.tpu, написание и подключение собственных
модулей (mono3d.tpu), работа с компилятором и пр.

3. Приложение
Текст программы «Жизнь» (файл life.pas)

uses
crt,graph,mono3d;

var
A,B:array[0..51,0..31]of boolean;
i,j,VP,step,live,dead,born:integer;
s,stri:string;

label l;

Function Nears(x,y:integer):integer;
{}
{} var
{} i,j,s:integer;
{}
Begin
{}
{} s:=0;
{} for i:=x-1 to x+1 do
{} for j:=y-1 to y+1 do
{} if a[i,j] then s:=s+1;
{} if a[x,y] then s:=s-1;
{} Nears:=s;
{}
End;

Function Change:Boolean;
Begin
{}
{} born:=0;
{} dead:=0;
{} Change:=False;
{}
{} for i:=1 to 50 do
{} for j:=1 to 30 do
{} begin
{} {}
{} {} if A[i,j] then
{} {} begin
{} {} {} if ((Nears(i,j)3)) then
{} {} {} begin
{} {} {} {} B[i,j]:=False;
{} {} {} {} dead:=dead+1;
{} {} {} {} Change:=True;
{} {} {} end;
{} {} end
{} {} else
{} {} begin
{} {} {} if Nears(i,j)=3 then
{} {} {} begin
{} {} {} {} B[i,j]:=True;
{} {} {} {} born:=born+1;
{} {} {} {} Change:=True;
{} {} {} end;
{} {} end;
{} {}
{} end;
{}
End;
Procedure Setup;
{}
{} var
{} i,j:integer;
{}
Begin
{}
{} Randomize;
{} for i:=1 to 50 do
{} for j:=1 to 30 do
{} if Random(2)=0 then A[i,j]:=True;
{}
End;

Procedure Draw;
{}
{} var
{} i,j:integer;
{}
Begin
{}
{} Rectangle(0,0,639,349);
{} for i:=0 to 51 do
{} for j:=0 to 31 do
{} begin
{} {}
{} {} if A[i,j] then SetFillStyle(1,10)
{} {} else SetFillStyle(9,1);
{} {} Bar(55+10*i,10+8*j,65+10*i,18+8*j);
{} {} Rectangle(55+10*i,10+8*j,65+10*i,18+8*j);
{} end;
{}
End;

Procedure Copy;
{}
{} var
{} i,j:integer;
{}
Begin
{}
{} for i:=1 to 50 do
{} for j:=1 to 30 do
{} A[i,j]:=B[i,j];
{}
End;

Procedure Print;
Begin
{}
{} Str(step:3,s);
{} stri:='Шаг # '+s;
{} Str(live:3,s);
{} stri:=stri+' Клеток '+s;
{} outtextxy(55,300,stri);
{} Str(born:3,s);
{} stri:='Появилось '+s;
{} Str(dead:3,s);
{} stri:=stri+' Погибло '+s;
{} outtextxy(55,315,stri);
{}
{}
End;

Procedure Count;
{}
{} var
{} i,j:integer;
{}
Begin
{}
{} live:=0;
{} for i:=1 to 50 do
{} for j:=1 to 30 do
{} if A[i,j] then live :=live+1;
{}
End;



BEGIN

Setup;

i:=9;
j:=1;
InitGraph(i,j,'c:dos');

SetColor(9);

While Change do
begin
{} step:=step+1;
{} FlipVP(VP);
{} Draw;
{} Count;
{} Print;
{} Copy;
{} Delay(22);
{} if KeyPressed then
{} if ReadKey''then
{} goto l;
end;

l:

ReadKey;

CloseGraph;
ClrScr;

END.





Новинки рефератов ::

Реферат: Билеты к экзамену по статистике с-х (Ботаника)


Реферат: Электронно-лучевой прибор (Компьютеры)


Реферат: Музыкальная драматургия в рок музыке (Музыка)


Реферат: Семья как социальный институт. Социология семьи (Социология)


Реферат: Контрольная работа (Математика)


Реферат: Электронная картотека (Компьютеры)


Реферат: МАСОНСТВО. ТРИСТА ЛЕТ В РОССИИ (Политология)


Реферат: Молодежь и курение (Безопасность жизнедеятельности)


Реферат: Экспертная система по расшифровке и анализу показаний томографа (Компьютеры)


Реферат: Бузина черная (Биология)


Реферат: Экзаменационные билеты по трем предметам из раздела программирования и компьютеров за декабрь 2000 г (Компьютеры)


Реферат: Функции менеджмента: планирование, организация, мотивация и контроль (Менеджмент)


Реферат: Философия Канта. Докритический и критические периоды жизни (Философия)


Реферат: Стекло (Химия)


Реферат: Социология образования (Социология)


Реферат: Особенности состава затрат, включаемых в себестоимость продукции (работ, услуг) и порядка формирования финансовых результатов при налогообложении прибыли (Налоги)


Реферат: Соловьёва В.С. Три разговора (Философия)


Реферат: Компьютерная подготовка (Программирование)


Реферат: Признаки организации в менеджменте (Менеджмент)


Реферат: Концепция правового государства (Теория государства и права)



Copyright © GeoRUS, Геологические сайты альтруист