РЕФЕРАТ

по дисциплине "Теория проектирования трансляторов"

на тему Протоколы и стандарты объектно-ориентированного программирования
Выполнен студентом группы АП-1-91 Маслюковым А.О.


СОДЕРЖАНИЕ
    Предисловие                                               

    MS Windows и новый метод разработки программ             

    Динамический обмен данными                               

    OLE-технология  

    Заключение                                       

    Список литературы                                       

    Приложение 1.Пример использования OLE-технологии       




Предисловие
     Наиболее распространенным языком программирования  последне-

го десятилетия безусловно является С. Этому способствовали  такие

его  особенности,  как  лаконичность,  мощность,  гибкость,   мо-

бильность. Вместе с тем, стремительное усложнение приложений, для

реализации которых применяются традиционные процедурно-ориентиро-

ваннные языки программирования и, в частности С, заставляют гово-

рить об определенном кризисе в их использовании, связанном  преж-

де всего с недостаточной надежностью и выразительной способностью.

     Подобных недостатков во многом лишены языки  объектно-ориен-

тированнго программирования (ООП), в сонове которыхлежит идея мо-

делирования объектов посредством иерархически связанных  классов.

Отдельно взятый класс рассматривается как совакупность  множества

данных и операций над ними,  причем  доступ  к  элементам  данных

класса возможен только посредством операций этого  класса.  Уста-

новление четкой взаимозависимости между данными и операциями  ве-

дет к большой целостности данных и  значительно  повышает  надеж-

ность программ по сравнению с традиционными языками  программиро-

вания. Кроме того, идея программирования  с  помощью  классов  во

многом использует тот же подход, который позволяет людям формиро-

вать модели объектов реального мира.

     Впервые идеи ООП были реализованы в середине  60-х  годов  в

языке программирования Симула-67. Последний, однако, не  нашел  в

то время широкого распространения как в силу  своей  относительно

меньшей производительности по сравнению с  традиционными  языками

типа FORTRAN, ALGOL, PL/1 так и, возможно, неадекватности предла-

гаемых средств решаемым в то время задачи. Еще одним важным огра-

ничением для распространеия Симулы-67 стали трудности, с  которы-

ми пришлось столкнуться большинству программистов при его  изуче-

нии. Дело в том, что наряду с целым рядом безусловных достоинств,

идеи ООП обладают и одним существенным недостатком -  они  далеко

не просты для понимания и особенно для освоения с  целью  практи-

ческого использования.
     С++ - развитие С.

     С++ - это объектно-ориентированыый язык, то есть язык,  поз-

воляющий  программисту  оперировать  объектами  некоторых  типов,

предварительно им определенным.  Название  языка  "С++"  отражает

эволюционный характер изменения языка С (запись "++", в языке  С,

означает, что к какой-то  переменной  прибавляется  единица).  Он

имеет еще более мощные и гибкие средства для написания  эффектив-

ных программ, чем С, от которого он произошел. Человек,  програм-

мирующий на традиционных языках, может просто потерять голову  от

тех возможностей, которые предоставляет С++.

     Но не менее важным является то, что такой распространенный и

универсальный язык, как С, сохранен в качестве основы.  С  прост,

эффективен, переносим. Чего только нет в языке С: строковых  дан-

ныхнет, матриц нет, средств параллельного  программирования  тоже

нет. Нет даже ввода-вывода.

     Типы, операции и операторы С очень близки к тому, с  чем  мы

имеем дело в Ассемблере,- числа, адреса, арифметические  и  логи-

ческие действия, циклы... Кроме того, многие особенности  С  нед-

вусмысленно намекаю компилятору, как сократить код и время испол-

нения программы. Эти характерные черты языка  С  позволяют  напи-

сать эффективно работающий и не слишком сложный компилятор. И хо-

тя в машинных кодах на разных компьютерах  элементарные  операции

обозначаютс по-разному, вряд ли разработчику компилятора придет в

голову интерпретировать простейшие выражения каким-нибудь  ориги-

нальным способом. Именно поэтому язык С "идет везде и  на  всем",

программы, написанные на нем, работают эффективно, и их можно пе-

