курсовые,контрольные,дипломы,рефераты
Темой данной курсовой работы является изучение объектно-ориентированных возможностей языка 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. Поэтому для объектов этих классов можно вызывать все члены-функции, присущие классу массива объектов.
Объектная модель книги
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_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 { CRazdel*
Razdel=new CRazdel; Razdel->Serialize(ar); m_Razdels.Add(Razdel); } for(Counter=0;Counter { CRazdel*
Razdel=(CRazdel*)m_Razdels.GetAt(Counter); for(WORD
Counter2=0;Counter2 { CGlava*
Glava=(CGlava*)Razdel->GetGlavas()->GetAt(Counter2); for(WORD
Counter3=0;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 { 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 { 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 { 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 { 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 { 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 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 { 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.
Порождение объектов
Вызов операций
Использование наследования
Реализация зависимостей
Анализ полученных результатов и выводы
Литература
Изучение взаимно влияющих друг на друга математических параметров
Разработка приложений на языке VBA в среде MS EXCEL по обработке данных для заданных объектов
Объектно-ориентированный подход к проектированию программного обеспечения на примере работы налоговой инспекции
Система дистанционного обучения
Программирование логической игры на visual basic
Интернет магазин - Техника для жизни
Использование компьютерных программ для анализа финансового состояния организации
Отчёт по созданию курсовой работы «База данных ACCESS»
Обработка данных о студентах
Разработка рисунка настенного календаря с помощью графического редактора CorelDRAW. Создание базы данных «Туристических фирм г. Минска» с помощью пакета программ Access
Copyright (c) 2024 Stud-Baza.ru Рефераты, контрольные, курсовые, дипломные работы.