WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!

Pages:     || 2 | 3 | 4 | 5 |   ...   | 6 |
-- [ Страница 1 ] --

Основы 2-е издание, исправленное и переработанное Дейл Роджерсон Оглавление ОТ АВТОРА

........................................................................................................................................................................9 ВВЕДЕНИЕ........................................................................................................................................................................11 ПРЕДВАРИТЕЛЬНЫЕ ЗНАНИЯ............................................................................................................................................11 Программисты, не заинтересованные в Windows — добро пожаловать!...........................................................11 C++...................................................................................................................................................................................12 Только обычный С++................................................................................................................................................. ПРИМЕРЫ.......................................................................................................................................................................... Пример программы Tangram..................................................................................................................................... Стилистические соглашения.................................................................................................................................... ПОЧЕМУ ПОЯВИЛАСЬ ЭТА КНИГА?................................................................................................................................... ТЕХНИЧЕСКАЯ ПОДДЕРЖКА............................................................................................................................................. 1 ГЛАВА КОМПОНЕНТЫ............................................................................................................................................................... ПРЕИМУЩЕСТВА ИСПОЛЬЗОВАНИЯ КОМПОНЕНТОВ........................................................................................................ Адаптация приложений............................................................................................................................................. Библиотеки компонентов.......................................................................................................................................... Распределенные компоненты.................................................................................................................................... ТРЕБОВАНИЯ К КОМПОНЕНТАМ....................................................................................................................................... Динамическая компоновка......................................................................................................................................... Инкапсуляция.............................................................................................................................................................. COM................................................................................................................................................................................. Компоненты СОМ — это…...................................................................................................................................... СОМ — это не…......................................................................................................................................................... Библиотека СОМ........................................................................................................................................................ Стиль СОМ................................................................................................................................................................. СОМ дает больше, чем необходимо......................................................................................................................... ЗАКЛЮЧИТЕЛЬНЫЕ ЗАМЕЧАНИЯ О КОМПОНЕНТАХ.......................................................................................................... 2 ГЛАВА ИНТЕРФЕЙС.................................................................................................................................................................... ИНТЕРФЕЙСЫ — ЭТО ВСЕ................................................................................................................................................ Повторное использование архитектур приложений.............................................................................................. Другие преимущества интерфейсов СОМ............................................................................................................... РЕАЛИЗАЦИЯ ИНТЕРФЕЙСА СОМ.................................................................................................................................... Соглашения о кодировании........................................................................................................................................ Законченный пример................................................................................................................................................... Взаимодействие в обход интерфейсов.................................................................................................................... Детали реализации..................................................................................................................................................... ТЕОРИЯ ИНТЕРФЕЙСОВ, ЧАСТЬ II..................................................................................................................................... Интерфейсы не изменяются..................................................................................................................................... Полиморфизм.............................................................................................................................................................. ЧТО ЗА ИНТЕРФЕЙСОМ..................................................................................................................................................... Таблица виртуальных функций................................................................................................................................. Указатели vtbl и данные экземпляра........................................................................................................................ Множественные экземпляры.................................................................................................................................... Разные классы, одинаковые vtbl................................................................................................................................ КИРПИЧИКИ СОМ, РЕЗЮМЕ............................................................................................................................................. 3 ГЛАВА QUERYINTERFACE........................................................................................................................................................ ЗАПРОС ИНТЕРФЕЙСА....................................................................................................................................................... IUnknown..................................................................................................................................................................... Получение указателя на IUnknown........................................................................................................................... Знакомство с QueryInterface..................................................................................................................................... Использование QueryInterface................................................................................................................................... Реализация QueryInterface......................................................................................................................................... А теперь все вместе.................................................................................................................................................. ПРАВИЛА И СОГЛАШЕНИЯ QUERYINTERFACE................................................................................................................... Вы всегда получаете один и тот же IUnknown..................................................................................................... Вы можете получить интерфейс снова, если смогли получить его раньше....................................................... Вы можете снова получить интерфейс, который у Вас уже есть..................................................................... Вы всегда можете вернуться туда, откуда начали.............................................................................................. Если Вы смогли попасть куда-то хоть откуда-нибудь, Вы можете попасть туда откуда угодно................ QUERYINTERFACE ОПРЕДЕЛЯЕТ КОМПОНЕНТ................................................................................................................... Вы не можете воспользоваться всеми знаниями сразу......................................................................................... РАБОТА С НОВЫМИ ВЕРСИЯМИ КОМПОНЕНТОВ............................................................................................................... Когда нужно создавать новую версию.................................................................................................................... Имена версий интерфейсов....................................................................................................................................... Неявные соглашения.................................................................................................................................................. «У ВАС ДВЕ НОГИ?»........................................................................................................................................................ 4 ГЛАВА ПОДСЧЕТ ССЫЛОК...................................................................................................................................................... УПРАВЛЕНИЕ ВРЕМЕНЕМ ЖИЗНИ..................................................................................................................................... ПОДСЧЕТ ССЫЛОК............................................................................................................................................................ Подсчет ссылок на отдельные интерфейсы........................................................................................................... Реализация AddRef и Release..................................................................................................................................... КОГДА ПОДСЧИТЫВАТЬ ССЫЛКИ..................................................................................................................................... Оптимизация подсчета ссылок................................................................................................................................ Правила подсчета ссылок......................................................................................................................................... АМУНИЦИЯ ПОЖАРНОГО, РЕЗЮМЕ.................................................................................................................................. 5 ГЛАВА ДИНАМИЧЕСКАЯ КОМПОНОВКА.......................................................................................................................... СОЗДАНИЕ КОМПОНЕНТА................................................................................................................................................. Экспорт функции из DLL.......................................................................................................................................... Загрузка DLL............................................................................................................................................................... РАЗБИВАЕМ МОНОЛИТ..................................................................................................................................................... Тексты программ....................................................................................................................................................... СВЯЗКИ ОБЪЕКТОВ........................................................................................................................................................... НЕГИБКОЕ СВЯЗЫВАНИЕ, РЕЗЮМЕ................................................................................................................................... 6 ГЛАВА HRESULT, GUID, РЕЕСТР И ДРУГИЕ ДЕТАЛИ.................................................................................................... HRESULT........................................................................................................................................................................ Поиск HRESULT......................................................................................................................................................... Использование HRESULT.......................................................................................................................................... Определение собственных кодов ошибки................................................................................................................ GUID................................................................................................................................................................................ Зачем нужен GUID?.................................................................................................................................................. Объявление и определение GUID.............................................................................................................................. Сравнение GUID......................................................................................................................................................... Использование GUID в качестве идентификаторов компонентов...................................................................... Передача GUID по ссылке......................................................................................................................................... РЕЕСТР WINDOWS............................................................................................................................................................ Организация Реестра................................................................................................................................................ Редактор Реестра..................................................................................................................................................... Необходимый минимум.............................................................................................................................................. Другие детали Реестра............................................................................................................................................. ProgID.......................................................................................................................................................................... Саморегистрация....................................................................................................................................................... Категории компонентов........................................................................................................................................... OleView........................................................................................................................................................................ НЕКОТОРЫЕ ФУНКЦИИ БИБЛИОТЕКИ COM..................................................................................................................... Инициализация библиотеки COM............................................................................................................................. Управление памятью................................................................................................................................................. Преобразование строк в GUID................................................................................................................................. РЕЗЮМЕ............................................................................................................................................................................ 7 ГЛАВА ФАБРИКА КЛАССА....................................................................................................................................................... COCREATEINSTANCE.......................................................................................................................................................... Прототип CoCreateInstance..................................................................................................................................... Использование CoCreateInstance............................................................................................................................... Контекст класса........................................................................................................................................................ Листинг кода клиента............................................................................................................................................... Но CoCreateInstance недостаточно гибка............................................................................................................... ФАБРИКИ КЛАССА............................................................................................................................................................ Использование CoGetClassObject.............................................................................................................................. IClassFactory............................................................................................................................................................... CoCreateInstance vs. CoGetClassObject..................................................................................................................... Фабрики класса инкапсулируют создание компонентов........................................................................................ РЕАЛИЗАЦИЯ ФАБРИКИ КЛАССА....................................................................................................................................... Использование DllGetClassObject.............................................................................................................................. Общая картина........................................................................................................................................................... Листинг кода компонента........................................................................................................................................ Последовательность выполнения........................................................................................................................... Регистрация компонента........................................................................................................................................ НЕСКОЛЬКО КОМПОНЕНТОВ В ОДНОЙ DLL................................................................................................................... Повторное применение реализации фабрики класса............................................................................................ ВЫГРУЗКА DLL.............................................................................................................................................................. Использование DllCanUnloadNow........................................................................................................................... LockServer.................................................................................................................................................................. РЕЗЮМЕ.......................................................................................................................................................................... 8 ГЛАВА ПОВТОРНАЯ ПРИМЕНИМОСТЬ КОМПОНЕНТОВ: ВКЛЮЧЕНИЕ И АГРЕГИРОВАНИЕ................... ВКЛЮЧЕНИЕ И АГРЕГИРОВАНИЕ.................................................................................................................................... Включение.................................................................................................................................................................. Агрегирование........................................................................................................................................................... Сравнение включения и агрегирования................................................................................................................... РЕАЛИЗАЦИЯ ВКЛЮЧЕНИЯ............................................................................................................................................. Расширение интерфейсов........................................................................................................................................ РЕАЛИЗАЦИЯ АГРЕГИРОВАНИЯ...................................................................................................................................... Магия QueryInterface................................................................................................................................................ Неверный IUnknown.................................................................................................................................................. Интерфейсы IUnknown для агрегирования............................................................................................................ Создание внутреннего компонента........................................................................................................................ Указатели внешнего компонента на интерфейсы внутреннего компонента................................................... ЗАКОНЧЕННЫЙ ПРИМЕР.................................................................................................................................................. Слепое агрегирование............................................................................................................................................... АГРЕГИРОВАНИЕ И ВКЛЮЧЕНИЕ В РЕАЛЬНОМ МИРЕ...................................................................................................... Предоставление информации о внутреннем состоянии...................................................................................... Моделирование виртуальных функций................................................................................................................... РЕЗЮМЕ.......................................................................................................................................................................... 9 ГЛАВА БУДЕМ ПРОЩЕ............................................................................................................................................................. УПРОЩЕНИЯ НА КЛИЕНТСКОЙ СТОРОНЕ........................................................................................................................ Smart-указатели на интерфейсы............................................................................................................................ Классы-оболочки C++............................................................................................................................................. УПРОЩЕНИЯ НА СЕРВЕРНОЙ СТОРОНЕ.......................................................................................................................... Базовый класс CUnknown........................................................................................................................................ Базовый класс CFactory........................................................................................................................................... Использование CUnknown и CFactory.................................................................................................................... Все вместе, шаг за шагом....................................................................................................................................... РЕЗЮМЕ.......................................................................................................................................................................... 10 ГЛАВА СЕРВЕРЫ В EXE........................................................................................................................................................... РАЗНЫЕ ПРОЦЕССЫ........................................................................................................................................................ Локальный вызов процедуры................................................................................................................................... Маршалинг................................................................................................................................................................ DLL заместителя/заглушки.................................................................................................................................... ВВЕДЕНИЕ В IDL/MIDL................................................................................................................................................. IDL............................................................................................................................................................................. Примеры описаний интерфейсов на IDL............................................................................................................... Компилятор MIDL................................................................................................................................................... РЕАЛИЗАЦИЯ ЛОКАЛЬНОГО СЕРВЕРА............................................................................................................................. Работа примера программы................................................................................................................................... Нет точек входа...................................................................................................................................................... Запуск фабрик класса.............................................................................................................................................. Изменения в LockServer........................................................................................................................................... УДАЛЕННЫЙ СЕРВЕР...................................................................................................................................................... Что делает DCOMCNFG.EXE?............................................................................................................................. Но как это работает?............................................................................................................................................ Другая информация DCOM..................................................................................................................................... РЕЗЮМЕ.......................................................................................................................................................................... 11 ГЛАВА ДИСПЕТЧЕРСКИЕ ИНТЕРФЕЙСЫ И АВТОМАТИЗАЦИЯ............................................................................ НОВЫЙ СПОСОБ ОБЩЕНИЯ............................................................................................................................................. Старый способ общения......................................................................................................................................... IDispatch, или «Я диспетчер, ты диспетчер…».................................................................................................... ИСПОЛЬЗОВАНИЕ IDISPATCH......................................................................................................................................... Параметры Invoke................................................................................................................................................... Примеры.................................................................................................................................................................... Тип VARIANT............................................................................................................................................................ Тип данных BSTR...................................................................................................................................................... Тип данных SAFEARRAY.......................................................................................................................................... БИБЛИОТЕКИ ТИПА........................................................................................................................................................ Создание библиотеки типа..................................................................................................................................... Использование библиотек типа............................................................................................................................. Библиотеки типа в Реестре................................................................................................................................... РЕАЛИЗАЦИЯ IDISPATCH................................................................................................................................................ Генерация исключений............................................................................................................................................. Маршалинг................................................................................................................................................................ ЧТО ВЫ ХОТИТЕ СДЕЛАТЬ СЕГОДНЯ?............................................................................................................................ 12 ГЛАВА МНОГОПОТОЧНОСТЬ............................................................................................................................................... ПОТОКОВЫЕ МОДЕЛИ COM........................................................................................................................................... Потоки Win32........................................................................................................................................................... Потоки СОМ............................................................................................................................................................ Подразделение................................................