реносить с одного компьютера на другой.

     Большинство языков программирования созданы для решения  оп-

ределенного круга задач. В них не только не хватает  определенных

типов данных и функций, но и много лишнего с точки зрения челове-

ка, далекого от области, на которую ориентирован язык.  Специали-

зированные типы данных  или  операторы,  требующие  нетривиальной

поддержки, затрудняют изучение языка и мешают вашей работе,  если

вы ими не собираетесь пользоваться. Поэтому С, в котором нет  ни-

чего лишнего, популярен среди широкого круга программистов. Соот-

ветствующие библиотеки могут добавить к средствам языка специали-

зированные функции для работы со строками, файлами, списками, ус-

тройствами ввода-вывода, математическими объектами и т.д. Остает-

ся только выбрать то, что нужно лично вам. Заголовочные файлы об-

легчают использование библиотек, предоставляют полезные типы дан-

ных, глобальные переменные, макроопределения... Они во многом ус-

траняют противоречие между эффективностью программы  и  удобством

использования библиотечных функций. Они также позволяют не повто-

рятся и не писать по нескольку раз одно и тоже в различных  прог-

раммах. Поскольку С был создан специально для системного програм-

мирования, он имеет возможности низкого уровня, позволяющие  "иг-

рать без правил". В зависимости от устройства и операционной сис-

темы вашей машины вы можете "влезть" в видеопамять или  использо-

вать системные программы, находящиеся в оперативной памяти.

     В любом случае вы можете рассматривать код собственной прог-

раммы как данные, а массив данных  как  код  функции,  квадратную

матрицу как вектор, а текст как бинарное дерево. Что бы ни  нахо-

дилось в памяти - это всего лишь последовательная цепочка  чисел.

Если вы не боитесь риска - можете делать все, что вам вздумается.

     Современные прграммисты выбирают С не только из-за его преи-

муществ. В настоящее время мы имеем дело с цепной  реакцией:  чем

больше написано на С, тем больше на нем напишут еще. Это одна  из

причин, почему язык С++ сохраняет С в качестве подмножества.

     По мнению автора С++,  Бьерна  Страуструпа,  различие  между

идеологией С и С++ заключается примерно в следующем: программ  на

С отражает "способ мышления" процессора, а С++ - способ  мышления

программиста. Отвечая требованиям современного  программирования,

С++ делает акцент на разработке новых типов данных, наиболее пол-

но соответствующих концепциям выбранной области знаний и  задачам

приложения. На С пишут библиотеки функций, С++  позволяет  созда-

вать библиотеки классов. Класс является  ключевым  понятием  С++.

Описание класса содержит описание данных, требующихся  для  пред-

ставления объектов этого типа, и набор операций для работы с  по-

добными объектами.

     В отличие от традиционных структур С  или  Паскаля,  членами

класса являются не только данные,  но  и  функции.  Функции-члены

класса имеют привилегированный доступ к  данным  внутри  объектов

этого класса и обеспечивают интерфейс между этими объектами и ос-

тальной программой. При дальнейшей работе  совершенно  не  обяза-

тельно помнить о внутренней структуре класса и  мехагизме  работы

"встроенных функций". В этом смысле класс подобен  электрическому

прибору - мало кто знает о его устройстве, но все знают,  как  им

пользоваться.

     Часто в целях повышения эффективности и упрощения  структуры

программы приходится заставлять ее работать с разнородными объек-

тами так, как если бы они имели один и тотже тип.  Например,  ок-

ружность и квадрат естественно рассматривать как варианты геомет-

рической фигуры. Полезно составлять списки фигур, нарисованных на

экране, или функций, которые их размножают, двигают и т.д. О точ-

ном типе объекта приходится порой забывать.  Список  геометричес-

ких фигур "не знает", что в нем находится - отрезки или  звездоч-

ки. Не знает этого и компилятор. Но все время,  пока  вы  рисуете

эти объекты, неизбежно приходится  "помнить",  что  они  из  себя

представляют. Конечно, возможности низкого уровня позволяют  "за-

бывать" и "вспоминать" когда и как нам заблагорассудится, но  при