.......................................................................................................... Разделенные потоки................................................................................................................................................ Свободные потоки................................................................................................................................................... Маршалинг и синхронизация................................................................................................................................... РЕАЛИЗАЦИЯ МОДЕЛИ РАЗДЕЛЕННЫХ ПОТОКОВ........................................................................................................... Автоматический маршалинг.................................................................................................................................. Ручной маршалинг.................................................................................................................................................... Настало время написать программу..................................................................................................................... Пример с разделенным потоком............................................................................................................................. РЕАЛИЗАЦИЯ МОДЕЛИ СВОБОДНЫХ ПОТОКОВ............................................................................................................... Пример со свободным потоком.............................................................................................................................. Оптимизация маршалинга для свободных потоков.............................................................................................. ИНФОРМАЦИЯ О ПОТОКОВОЙ МОДЕЛИ В РЕЕСТРЕ........................................................................................................ РЕЗЮМЕ.......................................................................................................................................................................... 13 ГЛАВА СЛОЖИМ ВСЕ ВМЕСТЕ............................................................................................................................................. ПРОГРАММА TANGRAM.................................................................................................................................................. Tangram в работе..................................................................................................................................................... Детали и составные части..................................................................................................................................... Клиентский EXE-модуль.......................................................................................................................................... Компонент TangramModel...................................................................................................................................... Компоненты TangramGdiVisual и TangramGLVisual............................................................................................ Компоненты TangramGdiWorld и TangramGLWorld............................................................................................ ЧТО ДЕМОНСТРИРУЕТ ПРИМЕР....................................................................................................................................... ФАЙЛЫ IDL.................................................................................................................................................................... Файл DLLDATA.C..................................................................................................................................................... ЦИКЛИЧЕСКИЙ ПОДСЧЕТ ССЫЛОК................................................................................................................................. Не вызывайте AddRef............................................................................................................................................... Используйте явное удаление.................................................................................................................................... Используйте отдельный компонент...................................................................................................................... СОБЫТИЯ И ТОЧКИ ПОДКЛЮЧЕНИЯ................................................................................................................................ IEnumXXX.................................................................................................................................................................. ОСНОВА COM — СТАНДАРТНЫЕ ИНТЕРФЕЙСЫ............................................................................................................ У-У-Ф!............................................................................................................................................................................ От автора Когда я учился в Технологическом институте Джорджии, мои однокурсники часто шутили насчет той известности, которую им приносили (или, точнее, не приносили) технические статьи. Обычно эти статьи подписывали три автора. Первым шел профессор — руководитель студента. Сразу за ним следовал еще один профессор. Этот второй, иронизировали мы, не имел к статье абсолютно никакого отношения, но ему нужны были печатные работы («публикуйся или пропадешь»). Фамилия же скромного дипломника, который и проделал всю работу, шла последней, как бы между прочим. В отличие от тех статей, на обложке этой книги значится только одно имя — мое. Однако книга не могла бы появиться без помощи множества людей. Их имена также заслуживают того, чтобы стоять в самом начале.

Без Найджела Томпсона (Nigel Tompson) я бы и не начал писать. Найджел видел, что разработчикам нужна понятная книга про COM, — и подвигнул меня на ее написание. Похвальные отзывы Нэнси Клатс (Nancy Cluts) вдохновляли меня в особенно трудных местах, когда я мучительно подбирал слова. Если же я подбирал не те слова, Найджел и Нэнси говорили об этом прямо и честно, и я старался улучшить текст.

Крейг Брокшмидт (Kraig Brockshmidt) и Крейг Виттенберг (Craig Wittenberg) задали основные направления работы в начальной стадии написания книги. Кроме того, они подбадривали меня и делали важные технические замечания.

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

по счастью, у этой книги была фантастическая команда. Многие в Microsoft Press не видели необходимости в книге, посвященной исключительно COM, но Эрик Строо (Eric Stroo) убедил их ее издать. Кэтлин Эткинс (Kathleen Atkins) проделала изумительную работу в качестве основного редактора. Она руководила всем проектом и правила текст. Мало того, она еще и делала фотографии и рисунки, с которых начинается каждая глава. Пэм Нидака (Pam Nidaka) разработала по-настоящему крутой дизайн, а Майкл Виктор (Michael Victor) — столь же замечательные графические эффекты, включая танграм* для фотографий. Технический редактор Гэри Нельсон (Gary Nelson) проделал работу, далеко выходящую за пределы его прямых обязанностей, проверяя все технические детали, сколь бы мудреными и запутанными они ни были. Шон Пек (Shawn Peck) возглавлял многочисленную и деятельную группу корректоров, успешно отыскивавших те ошибки, которые не попались на глаза Кэтлин и Гэри.

Кроме того, я в долгу перед всеми, кто читал и просматривал ранние сырые варианты. Это Мэри Кэртланд (Mary Kirtland), Марк Крамер (Mark Kramer), Джон Торнсон (John Thornson), Тим Брэгг (Tim Bragg), Вину Чериан (Vinoo Cherian), Чарли Киндел (Charlie Kindel), Джерри Нолл (Jerry Noll) и Кирк Годдард (Kirk Goddard).

Конечно, я должен поблагодарить моих товарищей в Microsoft Developer Studio, которые отпускали меня на выходные домой, работать над книгой. Особенно я благодарен Мартину Ловеллу (Martin Lovell) за ценнейшие обсуждения технических вопросов.

Я не смог бы написать эту книгу, если бы не опыт, полученный в Microsoft Developer Network. В MSDN я понял, как важно иметь хорошего редактора;

у меня был один из лучших — Хандан Селамоглу (Handan Selamoglu).

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

Наконец, я должен поблагодарить моих друзей и семью, всегда много значивших в моей жизни. Простите меня, Питер Ланкастер (Peter Lancaster) и Пол Шустер (Paul Schuster), за то, что в этом году я не пошел с вами на байдарках, поскольку был занят книгой. Эй, ребята, следующий год наш! Спасибо моей сестре за то, что всегда была рядом. Спасибо моим родителям за то, что они купили мне первый компьютер, Radio Shack TRS-80. И спасибо Саре, которая целый год провела с диким медведем вместо человека.

* Прим. перев.: Танграм — китайская геометрическая головоломка.

Введение Вы никогда не хотели изменить свою программу или добавить к ней что-нибудь новое уже после того, как она стала готовым продутом? Хотели бы Вы разрабатывать свои программы, постепенно расширяя их, а не переписывая заново каждые два года? Хотелось бы Вам, чтобы они проще настраивались? Были более гибкими и динамичными? Вы бы хотели ускорить разработку? А если Вам нужно разрабатывать распределенные приложения — Вы бы хотели писать их так же, как и обычные?

Вы интересуетесь компонентным программированием? Вы хотите разделить свое приложение на компоненты?

Вы хотите изучить COM? А OLE Автоматизацию? У Вас есть опыт безуспешных попыток изучения OLE? Вы находите, что COM и OLE трудны? Хотелось бы Вам понять основы технологий Microsoft, таких как ActiveX, DirectX и OLE? Вам нужно расширять или настраивать приложения или операционные системы Microsoft?

Если хотя бы на один из вопросов Вы ответили «да» — эта книга для Вас! Все эти вопросы связаны с одной технологией: моделью компонентных объектов Microsoft, более известной как COM (Component Object Model).

Эта книга посвящена разработке ваших собственных компонентов COM на C++.

COM — это метод разработки программных компонентов, небольших двоичных исполняемых файлов, которые предоставляют необходимые сервисы приложениям, операционным системам и другим компонентам. Разработка компонента COM подобна разработке динамического объектно-ориентированного API. Компоненты COM объединяются друг с другом для создания приложений или систем компонентов. Компоненты можно отключать и менять во время выполнения, без перекомпиляции или перекомпоновки приложения. COM — это основа, на которой построены такие технологии Microsoft, как ActiveX, DirectX и OLE. Разработчики Microsoft используют компоненты COM при разработке своих приложений и операционных систем.

Предварительные знания Эта книга рассчитана на обычного программиста на C++, имеющего некоторый опыт разработки для Win32. Но даже если Вы только начинаете использовать C++, пугаться не следует. Разрабатывать компоненты COM на C++ несложно, и мастерского владения языком не требуется. Самый «продвинутый» элемент С++, используемый в книге, — множественное наследование, и вся информация об этой концепции, необходимая для работы с COM, здесь предоставлена. Кстати, положительный побочный эффект для новичков состоит в том, что СОМ «подталкивает» к хорошему проектированию программ. Но, конечно, начинающим будет полезно познакомиться с книгами, специально посвященными изучению С++.

Опыт программирования для Microsoft Windows также полезен, но не обязателен. Я пытался максимально избегать кода, специфичного для Windows. У пользователей UNIX не должно возникнуть проблем при чтении примеров. Преимущество программистов для Windows лишь в том, что они знакомы с инструментами разработки Windows-приложений.

Знание Microsoft Foundation Class Library (MFC) и опыт работы с этой библиотекой не обязательны. MFC не дает никаких особых преимуществ при разработке COM, так что в примерах из первых 12 глав книги она вообще не используется.

Программисты, не заинтересованные в Windows — добро пожаловать!

Если Вы пишете программы для UNIX, Macintosh, Linux, VMS или какой-либо другой операционной системы, эта книга также будет Вам полезна. Концепции, заключенные в СОМ, работают не только в операционной системе Microsoft Windows, СОМ — это не большой API. COM — это способ программирования, стоящий в одном ряду с такими способами, как структурное или объектно-ориентированное программирование. Вы можете использовать подход СОМ в любой операционной системе. Конечно, Windows предоставляет код, который облегчает программирование «в духе СОМ», но большую часть этого кода нетрудно реализовать на Вашей любимой платформе. Если Вы не хотите делать это сами — не беда. Microsoft разрабатывает версию СОМ для Macintosh, а Software AG занимается переносом СОМ практически на все операционные системы в мире. Так что скоро Вы сможете воспользоваться преимуществами стандартной и совместимой версии СОМ в любой операционной системе, с которой придется столкнуться.

C++ Хотя сама по себе СОМ не зависит от языка программирования, для написания компонентов придется выбрать определенный язык. Годится практически любой, от С и Java до Python и Microsoft Visual Basic. Однако большинство компонентов разработано и будет разрабатываться на С++. В связи с этим в книге используется исключительно С++. Применение одного языка позволило мне представить спецификацию СОМ наиболее конкретно, что облегчает восприятие. Даже если Вы в конце концов решите использовать Java или Python, знания, полученные при разработке компонентов «с нуля» на С++, помогут Вам.

Только обычный С++ Поскольку не все компиляторы поддерживают последние расширения С++, я старался не употреблять большинство новых возможностей. Не используются ключевые слова bool, mutable и им подобные. За исключением классов smart-указателей на интерфейсы (гл. 9), я не использую шаблоны классов, так как они затрудняют понимание изложенных в книге концепций.

Тем не менее будут использоваться относительно новые операторы приведения типов static_cast, const_cast и reinterpret_cast, так как они уже более года поддерживаются Microsoft Visual C++. Приведение типов нового стиля заменяют старые. Таким образом, вместо CFoo* pI = (CFoo*)this;

Вы увидите:

CFoo* pI = static_castthis;

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

Примеры Каждая глава этой книги включает один или два примера. Моей целью при написании этих примеров было сделать их сжатыми, но законченными. Короткие примеры проще читать — они занимают лишь пару страниц.

Более длинные примеры потребовали бы чтения файлов с прилагаемого к книге диска. Кроме того, простые примеры лучше подчеркивают требования, предъявляемые к компонентам СОМ, не заставляя Вас продираться сквозь несущественные детали и сложности, присущие длинным примерам.

Для всех примеров характерно следующее:

Каждый пример можно найти на прилагаемом диске уже скомпилированным и готовым к работе под Microsoft Windows 95 или Microsoft Windows NT.

Для всех примеров, которые перед началом работы должны быть зарегистрированы в системе, приводится командный файл REGISTER.BAT, который выполняет регистрацию.

Win32 API используется весьма умеренно.

MFC не используется вообще.