этом компилятор теряет контроль над осмысленностью действий.

     Использование производных классов и виртуальных функций поз-

воляет избежать рискованной техники и не заботится о том,  в  ка-

кой форме объект типа "геометрическая фигура" хранит информацию о

том, круг он или квадрат. (Кроме возможностей ООП,  создание  ти-

пов данных "треугольник" или "квадрат" как производные от базово-

го класса "геометрическая фигура" отражает логическую связь поня-

тий). Виртуальные функции, по существу,  определяют,  что  именно

можно делать с объектом, а не то, как это делать. Создавая  класс

"геометрическая фигура", мы можем  включить  в  него  виртуальные

функции рисования, увеличения, поворота.  С  использованием  этих

функций можно создать еще один член класса.

     Затем можно разработать  библиотеку  программ  интерактивной

графики, снабдив ее средствами диалого, функциями вроде  дополне-

ния некоторой области экрана одинаковыми геометрическими  фигура-

ми и т.д. Библиотечные функции будут вызывать функции-члены клас-

са "геометрическая фигура": рисования, движения,  поворота,увели-

чения. А после того, как мы все это напишем, откомпилируем, спря-

чем текст функций, которые считаем  своей  интеллектуальной  соб-

ственностью, начинается самое интересное. Теперь  мы  можем  опи-

сать сколько угодно новых типов фигур - многоугольников,  звездо-

чек, эллипсов - производных от класса "геометрическая  фигура"  и

объяснить, как их рисовать, увеличивать и поворачивать. Как  дви-

гать - объяснять не надо. Это уже есть в базовом классе.  Функции

нашей библиотеки могут работать собъектами вновь созданных типов,

для них это варианты геометричесой фигуры. Следует отметить,  что

в производных классах могут (и, как  правило,  должны)  появлятся

данные и функции, которых нет в базовом классе. Однако ни одна из

функций, обрабатывающих "геометрические фигуры", никогда  не  уз-

нает о специфических свойствах многоугольника или эллипса,  кроме

того, что они по-своему рисуются, увеличиваются и поворачиваются.

Производный класс сам может быть базовым для  других  классов,  а

поздние версии С++ позволяют сделать один  класс  производным  от

нескольких других.

     При написании программы часто допускаются досадные оплошнос-

ти, обнаруживающиеся только на стадии выполнения и, увы,  слишком

поздно. Например, если переменная по смыслу - знаменатель  дроби,

хотелось бы получить сообщение об ошиюке тогда, когда ей присваи-

вается ноль, а не тогда, когда на этот ноль  что-нибудь  делится.

Или, скажем, функция рисования точки.  Невозможно  удержаться  от

соблазна вызвать ее хотя бы раз без проверки  выхода  за  границы

экрана. В то же время , если мы пишем программу рисования  линии,

обязательно нужна функция, которая тупо ставит точку - и как мож-

но быстрее. Существует много ситуаций,  когда  функции  и  данные

следует разрешить использовать только привилегированным функциям,

над которыми ва "хорошо подумали". В С++  этого  можно  добиться,

сделав "опасные" данные и функции защищенными членами  какого-ни-

будь класса. К ним имеют доступ  только  функции-члены  этого  же

класса, а так же друзья класса. Напротив, если  данные  или  фун-

кции-члены объявлены public, они являются общедоступными.

     С++ предоставляет в распоряжение программиста  сложные  типы

данных. Однако ни аппарат  классов,  ни  перегрузка  операций  не

влияют на эффективность. То, что  класс  -  это  класс,  известно

только компилятору. Если функции-члены классов объявлены  inline,

на их вызов не требуется время. Фактически это не функции, а под-

становки. Лишь виртуальные  функции  оставляют  относительно  не-

большой след в оперативной памяти.

     Из всего выше сказанного вытекает логичный вывод: С++ наибо-

лее удобный, универсальный и необходимый язык. Но все  же  возни-

кает вопрос, что же было написано на этом языке, используя  прин-

ципы ООП, что можно было бы "потрогать" любому  программисту  или

пользователю. Ответ очевиден - это Microsoft Windows.


MS Windows и новый метод разработки программ.
     Одним из наиболее важных механизмов взаимодействия программ

является обмен данными. В MS Windows существует несколько способов

взаимодействия приложений:

     - почтовый ящик;

     - динамический обмен данными;

     - встраивание объектов.
      Специальный почтовый  ящик  (clipboard)  Windows  позволяет

пользователю переносить информацию из одного приложения в другое,

не заботясь об ее форматах и представлении.
     В отличие от профессиональных  операциональных  операционных

систем, где механизм обмена данными  между  программами  доступен

только программисту, в Windows это делается очень просто  и  наг-

лядно для пользователя.
     Механизм обмена данных между приложениями - жизненно  важное

свойство многозадачной среды. И в настоящее  время  производители

программного обеспечения пришли уже к выводу,  что  для  переноса

данных из одного приложения в другое почтового ящика уже недоста-

точно. Появился новый,  более  универсальный  механизм  -  OLE  (

Object Linking and Embedding )

             - Встроенная объектная связь, который позволяет  пе-

реносить из одного приложения в другое разнородные данные. Напри-

мер, с помощью этого механизма данные, подготовленные  в  системе

сетевого планирования Time Line for Windows ( Symantec  ),  можно

переносить в текстовый процессор Just Write ( Symantec ),  а  за-

тем, скажем, в  генератор  приложений  Object  Vision  (Borland).

Правда, это уже нестандартное средство Microsoft Windows, но  тем

не менее реализация OLE стала возможной именно в Windows.
     Кроме механизма почтового ящика, предназначенного, в  основ-

ном, для

{

        if ( lpObject )

        {

                ret = OleClone( lpObject, (LPOLECLIENT)pOwlClient,

                                lhClientDoc, GetApplication()->Name,

                                &lpUndoObject );

                wait( ret, lpObject );

                lstrcpy( lpszLastObjectName, lpszObjectName );

                lstrcpy( lpszObjectName , GetNextObjectName() );

                bUndoObjectLoaded = bObjectLoaded;

        }

}
void TOleDocWindow::CMPaste( RTMessage )

{

        if ( OpenClipboard( HWindow ) )

        {

                BackupObject();
                lstrcpy( lpszObjectName, GetNextObjectName() );
                ret = OleCreateFromClip( "StdFileEditing",

                        (LPOLECLIENT)pOwlClient,

                        lhClientDoc,

                        lpszObjectName,

                        &lpObject,

                        olerender_draw,

                        0 );

                check( ret );
                ret = OleSetHostNames( lpObject,

                      GetApplication()->Name, lpszObjectName );

                wait( ret , lpObject );
                bObjectLoaded = TRUE;
                CloseClipboard();

                PostMessage( HWindow , WM_U_REDRAW, 0, 0L );

        }
}
LPSTR TOleDocWindow::GetNextObjectName()

{

        static char buffer[ MAXPATH ];

        wsprintf( buffer, "object #%03d", nNextObjectNum++ );

        return buffer;

}
void TOleDocWindow::Paint( HDC hdc, PAINTSTRUCT _FAR &)

{

        LPOLEOBJECT lpObjectToDraw = NULL;
        if ( bObjectLoaded )

                lpObjectToDraw = lpObject;

        else if ( lpUndoObject )

                lpObjectToDraw = lpUndoObject;
        if ( lpObjectToDraw ) {

                RECT rect;

                GetClientRect( HWindow, &rect );
// Замечание по OleDraw:

// OleDraw должен возвращать OLE_ERROR_OBJECT, если

// object был нарисован неверно.

                ret = OleDraw( lpObjectToDraw , hdc, &rect ,

                               NULL, 0 );

                wait( ret, lpObjectToDraw );

        }

}
TOleDocWindow::TOleDocWindow( PTWindowsObject parent,

                              LPSTR title )

        : TWindow( parent, title )