Полные исходные тексты всех примеров приведены на диске. Все, что Вам понадобится для компиляции примеров, это компилятор С++ и заголовочные файлы из Win32 SDK. Если у Вас есть Visual C++, то Win32 SDK не нужен, так как Visual C++ включает все необходимое. Это должно быть верно почти для всех Windows-совместимых компиляторов.

Гарантируется, что исполняемый код примеров успешно генерируется Visual C++ версий 4.x и 5.0.

Однако в этих компиляторах нет ничего такого, что бы требовало использовать именно их. Просто я сам работаю с Microsoft Visual C++ 5.0, так что пользовался им и здесь.

Примеры кода легко скомпилировать, запустив компилятор из командной строки. Используя Microsoft Visual C++, многие примеры можно скомпилировать по команде cl <имя файла>.

Более сложные примеры имеют простые make-файлы для Microsoft Visual C++. Для компоновки введите nmake –f makefile или nmake. Ради простоты и читабельности эти make-файлы рассчитаны на компоновку только отладочной версии.

Пример программы Tangram На прилагаемом диске имеется полностью готовое приложение, построенное из компонентов СОМ. Это приложение, Tangram, нарушает большую часть из перечисленных выше правил. Во-первых, оно не только интенсивно обращается к API Win32, особенно GDI, но и использует MFC и OpenGL. Во-вторых, его нельзя назвать простым. Оно содержит много компонентов в нескольких DLL и EXE. Программа Tangram показывает, как выглядит COM «в реальном мире», тогда как другие примеры имеют скорее «школьный» характер. На диске содержатся как исходные тексты, так и скомпилированный исполняемый код.

Стилистические соглашения Хотя в большинстве примеров MFC не используется, я тем не менее использую стиль кодирования MFC. Имена всех переменных-членов имеют префикс m_. Увидев переменную с именем m_SleepyBear, Вы будете знать, что это за переменная. Все имена классов начинаются с заглавной буквы С. Например, CcozyBear — это имя класса Cozy Bear. Некоторые другие используемые мною префиксы показаны в табл. В-1.

Таблица В-1. Примеры префиксов имен в стиле MFC Префикс Значение Пример C Класс CConnectionPoint I Интерфейс IConnectionPoint m_ Переменная-член BOOL m_bSleepyBear;

s_ Статическая переменная-член static int s_iBears;

g_ Глобальная переменная int g_Bears[100];

Если Вы программировали под Windows, то, вероятно, знаете о Венгерской нотации. Она представляет собой соглашение, по которому в имена переменных входит информация об их типах. Я использую подмножество Венгерской нотации, которое Вы можете найти в табл. В-2. Но я не всегда строго ему следую, поскольку частично использую и подмножество Венгерской нотации, рекомендованное другими разработчиками COM, OLE и ActiveX.

Таблица В-2. Венгерская нотация, используемая в книге Префикс Значение Пример p Указатель int* pCount;

pI Указатель на интерфейс IBear* pIBear;

b Булева переменная BOOL bBear;

i Целое int iNumberOfBears;

dw DWORD DWORD dwBears;

c Счетчик DWORD cRefs;

sz Массив символов char szName[] = “Fuzzy”;

wsz Массив символов Unicode wchar_t wszName[] = L“Fuzzy”;

Почему появилась эта книга?

Изучали ли Вы физику в школе? Если Вам преподавали физику, пользуясь элементами высшей математики, то знание последних было необходимым предварительным требованием. Изучая математический анализ, Вы учились применять его в разных областях. Только изучив и поняв дифференциальное исчисление как таковое, Вы смогли использовать его для решения физических задач. Такая последовательность обучения существовала не всегда. Сначала Исаак Ньютон изобрел дифференциальное исчисление как инструмент классической механики и динамики. Только позднее стало ясно, что этот мощный инструмент имеет приложения и за границами физики.

Связь между COM и OLE во многом похожа на связь высшей математики с физикой. Как дифференциальное исчисление было изобретено для решения физических задач, так и модель СОМ была разработана для решения проблемы «внедрения» электронной таблицы в текстовый редактор. Решение этой проблемы стало известно под именем OLE. Есть множество книг по OLE, но не по СОМ. Первая, лучшая и наиболее полная книга по OLE — книга Крейга Брокшмидта Inside OLE.

Когда Крейг писал эту книгу, у СОМ была только одна область применения, а именно OLE. Всякий, изучавший СОМ, на самом деле собирался изучать OLE. То, что две концепции смешивались, не имело значения. Это очень похоже на первые дни дифференциального исчисления. Вы не стали бы его осваивать, если бы не собирались заниматься физикой.

Теперь СОМ присутствует повсюду, и достаточно очевидно, что СОМ важнее OLE. На сегодняшний день у Microsoft есть множество СОМ интерфейсов и компонентов, которые не имеют отношения к OLE. Один из примеров — Direct3D, API Microsoft для программирования трехмерной графики. Когда Найджел Томпсон писал свой книгу 3D Graphics Programming for Windows 95, ему пришлось включить в нее главу, посвященную использованию СОМ. Это выглядит так, как если бы профессор физики давал пятнадцатиминутный обзор дифференциального исчисления, прежде чем погрузиться в свой предмет. В результате студенты не поймут физики, а будут слепо заучивать уравнения.

Задача этой книги — отделить СОМ от OLE и уделить первой то внимание, которого она заслуживает. Я вообще не собираюсь обсуждать в этой книге OLE. Я хочу рассмотреть базовые механизмы СОМ. После того, как Вы изучите эти механизмы, их можно будет применить к разработке компонентов OLE, DirectX и ActiveX, подобно тому как дифференциальное исчисление позволяет решать отнюдь не только проблемы физики.

Итак, если Вы хотите действительно понимать механизмы создания компонентов СОМ, то эта книга для Вас.

Полученные знания Вы сможете применить при создании компонентов ActiveX, OLE или своих собственных.

Будущее — это СОМ, и эта книга — Ваш ключ к будущему. (В худшем случае она поможет Вам более эффективно использовать множественное наследование в С++.) Техническая поддержка Мы приложили максимум усилий, чтобы эта книга и содержимое прилагаемого к ней диска были точными и правильными. Microsoft Press предоставляет исправления к своим книгам через World Wide Web по адресу:

http://www.microsoft.com/mspress/support/ Если у Вас есть комментарии, вопросы или идеи относительно этой книги или прилагаемого диска, посылайте их в Microsoft Press любым из описанных ниже способов:

По почте Microsoft Press Attn: Inside COM Editor One Microsoft Way Redmond, WA 98052- E-mail MSPINPUT@MICROSOFT.COM Пожалуйста, обратите внимание, что поддержка программных продуктов по данным адресам не оказывается.

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

Я рекомендую Web-узел Microsoft Developer Network (MSDN), который находится по адресу:

http://www.microsoft.com/MSDN/ Для того, чтобы воспользоваться всеми возможностями MSDN, подпишитесь на соответствующий сервис.

Информацию о подписке можно получить на указанном выше узле или по телефону (800) 759-5474.

Microsoft также предоставляет большой объем информации о поддержке программных продуктов (включая перечень известных проблем и исправление ошибок) по следующему адресу:

http://www.microsoft.com/support/ По вопросам, относящимся конкретно к СОМ, обращайтесь к персоналу Microsoft Win32 SDK Answer Point.

Звоните по телефону (800) 936-5800, Priority Developer line.

По вопросам, связанным с Microsoft Visual C++, обращайтесь по обычной линии поддержки по телефону (206) 635-7007 в рабочие дни с 6 утра до 6 вечера (Pacific time).

1 глава Компоненты Обычно приложение состоит из одного монолитного двоичного файла. После того, как приложение сгенерировано компилятором, он остается неизменным — пока не будет скомпилирована и поставлена пользователю новая версия. Чтобы учесть изменения в операционных системах, аппаратуре и желаниях пользователей, приходится ждать перекомпиляции. Приложение застывает, подобно скале посреди реки перемен.

И по мере того, как вся индустрия программирования стремительно уходит все дальше в будущее, оно стареет — и устаревает.

При современных темпах развития индустрии программирования приложениям нельзя оставаться застывшими.

Разработчики должны найти способ вдохнуть новую жизнь в программы, которые уже поставлены пользователям. Решение состоит в том, чтобы разбить монолитное приложение на отдельные части, или компоненты (рис. 1-1).

Монолитное приложение Компонентное приложение Компонент А Компонент C Компонент B Компонент D Компонент E Рис. 1-1 Разбиение монолитного приложения (слева) на компоненты (справа) облегчает адаптацию По мере развития технологии компоненты, составляющие приложение, могут заменяться новыми (рис. 1-2).

Приложение более не является статичным, обреченным устареть еще до выхода в свет. Вместо этого оно постепенно эволюционирует с заменой старых компонентов новыми. Из существующих компонентов легко создать и абсолютно новые приложения.

Традиционно приложение состояло из отдельных файлов, модулей или классов, которые компилировались и компоновались в единое целое. Разработка приложений из компонентов — так называемых приложений компонентной архитектуры — происходит совершенно иначе. Компонент подобен миниприложению;

он поставляется пользователю как двоичный код, скомпилированный и готовый к использованию. Единого целого больше нет. Его место занимают специализированные компоненты, которые подключаются во время выполнения к другим компонентам, формируя приложение. Модификация или расширение приложения сводится просто к замене одного из составляющих его компонентов новой версией.

Компонентное приложение Компонент А Компонент C Компонент B Новый, улучшенный компонент D Компонент E Рис. 1-2 Замена компонента D на новую, улучшенную версию Для того, чтобы разбить монолитное приложение на компоненты, необходим мощный инструмент. Инструмент, который мы будем использовать, называется СОМ. СОМ — модель компонентных объектов (Component Object Model) — это спецификация метода создания компонентов и построения из них приложений. Более четырех лет назад СОМ была разработана в Microsoft, чтобы сделать программный продукты фирмы более гибкими, динамичными и настраиваемыми. Практически все продаваемые сегодня приложения Microsoft используют СОМ. Технология ActiveX этой фирмы построена на основе компонентов СОМ.

Эта книга посвящена созданию компонентов СОМ с помощью С++. Изучая примеры программ, Вы увидите, как построить компоненты СОМ, которые объединяются в приложения, способные не только работать, но и с течением времени расти и развиваться.

Прежде чем перейти к подробному изучению СОМ, посмотрим, какие выгоды дает компонентная архитектура и что необходимо для создания приложений из компонентов.

Преимущества использования компонентов Мы уже упоминали одно из преимуществ компонентных архитектур — способность приложения эволюционировать с течением времени. Кроме удобства и гибкости при модернизации существующих приложений, создание программ из компонентов имеет другие достоинства. Они связаны с адаптацией приложений к нуждам пользователя, библиотеками компонентов и распределенными компонентами.

Адаптация приложений Пользователи часто хотят подстроить приложения к своим нуждам, точно так же, как мы подбираем домашнюю обстановку к своим вкусам. Конечные пользователи предпочитают, чтобы приложение работало так, как они привыкли. Программистам в корпорациях нужны адаптируемые приложения, чтобы создавать специализированные решения на основе готовых продуктов. Компонентные архитектуры хорошо приспособлены для адаптации, так как любой компонент можно заменить другим, более соответствующим потребностям пользователя.

Предположим, что у нас есть компоненты на основе редакторов vi и Emacs. Как видно из рис. 1-3, пользователь может настроить приложение на использование vi, тогда как пользователь 2 — предпочесть Emacs. Приложения можно легко настраивать, добавляя новые компоненты или заменяя имеющиеся.

Пользователь 1 Пользователь Компонент А vi Компонент А Emacs Компонент B Компонент D Компонент B Компонент D Компонент E Компонент E Рис. 1-3 Создание приложений из компонентов упрощает адаптацию.

Пользователь 1 предпочитает редактор vi, а пользователь 2 — Emacs.

Библиотеки компонентов Одна из самых многообещающих сторон внедрения компонентной архитектуры — быстрая разработка приложений. Если наши ожидания сбудутся, Вы сможете выбирать компоненты из библиотеки и составлять из них, как из деталей конструктора, цельные приложения (рис. 1-4).

Библиотека компонентов Новое приложение Компонент C Компонент А Компонент B Пользовательский компонент Рис. 1-4 Из компонентов создаются библиотеки, используя которые, можно быстро разрабатывать приложения Сборка приложений из стандартных блоков давно была заветной мечтой программистов. Этот процесс уже начался с созданием управляющих элементов ActiveX (ранее известных как управляющие элементы OLE).

Программисты на Visual Basic, C, C++ и Java могут воспользоваться управляющими элементами ActiveX для Компонент А Компонент B Компонент C Компонент D ускорения разработки своих приложений и страниц Web. Конечно, каждому приложению по-прежнему будут нужны и некоторые специализированные компоненты, но в основном можно будет обойтись стандартными.

Распределенные компоненты С возрастанием производительности и общего значения сетей потребность в приложениях, состоящих из разбросанных по разным местам кусков, будет только повышаться. Компонентная архитектура помогает упростить процесс разработки подобных распределенных приложений. Приложения клиент-сервер — это уже шаг в сторону компонентной архитектуры, поскольку они разделены на две части, клиентскую и серверную.

Создать из обычного приложения распределенное легче, если это обычное приложение состоит из компонентов.

Во-первых, оно уже разделено на функциональные части, которые могут располагаться вдали друг от друга. Во вторых, поскольку компоненты заменяемы, вместо некоторого компонента можно подставить другой, единственной задачей которого будет обеспечивать связь с удаленным компонентом. Например, на рис. 1- компонент C и компонент D расположены в сети на двух удаленных машинах. На локальной машине они заменяются двумя новыми компонентами, переадресовщиками C и D. Последние переправляют запросы от других компонентов к удаленным C и D по сети. Для приложения на локальной машине неважно, что настоящие компоненты C и D где-то в другом месте. Точно так же для самих удаленных компонентов не имеет значения их расположение. При наличии подходящих переадресующих компонентов приложение может совершенно игнорировать фактическое местоположение своих частей.

Компонентное приложение с удаленными компонентами Локальная машина Удаленная машина Компонент А Переадресовщик C Компонент C Сеть Компонент B Переадресовщик D Удаленная машина Компонент E Компонент D Рис. 1-5 Расположение компонентов на удаленных машинах в сети Теперь, когда мы познакомились с некоторыми достоинствами компонентов, посмотрим, что требуется для их создания. Затем мы остановимся на роли, которую в создании компонентов играет СОМ.

Требования к компонентам Преимущества использования компонентов непосредственно вытекают из способности последних подключаться к приложению и отключаться от него. Для этого компоненты должны удовлетворять двум требованиям. Во первых, они должны компоноваться динамически. Во-вторых, они должны скрывать (или инкапсулировать) детали своей реализации. Попытка определить, какое из этих требований важнее, приводит к дилемме курицы и яйца. Каждое из этих требований зависит от другого. Я склонен считать, что критически важна динамическая компоновка, а сокрытие информации есть ее необходимое условие. Давайте рассмотрим эти требования более подробно.

Динамическая компоновка Наша конечная цель — предоставить пользователю возможность заменять компоненты во время работы приложения. Хотя эта возможность не всегда реализуется, хотелось бы иметь для нее поддержку. Поддержка замены компонента во время выполнения требует динамической компоновки.

Чтобы понять, как это важно, лучше всего представить себе приложение, построенное из компонентов, которые не могут объединяться во время выполнения. Если Вы захотите изменить один из компонентов такой системы, Вам придется статически перекомпоновать или перекомпилировать программу и заново разослать ее пользователям. В конце концов, нельзя требовать от конечных пользователей, чтобы они перекомпилировали приложение самостоятельно. Даже если они знают, как это сделать, у них скорее всего нет компоновщика — либо вообще, либо конкретного, необходимого. Приложение, собранное из компонентов, которые надо статически перекомпоновывать каждый раз при замене одного из них, эквивалентно приложению-монолиту.

Инкапсуляция Теперь давайте разберемся, почему динамическая компоновка требует инкапсуляции. Чтобы сформировать приложение, компоненты подключаются друг к другу. Если Вы хотите заменить один из компонентов, надо отключить от системы старый и подсоединить новый. Новый компонент должен подсоединяться тем же способом, что и старый, иначе компоненты придется переписывать, перекомпилировать и перекомпоновывать.

Неважно, поддерживают ли компоненты и приложение динамическую компоновку, Вы разрушаете всю систему и должны перекомпилировать, если не переписывать, все заново.

Чтобы понять, как это связано с инкапсуляцией, нам необходимо определить некоторые термины. Программа или компонент, использующие другой компонент, называется клиентом (client). Клиент подсоединяется к компоненту через интерфейс (interface). Если компонент изменяется без изменения интерфейса, то изменений в клиенте не потребуется. Аналогично, если клиент изменяется без изменения интерфейса, то нет необходимости изменять компонент. Однако если изменение либо клиента, либо компонента вызывает изменение интерфейса, то и другую сторону интерфейса также необходимо изменить.

Таким образом, для того, чтобы воспользоваться преимуществами динамической компоновки, компоненты и клиенты должны стараться не изменять свои интерфейсы. Они должны быть инкапсулирующими. Детали реализации клиента и компонента не должны отражаться в интерфейсе. Чем надежнее интерфейс изолирован от реализации, тем менее вероятно, что он изменится при модификации клиента и компонента. Если интерфейс не изменяется, то изменение компонента оказывает лишь незначительное влияние на приложение в целом.

Необходимость изоляции клиента от деталей реализации накладывает на компоненты ряд важных ограничений.

Ниже приведен список этих ограничений:

1. Компонент должен скрывать используемый язык программирования. Любой клиент должен иметь возможность использовать компонент, независимо от языков программирования, на которых написаны тот или другой. Раскрытие языка реализации создает новые зависимости между клиентом и компонентом.

2. Компоненты должны распространяться в двоичной форме. Действительно, поскольку они должны скрывать язык реализации, их необходимо поставлять уже скомпилированными, скомпонованными и готовыми к использованию.

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

4. Должна быть возможность прозрачно перемещать компоненты в сети. Необходимо, чтобы компонент и использующая его программа могли выполняться внутри одного процесса, в разных процессах или на разных машинах. Клиент должен рассматривать удаленный компонент так же как и локальный. Если бы с удаленными компонентами надо было работать иначе, чем с локальными, то потребовалось бы перекомпилировать клиент всякий раз, когда локальный компонент перемещается в другое место сети.

Давайте рассмотрим некоторые из этих пунктов подробнее.

Независимость от языка Многие не считают нужным требовать от компонентов независимости от языка программирования, как это сделано выше. Для обоснования своей позиции предположим, что у нас есть приложение, которое можно настраивать и перестраивать только при помощи компонентов, написанных на Objective C. Желающих писать для нас компоненты найдется немного, так как большинство программистов пользуются С++. Через некоторое время мы поймем, что никто не собирается писать для нашего приложения компоненты, и зададим в качестве рабочего языка С++. В результате у приложения появится значительно больше компонентов. Однако тут родится мода на новый язык, скажем, EspressoBeans, и все перейдут на него, оставляя компиляторы С++ пылиться без дела. Чтобы не сойти с дистанции, мы тоже потребуем писать компоненты на EspressoBeans. Итак, в этому моменту у нас уже будет три совершенно разных варианта создания компонентов для нашего приложения. Тут мы как раз и разоримся. Оказывается, в нашем сегменте рынка доминирует Visual Basic. Наш конкурент предоставил своим клиентам возможность писать компоненты на любом языке, включая Visual Basic, и по-прежнему процветает.

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

Версии Пользователь может иметь два клиентских приложения, использующих один и тот же компонент. Предположим, что одно приложение применяет новую версию этого компонента, а другое — старую. Установка новой версии не должна нарушить работу приложения, которое использовало старую версию. На рис. 1-6 старое приложение использует новый компонент vi абсолютно так же, как это делает новое.

Однако обратная совместимость не должна ограничивать развитие компонентов. Нужно, чтобы поведение компонента для новых приложений можно было радикально изменять, не нарушая поддержку старых приложений.

Старое приложение Новое приложение Старый А Новый vi Новый А Новый vi Старый B Старый D Новый B Новый D Старый E Новый E Рис. 1-6 От новых компонентов требуется не нарушать работу старых и улучшать работу новых версий других компонентов Теперь посмотрим, как СОМ согласуется с этими требованиями.

COM COM — это спецификация. Она указывает, как создавать динамически взаимозаменяемые компоненты. СОМ определяет стандарт, которому должны следовать компоненты и клиенты, чтобы гарантировать возможность совместной работы. Стандарты важны для компонентных архитектур так же, как и для любой системы с взаимозаменяемыми частями. Если бы не было стандарта на видеокассеты VHS, то найти подходящую ленту к Вашему видеомагнитофону было бы редкой удачей. Стандарты определяют диаметры резьбы для садовых шлангов и водопроводных кранов, на которые шланги надевают. Стандартам следуют платы PCMCIA и разъемы под них. Сигнал, принимаемый телевизором или радиоприемником, подчиняется стандарту. Стандарты особенно важны, когда разные части системы разрабатывают разные люди из разных организаций в разных странах. Без стандартов ничто не могло бы работать вместе. И у Microsoft есть внутренние стандарты, которым мы следуем при программировании (по крайней мере, большей частью).

Спецификация СОМ (COM Specification) — это документ, который устанавливает стандарт для нашей компонентной архитектуры. Компоненты, которые мы будем разрабатывать в этой книге, следуют данному стандарту. Спецификация СОМ содержится на сайте Microsoft. Однако Вы, вероятно, уже хотите точно знать, что же такое компоненты СОМ.

Компоненты СОМ — это… Компоненты СОМ состоят из исполняемого кода, распространяемого в виде динамически компонуемых библиотек (DLL) или EXE-файлов Win32. Компоненты, написанные в соответствии со стандартом СОМ, удовлетворяют всем требованиям компонентной архитектуры.

Компоненты СОМ подключаются друг к другу динамически. Для этой цели СОМ использует DLL. Но, как мы видели, сама по себе динамическая компоновка не обеспечивает компонентной архитектуры. Компоненты должны быть инкапсулированы.

Инкапсуляция в компонентах СОМ достигается легко, поскольку они удовлетворяют нашим ограничениям:

Компоненты СОМ полностью независимы от языка программирования. Они могут быть разработаны с помощью практически любого процедурного языка, включая Ada, C, Java, Modula-3, Oberon и Pascal.

Любой язык, в том числе Smalltalk и Visual Basic, можно приспособить к использованию компонентов СОМ. Можно даже написать компоненты СОМ, используемые из языков макрокоманд.

Компоненты СОМ могут распространяться в двоичной форме.

Компоненты СОМ можно модернизировать, не нарушая работы старых клиентов. Как мы увидим в гл. 3, СОМ предоставляет стандартный способ реализации разных версий компонента.

Компоненты СОМ можно прозрачно перемещать по сети. Компонент на удаленной система рассматривается так же, как компонент на локальном компьютере.

Компоненты СОМ объявляют о своем присутствии стандартным способом. Используя схему объявлений СОМ, клиенты могут динамически находить нужные им компоненты.

Компоненты СОМ — отличный способ предоставления объектно-ориентированных API или сервисов другим приложениям. Они прекрасно подходят и для создания библиотек, не зависящих от языка программирования компонентов, из которых можно быстро строить новые приложения.

Про многие вещи можно сказать «это — СОМ», но есть и много вещей, которые к СОМ не относятся, хотя их часто путают.

СОМ — это не… СОМ — это не язык программирования. СОМ — не конкурент языкам программирования. Спор о том, что лучше — С++ или СОМ не имеет смысла;

у них разное назначение. СОМ указывает нам, как писать компоненты.

При этом мы свободны в выборе языка. В данной книге для разработки компонентов используется исключительно С++.

СОМ не является также конкурентом или заменой DLL. СОМ использует их для динамического объединения компонентов. Однако, по моему мнению, СОМ дает наилучший способ использовать возможности DLL. Любая проблема, которую можно решить при помощи DLL, лучше решается с компонентами СОМ. Я бы вообще не использовал DLL иначе как для поддержки компонентов СОМ. Это показывает, как эффективно СОМ использует DLL.

СОМ, по своей сути, — это не API или набор функций, подобный API Win32. СОМ не предоставляет таких сервисов, как MoveWindow и т.п. (Тем не менее, СОМ предоставляет некоторые сервисы управления компонентами, которые описаны ниже.) Напротив, СОМ — это способ создания компонентов, которые могут предоставлять сервисы через объектно-ориентированные API. COM — и не библиотека классов С++, подобная MFC. COM обеспечивает способ разработки библиотек компонентов, независимых от языка программирования, но не занимается собственно разработкой.

Библиотека СОМ СОМ — это больше, чем просто спецификация: в состав СОМ входит и некоторое количество кода. В СОМ есть API;

это библиотека СОМ, предоставляющая сервисы управления компонентами, которые полезны всем клиентам и компонентам. Большинство функций этого API несложно реализовать самостоятельно, если Вы разрабатываете компоненты в стиле СОМ не для Windows. Библиотека СОМ создана, чтобы гарантировать единообразное выполнение всеми компонентами наиболее важных операций. Она экономит время разработчикам, создающим собственные компоненты и клиенты. Большая часть кода в библиотеке СОМ служит для поддержки распределенных или сетевых компонентов. Реализация распределенной СОМ (Distributed COM, DCOM) в системах Windows предоставляет код, необходимый для обмена информацией с компонентами по сети.