{

        ret = OLE_OK;

        lhClientDoc = 0;
        bObjectLoaded = FALSE;

        bUndoObjectLoaded = FALSE;

        bUndoObjectLoaded = FALSE;
        pOwlClient = NULL;

        lpObject = NULL;

        lpUndoObject = NULL;
        strcpy( lpszDocName , "noname.ole" );

        *lpszLastObjectName = 0;

        *lpszObjectName = 0;

        bDefDocName = TRUE;

}
void TOleDocWindow::SetupWindow() {

        TWindow::SetupWindow();

        RegisterClientDoc();

        pOwlClient = new TOwlClient( this );
}
void TOleDocWindow::RegisterClientDoc() {
        ret = OleRegisterClientDoc(

                        GetApplication()->Name,

                        lpszDocName,

                        0,

                        &lhClientDoc );

        check( ret );

}
void TOleDocWindow::ShutDownWindow()

{

        CloseCurrentOle();

        if ( pOwlClient ) delete pOwlClient;

        TWindow::ShutDownWindow();

}
void TOleDocWindow::RegFileName( LPSTR FileName )

{

        lstrcpy( lpszDocName , FileName );

        ret = OleRegisterClientDoc( GetApplication()->Name,

                        lpszDocName ,

                        0,

                        &lhClientDoc );

        check ( ret );

}
void TOleDocWindow::CMActivate( RTMessage )

{

        BackupObject();

        RECT rect;

        GetClientRect( HWindow, &rect );

        ret = OleActivate( lpObject , OLEVERB_PRIMARY, TRUE,

                        TRUE ,

                        HWindow , &rect );

        wait ( ret, lpObject );

        PostMessage( HWindow , WM_U_REDRAW, 0, 0L );

}
void TOleDocWindow::WMInitMenu( RTMessage msg )

{

        HMENU hMenu = (HMENU)msg.WParam;

        WORD wEnableUndo;
        if ( (lpObject != lpUndoObject) &&

             ( lpUndoObject != NULL ))

                wEnableUndo = MF_ENABLED;

        else wEnableUndo = MF_GRAYED;

        EnableMenuItem( hMenu, CM_UNDO     ,

                        wEnableUndo );

        EnableMenuItem( hMenu, CM_COPY     ,

                    ( bObjectLoaded ? MF_ENABLED : MF_GRAYED ));

        EnableMenuItem( hMenu, CM_CUT      ,

                    ( bObjectLoaded ? MF_ENABLED : MF_GRAYED ));

        ret = OleQueryCreateFromClip( "StdFileEditing",

                      olerender_draw, 0 );

        EnableMenuItem( hMenu, CM_PASTE    ,

                 (( ret == OLE_OK ) ? MF_ENABLED : MF_GRAYED ));

        EnableMenuItem( hMenu, CM_ACTIVATE ,

                    ( bObjectLoaded ? MF_ENABLED : MF_GRAYED ));

        EnableMenuItem( hMenu, CM_CLEAR    ,

                    ( bObjectLoaded ? MF_ENABLED : MF_GRAYED ));
        DrawMenuBar( HWindow );

}
LPSTR TOleDocWindow::GetClassName() { return "OLEDOCWINDOW"; }
void TOleDocWindow::GetWindowClass(WNDCLASS _FAR &wc )

{

        TWindow::GetWindowClass( wc );

        wc.lpszMenuName = "MENU_DOCWINDOW";

}
void TOleDocWindow::CMClear( RTMessage )

{

        CloseCurrentOle();

}
void TOleDocWindow::CloseCurrentOle()

{

        // окончательное сохранение

        if ( lpObject ) {

                ret = OleDelete( lpObject );

                wait( ret , lpObject );

        }

        if ( lpUndoObject ) {

                ret = OleDelete( lpUndoObject );

                wait( ret , lpObject );

        }

        lpObject = lpUndoObject = NULL;
        bObjectLoaded = FALSE;
        InvalidateRect( HWindow , NULL, TRUE );

        UpdateWindow( HWindow );

}
void TOleApp::InitMainWindow()

{

  MainWindow = new TOleDocWindow(NULL, "OWL OLE Application" );

}
int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,

                   LPSTR lpCmd, int nCmdShow)

{

        TOleApp OleApp ("OleApp", hInstance, hPrevInstance,

                lpCmd, nCmdShow);

        OleApp.Run();

        return (OleApp.Status);

}