Это избавляет Вас не только от необходимости писать такой код, но и от необходимости знать, как это делать.

Стиль СОМ Мне больше всего нравится трактовка СОМ как стиля программирования. Этот стиль можно использовать в рамках любой операционной системы и, как я уже говорил, любого языка программирования. Для этого Вам не нужен никакой Windows-специфичный код СОМ. Примеры в первых восьми главах этой книги легко модифицировать так, чтобы вообще не использовать код Windows. СОМ — это воплощение концепций компонентного программирования. Подобно структурному или объектно-ориентированному программированию, СОМ — это способ организации программ. Концепции правильного проектирования программ входят в спецификацию СОМ как составная часть.

СОМ дает больше, чем необходимо СОМ удовлетворяет всем требованиям к компонентной архитектуре, которые обсуждались ранее. СОМ использует DLL для поддержки компонентов, которые могут взаимозаменяться во время выполнения. СОМ гарантирует, что такие компоненты могут воспользоваться всеми преимуществами динамической компоновки, посредством:

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

практически прозрачной поддержки нескольких версий компонента;

обеспечения возможности работы со сходными компонентами одинаковым способом;

определения архитектуры, независимой от языка;

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

СОМ обеспечивает строгое отделение клиента от компонента. Именно в этой строгой изоляции заключена сила СОМ.

Теперь те, кому это интересно, могут познакомиться с историей СОМ.

Краткая история мира СОМ СОМ разрабатывалась для того, чтобы сделать приложения более настраиваемыми и гибкими.

Первоначальной целью была поддержка концепции, известной как связывание и внедрение объектов (object linking and embedding). Идея заключалась в том, чтобы обеспечить документоориентированное представление мира, когда, например, Вы можете редактировать электронную таблицу из текстового процессора. Реализация связывания и внедрения объектов, созданная в Microsoft, получила название OLE. Первая версия OLE для связи между клиентом и компонентом использовала аппарат, известный как динамический обмен данными (dynamic data exchange — DDE). В OLE 1 не было СОМ. DDE был построен на основе архитектуры передачи сообщений Windows. Самое лучшее, что я могу сказать об OLE 1, — этот инструмент работает, точнее, более или менее работает. DDE медлителен. Написать корректно работающий код DDE сложно. Вдобавок, DDE не слишком надежен и гибок. Излишне говорить, что требовалось изобрести что-нибудь получше.

Решением стала СОМ. СОМ меньше, быстрее, гибче, надежнее DDE. Вторая версия OLE была переписана с использованием СОМ вместо DDE. СОМ стала новым фундаментом, на котором выстроены конструкции OLE. Однако OLE — первая система на основе СОМ, и уже поэтому она не дает лучший пример использования возможностей СОМ. У OLE репутация сложного, медленного и трудного для программирования аппарата. Это недостатки реализации, а не СОМ.

Напомню еще раз, OLE — это первая попытка сделать то, чего раньше никто не делал. С помощью OLE можно поместить картинку, созданную графическим редактором одного производителя, в текстовый редактор другого и модифицировать прямо там.

Создатели OLE старались реализовать все возможности без каких-либо ограничений. Вместо того, чтобы вынуждать клиента и компонент установить ограниченную связь, OLE определяет избыточную связь.

Компонент может делать практически все, что угодно, а клиент должен быть к этому готов. Это делает OLE очень трудным для программирования.

Скоро появятся новые продукты Microsoft на основе СОМ, и некоторые из них просто изумительны.

Несомненно, другие разработчики тоже пишут компоненты СОМ. СОМ ждет блестящее будущее!

Заключительные замечания о компонентах Технология производства программного обеспечения развивается слишком быстро, чтобы позволить Вашему приложению год или два ждать модернизации. Эту проблему решает разделение приложения на отдельные маленькие приложения, или компоненты, которые объединяются в единое целое во время выполнения.

Компоненты можно модернизировать независимо друг от друга, что позволяет приложению эволюционировать с течением времени.

СОМ определяет стандартный способ написания компонентов. Компоненты, написанные в соответствии со стандартом СОМ, можно объединять в приложение. При этом не имеет значения, кем они написаны и как реализованы. Компонент СОМ можно использовать вместе с другими компонентами. Ключевой момент в обеспечении взаимозаменяемости компонентов — инкапсуляция. СОМ обеспечивает ее, уделяя основное внимание соединению, или интерфейсу между компонентом и клиентом. В следующей главе мы увидим, почему для компонентов так важны интерфейсы. Мы также посмотрим, как реализуется интерфейс СОМ.

2 глава Интерфейс Несколько лет назад «космический челнок» «Атлантис» состыковался с российской орбитальной станцией «Мир». Американцы установили на свой корабль российский стыковочный узел, подходящий к соответствующему узлу станции. Только представьте, что Вы могли бы сделать с таким стыковочным узлом! Его можно установить на Вашем доме, и туда мог бы пристыковаться космический корабль. Вы могли бы установить этот узел на старый «Фольксваген», на башню «Космическая игла» в Сиэтле или на свой гараж — и «челнок» мог бы стыковаться и с ними. Пока узел не изменился и пока установлен на корабле, космический аппарат может стыковаться с чем угодно. Имея два узла, Вы могли бы пристыковать свой «Фольксваген» к дому, а не ставить его в гараж. Не правда ли, забавно!

Стыковочный узел — это пример интерфейса (interface). Интерфейс обеспечивает соединение двух разных объектов. Хотя стыковочные узлы отлично соединяют друг с другом космические корабли, они не слишком годятся для соединения частей компьютерной программы. Для стыковки в компьютерных программах применяются наборы функций. Именно такие наборы и определяют интерфейс между разными частями программы.

Интерфейс DLL — это набор функций, экспортируемых ею. Интерфейс класса С++ — это набор членов данного класса. Однако когда в этой книге я употребляю слово интерфейс, имеется в виду интерфейс СОМ, а не все прочие. Интерфейс СОМ также включает в себя набор функций, которые реализуются компонентами и используются клиентами. Но СОМ дает более точное определение интерфейса. В СОМ интерфейсом является определенная структура в памяти, содержащая массив указателей на функции. Каждый элемент массива содержит адрес функции, реализуемой компонентом. С точки зрения СОМ интерфейсом является упомянутая структура в памяти;

все остальное — это детали реализации, которые СОМ не касаются. Мы остановимся на этой структуре в конце главы, после того как посмотрим на ее реализацию с помощью С++.

На С++ интерфейс реализуется с помощью абстрактных классов. Поскольку каждый компонент СОМ может поддерживать сколь угодно много интерфейсов, для реализации компонента с несколькими интерфейсами мы будем использовать множественное наследование абстрактных базовых классов. Техники мы коснемся ниже, в первом примере.

Давайте более подробно рассмотрим роль интерфейсов в СОМ. Затем реализуем один интерфейс. После этого внимательно присмотримся к некоторым интересным деталям интерфейсов. И, наконец, разберем структуру блока памяти, соответствующего интерфейсу в смысле СОМ.

Интерфейсы — это все В СОМ интерфейсы — это все. Для клиента компонент представляет собой набор интерфейсов. Клиент может взаимодействовать с компонентом СОМ только через интерфейс. Как мы увидим далее, клиент очень мало знает о компоненте в целом. Часто ему даже не известны все интерфейсы, которые тот поддерживает.

На рисунках в гл. 1 были представлены приложения, построенные из компонентов (эти рисунки напоминают левую часть рис. 2-1). Они могут ввести Вас в заблуждение, так как подчеркивают важность компонентов и не обращают внимания на интерфейсы. С точки зрения программиста СОМ, интерфейсы — важная часть любого приложения. Компоненты сами по себе есть просто детали реализации интерфейсов. Правая часть рис. 2-1 более точно отражает значение интерфейсов для программ СОМ.

Повторное использование архитектур приложений Утверждение, что компонент — всего лишь деталь реализации интерфейса, конечно, преувеличение. В конце концов, интерфейс без реализации ничего не сделает. Однако компонент можно удалить и заменить другим;

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

Отдельные компоненты сами по себе не определяют приложения. Приложение определяют интерфейсы между компонентами. Пока интерфейсы неизменны, компоненты могут появляться и исчезать.

Компоненты Интерфейсы Компонент A Компонент C A C Компонент B Компонент D Компонент E Интерфейс A-B Интерфейс C-D B D Интерфейс B-E Интерфейс D-E E Рис. 2-1 В СОМ интерфейсы значат больше, чем реализующие их компоненты Интерфейсы очень похожи на элементы каркаса сборного дома. Каркас задает структуру, без которой крыша и стены не защитят от стихии. Если Вы не трогаете каркас, дом остается структурно тем же самым. Если заменить кирпичные стены на деревянные, изменится внешний вид, но не структура. Аналогично этому, замена компонентов может изменить поведение приложения, но не его архитектуру. Одно из самых больших преимуществ компонентной модели — возможность повторного использования архитектуры приложения. При помощи тщательно разработанных интерфейсов можно создать архитектуры с очень высокой степенью пригодности к повторному использованию. Просто разрешив заменять некоторые ключевые компоненты, мы добиваемся того, что одна и та же архитектура может поддерживать несколько различных приложений.

Однако построение повторно используемой архитектуры — непростая задача. В некотором смысле для этого надо уметь предсказывать будущее, что вряд ли многим по силам. Тем не менее, есть и другие причины для использования интерфейсов.

Другие преимущества интерфейсов СОМ Сценарий, написанный в начале этой главы, иллюстрирует две причины, по которым стоит использовать интерфейсы. Во-первых, они позволяют Вам подсоединить космический корабль к «Фольксвагену». Нет, шутки в сторону… Во-первых, интерфейсы предохраняют систему от повреждений при модификации. До тех пор, пока применяются одни и те же стыковочные узлы, и космический корабль, и орбитальная станция могут изменяться.

Во-вторых, интерфейсы позволяют клиенту работать с разными компонентами единообразно. Эта способность к унифицированной работе с разными компонентами известна как полиморфизм (polymorphism). Космический «челнок» работает с каждым объектом, имеющим стыковочный узел, так, будто это орбитальная станция. Ниже мы обсудим полиморфизм подробнее.

Интерфейс обеспечивает описанные выше преимущества путем инкапсуляции определенного поведения.

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

Поскольку корабль стыкуется с другим стыковочным узлом, постольку станцию можно заменить на очень большую вафельницу, что не повлияет на «челнок» — по крайней мере, в смысле стыковки.

Теперь, когда мы слегка затронули теорию интерфейсов, пора отставить ее в сторону и приложить руки к созданию какого-нибудь интерфейса. В конце этой главы мы погрузимся в теорию с головой.

Реализация интерфейса СОМ Теперь рассмотрим код, реализующий простой интерфейс. В приведенном ниже тексте программы компонент CA использует IX и IY для реализации двух интерфейсов.

class IX // Первый интерфейс { public:

virtual void Fx1() = 0;

virtual void Fx2() = 0;

};

class IY // Второй интерфейс { Интерфейс B-D Интерфейс A-C public:

virtual void Fy1() = 0;

virtual void Fy2() = 0;

};

class CA : public IX, public IY // Компонент { public:

// Реализация абстрактного базового класса IX virtual void Fx1() { cout << “Fx1” << endl;

} virtual void Fx2() { cout << “Fx2” << endl;

} // Реализация абстрактного базового класса IY virtual void Fy1() { cout << “Fy1” << endl;

} virtual void Fy2() { cout << “Fy2” << endl;

} };

IX и IY — это чисто абстрактные базовые классы, которые используются для реализации интерфейсов. Чисто абстрактный базовый класс (pure

Abstract

base class) — это базовый класс, который содержит только чисто виртуальные функции (pure virtual functions). Чисто виртуальная функция — это виртуальная функция, «помеченная =0 — знаком спецификатора чистоты (pure specifier). Чисто виртуальные функции не реализуются в классах, в которых объявлены. Как видно из приведенного выше примера, функции IX::Fx1, IX::Fx2, IY::Fy1 и IY::Fy2 только декларируются. Реализуются же они в производном классе. В приведенном фрагменте кода компонент CA наследует два чисто абстрактных базовых класса — IX и IY — и реализует их чисто виртуальные функции.

Для того, чтобы реализовать функции-члены IX и IY, CA использует множественное наследование. Последнее означает, что класс является производным более чем от одного базового класса. Класс С++ чаще всего использует единичное наследование, т.е. имеет только один базовый класс. Далее в этой главе мы более подробно поговорим о множественных интерфейсах и множественном наследовании.

Абстрактный базовый класс напоминает канцелярский бланк, а производный класс заполняет этот бланк.

Абстрактный базовый класс определяет функции, которые будет предоставлять производный класс, а производные классы реализуют их. Открытое (public) наследование от чисто абстрактного базового класса называется наследованием интерфейса (interface inheritance), так как производный класс наследует лишь описания функций. Абстрактный базовый класс не содержит никакой реализации, которую можно было бы унаследовать.

В этой книге все интерфейсы будут реализованы при помощи чисто абстрактных базовых классов. Поскольку СОМ не зависит от языка программирования, имеется двоичный стандарт того, что в этой модели считается интерфейсом. В последнем разделе данной главы — «Что за интерфейсом» — представлена эта структура. По счастью, многие компиляторы С++ автоматически генерируют в памяти верную структуру, если использовать чисто абстрактные базовые классы.

IX и IY не совсем интерфейсы в смысле СОМ. Чтобы стать настоящими интерфейсами, IX и IY должны наследовать специальный интерфейс IUnknown. Однако IUnknown — это предмет следующей главы, поэтому я не буду обсуждать его сейчас. До конца данной главы мы будем считать, что IX и IY — это интерфейсы СОМ.

Соглашения о кодировании В своих программах я использую некоторые соглашения, чтобы отличать интерфейсы от других классов. Все имена интерфейсов начинаются с буквы «I». Так, «IX» следует читать «интерфейс X». Имена классов имеют префикс «C», и «CA» читается как «класс A».

Другое соглашение состоит в том, что вместо определения интерфейса как класса я использую следующее определение из заголовочного файла OBJBASE.H Microsoft Win32 Software Development Kit (SDK):

#define interface struct Определение использует ключевое слово struct, а не class, поскольку члены структуры автоматически объявляются имеющими общий доступ, так что не требуется ключевое слово public. Это меньше загромождает код. Ниже повторно приводятся примеры интерфейсов, записанные теперь в рамках новых соглашений.

#include interface IX { virtual void stdcall Fx1() = 0;

virtual void stdcall Fx2() = 0;

};

interface IY { virtual void stdcall Fy1() = 0;

virtual void stdcall Fy2() = 0;

} Чтобы показать интерфейс на картинке, я использую прямоугольник с «разъемом для подключения» на одной из сторон. Пример дан на рис. 2-2.

Компонент IX IY Рис. 2-2 Компонент с двумя интерфейсами На такой основе мы и будем рассматривать и реализовывать интерфейсы СОМ на С++. Согласитесь, что это не сложнее обычной азбуки (A, B, C++, …).

Законченный пример Давайте рассмотрим несложную, но законченную реализацию интерфейсов IX и IY. Для реализации компонентов мы используем простую программу на С++ без динамической компоновки. Динамическую компоновку мы добавим в гл. 5, а пока гораздо проще обойтись без нее. В листинге 2-1 класс CA реализует компонент, который поддерживает интерфейсы IX и IY. В качестве клиента в этом примере выступает процедура main.

Копия приведенного в книге кода содержится в файле IFACE.CPP на прилагаемом к книге диске. Чтобы скомпилировать его с помощью Microsoft Visual C++, введите команду cl iface.cpp Соглашение о вызове stdcall (или Pascal) Возможно, Вы заметили в приведенном выше примере ключевое слово stdcall. Это расширение языка, специфичное для компилятора Microsoft. (Вряд ли Вы сомневались, что какое-то расширение должно присутствовать.) Любой компилятор, поддерживающий разработку для Win32, поддерживает и это ключевое слово или его синоним. Это верно для компиляторов Borland, Symantec и Watcom. Функция, помеченная как stdcall, использует соглашение о вызове языка Pascal. Такая функция выбирает параметры из стека перед возвратом в вызывающую процедуру. В соответствии же с обычным соглашением о вызове С/С++ стек очищает вызывающая процедура, а не вызываемая. В большинстве других языков, в том числе в Visual Basic, по умолчанию используется это же стандартное соглашение о вызове. Название «стандартное» применяется потому, что оно используется для всех функций Win32 API, за исключением имеющих переменное число аргументов. Для функций с переменным числом аргументов по-прежнему используется соглашение языка С, или cdecl. Стандартное соглашение о вызовах применяется в Windows потому, что уменьшает размер кода, а первые версии Windows должны были работать на системах с 640 КБ памяти.* Практически для всех функций, предоставляемых интерфейсами СОМ на платформах Microsoft, используется стандартное соглашение о вызовах. Только для функций с переменным числом аргументов применяется соглашение о вызовах С. Предполагается, что и Вы будете следовать этим правилам. Однако это требование не абсолютно. Вы можете использовать и другие соглашения о вызове, но должны их ясно документировать и учитывать, что клиенты, написанные на некоторых языках, могут оказаться не в состоянии использовать Ваши интерфейсы.

Если Вы предпочитаете слово, которое легче запомнить, используйте pascal. Оно определено в WINDEF.H как #define pascal stdcall Если же Вы полагаете, что наличие в Вашем коде слова pascal сделает Вас жалким Pascal’истом, можете воспользоваться следующим определением из OBJBASE.H:

#define STDMETHODCALLTYPE stdcall * В языке Pascal параметры передаются в вызываемую процедуру слева на право (сначала первый, потом второй и т.д.), а в языке С — наоборот, справа налево (сначала последний, потом предпоследний и т.д.). Стандартное соглашение о вызове является компромиссом:

порядок передачи параметров взят из С, а порядок очистки стека — из Pascal. Прим. ред.

IFACE.CPP // // Iface.cpp // Копиляция: cl Iface.cpp // #include #include // Определить интерфейс void trace(const char* pMsg) { cout << pMsg << endl;

} // Абстрактные интерфейсы interface IX { virtual void stdcall Fx1() = 0;

virtual void stdcall Fx2() = 0;

};

interface IY { virtual void stdcall Fy1() = 0;

virtual void stdcall Fy2() = 0;

};

// Реализация интерфейса class CA : public IX, public IY { public:

// Реализация интерфейса IX virtual void stdcall Fx1() { cout << "CA::Fx1" << endl;

} virtual void stdcall Fx2() { cout << "CA::Fx2" << endl;

} // Реализация интерфейса IY virtual void stdcall Fy1() { cout << "CA::Fy1" << endl;

} virtual void stdcall Fy2() { cout << "CA::Fy2" << endl;

} };

// Клиент int main() { trace("Клиент: Создание экземпляра компонента");

CA* pA = new CA;

// Получить указатель IX IX* pIX = pA;

trace("Клиент: Использование интерфейса IX");

pIX->Fx1();

pIX->Fx2();

// Получить указатель IY IY* pIY = pA;

trace("Клиент: Использование интерфейса IY");

pIY->Fy1();

pIY->Fy2();

trace("Клиент: Удаление компонента");

delete pA;

return 0;

} Листинг 2-1 Полный пример использования интерфейсов Результаты работы этой программы таковы:

Клиент: Создание экземпляра компонента Клиент: Использование интерфейса IX CA::Fx CA::Fx Клиент: Использование интерфейса IY CA::Fy CA::Fy Клиент: Удаление компонента Как видно из текста, клиент и компонент взаимодействуют через два интерфейса. Последние реализованы с помощью двух чисто абстрактных базовых классов IX и IY. Компонент реализуется классом CA, который наследует как IX, так и IY. Класс CA реализует функции-члены обоих интерфейсов.

Клиент создает экземпляр компонента. Далее он получает указатели на интерфейсы, поддерживаемые компонентом. Потом клиент использует эти указатели совершенно аналогично указателям на классы С++, поскольку интерфейсы реализованы как чисто абстрактные базовые классы. Ключевыми в этом примере являются следующие моменты:

Интерфейсы СОМ реализуются как чисто абстрактные базовые классы С++ Один компонент СОМ может поддерживать несколько интерфейсов Класс С++ может использовать множественное наследование для реализации компонента, поддерживающего несколько интерфейсов.

В этом примере я оставил в инкапсуляции некоторые «прорехи», которые мы заделаем в нескольких последующих главах. Но мне хотелось бы обсудить кое-какие проблемы сразу, поскольку они очевидны из листинга 2-1.

Взаимодействие в обход интерфейсов Помните, как я говорил, что клиент и компонент взаимодействуют только через интерфейс? Клиент из листинга 2-1 не следует этому правилу. Он взаимодействует с компонентом посредством pA — указателя на класс CA, а не на интерфейс. Это может показаться несущественным, но на самом деле очень важно. Использование указателя на CA требует, чтобы клиент знал, как объявлен (обычно в заголовочном файле) класс CA. Объявление класса содержит множестве деталей реализации. Изменение этих деталей потребует перекомпиляции клиента.

Компоненты (как я уже говорил) должны уметь добавлять и удалять интерфейсы без нарушения работы старых клиентов. Это одна из причин, по которым мы настаиваем, что клиент и компонент должны взаимодействовать только через интерфейсы. Вспомните, что интерфейсы основаны на чисто абстрактных базовых классах, с которыми не связана какая-либо реализация.

Конечно, не обязательно изолировать клиент от компонента, если они находятся в одном файле. Однако подобная изоляция необходима, если клиент и компонент подключаются друг к другу динамически, особенно когда у Вас нет исходных текстов. В гл. 3 мы исправим наш пример так, чтобы в нем не использовался указатель на CA.

Клиенту более не потребуется знать как объявлен класс CA.

Использование указателя на CA — не единственное место, где клиент из предыдущего примера в обход интерфейса взаимодействует с компонентом. Для управления существованием компонента клиент применяет операторы new и delete. Эти операторы не только не входят ни в один из интерфейсов, но и специфичны для языка С++. В гл. 4 мы рассмотрим, как удалить компонент через интерфейс без помощи специфичного для языка оператора. В гл. 6 и 7 мы рассмотрим гораздо более мощный способ создания компонентов.

Теперь давайте обсудим некоторые более тонкие детали реализации клиента и компонента из предыдущего примера.

Детали реализации Листинг 2-1 — это стандартная программа на С++. В ней нет ничего необычного, за исключением того, что она стала нашим первым шагом в создании компонента и клиента СОМ. Очень легко спутать требования СОМ к компоненту и конкретный способ реализации. В этом разделе я проясню некоторые места, где часто возникает путаница.

Класс — это не компонент В листинге 2-1 класс CA реализует один компонент. СОМ не требует, чтобы один класс С++ соответствовал одному компоненту. Вы можете реализовать один компонент при помощи нескольких классов. На самом деле компонент можно реализовать вообще без классов. Классы С++ не используются при реализации компонентов СОМ на С, а потому они не обязательно должны использоваться и на С++. Просто компоненты СОМ гораздо легче реализовать через классы, чем строить вручную.

Интерфейсы не всегда наследуются Класс CA наследует поддерживаемые им интерфейсы. СОМ не требует, чтобы класс, реализующий интерфейсы, наследовал их, поскольку клиент никогда не видит иерархию наследования в компоненте СОМ. Наследование интерфейсов — это в чистом виде деталь реализации. Вместо того, чтобы собирать все интерфейсы в одном классе, Вы можете реализовать их отдельно и использовать указатели на соответствующие классы. Крейг Брокшмидт использует такой метод в своей книге Inside OLE. Мы будем использовать для реализации всех интерфейсов один класс, поскольку этот метод проще и легче для восприятия;

он также делает программирование для СОМ на С++ более естественным.

Множественные интерфейсы и множественное наследование Компоненты могут поддерживать сколь угодно много интерфейсов. Для поддержки нескольких интерфейсов мы используем множественное наследование. В листинге 2-1 CA является производным от двух интерфейсов IX и IY, которые он поддерживает. Благодаря поддержке множественных интерфейсов компонент можно рассматривать как набор интерфейсов.

Это определяет рекурсивно-вложенную природу компонентной архитектуры (см. рис. 2-3). Интерфейс — это набор функций, компонент — набор интерфейсов, а система — набор компонентов. Некоторые считают интерфейсы эквивалентами функциональных возможностей и при добавлении к компоненту новых интерфейсов говорят о появлении новых возможностей. Я же предпочитаю рассматривать интерфейсы как различные варианты поведения компонента. Набор интерфейсов соответствует набору таких вариантов.

Компонент n Компонент 1 Компонент Fx Fx1 Fx Fx Fx2 Fx IX IX1 IX...

......

Fxn Fxn Fxn Fx Fx1 Fx Fx Fx2 Fx IX IX2 IX2...

...

......

Fxn Fxn Fxn...

......

Fx Fx1 Fx Fx Fx2 Fx IXn IXn IXn...

......

Fxn Fxn Fxn Рис. 2-3 Система компонентов — это набор компонентов, из которых каждый поддерживает набор интерфейсов, из которых каждый содержит набор функций Конфликт имен Поскольку компонент может поддерживать несколько интерфейсов, легко возникает конфликт имен функций этих интерфейсов. Действительно, СОМ нет до этого дела. Интерфейсы СОМ отвечают двоичному стандарту;

клиент подключается к интерфейсу не по имени самого интерфейса или его функций. Клиент обращается к функции интерфейса по ее адресу в блоке памяти, представляющем интерфейс. Структура этого блока памяти будет рассмотрена в конце данной главы. Техника изменения имен интерфейсов и функций обсуждается в гл. 8.

Другое решение проблемы конфликта имен — отказ от множественного наследования. Классу, управляющему компонентом, нет необходимости наследовать каждый интерфейс;

он может содержать указатели на другие классы, которые реализуют отдельные интерфейсы.

Конфликт имен интерфейсов встречался бы реже, если бы все разработчики СОМ следовали простому соглашению. Начинайте имена интерфейсов и функций с названия Вашей фирмы или программного продукта.

Например, вместо IFly для продукта Xyz можно было бы использовать IXyzFly.

Теперь, став экспертами в реализации интерфейсов, снова погрузимся в теорию.

Теория интерфейсов, часть II Перед реализацией интерфейсов я обещал, что позже дам некоторые дополнительные сведения из теории. Я Вас не обманывал. В этом разделе мы рассмотрим три вопроса: неизменность интерфейсов СОМ, полиморфизм и наследование интерфейсов.

Интерфейсы не изменяются Хотя из листинга 2-1 это не очевидно, интерфейсы нельзя изменять, причем нельзя изменять никогда. Это один из наиболее шокирующих моментов СОМ. После того, как интерфейс опубликован, он обязан быть всегда тем же самым. При модификации компонента следует не изменять существующий интерфейс, а создать и добавить новый. Множественные интерфейсы позволяют компоненту поддерживать новые интерфейсы в дополнение к старым. Таким образом, множественные интерфейсы обеспечивают прочный фундамент, на основе которого клиенты и компоненты могут воспринимать новые версии партнеров. Проблему версий мы затронем в следующей главе.

Полиморфизм Полиморфизм, как Вы помните, — это способность обрабатывать разные объекты единообразно. Поддержка множественных интерфейсов обеспечивает дополнительные возможности для полиморфизма. Если два разных компонента поддерживают один и тот же интерфейс, для работы с ними клиент может использовать один и тот же код. Таким образом, клиент может работать с разными компонентами полиморфно.

Множественные интерфейсы поощряют полиморфизм. Чем больше интерфейсов поддерживает компонент, тем меньше может быть каждый из них. Маленький интерфейс представляет один вариант поведения, а большой — несколько вариантов. Чем больше вариантов поведения поддерживает данный интерфейс, тем более специфичным для конкретной ситуации он становится. Чем специфичнее интерфейс, тем меньше вероятность его повторного использования другим компонентом. Если же интерфейс не используется повторно, то и работающий с ним клиентский код также нельзя использовать повторно.

Например, что имеет больший потенциал повторного применения — единичный интерфейс, представляющий поведение вертолета и описывающий полет, зависание, подъем, вращение, вибрацию, удары и падение, или несколько интерфейсов, реализующих отдельные варианты поведения? Интерфейс, представляющий полет, имеет гораздо больше шансов быть повторно использованным, чем интерфейс «вертолета вообще». Вряд ли что либо, кроме вертолета, будет вести себя в точности как он;

однако есть много аппаратов, которые летают.

Замечательный результат полиморфизма — возможность повторного использования всего приложения.

Предположим, что Вы пишете приложение Viewer для просмотра растровых изображений (bitmap). Последние, реализуются как компоненты СОМ, поддерживающие интерфейс IDisplay. Viewer взаимодействует с компонентами только через этот интерфейс. Приходит Ваш начальник и говорит, что ему нужно просматривать файлы VRML. Вместо того, чтобы писать новую версию Viewer, Вы должны просто написать компонент СОМ, реализующий интерфейс IDisplay, но отображающий не растровые изображения, а файлы VRML. Конечно, написание программы отображения VRML потребует значительной работы, но не придется переписывать приложение целиком.

Возможность повторного применения целых архитектур не возникает автоматически. Она требует тщательного планирования при разработке интерфейсов, чтобы последние могли поддерживать много разных реализаций. Не только интерфейсы должны быть универсальными;

и клиент должен использовать интерфейс универсальным образом, который не ограничивает возможности реализации интерфейса. Интерфейсы или приложения, не готовые к появлению новых компонентов, не могут воспользоваться всеми преимуществами полиморфизма и повторно применять целые конструкции. Кстати, в нашем примере маловероятно, что интерфейс IDisplay окажется достаточно универсальным и гибким для отображения файлов VRML в дополнение к растровым изображениям, если мы не запланируем это сразу. Одна из самых больших трудностей компонентного программирования — разработка повторно используемых, адаптируемых, гибких и готовых к будущим нововведениям интерфейсов.

Теперь, когда мы знаем, как реализовывать интерфейсы, и примерно представляем, на что они способны, давайте посмотрим, что же представляет собой интерфейс СОМ и почему для его реализации используют абстрактный базовый класс.

Что за интерфейсом Сквозной сюжет этой главы сводится к тому, что интерфейсы СОМ реализуются на С++ при помощи чисто абстрактных базовых классов. В данном разделе объясняется, почему эти классы подходят для реализации интерфейсов. Мы увидим, что чисто абстрактный базовый класс определяет в памяти как раз структуру, которую СОМ требует от интерфейса.

Таблица виртуальных функций Определяя чисто абстрактный базовый класс, мы фактически определяем структуру некоторого блока памяти.

Все реализации чисто абстрактных базовых классов являются блоками памяти однотипной структуры. На рис. 2- показана структура памяти для абстрактного базового класса, определяемого следующим кодом:

interface IX { virtual void stdcall Fx1() = 0;

virtual void stdcall Fx2() = 0;

virtual void stdcall Fx3() = 0;

virtual void stdcall Fx4() = 0;

};

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

IX Таблица виртуальных функций pIX Указатель vtbl &Fx &Fx &Fx &Fx Таблица виртуальных функций содержит указатели на функции-члены Рис. 2-4 Пример структуры блока памяти, определяемой абстрактным базовым классом Блок памяти, определяемый чисто абстрактным базовым классом, состоит из двух частей. На рис. 2-4 справа показана таблица виртуальных функций (virtual function table). Таблица виртуальных функций, или vtbl — это массив указателей на реализации виртуальных функций. На рисунке первый элемент vtbl содержит адрес функции Fx1, реализованной в производном классе. Второй элемент содержит адрес Fx2, и т.д. Слева на рисунке показан указатель на vtbl, ил просто указатель vtbl. Указатель на абстрактный базовый класс указывает на указатель vtbl, который, естественно, указывает на таблицу vtbl.

Оказывается, что формат блока памяти для интерфейса СОМ совпадает с форматом блока памяти, который компилятор С++ генерирует для абстрактного базового класса. Это значит, что для определения интерфейсов СОМ можно использовать абстрактные базовый классы. Так, интерфейс IX — это и интерфейс, и абстрактный базовый класс. Он является интерфейсом СОМ, поскольку формат его структуры в памяти следует спецификации СОМ. Он является и абстрактным базовым классом, поскольку именно так мы его определили.

Конечно, гладко все выглядит только на бумаге. Компилятор С++ не обязан генерировать для абстрактного базового класса структуру, представленную на рис. 2-4. Ни один стандарт не задает такой формат. Причина отсутствия стандарта очевидна — программы на С++ используют один и тот же компилятор для всех исходных файлов, так что от него требуется совместимость только с самим собой. Однако так сложилось, что большинство компиляторов генерируют именно структуру, показанную на рис. 2-4. Все компиляторы С++ для Windows генерируют формат vtbl, подходящий для СОМ1.

Имеется дополнительное требование, которому должен удовлетворять интерфейс, чтобы он был интерфейсом СОМ. Все интерфейсы СОМ должны наследовать интерфейс IUnknown, до которого мы доберемся в следующей главе. Это означает, что первые три элемента vtbl одни и те же для всех интерфейсов СОМ. Они содержат адреса реализации трех функций-членов Iunknown. Подробнее об этом рассказывается в гл. 3.

Указатели vtbl и данные экземпляра Зачем же нужен указатель vtbl? Указатель vtbl еще на ступеньку повышает уровень абстракции в процессе получения указателя на функцию по указателю на базовый класс. Это дает нам дополнительную свободу реализации интерфейса.

Компилятор С++ может генерировать код, в котором класс, реализующий абстрактный базовый класс, хранит вместе с указателем vtbl информацию, специфичную для экземпляра. Например, класс CA в представленном ниже коде реализует абстрактный базовый класс IX, определенный в предыдущем разделе.

class CA : public IX { public:

Формат интерфейса может различаться для разных операционных систем. Например, для Mac указатель vtbl указывает на фиктивный указатель, а первый указатель функции располагается во втором элементе таблицы.

// Реализация интерфейса IX virtual void stdcall Fx1() { cout << “CA::Fx1” << endl;

} virtual void stdcall Fx2() { cout << m_Fx2 << endl;

} virtual void stdcall Fx3() { cout << m_Fx3 << endl;

} virtual void stdcall Fx4() { cout << m_Fx4 << endl;

} // Конструктор CA(double d) : m_Fx2(d*d), m_Fx3(d*d*d), m_Fx4(d*d*d*d) {} // Данные экземпляра double m_Fx2;

double m_Fx3;

double m_Fx4;

};

Таблица vtbl и данные класса CA, сгенерированные компилятором, показаны на рис. 2-5. Обратите внимание, что данные экземпляра потенциально доступны через указатель класса CA. Однако обычно клиент не знает, какие именно данные там хранятся, и потому не может обращаться к ним.

IX Клиент Таблица виртуальных функций CA pA Указатель vtbl &Fx1 Fx &m_Fx2 &Fx2 Fx &m_Fx3 &Fx3 Fx &m_Fx4 &Fx4 Fx Рис. 2-5 Данные, специфичные для экземпляра, хранятся вместе с указателем vtbl В то время как классы С++ могут обращаться к данным экземпляра напрямую, компоненты СОМ никогда не смогут добраться до них. В СОМ Вы можете работать с компонентом только через функции, и никогда — через переменные. Это соответствует тому способу, которым мы определяем интерфейсы СОМ. У чисто абстрактных базовых классов есть только чисто виртуальные функции, они не имеют данных экземпляра.

Множественные экземпляры Однако указатель vtbl — это больше, чем просто удобное место для хранения данных экземпляра. Он также позволяет разным экземплярам одного класса использовать одну и ту же vtbl. Если мы создадим два экземпляра CA, то получим два отдельных набора данных экземпляра. Однако эти экземпляры могут совместно использовать одну и ту же vtbl и одну и ту же реализацию. Например, предположим, что мы создали два объекта CA:

int main() { // Создать первый экземпляр CA CA* pA1 = new CA(1.5);

// Создать второй экземпляр CA CA* pA2 = new CA(2.75);

… } Эти объекты могут использовать одну и ту же vtbl, элементы которой указывают на одни и те же реализации виртуальных функций-членов. Однако у объектов будут разные данные экземпляра (рис. 2-6).

Компоненты СОМ могут, но не обязаны применять указатель vtbl для совместного использования vtbl. Каждый экземпляр компонента СОМ может иметь свою vtbl.

Разные классы, одинаковые vtbl По настоящему сила интерфейсов проявляется в том, что классы, производные от данного интерфейса, клиент может рассматривать одинаково. Предположим, что мы реализовали класс CB, который также является производным от IX:

class CB : public IX { public:

// Реализация интерфейса IX virtual void stdcall Fx1() { cout << “CB::Fx1” << endl;

} virtual void stdcall Fx2() { cout << “CB::Fx2” << endl;

} virtual void stdcall Fx3() { cout << “CB::Fx3” << endl;

} virtual void stdcall Fx4() { cout << “CB::Fx4” << endl;

} };

Указатель vtbl Таблица виртуальных &m_Fx функций CA Клиент &m_Fx &Fx1 Fx pA &m_Fx &Fx2 Fx &Fx3 Fx pA2 Указатель vtbl &Fx4 Fx &m_Fx &m_Fx &m_Fx Рис. 2-6 Несколько экземпляров класса используют одну vtbl С помощью указателя на IX клиент может работать как с CA, так и с CB:

void foo(IX* pIX) { pIX->Fx1();

pIX->Fx2();

} int main () { // Создать экземпляр CA CA* pA = new CA(1.789);

// Создать экземпляр CB CB* pB = new CB;

// Получить указатель IX для CA IX* pIX = pA;

foo(pIX);

// Получить указатель IX для CB pIX = pB;

foo(pIX);

… } В данном примере мы использовали и CA, и CB так, словно они являются интерфейсом IX. Это и есть полиморфизм. На рис. 2-7 показан формат структур памяти для данного примера. Я не нарисовал данные экземпляров, поскольку нам как СОМ-программистам не важно, что они собой представляют.

Таблица виртуальных функций CA Указатель vtbl &Fx1 Fx &Fx2 Fx Клиент &Fx3 Fx pA &Fx4 Fx Таблица виртуальных функций CB pB Указатель vtbl &Fx1 Fx &Fx2 Fx &Fx3 Fx &Fx4 Fx Рис. 2-7 Полиморфное использование двух разных классов при помощи общего абстрактного базового класса Из рис. 2-7 видно, что два наших класса — CA и CB — имеют отдельные и различные данные экземпляра, vtbl и реализации. Однако доступ к их vtbl может осуществляться одинаково, поскольку формат обеих таблиц один и тот же. Адрес функции Fx1 находится в первом элементе обеих таблиц, адрес Fx2 — во втором, и т.д. Формат таблиц соответствует тому, который генерирует компилятор для абстрактного базового класса. Когда класс реализует абстрактный базовый класс, он обязуется следовать данному формату. То же самое верно для компонентов. Когда компонент возвращает указатель интерфейса IX, он обязан гарантировать, что тот указывает на корректную структуру.

Кирпичики СОМ, резюме В этой главе мы превратили интерфейс из формальной концепции в конкретную структуру в памяти. Мы увидели, что благодаря инкапсуляции деталей реализации интерфейсы защищают систему компонентов от разрушительного влияния изменений. До тех пор, пока интерфейсы неизменны, клиент и компонент можно спокойно изменять. Благодаря этому старые компоненты можно заменять новыми, не нарушая работу системы.

Клиенты также могут работать с компонентами, реализующими один и тот же интерфейс, полиморфно.

Кроме того, мы увидели, как реализовать интерфейс на С++ с помощью чисто абстрактного базового класса.

Формат блока памяти, генерируемый компилятором С++ для чисто абстрактного базового класса, совпадает с определяемым СОМ форматом для интерфейса.

В этой главе Вы узнали, что такое интерфейс, как его реализовать и использовать. Однако приведенные в примерах интерфейсы — не настоящие интерфейсы СОМ. СОМ требует, чтобы все интерфейсы поддерживали три функции. Со ссылок на них начинается vtbl интерфейса. В следующей главе мы рассмотрим первую из этих трех функций — QueryInterface. Мне не терпится прочитать эту главу — может я наконец узнаю, как расстыковать «космический челнок» и мой компьютер!

3 глава QueryInterface Вы – млекопитающее?

> да У Вас две ноги?

> нет У Вас длинные уши?

> да Вы крупное животное?

> нет Вы кролик?

> да Тот, кто достаточно долго работает с компьютерами, вспомнит одну из первых компьютерных игр — «Угадай животное» (Animal). Эта простая маленькая программа демонстрировала, что компьютер может обучаться;

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

Animal строила двоичное дерево, в концевых вершинах которого были названия животных, а в точках ветвления — вопросы. Программа проходила вниз по дереву, задавала вопросы, соответствующие узлам, и на основании Ваших ответов определяла, куда идти дальше. Дойдя до висячей вершины, она должна была отгадать животное. В случае ошибки программа задавала новый вопрос, по ответу на который можно было бы отличить задуманное животное от угаданного ею. Затем этот вопрос и имя нового животного добавлялись к дереву.

В этой главе мы увидим, что клиент СОМ во многом напоминает программу Animal. Animal не знала, какое животное Вы задумали;

клиент СОМ не знает, какие интерфейсы поддерживает компонент. Чтобы определить, поддерживается ли некоторый интерфейс, клиент запрашивает у компонента этот интерфейс во время выполнения. Это похоже на то, как программа Animal расспрашивала Вас о характерных чертах задуманного животного. Более того, как программа Animal на самом деле мало что понимала в животных, так и клиент СОМ не имеет полного представления о возможностях компонента, который использует.

Однажды летом я учил первоклассников программировать на Logo. На занятиях мы писали на Logo версию Animal. Поиграв день с программой, мы распечатали созданное ею двоичное дерево и узнали кое-что интересное.

С точки зрения Animal, кролик — это четвероногое млекопитающее с большими ушами, тогда как слон — большое четвероногое млекопитающее с большими ушами. Что и говорить, представление программы о слоне или кролике весьма ограничено.

Знания клиента о компоненте также весьма ограничены. Клиент может запросить компонент, поддерживает ли тот некоторый интерфейс. Задав достаточно вопросов, клиент получит сравнительно определенное представление о компоненте, но оно никогда не бывает полным. Дети, которых я учил, прекрасно представляли, как выглядит кролик, но программа Animal этого не знала.

Если у Animal недостаточное понимание предмета было побочным эффектом реализации, то для клиента недостаточное понимание существа компонента — не случайность. Мы хотим, чтобы клиент знал о компоненте настолько мало, насколько возможно. Чем меньше его знания, тем сильнее можно изменить компонент, не нарушив работы клиента. Если клиент должен явно запрашивать у компонента каждый интерфейс, который собирается использовать, то на клиент и влияют изменения только этих интерфейсов. Компонент можно заменить другим, предоставляющим дополнительные интерфейсы, не влияя на клиент. Если клиент не использует некоторый интерфейс, то новому компоненту нет необходимости его поддерживать.

Как мы увидим далее, даже если новый компонент не предоставляет интерфейс, нужный клиенту, последний может элегантно обработать ситуацию, когда запрос на интерфейс отклонен. В этой главе мы познакомимся с тем, как клиент запрашивает у компонента интерфейсы, как компонент отвечает на его запросы и что следует из принятого порядка. Мы также увидим, что требование к клиенту обязательно запрашивать интерфейс обеспечивает устойчивую систему прозрачной обработки изменений версий компонентов.

Запрос интерфейса Поскольку в СОМ все начинается и заканчивается интерфейсом, давайте и мы начнем с интерфейса, через который запрашиваются другие интерфейсы.

Клиент всегда взаимодействует с компонентом через некоторый интерфейс. Даже для запроса у компонента интерфейса используется специальный интерфейс IUnknown. Определение IUnknown, содержащееся в заголовочном файле UNKNWN.H, входящим в состав Win32 SDK, выглядит так:

interface IUnknown { virtual HRESULT stdcall QueryInterface(const IID& iid, void** ppv) = 0;

virtual ULONG stdcall AddRef() = 0;

virtual ULONG stdcall Release() = 0;

} В IUnknown имеется функция с именем QueryInterface. Клиент вызывает ее, чтобы определить, поддерживает ли компонент некоторый интерфейс. В этой главе я собираюсь поговорить о QueryInterface. В гл. 4 мы рассмотрим AddRef и Release, которые предоставляют способ управления временем жизни интерфейса.

IUnknown Мне всегда казалось забавным название IUnknown. Это единственный интерфейс, о котором знают все клиенты и компоненты, и тем не менее это «неизвестный интерфейс»*. Происхождение названия просто. Все интерфейсы СОМ должны наследовать IUnknown. Таким образом, если у клиента имеется указатель на IUnknown, то клиент, не зная, указателем на какой именно интерфейс обладает, знает, что может запросить через него другие интерфейсы.

Клиент IX CA Таблица виртуальных функций pA Указатель vtbl QueryInterface QueryInterface AddRef AddRef Release Release Fx Fx Рис. 3-1 Все интерфейсы СОМ наследуют IUnknown и содержат указатели на QueryInterface, AddRef и Release в первых трех элементах своих vtbl Поскольку все интерфейсы СОМ наследуют IUnknown, в каждом интерфейсе есть функции QueryInterface, AddRef и Release — три первые функции в vtbl (см. рис. 3-1). Благодаря этому все интерфейсы СОМ можно полиморфно трактовать как интерфейсы IUnknown. Если в первых трех элементах vtbl интерфейса не содержатся указатели на три перечисленные функции, то это не интерфейс СОМ. Поскольку все интерфейсы наследуют IUnknown, постольку все они поддерживают QueryInterface. Таким образом, любой интерфейс можно использовать для получения всех остальных интерфейсов, поддерживаемых компонентом.

Поскольку все указатели интерфейсов являются также и указателями на IUnknown, клиенту не требуется хранить отдельный указатель на собственно компонент. Клиент работает только с указателями интерфейсов.

Получение указателя на IUnknown Каким образом клиент может получить указатель на IUnknown? Мы используем функцию с именем CreateInstance, которая создает компонент и возвращает указатель на IUnknown:

IUnknown* CreateInstance();

Клиент использует CreateInstance вместо оператора new. В этой главе мы создадим простую версию данной функции, которую будем изменять на протяжении нескольких последующих глав в соответствии с нашими потребностями. В гл. 6 и 7 будет представлен «официальный» способ создания компонентов СОМ.

Теперь, когда мы знаем, как клиент получает указатель на IUnknown, давайте посмотрим, как он может использовать QueryInterface для получения других интерфейсов, а затем займемся реализацией QueryInterface.

* Unknown (англ.) — неизвестный. — Прим. перев.

Знакомство с QueryInterface IUnknown содержит функцию-член QueryInterface, при помощи которой клиент определяет, поддерживается ли тот или иной интерфейс. QueryInterface возвращает указатель на интерфейс, если компонент его поддерживает;

в противном случае возвращается код ошибки (тогда клиент может запросить указатель на другой интерфейс или аккуратно выгрузить компонент).

У QueryInterface два параметра:

Virtual HRESULT stdcall QueryInterface(const IID& iid, void** ppv);

Первый параметр — идентификатор интерфейса, так называемая IID-структура. Более подробно IID будут рассматриваться в гл. 6. Пока же мы будем рассматривать их как константы, задающие интерфейс. Второй параметр — адрес, по которому QueryInterface помещает указатель на искомый интерфейс.

QueryInterface возвращает HRESULT;

это не описатель (handle), как может показаться по названию. HRESULT — просто 32-разрядный код результата, записанный в определенном формате. QueryInterface может возвратить либо S_OK, либо E_NOINTERFACE. Клиент не должен прямо сравнивать возвращаемое QueryInterface значение с этими константами;

для проверки надо использовать макросы SUCCEEDED или FAILED. Исчерпывающее обсуждение HRESULT содержится в гл. 6.

Теперь посмотрим, как используется, а затем — как реализуется QueryInterface.

Использование QueryInterface Предположим, что у нас есть указатель на IUnknown, pI. Чтобы определить, можно ли использовать некоторый другой интерфейс, мы вызываем QueryInterface, передавая ей идентификатор нужного нам интерфейса. Если QueryInterface отработала успешно, мы можем пользоваться указателем:

void foo(IUnknown* pI) { // Определить указатель на интерфейс IX* pIX = NULL;

// Запросить интерфейс IX HRESULT hr = pI->QueryInterface(IID_IX, (void**)&pIX);

// Проверить значение результата if (SUCCEEDED(hr)) { // Использовать интерфейс pIX->Fx();

} } В этом фрагменте кода мы запрашиваем у pI интерфейс, идентифицируемый с помощью IID_IX. Определение IID_IX содержится в заголовочном файле, предоставляемом компонентом (или, что более вероятно, оно извлекается из библиотеки типа, как будет показано в гл. 13).

Обратите внимание, что pIX устанавливается в NULL перед вызовом QueryInterface. Это пример хорошего программирования с защитой от ошибок. Как мы вскоре увидим, предполагается, что для неудачного запроса QueryInterface должна устанавливать возвращаемый указатель в NULL. Однако, поскольку QueryInterface реализуется программистом компонента, в некоторых реализациях это наверняка не будет сделано. Для безопасности следует установить указатель в NULL самостоятельно.

Таковы основы использования QueryInterface. Позже мы рассмотрим некоторые более продвинутые приемы ее применения. Но сначала давайте посмотрим, как следует реализовывать QueryInterface в наших компонентах.

Реализация QueryInterface Реализовать QueryInterface легко. Все, что нужно сделать, — это вернуть указатель интерфейса, соответствующего данному IID. Если интерфейс поддерживается, то функция возвращает S_OK и указатель. В противном случае возвращаются E_NOINTERFACE и NULL. Теперь давайте запишем QueryInterface для следующего компонента, реализуемого классом CA:

interface IX : IUnknown { /*...*/ };

interface IY : IUnknown { /*...*/ };

class CA : public IX, public IY { /*...*/ };

Иерархия наследования для этого класса и его интерфейсов показана на рис. 3-2.

IUnknown IUnknown IX IY CA Рис. 3-2 Иерархия наследования для приведенного выше фрагмента кода Невиртуальное наследование Обратите внимание, что IUnknown — не виртуальный базовый класс. IX и IY не могут наследовать IUnknown виртуально, так как виртуальное наследование приводит к vtbl, несовместимой с форматом СОМ. Ели бы IX и IY наследовали IUnknown виртуально, то первые три элемента их vtbl не были бы указателями на три функции-члена IUnknown.

Pages:     || 2 | 3 | 4 | 5 |   ...   | 6 |



© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.