Пример использования mfc в visual c


Содержание

Пример использования MFC в Visual C++

В этой статье будет показано как включить потдержку MFC в Visual C++ на примере двух типов приложений:

1. Консольное приложение

2. Приложение типа Windows Application

1. Консольное приложение

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

int main( int argc, char* argv[] )

if ( !AfxWinInit( ::GetModuleHandle( NULL ), NULL, ::GetCommandLine( ), 0 ) )

cerr » ( Вам надо выбрать «Dialog based»).

5. MFC AppWizard — Step 2. Нажмите кнопку «Next>».

6. MFC AppWizard — Step 3. Нажмите кнопку «Finish».

7. New Project Information. Нажмите кнопку «OK».

Ну вот и всё, у Вас есть уже готовая программа, потдерживающая

Пример использования mfc в visual c

В связи с тем, что сегодня уровень сложности программного обеспечения очень высок, разработка приложений Windows с использованием только какого-либо языка программирования (например, языка C) значительно затрудняется. Программист должен затратить массу времени на решение стандартных задач по созданию многооконного интерфейса. Реализация технологии связывания и встраивания объектов — OLE — потребует от программиста еще более сложной работы.

Чтобы облегчить работу программиста практически все современные компиляторы с языка C++ содержат специальные библиотеки классов. Такие библиотеки включают в себя практически весь программный интерфейс Windows и позволяют пользоваться при программировании средствами более высокого уровня, чем обычные вызовы функций. За счет этого значительно упрощается разработка приложений, имеющих сложный интерфейс пользователя, облегчается поддержка технологии OLE и взаимодействие с базами данных.

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

Подобные средства автоматизированного создания приложений включены в компилятор Microsoft Visual C++ и называются MFC AppWizard. Заполнив несколько диалоговых панелей, можно указать характеристики приложения и получить его тексты, снабженные обширными комментариями. MFC AppWizard позволяет создавать однооконные и многооконные приложения, а также приложения, не имеющие главного окна , -вместо него используется диалоговая панель. Можно также включить поддержку технологии OLE, баз данных, справочной системы.

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

Нужно отметить, что MFC AppWizard создает тексты приложений только с использованием библиотеки классов MFC (Microsoft Foundation Class library). Поэтому только изучив язык C++ и библиотеку MFC, можно пользоваться средствами автоматизированной разработки и создавать свои приложения в кратчайшие сроки.

Некоторые сведения о программировании Windows-приложений

MFC — это базовый набор (библиотека) классов, написанных на языке С++ и предназначенных для упрощения и ускорения процесса программирования под Windows. Перед изучением библиотеки MFC и ее использованием для создания Windows-приложений, следует вспомнить, как работает сама Windows и каковы принципы взаимодействия программ с ней, какова структура типичной Windows-программы.

Программная среда Windows

Рассмотрим наиболее важные моменты работы Windows и принципы взаимодействия программ с ней.

Интерфейс вызовов функций в Windows

Благодаря данному интерфейсу доступ к системным ресурсам осуществляется через целый рад системных функций. Совокупность таких функций называется прикладным программным интерфейсом, или API (Application Programming Interfase). Для взаимодействия с Windows приложение запрашивает функции API, с помощью которых реализуются все необходимые системные действия, такие как выделение памяти, вывод на экран, создание окон и т.п.

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

Библиотеки динамической загрузки (DLL)

Поскольку API состоит из большого числа функций, может сложиться впечатление, что при компиляции каждой программы, написанной для Windows, к ней подключается код довольно значительного объема. В действительности это не так. Функции API содержатся в библиотеках динамической загрузки (Dynamic Link Libraries, или DLL), которые загружаются в память только в тот момент, когда к ним происходит обращение, т.е. при выполнении программы. Рассмотрим, как осуществляется механизм динамической загрузки.

Динамическая загрузка обеспечивает ряд существенных преимуществ. Во-первых, поскольку практически все программы используют API-функции, то благодаря DLL-библиотекам существенно экономится дисковое пространство, которое в противном случае занималось бы большим количеством повторяющегося кода, содержащегося в каждом из исполняемых файлов. Во-вторых, изменения и улучшения в Windows-приложениях сводятся к обновлению только содержимого DLL-библиотек. Уже существующие тексты программ не требуют перекомпиляции.

Win16 или Win32

В настоящее время широко распространены две версии API. Первая называется Win16 и представляет собой 16-разрядную версию, используемую в Windows 3.1. Вторая, 32-разрядная версия, называется Win32 и используется в Windows 95 и Windows NT. Win32 является надмножеством для Win16 (т.е. фактически включает в себя этот интерфейс), так как большинство функций имеет то же название и применяется аналогичным образом. Однако, будучи в принципе похожими, оба интерфейса все же отличаются друг от друга. Win32 поддерживает 32-разрядную линейную адресацию, тогда как Win16 работает только с 16-разрядной сегментированной моделью памяти. Это привело к тому, что некоторые функции были модифицированы таким образом, чтобы принимать 32-разрядные аргументы и возвращать 32-разрядные значения. Часть из них пришлось изменить с учетом 32-разрядной архитектуры. Была реализована поддержка потоковой многозадачности, новых элементов интерфейса и прочих нововведений Windows.

Так как Win32 поддерживает полностью 32-разрядную адресацию, то логично, что целые типы данных (intergers) также объявлены 32-разрядными. Это означает, что переменные типа int и unsignerd будут иметь длину 32 бита, а не 16, как в Windows 3.1. Если же необходимо использовать переменную или константу длиной 16 бит, они должны быть объявлены как short. (дальше будет показано, что для этих типов определены независимые typedef-имена.) Следовательно, при переносе программного кода из 16-разрядной среды необходимо убедиться в правильности использования целочисленных элементов, которые автоматически будут расширены до 32 битов, что целочисленных элементов, которые автоматически будут расширены до 32 битов, что может привести к появлению побочных эффектов.

Другим следствием 32-разрядной адресации является то, что указатели больше не нужно объявлять как near и far. Любой указатель может получить доступ к любому участку памяти. В Windows 95 и Windows NT константы near и far объявлены (с помощью директивы #define)пустыми.

Одним из подмножеств API является GDI (Graphics Device Interfase — интерфейс графического устройства). GDI — это та часть Windows, которая обеспечивает поддержку аппаратно-независимой графики. Благодаря функциям GDI Windows-приложение может выполняться на самых различных компьютерах.

Многозадачность в Windows

Как известно, все версии Windows поддерживают многозадачность. В Windows 3.1 имеется только один тип многозадачности — основанный на процессах. В более передовых системах, таких как Windows 95 и Windows NT, поддерживается два типа многозадачности: основанный на процессах и основанный на потоках. Давайте рассмотрим их чуть подробнее.

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

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

Отсюда можно сделать вывод, что в Windows 95 и Windows NT допускается существование процессов, две или более частей которых выполняются одновременно. Оказывается, такое предположение верно. Следовательно, при работе в этих операционных системах возможно параллельное выполнение, как программ, так и отдельных частей самих программ. Это позволяет писать очень эффективные программы.

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

Взаимодействие программ и Windows

Во многих операционных системах взаимодействие между системой и программой инициализирует программа. Например, в DOS программа запрашивает разрешение на ввод и вывод данных. Говоря другими словами, не- Windows-программы сами вызывают операционную систему. Обратного процесса не происходит. В Windows все совершенно наоборот: именно система вызывает программу. Это осуществляется следующим образом: программа ожидает получения сообщения от Windows. Когда это происходит, то выполняется некоторое действие. После его завершения программа ожидает следующего сообщения.

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

Основы программирования под Windows

Поскольку архитектура Windows-программ основана на принципе сообщений, все эти программы содержат некоторые общие компоненты. Обычно их приходится в явном виде включать в исходный код. Но, к счастью, при использовании библиотеки MFC это происходит автоматически; нет необходимости тратить время и усилия на их написание. Тем не менее, чтобы до конца разобраться, как работает Windows-программа, написанная с использованием MFC, и почему она работает именно так, необходимо в общих чертах понять назначение этих компонентов.

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

Все Windows-программы должны содержать специальную функцию, которая не используется в самой программе, но вызывается самой операционной системой. Эту функцию обычно называют функцией окна , или процедурой окна . Она вызывается Windows, когда системе необходимо передать сообщение в программу. Именно через нее осуществляется взаимодействие между программой и системой. Функция окна передает сообщение в своих аргументах. Согласно терминологии Windows, функции, вызываемые системой, называются функциями обратного вызова . Таким образом, функция окна является функцией обратного вызова.

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

В большинстве Windows-программ задача создания функции окна лежит на программисте. При использовании библиотеки MFC такая функция создается автоматически. В этом заключается одно из преимуществ библиотеки. Но в любом случае, если сообщение получено, то программа должна выполнить некоторое действие. Хотя она может вызывать для этого одну или несколько API-функций, само действие было инициировано Windows. Поэтому именно способ взаимодействия с операционной системой через сообщения диктует общий принцип построения всех программ для Windows, написанных как с использованием MFC, так и без нее.

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

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

Как будет показано дальше, каждое окно в Windows-приложении характеризуется определенными атрибутами, называемыми классом окна . (Здесь понятие ‘класс’ не идентично используемому в С++. Оно, скорее, означает стиль или тип.) В традиционной программе класс окна должен быть определен и зарегистрирован прежде, чем будет создано окно. При регистрации необходимо сообщить Windows, какой вид должно иметь окно и какую функцию оно выполняет. В то же время регистрация класса окна еще не означает создание самого окна. Для этого требуется выполнить дополнительные действия. При использовании библиотеки MFC создавать собственный класс окна нет необходимости. Вместо этого можно работать с одним из заранее определенных классов, описанных в библиотеке. В этом еще одно ее преимущество.

Специфика программ для Windows

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

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

Хотя создание удобного интерфейса ‘под Windows’ является основной задачей при написании любой Windows-программы, такой интерфейс не создается автоматически. То есть вполне можно написать программу, в которой элементы интерфейса используются неэффективно. Чтобы этого избежать, необходимо целенаправленно применять методику, описанную в данной книге. Только программы, написанные таким способом, будут выглядеть и работать действительно так, как надлежит Windows-программам.

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

Типы данных в Windows

В Windows-программах вообще (и в использующих библиотеку MFC в частности) не слишком широко применяются стандартные типы данных из С или С++, такие как int или char*. Вместо них используются типы данных, определенные в различных библиотечных (header) файлах. Наиболее часто используемыми типами являются HANDLE, HWND, BYTE, WORD, DWORD, UNIT, LONG, BOOL, LPSTR и LPCSTR. Тип HANDLE обозначает 32-разрядное целое, используемое в качестве дескриптора. Есть несколько похожих типов данных, но все они имеют ту же длину, что и HANDLE, и начинаются с литеры Н. Дескриптор — это просто число, определяющее некоторый ресурс. Например, тип HWND обозначает 32-разрядное целое — дескриптор окна. В программах, использующих библиотеку MFC, дескрипторы применяются не столь широко, как это имеет место в традиционных программах. Тип BYTE обозначает 8-разрядное беззнаковое символьное значение, тип WORD — 16-разрядное беззнаковое короткое целое, тип DWORD — беззнаковое длинное целое, тип UNIT — беззнаковое 32-разрядное целое. Тип LONG эквивалентен типу l o ng. Тип BOOL обозначает целое и используется, когда значение может быть либо истинным, либо ложным. Тип LPSTR определяет указатель на строку, а LPCSTR — константный (const) указатель на строку.

Преимущества использования MFC

Как уже упоминалось, MFC — это базовый набор (библиотека) классов, написанных на языке С++ и предназначенных для упрощения и ускорения процесса программирования для Windows. Библиотека содержит многоуровневую иерархию классов, насчитывающую около 200 членов. Они дают возможность создавать Windows-приложения на базе объектно-ориентированного подхода. С точки зрения программиста, MFC представляет собой каркас, на основе которого можно писать программы для Windows.

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

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

Еще одним существенным преимуществом MFC является упрощение взаимодействия с прикладным программным интерфейсом (API) Windows. Любое приложение взаимодействует с Windows через API, который содержит несколько сот функций. Внушительный размер API затрудняет попытки понять и изучить его целиком. Зачастую даже сложно проследить, как отдельные части API связанны друг с другом! Но поскольку библиотека MFC объединяет (путем инкапсуляции) функции API в логически организованное множество классов, интерфейсом становится значительно легче управлять.

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

Замечание . Небольшое число классов, определенных в библиотеке, не связанно непосредственно с программированием под Windows. Это, в частности, классы, предназначенные для создания строк, управления файлами и обработки особых ситуаций. Иногда называемые классами общего назначения , они могут использоваться как Windows-, так и не- Windows-приложениями.

Обзор среды Microsoft Developer Studio

Студия разработчика фирмы Microsoft (Microsoft Developer Studio) — это интегрированная среда для разработки, позволяющая функционировать различным средам разработки, одна из которых Visual C++, другая — Visual J++. В дальнейшем будет идти речь только о среде разработки Visual C++.

В студии разработчика можно строить обычные программы на C и С++, создавать статические и динамические библиотеки, но основным режимом работы является создание Windows-приложений с помощью инструмента MFC AppWizard (Application Wizard — мастер приложений) и библиотеки базовых классов MFC (Microsoft Foundation Class Library). Такие приложения называются MFC-приложениями. Главная особенность этих Windows-приложений состоит в том, что они работают как совокупность взаимодействующих объектов, классы которых определены библиотекой MFC.

Библиотека MFC

Главная часть библиотеки MFC состоит из классов, используемых для построения компонентов приложения. С каждым MFC-приложением связывается определяющий его на верхнем уровне объект theApp , принадлежащий классу, производному от CWinApp .

Как правило, структура приложения определяется архитектурой Document-View (документ-облик). Это означает, что приложение состоит из одного или нескольких документов — объектов, классы которых являются производными от класса CDocument (класс «документ»). С каждым из документов связаны один или несколько обликов — объектов классов, производных от CView (класс «облик «) и определяющих облик документа.

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

Классы CView, CFrameWnd, CDialog и все классы элементов управления наследуют свойства и поведение своего базового класса CWnd («окно»), определяющего по существу Windows-окно. Этот класс в свою очередь является наследником базового ласса CObject («объект»).

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

Архитектура приложения

У всех Windows-приложений фиксированная структура, определяемая функцией WinMain. Структура приложения, построенного из объектов классов библиотеки MFC, является еще более определенной.

Приложение состоит из объекта theApp , функции WinMain , и некоторого количества других объектов. Сердцевина приложения — объект theApp — отвечает за создание всех остальных объектов и обработку очереди сообщений. Объект theApp является глобальным и создается еще до начала работы функции WinMain . Работа функции WinMain заключается в последовательном вызове двух методов объекта theApp : InitInstance и Run . В терминах сообщений можно сказать, WinMain посылает объекту theApp сообщение InitInstance, которое приводит в действие метод InitInstance .

Получив сообщение InitInstance, theApp создает внутренние объекты приложения . Процесс создания выглядит как последовательное порождение одних объектов другими. Набор объектов, порождаемых в начале этой цепочки, определен структурой MFC практически однозначно — это главная рамка, шаблон, документ, облик. Их роли в работе приложения будут обсуждаться позже.

Следующее сообщение, получаемое theApp, — Run — приводит в действие метод Run . Оно как бы говорит объекту: «Начинай работу, начинай процесс обработки сообщений из внешнего мира». Объект theApp циклически выбирает сообщения из очереди и инициирует обработку сообщений объектами приложения.

Некоторые объекты имеют графический образ на экране, с которым может взаимодействовать пользователь. Эти интерфейсные объекты обычно связаны с Windows-окном. Среди них особенно важны главная рамка и облик. Именно им объект прежде всего распределяет сообщения из очереди через механизм Windows-окон и функцию Dispatch.

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

При работе приложения возникают и обычные вызовы одними объектами методов других объектов. В объектно-ориентированной терминологии такие вызовы могут называться сообщениями . В Visual C++ некоторым методам приписан именно этот статус (например, методу OnDraw).

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

Каркас приложения

Наследование — одна из фундаментальных идей объектно-ориентированного программирования. Именно этот механизм наследования позволяет программисту дополнять и переопределять поведение базового класса, не вторгаясь в библиотеку MFC, которая остается неизменной. Все изменения делаются в собственном производном классе. Именно в этом и заключается работа программиста.

Объекты, их которых состоит приложение, являются объектами классов, производных от классов библиотеки MFC. Разработка приложения состоит в том, что программист берет из библиотеки MFC классы CWinApp, CFrameWnd, CDocument, CView и т.д. и строит производные классы. Приложение создается как совокупность объектов этих производных классов. Каждый объект несет в себе как наследуемые черты, определяемые базовыми классами, так и новые черты, добавленные программистом. Наследуемые черты определяют общую схему поведения, свойственную таким приложениям. Новые же черты позволяют реализовать специфические особенности поведения приложения, необходимые для решения стоящей перед ним задачи.

При определении производного класса программист может:

  • переопределить некоторые методы базового класса, причем те методы, что не были переопределены, будут наследоваться в том виде, в каком они существуют в базовом классе;
  • добавить новые методы;
  • добавить новые переменные.

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

Если метод базового класса объявлен виртуальным и разработчик переопределил его в производном классе, это значит, что при вызове данного метода в некоторой полиморфной функции базового класса в момент исполнения будет вызван метод производного класса и, следовательно, каркас вызывает метод, определенный программистом. Точнее говоря, обращение к этому методу должно производиться через ссылку на производный объект либо через объект, являющийся формальным параметром и получающий при вызове в качестве своего значения объект производного класса. Когда вызывается виртуальный метод М1, переопределенный разработчиком, то согласно терминологии Visual C++, каркас посылает сообщение М1 объекту производного класса, а метод М1 этого объекта обрабатывает это сообщение. Если сообщение М1 послано объекту производного класса, а обработчик этого сообщения не задан программистом, объект наследует метод М1 ближайшего родительского класса, в котором определен этот метод. Если же обработчик такого сообщения создан программистом, он автоматически отменяет действия, предусмотренные родительским классом в отсутствие этого обработчика.

Каркас приложений

С Visual C++ тесно связано еще одно понятие — каркас приложений , которое близко и созвучно понятию каркаса приложения, но в отличие от него относится не к одному конкретному приложению, а к библиотеке, с помощью которой строятся многие приложения. Каркас приложений — это библиотека классов, из которых программист берет не только набор классов, играющих роль дополнительных типов данных, но и классы, служащие строительными блоками приложения на самом верхнем уровне. С этой точки зрения, каркас приложения является частью каркаса приложений, относящейся к данному приложению. Примеры каркасов приложений — библиотеки классов MFC и OWL.

Проект приложения

О принципах устройства приложения рассказывалось выше. Теперь рассмотрим, как оно создается с помощью Visual C++. Сначала разберем одно важное понятие — проект . До сих пор приложение рассматривалось, как только как совокупность объектов базовых и производных классов. Но для обеспечения работы приложения требуется нечто большее — наряду с описанием классов необходимо описание ресурсов, связанных с приложением, нужна справочная система и т.п. Термин «проект» как раз и используется, когда имеется в виду такой более общий взгляд на приложение.

В среде Visual C++ можно строить различные типы проектов. Такие проекты после их создания можно компилировать и запускать на исполнение. Фирма Microsoft разработала специальный инструментарий, облегчающий и ускоряющий создание проектов в среде Visual C++. Например, мастер MFC AppWizard (exe) позволяет создать проект Windows-приложения которое имеет однодокументный, многодокументный или диалоговый интерфейс и использует библиотеку MFC.

Создаваемый остов приложения составлен так, что в дальнейшей работе с проектом можно использовать другое инструментальное средство — ClassWizard (мастер классов), предназначенное для создания остовов новых производных классов. Еще одно основное назначение ClassWizard в том, что он создает остовы для переопределяемых методов. Он позволяет показать все сообщения, приходящие классу, и создать остов обработчика любого из этих сообщений. Это только две основные функции ClassWizard. Он не всесилен, но его возможности довольно велики.

Использование средств разработки

В состав компилятора Microsoft Developer Studio встроены средства, позволяющие программисту облегчить разработку приложений. В первую очередь к ним относятся MFC AppWisard, ClassWizard и редактор ресурсов.

Благодаря MFC AppWizard среда разработчика позволяет быстро создавать шаблоны новых приложений. При этом программисту не приходится писать ни одной строчки кода. Достаточно ответить на ряд вопросов, касающихся того, какое приложение требуется создать, и исходные тексты шаблона приложения вместе с файлами ресурсов готовы. Эти тексты можно оттранслировать и получить готовый загрузочный модуль приложения.

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

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

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

Типы мастеров проектов

В среде Visual C++ можно строить различные типы проектов. Такие проекты после их создания можно компилировать и запускать на исполнение. Фирма Microsoft разработала специальный инструментарий, облегчающий и ускоряющий создание проектов в среде Visual C++.

Рассмотрим некоторые типы проектов, которые можно создавать при помощи различных средств (мастеров проектов) Microsoft Visual C++:

MFC AppWizard (exe) — при помощи мастера приложений можно создать проект Windows-приложения которое имеет однодокументный, многодокументный или диалоговый интерфейс. Однодокументное приложеие может предоставлять пользователю в любой момент времени работать только с одним файлом. Многодокументное приложение, напротив, может одновременно представлять несколько документов, каждый в собственном окне. Пользовательский интерфейс диалогового приложения представляет собой единственное диалоговое окно.

MFC AppWizard (dll) — этот мастер приложений позволяет создать структуру DLL, основанную на MFC. При помощи него можно определить характеристики будующей DLL.

AppWizard ATL COM — это средство позволяет создать элемент управления ActiveX или сервер автоматизации, используя новую библиотеку шаблонов ActiveX (ActiveX Template Library — ATL). Опции этого мастера дают возможность выбрать активный сервер (DLL) или исполняемый внешний сервер (exe-файл).

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

DevStudio Add-in Wizard — мастер дополнений позволяет создавать дополнения к Visual Studio. Библиотека DLL расширений может поддерживать панели инструментов и реагировать на события Visual Studio.

MFC ActiveX ControlWizard — мастер элементов управления реализует процесс создания проекта, содержащего один или несколько элементов управления ActiveX, основанных на элементах управления MFC.

Win32 Application — этот мастер позволяет создать проект обычного Window-приложения. Проект создается незаполненным, файлы с исходным кодом в него следует добавлять вручную.

Win32 Console Application — мастер создания проекта консольного приложения. Консольная приложение — это программа, которая выполняется из командной cтроки окна DOS или Windows и не имеет графического интерфейса (окон). Проект консольного приложения создается пустым, предполагая добавление файлов исходного текста в него вручную.

Win32 Dynamic-Link Library — создание пустого проекта динамически подключаемой библиотеки. Установки компилятора и компоновщика будут настроены на создание DLL. Исходные файлы следует добавлять вручную.

Win32 Static Library — это средство создает пустой проект, предназначенный для генерации статической (объектной) библиотеки. Файлы с исходным кодом в него следует добавлять вручную.

Преимущества мастеров проектов

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

Например, все Windows-приложения имеют достаточно общую структуру, и, следовательно, можно построить некоторые шаблонные заготовки, подходящие для того или иного типа проектов. Построению таких заготовок способствует то, что приложения, создаваемые на основе MFC, строятся из элементов фиксированных классов. Логическим развитием этой идеи было введение специальных классов и специальной архитектуры построения приложения, которая подходила бы широкому классу приложений. О такой архитектуре уже упоминалось, когда речь шла о библиотеке MFC, — это архитектура Document-View. Она является основной, но не единственной при построении проектов в среде Visual C++.

Суть этой архитектуры в том, что работу многих приложений можно рассматривать как обработку документов. При этом можно отделить сам документ, отвечающий за представление и хранение данных, от образа этого документа, видимого на экране и допускающего взаимодействие с пользователем, который просматривает и (или) редактирует документ. В соответствии с этой архитектурой библиотека MFC содержит два семейства классов, производных от базовых классов CDocument и CView .

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

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

Термин остов (приложения, класса, функции) применяется для заготовок, создаваемых инструментальными средствами AppWizard и ClassWizard. Нужно подчеркнуть — остов приложения и каркас приложения — разные понятия.

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

Обзор возможностей >

Средство ClassWizard предоставляет широкий спектр услуг. Он позволяет не только добавлять к существующему классу новые методы и данные.

Создание нового класса. При помощи ClassWizard можно добавить новый класс, созданный на основе базовых классов. В качестве базового класса можно использовать классы, наследованные от класса CCmdTarget или класса CRecordset . Для наследования классов от других базовых классов использовать средства ClassWizard нельзя. Такие классы надо создавать вручную, непосредственно в текстовом редакторе.

Объекты, порожденные от класса CCmdTarget , могут обрабатывать сообщения Windows и команды, поступающие от меню, кнопок, акселераторов. Класс CCmdTarget и другие наследованные от него классы имеют таблицу сообщений (Message Map) — набор макрокоманд, позволяющий сопоставить сообщения Windows и команды метода класса.

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

Включение в класс новых методов. Очень удобно использовать ClassWizard для включения в состав класса новых методов. Можно добавлять к классу методы, служащие для обработки сообщений Windows и команд от объектов, а также методы, переопределяющие виртуальные методы базовых классов.

ClassWizard не только позволяет добавить в класс новые методы, но и удалить их. ClassWizard самостоятельно удалит объявление метода из класса.

Включение в класс новых элементов данных. ClassWizard позволяет включать в класс не только новые методы, но и элементы данных, связанные с полями диалоговых панелей, форм просмотра и форм для просмотра записей баз данных и полей наборов записей. ClassWizard использует специальные процедуры, чтобы привязать созданные им элементы данных к класса к полям диалоговых панелей. Эти процедуры носят названия «обмен данными диалоговой панели» и «проверка данных диалоговой панели» (Dialog Data Exchange and Dialog Data Validation — DDX/DDV). Чтобы привязать поля из наборов записей к переменным, используется процедура обмена данными с полями записей (Record Field Exchange — RFX).

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

Имена, используемые в MFC

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

Названия всех классов и шаблонов классов библиотеки MFC начинаются с заглавной буквы C. При наследовании классов от классов MFC можно давать им любые имена. Рекомендуется начинать их названия с заглавной буквы C. Это сделает исходный текст приложения более ясным для понимания.

Чтобы отличить элементы данных, входящих в класс, от простых переменных, их имена принято начинать с префикса m_. Названия методов классов, как правило, специально не выделяются, но обычно их начинают с заглавной буквы.

Библиотека MFC включает в себя, помимо классов, набор служебных функций. Названия этих функций начинаются с символов Afx, например AfxGetApp . Символы AFX являются сокращением от словосочетания Application FrameworkX, означающих основу приложения, его внутреннее устройство.

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

Когда приложение разрабатывается средствами MFC AppWizard и ClassWizard, они размещают в исходном тексте приложения комментарии следующего вида:

Такие комментарии образуют блок кода программы, который управляется только средствами MFC AppWizard и ClassWizard. Пользователь не должен вручную вносить изменения в этом блоке. Для этого необходимо употреблять средства ClassWizard.

В следующей таблице представлено краткое описание некоторых блоков //<

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

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

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

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

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

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

MFC AppWizard и ClassWizard помогают разрабатывать приложения. Они создают все классы и методы, необходимые для его работы. Программисту остается дописать к ним свой код. В тех местах, где можно вставить свой код, MFC AppWizard и ClassWizard, как правило помещают комментарии:

Какова судьба MFC и C++?

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

Java едва ли чаще используется для десктопа, чем MFC. А вот C# сейчас цветет бурным цветом. Хотя часто встречается тандем из бизнес-логики на C++ и интерфейса на С#.

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

Новые книги

Что такое блог, сегодня знает каждый или практически каждый пользователь Интернета. И судя по стремительно возрастающему количеству блогов в Сети, для многих блогинг – достаточно серьезное увлечение. Но далеко не каждый знает, что это увлечение вполне может быть очень прибыльным. Как «заставить» блог приносить деньги? Как создать и раскрутить свой блог? Как выбрать целевую аудиторию и тематику? Ответы на эти и многие другие вопросы вы найдете в практическом руководстве Евгения Литвина.

Откройте для себя профессиональные секреты успеха, узнайте, как хобби может приносить прибыль!

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

В книге изложены методы восстановления данных с различных носителей информации – жестких дисков, массивов RAID, CD, DVD, карт флэш-памяти, карт фотоаппаратов и мобильных телефонов. Ремонт поврежденного оборудования рассматривается в издании только как один из аспектов всего процесса извлечения данных. Основная тема – извлечение данных, поврежденных из-за физических или логических нарушений в работе компьютерной системы либо неверных действий пользователя. В книге рассматривается восстановление случайно удаленных файлов, извлечение ценной информации с поломанных жестких дисков; описываются программы и методика восстановления данных с поврежденных массивов RAID, что критически важно для работы корпоративных компьютерных систем.

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

8. Пример использования MFC в Visual C++.

В этой главе будет показано как включить потдержку MFC в Visual C++ на примере двух типов приложений:

1. Консольное приложение

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

int main( int argc, char* argv[] )
<
if ( !AfxWinInit( ::GetModuleHandle( NULL ), NULL, ::GetCommandLine( ), 0 ) )
<
cerr

2. Приложение типа Windows Application

Что бы создать приложение типа Windows Application с использованиеи MFC нужно сделать следующие шаги( создадим для простоты приложение основанное на диалогах ):

    1. Запустите Visual C++.
    2. Выберите File / New.
    3. Выберите закладку «Projects» / «MFC AppWizard( exe )», введите имя проекта( Project name ) и место для проекта( Location ) и нажмите кнопку «OK». В ответ будут выводится диалоговые панели.
    4. MFC AppWizard — Step 1. Выберите интересующий тип проекта( простой документ, мулти-документ или документ, основанный на диалогах ) и нажмите кнопку «Next>» ( Вам надо выбрать «Dialog based»).
    5. MFC AppWizard — Step 2. Нажмите кнопку «Next>».
    6. MFC AppWizard — Step 3. Нажмите кнопку «Finish».
    7. New Project Information. Нажмите кнопку «OK».

Ну вот и всё, у Вас есть уже готовая программа, потдерживающая MFC.

Статья: Пример использования MFC в Visual C

Пример использования MFC в Visual C++

В этой статье будет показано как включить потдержку MFC в Visual C++ на примере двух типов приложений:

1. Консольное приложение

2. Приложение типа Windows Application

1. Консольное приложение

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

int main( int argc, char* argv[] )

if ( !AfxWinInit( ::GetModuleHandle( NULL ), NULL, ::GetCommandLine( ), 0 ) )

cerr » ( Вам надо выбрать «Dialog based»).

5. MFC AppWizard — Step 2. Нажмитекнопку «Next>».

6. MFC AppWizard — Step 3. Нажмитекнопку «Finish».

7. New Project Information. Нажмитекнопку «OK».

Ну вот и всё, у Вас есть уже готовая программа, потдерживающая MFC

Исследование новых возможностей C++ и MFC в Visual Studio 2010

Сумит Кумар

Visual Studio 2010 предоставляет огромные возможности для разработчиков на С++ — от использования новых возможностей Windows 7 до улучшенных средств более эффективной работы с большими кодовыми базами.

В этой статье я объясню, как Microsoft решила некоторые значимые проблемы, с которыми сталкивались разработчики на C++. Конкретнее, Visual Studio 2010 поддерживает более современную модель программирования за счет введения основных языковых средств из будущего стандарта C++0x и переработки стандартной библиотеки, чтобы она позволяла использовать новые языковые средства. Появились новые инструменты и библиотеки для создания параллельных программ. Вы также найдете более совершенные IntelliSense и средства распознавания кода, способные работать с большими кодовыми базами. Кроме того, вы получите выигрыш от повышенного быстродействия библиотек и прочей функциональности, применяемых на этапах проектирования, разработки, компилирования и связывания.

В Visual Studio 2010 система сборки перенесена в MSBuild, чтобы повысить ее гибкость и обеспечить поддержку ориентации на разные платформы. А доработанная библиотека MFC позволит задействовать всю мощь новых Windows 7 API и писать отличные приложения для Windows 7.

Давайте подробнее рассмотрим усовершенствования в Visual Studio 2010, ориентированные на C++.

Основные языковые средства C++0x

Принятие нового стандарта C++ уже не за горами. Чтобы помочь вам приступить к работе с расширениями C++0x, компилятор Visual C++ в Visual Studio 2010 поддерживает шесть основных языковых средств C++0x: лямбда-выражения, ключевое слово auto, ссылки rvalue, static_assert, nullptr и decltype.

Лямбда-выражения неявно определяют и конструируют безымянные объекты-функции (function objects). Лямбды предоставляют упрощенный естественный синтаксис для определения объектов-функций там, где они используются, не создавая дополнительных издержек.

Объекты-функции — очень эффективный способ настройки поведения алгоритмов Standard Template Library (STL) и могут инкапсулировать как код, так и данные (в отличие от обычных функций). Но определять объекты-функции было неудобно, потому что для этого приходилось писать целые классы. Более того, они определялись вовсе не в том месте, где использовались, и это отсутствие локальности дополнительно затрудняло их применение. В библиотеках пытались снять остроту части проблем, но это слабо помогало из-за того, что синтаксис становился еще сложнее, а сообщения компилятора об ошибках были весьма невнятными. Кроме того, использование объектов-функций из библиотек менее эффективно, так как объекты-функции, определенные как поля данных, не подставляются в строку.

Лямбда-выражения решают эти проблемы. Следующий фрагмент кода иллюстрирует лямбда-выражение, используемое в программе для удаления целых чисел между значениями переменных x и y из целочисленного вектора:

Во второй строке расположено лямбда-выражение. Квадратные скобки, называемые интродукторами лямбды (lambda-introducer), указывают определение лямбда-выражения. В данном случае лямбда принимает целое значение n в качестве параметра, а генерируемый лямбда-выражением объект-функция имя для поля данных:x и y. Сравните эти строки кода с эквивалентным объектом-функцией, написанным вручную, чтобы оценить, насколько удобнее и быстрее писать лямбды:

Ключевое слово auto всегда присутствовало в C++, но им редко пользовались, потому что оно не давало особой пользы. Смысл этого ключевого слова в C++0x пересмотрен, и теперь оно автоматически определяет тип переменной по ее инициализатору. Auto делает код лаконичнее, редотвращает ошибки с типами и ошибки усечения. Оно также помогает сделать код более обобщенным, позволяя писать шаблоны, где меньше внимания уделяется типам промежуточных выражений. Следующий код показывает, как ключевое слово auto избавляет вас от указания типа шаблона в цикле for, в котором перебирается вектор:

Ссылки rvalue — новый ссылочный тип, введенный в C++0x, который помогает решить проблему необязательного копирования и обеспечивает корректное перенаправление (perfect forwarding). Когда в правой части выражения присваивания находится rvalue, объект в левой части этого выражения может заимствовать ресурсы у объекта в правой части, не выполняя отдельную операцию выделения памяти; тем самым реализуется семантика перемещения.

Корректное перенаправление позволяет написать единственный шаблон функции, принимающий n произвольных аргументов и прозрачно перенаправлять их другой произвольной функции. Природа аргумента (модифицируемый, const, lvalue или rvalue) в процессе перенаправления сохраняется:

Подробное описание ссылок rvalue выходит за рамки этой статьи, поэтому дополнительные сведения приведены в документации MSDN по ссылке msdn.microsoft.com/library/dd293668(VS.100).

Static_assert позволяет проверять контрольные выражения (assertions) при компиляции, а не в период выражения. И дает возможность инициировать ошибки компиляции с собственными, более понятными сообщениями. Ключевое слово static_assert особенно полезно для проверки допустимости параметров шаблона. Например, компиляция следующего кода приведет к ошибке «error C2338: custom assert: n should be less than 5»:

Ключевое слово nullptr добавляет null-указателям безопасность типов в многопоточной среде и тесно связано со ссылками rvalue. В качестве null-указателя часто используются макрос NULL (определенный как 0) и литерал 0. До сих пор это не было проблемой, но они плохо работают в C++0x из-за потенциальных проблем в корректном перенаправлении (perfect forwarding). Поэтому ключевое слово nullptr отчасти было введено для того, чтобы избежать таинственных сбоев в функциях корректного перенаправления.

Nullptr является константой типа type nullptr_t, который можно преобразовать в любой тип-указатель, но не в другие типы вроде int или char. Помимо использования в функциях корректного перенаправления, nullptr можно применять везде, где раньше в качестве null-указателя был задействован макрос NULL.

Но будьте осторожны: NULL по-прежнему поддерживается компилятором и пока не заменен nullptr. Это сделано в основном для того, чтобы не разрушать существующий код, в котором часто используется NULL. Но в будущем nullptr должен полностью заменить NULL, и на данном этапе NULL следует рассматривать только как средство поддержания обратной совместимости.

Наконец, decltype позволяет компилятору логически распознавать тип, возвращаемый функцией, исходя из произвольного выражения, и делать корректное перенаправление более обобщенным. В прошлых версиях для двух произвольных типов T1 и T2 нельзя было логически вычислить тип выражения, в которым эти два типа присутствовали. Так вот, decltype дает вам возможность заявлять, что, например, выражение с аргументами шаблона — такое как sum () — имеет тип T1+T2.

Изменения в стандартной библиотеке

Значительная часть стандартной библиотеки C++ была переписана, чтобы задействовать преимущества новых языковых средств C++0x и увеличить ее быстродействие. Кроме того, в эту библиотеку внесли много новых алгоритмов.

Стандартная библиотека в полной мере использует ссылки rvalue. Такие типы, как vector и list, теперь имеют собственные конструкторы и операторы присваивания move. Операции повторного выделения памяти под векторы используют семантику move через эти новые конструкторы, поэтому, если в ваших типах есть конструкторы и операторы присваивания move, библиотека будет выбирать их автоматически.

Теперь вы можете создать общий указатель (shared pointer) на объект прямо при конструировании этого объекта с помощью новой функции шаблона make_shared в C++0x:

В Visual Studio 2008 с той же целью вам пришлось бы написать:

Использовать make_shared удобнее (вы будете реже набирать имя типа), надежнее (новое ключевое слово предотвращает классическую утечку памяти с безымянным shared_ptr, так как указатель и объект создаются одновременно) и эффективнее (выполняется одна операция динамического выделения памяти вместо двух).

В библиотеке также содержится новый, более «интеллектуальный» тип указателей — unique_ptr (его появление стало возможным благодаря введению ссылок rvalue). В итоге auto_ptr переведено в разряд устаревших; с unique_ptr вы не столкнетесь с такими подвохами auto_ptr, как возможность перемещения, но не копирования. Это позволяет вам реализовать строгую семантику владения, не затрагивая безопасность. Новое ключевое слово также отлично работает с контейнерами Visual C++ 2010, поддерживающими ссылки rvalue.

В контейнерах появились новые функции-члены cbegin и cend, которые позволяют использовать const_iterator для просмотра содержимого контейнера независимо от его типа:

В Visual Studio 2010 в стандартную библиотеку добавлено большинство алгоритмов, предложенных в различных технических документах C++0x. Теперь в ней доступно подмножество библиотеки преобразований Dinkumware, и вы можете очень легко выполнять различные преобразования, например UTF-8 в UTF-16. Стандартная библиотека поддерживает распространение исключения через exception_ptr. Много обновлений было внесено в заголовочный файл . В этом выпуске есть однонаправленный список (singly linked list) с именем forward_list. Появился заголовочный файл , улучшающий диагностику. Кроме того, многие средства TR1, которые в предыдущем выпуске находились в пространстве имен std::tr1 (например, shared_ptr и regex), теперь являются частью стандартной библиотеки в пространстве имен std.

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

В Visual Studio 2010 введена платформа параллельных вычислений (Parallel Computing Platform), которая помогает быстро писать высокопроизводительный параллельный код и в то же время предотвращает тонкие ошибки в параллельной обработке. Это позволит вам избавиться от некоторых традиционных проблем, связанных с параллельной обработкой.

Parallel Computing Plat­form состоит из четырех основных частей: Concurrency Runtime (ConcRT), Parallel Patterns Library (PPL), Asynchronous Agents Library и средств отладки и профилирования параллельного кода.

ConcRT — самый низкий программный уровень, взаимодействующий непосредственно с ОС, и осуществляющий арбитраж множества параллельных компонентов в их конкуренции за ресурсы. Поскольку это процесс пользовательского режима, он может отзывать ресурсы, когда используются его механизмы кооперативной блокировки. ConcRT поддерживает локальность и предотвращает переключение задач между разными процессорами. Он также использует механизм планирования пользовательского режима (User Mode Scheduling, UMS) из Windows 7, что в ряде случаев может резко повысить производительность, даже если механизм кооперативной блокировки не применяется.

PPL предоставляет шаблоны для написания параллельного кода. Если вычисления допускают разложение на независимые операции, которые можно представить функциями или объектами-функциями, каждая из этих операций может рассматриваться как задача (task). Концепция задач намного ближе к предметной области, чем потоки, которые уводят вас от предметной области, заставляя думать об оборудовании, ОС, критических секциях и т. п. Задача может выполняться параллельно с другими задачами независимо от того, что именно делают эти другие задачи. Например, сортировку двух половин массива можно выполнять как две параллельные задачи.

PPL включает параллельные классы (task_handle, task_group и structured_task_group), параллельные алгоритмы (parallel_invoke, parallel_for и parallel_for_each), параллельные контейнеры (combinable, concurrent_queue и concurrent_vector), а также синхронизирующие примитивы, поддерживаемые ConcRT (critical_section, event и reader_writer_lock), — все они полностью поддерживают концепцию задач. Все компоненты PPL находятся в пространстве имен concurrency.

Группы задач позволяют выполнять наборы задач и ждать завершения их всех. В частности, в примере с сортировкой задачи, обрабатывающие две половины массива, могут быть одной группой задач. Тогда вы получите гарантию, что эти две задачи будут завершены в конце вызова функции-члена wait, как показано ниже на примере рекурсивной сортировки «quicksort», написанной с применением параллельных задач и лямбд:

Этот код можно еще больше улучшить, используя structured_task_group, поддерживаемую алгоритмом parallel_invoke. Он принимает от двух до десяти объектов-функций и выполняет их все параллельно, используя столько ядер, сколько предоставляет ConcRT, а затем ждет их завершения:

Каждая из задач может порождать несколько подзадач. Сопоставление между задачами и потоками (и обеспечение оптимального использования всех ядер) берет на себя ConcRT. Поэтому разложение ваших вычислений на максимально возможное количество задач поможет задействовать все доступные ядра.

Еще один полезный параллельный алгоритм — parallel_for, применяемый для параллельного перебора в цикле:

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

Asynchronous Agents Library предоставляет модель программирования, основанную на потоках данных (dataflow-based programming model), где вычисления зависят от доступности необходимых данных. Эта библиотека базируется на концепциях агентов, блоков сообщений и функций передачи сообщений. Агент — это компонент приложения, выполняющий определенные вычисления и асинхронно взаимодействующий с другими агентами для решения более крупной вычислительной операции. Взаимодействие между агентами осуществляется через функции передачи сообщений и блоки сообщений.

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

Чтобы задействовать преимущества этих шаблонов, вам не нужно связывание с дополнительными компонентами, равно как не требуется и распространять какие-либо редистрибутивы. ConcRT, PPL и Asynchronous Agents Library реализованы в msvcr100.dll, msvcp100.dll и libcmt.lib/libcpmt.lib попутно со стандартной библиотекой. Реализации PPL и Asynchronous Agents Library в основном заключены только в заголовочных файлах.

Отладчик Visual Studio теперь поддерживает ConcRT и позволяет легко отлаживать ошибки, связанные с параллельной обработкой, — в отличие от Visual Studio 2008, где отладчик ничего не знал о высокоуровневых концепциях распараллеливания. В Visual Studio 2010 имеется средство профилирования параллельного кода, с помощью которого можно визуализировать поведение параллельных приложений. В отладчик введены новые окна, визуализирующие состояние всех задач в приложении и их стеки вызовов. Рис. 1 показаны окна Parallel Tasks и Parallel Stacks.

Рис. 1 Отладочные окна Parallel Stacks и Parallel Tasks

IntelliSense и производительность в соотношении разработка-время

В Visual Studio 2010 включена совершенно новая инфраструктура IntelliSense и просмотра. Она не только быстро работает в проектах с большими кодовыми базами, но и предоставляет ряд новых средств, повышающих производительность труда на этапе разработки.

В IntelliSense содержатся такие средства, как активная система отчетов об ошибках и подсказки Quick Info; они базируются на новом клиентском интерфейсе компилятора, который «на лету» разбирает единицы трансляции и предоставляет полную и точную информацию о семантике кода даже в процессе модификации файлов исходного кода.

Все средства просмотра кода, такие как представление классов и иерархия классов, теперь используют информацию об исходном коде, хранящуюся в базе данных SQL, которая обеспечивает индексацию и занимает фиксированный объем памяти. В отличие от предыдущих выпусков Visual Studio 2010 IDE всегда отвечает, и вам больше не придется ждать, пока не будет выполнен повторный разбор единиц компиляции из-за изменений в заголовочном файле.

Активная система отчетов об ошибках в IntelliSense (знакомые красные волнистые линии) выделяет синтаксические и семантические ошибки при просмотре и редактировании кода. Задержав курсор мыши над одной из таких ошибок, вы получите сообщение (рис. 2). Окно со списком ошибок также показывает ошибку из текущего просматриваемого файла, равно как и ошибки, обнаруженные Intelli­Sense в любой части единицы компиляции. Вся эта информация доступна вам без выполнения процесса сборки.

Рис. 2 Активная система отчетов об ошибках в IntelliSense

Кроме того, при наборе директивы #include в раскрывающемся списке показываются релевантные включаемые файлы, и этот список обновляется по мере ввода новых символов.

Новая функция Navigate To (Edit | Navigate To или Ctrl+запятая) ускорит вам поиск файла или символа. Она предоставляет результаты поиска в реальном времени, исходя из уже набранных вами частей строк (рис. 3). Эта функция также работает с файлами C# и Visual Basic и является расширяемой.

Рис. 3 Использование функции Navigate To

Call Hierarchy (вызывается клавишами Ctrl+K, Ctrl+T или из контекстного меню) позволяет перемещаться к любым функциям, вызываемым из конкретной функции, или к конкретной функции, вызываемой из всех интересующих вас функций. Это более совершенная версия функции Call Browser, содержавшейся в предыдущих выпусках Visual Studio. Окно Call Hierarchy организовано намного лучше и показывает вызовы из деревьев для любой функции, присутствующей в окне, а также вызовы к этим деревьям.

Заметьте: хотя все функции просмотра кода доступны как для чистого C++, так и для C++/CLI, IntelliSense-средства вроде активной системы отчетов об ошибках и Quick Info не будут поддерживаться для C++/CLI в финальном выпуске Visual Studio 2010.

В этом выпуске усовершенствованы и другие средства редактора. Так, популярная функция Find All References, применявшаяся для поиска ссылок на элементы кода (классы, члены класса, функции и т. д.) в рамках полного решения, стала более гибкой. Результаты поиска можно еще больше сужать, используя команду Resolve Results из контекстного меню.

Неактивный код теперь сохраняет семантическую информацию, не теряя цветовые выделения (раньше он становился просто серым). На рис. 4 показано, как затемняется неактивный код, но при этом сохраняет все цветовые выделения, относящиеся к семантической информации.

Рис. 4 Неактивные блоки кода сохраняют цветовые выделения

Помимо уже описанных функций, редактор в Visual Studio 2010 просто удобнее в использовании.Новая IDE на базе Windows Presentation Foundation (WPF) основательно переработана, и из нее были убраны все нагромождения в UI. Окна документов, например редактора кода и дизайнера, можно перемещать за пределы основного окна IDE и отображать на нескольких мониторах. Стало намного проще увеличивать или уменьшать содержимое окна редактора кода, используя клавишу Ctrl и колесико мыши. IDE также обеспечивает более широкие возможности расширения.

Системы сборки и проектов

В Visual Studio 2010 внесены существенные изменения в систему сборки (build system) и в систему проектов (project system) для C++.

Самое важное изменение заключается в том, что для сборки проектов на C++ теперь используется MSBuild. MSBuild является расширяемым ядром управления сборкой и базируется на XML.Оно применялось для проектов на C# и Visual Basic в предыдущих версиях Visual Studio. Теперь MSBuild — общая система сборки от Microsoft для всех языков. Ее можно использовать как в сборочной лаборатории, так и на индивидуальных компьютерах разработчиков.

Процессы сборки проектов на C++ теперь определяются в терминах MSBuild (файлы задач и целевых платформ) и дают вам более широкие возможности в настройке, управлении и прозрачности.

Тип файлов проектов на C++ получил новое расширение: .vcxproj. Visual Studio будет автоматически обновлять старые файлы и решения .vcproj до нового формата. Также имеется утилита командной строки vcupgrade.exe, позволяющая обновлять отдельные проекты из командной строки.

В прошлом вы могли использовать только тот набор инструментов (компилятор, библиотеки и т. д.), который предоставлялся текущей версией Visual Studio. И начать работу с новой IDE было невозможно до перехода на новый набор инструментов. Visual Studio 2010 решает эту проблему и позволяет выполнять сборку с ориентацией на несколько разных версий наборов инструментов. Например, работая в Visual Studio 2010, вы могли бы ориентироваться на компилятор и библиотеки Visual C++ 9.0. На рис. 5 показаны соответствующие настройки, доступные на странице свойств.

Рис. 5 Ориентация на несколько Platform Toolset

Применение MSBuild делает систему сборки кода на C++ гораздо более расширяемой. Если система сборки по умолчанию не удовлетворяет вашим потребностям, вы можете расширить ее, добавив собственный инструмент или введя какую-либо дополнительную стадию сборки. При операциях сборки MSBuild использует задачи как повторно применяемые единицы исполняемого кода. Вы можете создавать собственные задачи и расширять систему сборки, определяя их в XML-файле. MSBuild генерирует задачи по таким XML-файлам «на лету».

Существующие платформы и наборы инструментов можно расширять добавлением файлов .props и .targets в папки ImportBefore и Import­After. Это особенно полезно для поставщиков библиотек и инструментов, которые предназначены для расширения существующих систем сборки. Вы также можете определить собственный набор инструментов платформы (platform toolset). Кроме того, MSBuild предоставляет более полную диагностическую информацию, упрощая отладку проблем сборки и делая сборки с приращением (incremental builds) более надежными. Плюс вы можете создавать системы сборки, теснее связанные с системой контроля версий исходного кода и сборочной лабораторией и менее зависимые от конфигураций компьютеров разработчиков.

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

Все изменения видны на страницах свойств и могут настраиваться в соответствии с вашими потребностями. Вы можете сконфигурировать систему проектов на использование собственной платформы (например, существующих платформ x86 или x64) или собственного отладчика. Страницы свойств позволяют писать и интегрировать компоненты, динамически обновляющие значения свойства в зависимости от контекста. Система проектов Visual Studio 2010 дает возможность даже создать собственный UI для чтения и записи свойств вместо механизма на основе страниц свойств.

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

Помимо уже описанных улучшений в использовании функциональности этапа проектирования, Visual Studio 2010 также повышает скорость компиляции, качество и производительность приложений, создаваемых с помощью компилятора Visual C++, в результате множества усовершенствований, внесенных в процесс генерации кода.За счет ряда оптимизаций скорость компиляции на платформах x64 заметно увеличена.

Производительность некоторых приложений зависит от рабочего набора (working set). Размер кода для архитектуры x64 был уменьшен на 3–10% за счет множества оптимизаций в этом выпуске, что привело к повышению скорости работы таких приложений.

Генерация кода с применением SIMD (Single Instruction Multiple Data), важная для разработчиков игр и приложений, имеющих дело с аудио, видео и графикой, также оптимизирована для повышения качества и производительности кода. Улучшения обеспечивают, в частности, разрыв ложных зависимостей, векторизацию инициализаций векторов констант и более эффективного выделения регистров XMM для удаления лишних загрузок, сохранений и перемещений. Кроме того, было оптимизировано семейство внутренних команд __mm_set_**, __mm_setr_** и __mm_set1_**.

Для большей производительности приложения следует компилировать с применением Link Time Code Generation (LTCG) и Profile Guided Optimization (PGO).

За счет ряда оптимизаций скорость компиляции на платформах x64 заметно увеличена. Компиляция с LTCG, рекомендованная для более качественной оптимизации, обычно выполняется дольше, чем без LTCG, особенно в больших приложениях. В Visual Studio 2010 компиляция с LTCG ускорена вплоть до 30%. В этом выпуске введен выделенный поток для записи PDB-файлов, поэтому вы увидите ускорение процесса связывания при использовании ключа /DEBUG.

Проходы с инструментарием PGO выполняются быстрее за счет введения поддержки версий оснащенных двоичных файлов, не содержащих блокировок. Также появился новый вариант POGO — PogoSafeMode, который позволяет указывать, какой режим следует использовать при оптимизации приложения — безопасный или быстрый. По умолчанию применяется быстрый режим. Безопасный режим медленнее быстрого, но безопасен в многопоточной среде.

Повышено качество кода, генерируемого компилятором. Теперь полностью поддерживаются Advanced Vector Extensions (AVX), которые очень важны для приложений, выполняющих интенсивные вычисления с плавающей точкой на процессорах AMD и Intel; они включаются встроенными параметрами и /arch:AVX. Точность вычислений с плавающей точкой повышается при использовании параметра /fp:fast.

Создание приложений для Windows 7

В Windows 7 появился целый ряд новых потрясающих технологий и средств, а также добавлены новые API, и Visual Studio 2010 обеспечивает доступ ко всем новым Windows API. Компоненты Windows SDK, необходимые для написания кода для неуправляемых Windows API, поставляются вместе с Visual Studio 2010. Вы можете задействовать такие инновационные API, как Direct3D 11, DirectWrite, Direct2D и Windows Web Service, используя заголовочные файлы SDK и библиотеки, доступные в Visual Studio 2010.

Этот выпуск Visual Studio не только обеспечивает доступ ко всем Windows API, но и упрощает написание Windows-приложений с помощью кардинально переработанной MFC. К значительной части функциональности Windows 7 можно получить доступ через библиотеки MFC, не обращаясь к неуправляемым API напрямую. Ваши существующие MFC-приложения заиграют «новыми красками» в Windows 7 просто за счет перекомпиляции. Ну а новые приложения смогут задействовать все преимущества новых средств.

MFC теперь обеспечивает улучшенную интеграцию с оболочкой Windows. Интеграция вашего приложения с Windows Explorer может быть более полной за счет применения обработчиков файлов для предварительного просмотра, вывода эскизов и поиска, поддерживаемых в этом выпуске. Эти средства предоставляются как выбираемые параметры в MFC Application Wizard (рис. 6) MFC автоматически сгенерирует проект ATL DLL, реализующий эти обработчики.

Рис. 6 MFC Application Wizard со страницей параметров обработчика файлов

Одно из самых заметных изменений UI в Windows 7 — новая панель задач. MFC позволяет быстро задействовать преимущества таких средств, как списки переходов (jump lists), строки ярлычков эскизов (tabbed thumbnails), предварительного просмотра эскизов (thumbnail preview), полосок прогресса (progress bars), оверлейных значков (icon overlay) и т. д. На рис. 7 показаны предварительно просматриваемые эскизы и строка с ярлычками эскизов для MFC-приложения типа MDI.

Рис. 7 Предварительный просмотр эскизов и строка с их ярлычками в MFC-приложении

Ленточный UI теперь имеет стиль, принятый для лент в Win­dows 7, и в вашем приложении можно «на лету» менять UI в любой момент во время разработки с нескольких лент в стиле Office на ленту в стиле Windows 7, используя раскрывающийся список стилей рис. 8.

Рис. 8 Раскрывающийся список Style в MFC-приложении

MFC дает возможность вводить в ваши приложения мультисенсорную поддержку (multi-touch) и передает вам соответствующие сообщения для обработки при возникновении различных событий касания. Вам нужно лишь зарегистрироваться на события касания и жестов, и они будет направляться вашему приложению. Кроме того, MFC-приложения по умолчанию поддерживают высокие DPI-разрешения, поэтому они способны адаптироваться к экранам с высоким DPI, и при этом их окна не выглядят размытыми или мозаичными. MFC на внутреннем уровне масштабирует и изменяет шрифты и другие элементы, гарантируя четкость отображения вашего UI на экранах с высоким DPI.

Кроме новых средств Windows 7, существовала и другая функциональность, введенная со времен Windows Vista, но не поддерживавшаяся в предыдущих выпусках MFC.Эта ситуация теперь исправлена. Например, Restart Manager — полезная функция Windows Vista, которая позволяет сохранять приложение перед его принудительным завершением. Приложение может вызвать эту функцию и после перезапуска восстановить свое состояние. Теперь вы можете в полной мере использовать Restart Manager в своем MFC-приложении для более элегантной обработки его краха и перезапуска. Чтобы разрешить перезапуск и восстановление в существующем приложении, просто добавьте строку кода:

Новые MFC-приложения получают эту функциональность автоматически при использовании MFC Application Wizard. Механизм автоматического сохранения доступен приложениям, которые сохраняют документы, а пользователь может определять интервалы автоматического сохранения. В MFC Application Wizard для программы можно выбрать поддержку лишь перезапуска или только восстановления (применимо к приложениям типа Doc/View).

Еще одно добавление — диалог Windows Task, который является улучшенным видом окна сообщения (рис. 9). В MFC теперь есть оболочка диалога Task, которую можно применять в приложениях.

Рис. 9 Диалог Task

MFC Class Wizard возвращается

В библиотеку MFC не только добавлена новая функциональность — этот выпуск упрощает работу с MFC в Visual Studio IDE. Было очень много просьб вернуть MFC Class Wizard (рис. 10), и вот он возвращен и вдобавок усовершенствован. С его помощью можно добавлять классы, обработчики событий и другие элементы приложения.

Рис. 10 MFC Class Wizard

Другое дополнение — Ribbon Designer (дизайнер лент), который позволяет визуально проектировать ленточный UI (вместо его определения в коде, как в Visual Studio 2008) и сохранять его как XML-ресурс. Этот дизайнер, очевидно, будет полезен при разработке новых приложений, но и в существующих приложениях с его помощью можно обновить UI. XML-определение можно создать простым добавлением временной строки к существующему определению ленточного UI в коде:

Полученный XML-файл можно использовать как файл ресурса и в дальнейшем модифицировать с помощью Ribbon Designer.

Заключение

Visual Studio 2010 — важный выпуск в эволюции Visual C++, и он во многих отношениях облегчает жизнь программистам. В этой статье я лишь кратко обрисовал наиболее важные усовершенствования, связанные с C++. Более подробное описание различных средств см. в документации MSDN и в блоге группы Visual C++ по ссылке blogs.msdn.com/vcblog, сообщения в котором послужили основой для некоторых разделов этой статьи.

Сумит Кумар (Sumit Kumar) — менеджер программ в группе Visual C++ IDE. Магистр компьютерных наук (Техасский университет в Далласе).

Благодарю следующих технических специалистов: Стефан Т. Лававей (Stephan T. Lavavej), Мариан Лупару (Marian Luparu) и Тарек Мадкур (Tarek Madkour)

2. Введение в MFC

На сегодня существует более десятка версий библиотеки MFC. Практически каждая новая версия среды Microsoft Visual C++ (MSVC) поставляется с обновленной версией библиотеки MFC, в которой исправлены обнаруженные ошибки и добавлены новые классы.

Все версии библиотеки MFC можно разделить на две группы. К первой относятся 16-разрядные версии MFC, предназначенные для операционных систем Windows 3.1 и 3.11. Вторая группа включает версии MFC, предназначенные для 32-разрядных операционных систем Windows NT и Windows 95. В следующей таблице перечислены все основные версии Microsoft Visual C++ и соответствующие им версии MFC.

Среда разработки Версия MFC Разрядность
Microsoft C/C++ версии 7.0 1.0 16
MSVC 1.0 2.0 16
MSVC 1.1 2.1 32
MSVC 1.5 2.5 16
MSVC 2.0 2.51 16
MSVC 2.1 2.52 16
MSVC 2.2 2.52b 16
MSVC 4.0 2.5c 16
MSVC 2.0 3.0 32
MSVC 2.1 3.1 32
MSVC 2.2 3.2 32
MSVC 4.0 4.0 32
MSVC 4.1 4.1 32

Вы легко можете определить версию библиотеки MFC, установленной на вашем компьютере. Для этого достаточно просмотреть включаемый файл afxver_.h, расположенный в каталоге include библиотеки MFC. В одной из первых строк этого файла определена константа _MFC_VER, содержащая версию MFC:

// Microsoft Foundation Classes версии 4.00

Мы будем рассматривать библиотеку MFC версий 3.0, 4.0 и 4.1, однако приведенная информация верна и для других версий MFC. В тех случаях, когда эти версии имеют существенные отличия мы будем на это специально указывать.

Классы библиотеки MFC

Библиотека классов MFC содержит большое количество разнообразных классов. Так MFC версии 4.0 включает немного меньше 200 классов. Каждый класс, как правило, содержит от нескольких единиц до нескольких десятков различных методов и элементов данных. Конечно это значительно усложняет освоение программирования с помощью MFC. Но не стоит расстраиваться и опускать руки. Вам вовсе не обязательно знать как устроены все 200 классов. Большинство приложений можно построить на основе нескольких основных классов. Более того, самое простое приложение, которое мы предложим вашему вниманию, будет использовать только один класс из библиотеки MFC.

Мы не станем приводить здесь всю иерархию классов MFC. Вы можете изучить ее, воспользовавшись документацией или справочной системой среды Visual C++. Чтобы просмотреть иерархию классов в справочной системе Visual C++, выберите из окна Project Workspace страницу InfoView, откройте описание MFC 4.0, а затем из раздела Class Library Reference выберите статью Hierarcy Chart (рис. 2.1).

Рис. 2.1. Просмотр иерархии классов MFC

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

Самый базовый класс MFC (класс CObject)

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

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

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

Ряд методов класса CObject предназначен для получения дампа объектов класса во время отладки приложения. Эта особенность класса может ускорить процесс поиска ошибок в приложении.

Основа структуры приложения (класс CCmdTarget)

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

Структура классов, связанных с классом CCmdTarget представлена на рисунке 2.2.

Рис. 2.2. Класс CCmdTarget

Подзадачи приложения (классы CWinThread и CWinApp)

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

Документ приложения (класс CDocument)

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

Шаблон документов (классы CDocTemplate, CSingleDocTemplate и CMultiDocTemplate)

Еще один важный класс, наследуемый от CCmdTarget, называется CDocTemplate. От этого класса наследуются два класса CSingleDocTemplate и CMultiDocTemplate. Все эти классы предназначены для синхронизации и управления основными объектами представляющими приложение – окнами, документами и используемыми ими ресурсами.

Окна (класс CWnd)

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

Вы очень редко будете создавать объекты класса CWnd. Класс CWnd сам является базовым классом для большого количества классов, представляющих разнообразные окна. На рисунке 2.3 представлена только небольшая часть дерева наследования класса CWnd.

Рис. 2.3. Класс CWnd

Перечислим классы, наследованные от базового класса CWnd.

• Обрамляющие окна (класс CFrameWnd)

Класс CFrameWnd представляет окна, выступающие в роли обрамляющих окон (frame window), в том числе главные окна приложения. От этого класса также наследуются классы CMDIChildWnd и CMDIFrameWnd, используемые для отображения окон многооконного интерфейса MDI. Класс CMDIFrameWnd представляет главное окно приложения MDI, а класс CMDIChildWnd – его дочерние окна MDI. Класс CMiniFrameWnd применяется для отображения окон уменьшенного размера. Такие окна обычно используются для отображения в них панели управления.

• Окна органов управления

В предыдущих томах серии “Библиотека системного программиста” мы рассказывали о том, что существует ряд органов управления, встроенных в операционную систему. К ним относятся кнопки, полосы прокрутки, редакторы текста, переключатели и т. д.

Для работы с этими органами управления в библиотеке MFC предусмотрены специальные классы, наследованные непосредственно от класса CWnd.

Класс Орган управления
CAnimateCtrl Используется для отображения видеоинформации
CBitmapButton Кнопка с рисунком
CButton Кнопка
CComboBox Список с окном редактирования
CEdit Поле редактирования
CHeaderCtrl Заголовок для таблицы
CHotKeyCtrl Предназначен для ввода комбинации клавиш акселераторов
CListBox Список
CListCrtl Может использоваться для отображения списка пиктограмм
CProgressCtrl Линейный индикатор
CPropertySheet Блокнот. Может состоять из нескольких страниц
CRichEditCtrl Окно редактирования, в котором можно редактировать форматированный текст
CScrollBar Полоса просмотра
CSliderCtrl Движок
CSpinButtonCtrl Обычно используется для увеличения или уменьшения значения какого-нибудь параметра
CStatic Статический орган управления
CTabCtrl Набор “закладок”
CToolBarCtrl Панель управления
CToolTipCtrl Маленькое окно содержащее строку текста
CTreeCtrl Орган управления, который позволяет просматривать иерархические структуры данных

• Управляющие панели (классы CControlBar, CStatusBar, CDialogBar)

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

Так, класс CStatusBar предназначен для создания панели управления. Эта панель обычно содержит ряд кнопок, дублирующих действие меню приложения.

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

Большие возможности представляет управляющая панель, созданная на основе класса CDialogBar. Такая панель использует обычный шаблон диалоговой панели, который вы можете разработать в редакторе ресурсов Visual C++.

• Блокнот (класс CPropertySheet)

Класс CPropertySheet представляет блокнот – диалоговую панель, содержащую несколько страниц. Отдельные страницы такого блокнота управляются объектами другого класса – CPropertyPage. Класс CPropertyPage наследуется от базового класс CDialog, который мы рассмотрим ниже.

• Окна просмотра (класс CView и классы наследованные от него)

Большой интерес представляет класс CView и классы, наследуемые от него (рис. 2.4). Эти классы представляют окно просмотра документов приложения. Именно окно просмотра используется для вывода на экран документа, с которым работает приложения. Через это окно пользователь может изменять документ.

Разрабатывая приложение, вы будете наследовать собственные классы просмотра документов либо от базового класса CView, либо от одного из нескольких порожденных классов, определенных в библиотеке MFC.

Классы, наследованные от CCtrlView, используют для отображения документа готовые органы управления. Например, класс CEditView использует орган управления edit (редактор). Более подробно эти классы будут описаны позже, когда мы будем рассказывать о средствах автоматизированного программирования MFC AppWizard и ClassWizard.

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

Класс CFormView позволяет создать окно просмотра документа, основанное на диалоговой панели. От этого класса наследуются еще два класса CRecordView и CDaoRecordView. Эти классы используются для просмотра записей баз данных.

Рис. 2.4. Класс CView

• Диалоговые панели (класс CDialog и классы наследованные от него)

Кроме перечисленных классов от базового класса CWnd наследуются классы, управляющие диалоговыми панелями. Если вы желаете создать диалоговую панель, вы можете наследовать класс от CDialog (рис. 2.5).

Вместе с диалоговыми панелями обычно используется класс CDataExchange. Класс CDataExchange обеспечивает работу процедур обмена данными DDX (Dialog Data Exchange) и проверки данных DDV (Dialog Data Validation) используемых для диалоговых панелей. В отличие от класса CDialog, класс CDataExchange не наследуется от какого-либо другого класса.

Когда вы создаете блокнот, состоящий из нескольких страниц, то каждая такая страница является объектом класса, наследованного от CPropertyPage.

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

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

Рис. 2.5. Класс CDialog

Исключения (класс CException)

Для реализации механизма исключений в MFC определен специальный класс CException, наследованный от базового класса CObject. Все исключения, определенные в MFC, наследуются от этого класса. Вот список классов, наследованных от CException и их краткое описание. Более полное описание классов, связанных с исключениями, вы можете найти в разделе “Исключения – класс CException” главы “Вспомогательные классы MFC”.

Класс Описание
CArchiveException Исключение, вызванное ошибкой при использовании объекта класса CArchive. Класс CArchive применяется для сохранения и загрузки документа из файла на диске
CDaoException Ошибка при работе с базами данных (при использовании классов DAO)
CDBException Ошибка при работе с базами данных (при использовании ODBC)
CFileException Ошибка, связанная с файловой системой
CMemoryException Недостаточно оперативной памяти
CNotSupportedException Попытка выполнить неопределенную операцию
COleDispatchException, COleException Ошибка OLE
CResourceException Не найден ресурс
CUserException Ошибка приложения, вызванная действиями пользователя

Массивы, списки и словари

В состав MFC включен целый набор классов, предназначенных для хранения информации в массивах, списках и словарях. Все эти классы наследованы от базового класса CObject.

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

Для представления массивов предназначены следующие классы.

Класс Массив содержит
CByteArray Байты
CDWordArray Двойные слова
CObArray Указателей на объекты класса CObject
CPtrArray Указателей типа void
CStringArray Объекты класса CString
CUIntArray Элементы класса unsigned integer или UINT
CWordArray Слова

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

Для построения массивов вы можете также воспользоваться шаблоном CTypedPtrArray. Этот шаблон не наследуется от базового класса CObject, поэтому использовать методы класса CObject для него нельзя.

Для решения многих задач используются такие структуры хранения данных, как списки. MFC включает ряд классов, наследованных от базового класса CObject, которые предоставляют программисту готовое средство для создания собственных списков. В этих классах определены все методы необходимые при работе со списками – добавление нового элемента, вставка нового элемента, определение следующего или предыдущего элемента в списке, удаление элемента и т. д.

Класс Список содержит элементы
CObList Указатели на объекты класса CObject
CPtrList Указатели типа void
CStringList Объекты класса CString

Перечисленные в таблице классы позволяют построить списки из элементов любых типов и объектов любых классов. Однако удобнее пользоваться шаблоном CList, также наследованным от базового класса CObject. Для построения списков вы можете также использовать шаблон CTypedPtrList. Этот шаблон не наследуется от базового класса CObject.

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

Класс Ключевое поле Поле, связанное с ключевым
CMapPtrToPtr Указатель типа void Указатель типа void
CMapPtrToWord Указатель типа void Слово
CMapStringToOb Объекты класса CString Указатели на объекты класса CObject
CMapStringToPtr Объекты класса CString Указатель типа void
CMapStringToString Объекты класса CString Объекты класса CString
CMapWordToOb Слово Указатели на объекты класса CObject
CMapWordToPtr Слово Указатель типа void

Вы можете создавать словари, имеющие поля любых типов и классов, если воспользуетесь шаблоном CMap. Шаблон CMap наследуется от базового класса CObject. Для построения словарей можно также использовать шаблон CTypedPtrMap. Шаблон CTypedPtrMap не наследуется от базового класса CObject.

Файловая система (класс CFile)

Библиотека MFC включает класс для работы с файловой системой компьютера. Он называется CFile и также наследуется от базового класса CObject. Непосредственно от класса CFile наследуются еще несколько классов – CMemFile, CStdioFile, CSocketFile.

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

Контекст отображения (класс CDC)

Для отображения информации в окне или на любом другом устройстве приложение должно получить так называемый контекст отображения. Основные свойства контекста отображения определены в классе CDC. От него наследуется четыре различных класса, представляющие контекст отображения различных устройств (рис. 2.6).

Рис. 2.6. Класс CDC

В следующей таблице приведено краткое описание классов, наследованных от CDC.

Класс Описание
CClientDC Контекст отображения, связанный с внутренней областью окна (client area). Для получения контекста конструктор класса вызывает функцию программного интерфейса GetDC, а деструктор – функцию ReleaseDC
CMetaFileDC Класс предназначен для работы с метафайлами
CPaintDC Конструктор класса CPaintDC для получения контекста отображения вызывает метод CWnd::BeginPaint, деструктор метод CWnd::EndPaint. Объекты данного класса могут использовать только при обработке сообщения WM_PAINT. Это сообщение обычно обрабатывает метод OnPaint
CWindowDC Контекст отображения, связанный со всем окном. Для получения контекста конструктор класса вызывает функцию программного интерфейса GetWindowDC, а деструктор – функцию ReleaseDC

Объекты графического интерфейса (класс CGdiObject)

Для отображения информации используются различные объекты графического интерфейса – GDI объекты. Для каждого из этих объектов библиотека MFC содержит описывающий его класс, наследованный от базового класса CGdiObject (рис. 2.7).

Рис. 2.7. Класс CGdiObject

Класс Описание
CBitmap Растровое изображение bitmap
CBrush Кисть
CFont Шрифт
CPalette Палитра цветов
CPen Перо
CRgn Область внутри окна

Меню (класс CMenu)

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

Для управления меню и панелями управления используется также класс CCmdUI. Этот класс не наследуется от базового класса CObject.

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

Базы данных (классы для работы с базами данных)

В MFC включены несколько классов, обеспечивающую поддержку приложений, работающих с базами данных. В первую очередь это классы ориентированные на работу с ODBC драйверами – CDatabase и CRecordSet. Поддерживаются также новые средства для работы с базами данных DAO (Data Access Object). Для этого предназначены классы CDaoDatabase, CDaoRecordSet, CDaoQueryDef, CDaoTableDef, CDaoWorkspace и CLongBinary.

Для работы с базами данных также предназначены классы CFieldExchange и CDaoFieldExchange. Это самостоятельные классы, они не наследуются от базового класса CObject.

Классы CFieldExchange и CDaoFieldExchange работают с процедурами обмена данными RFX (Record Field Exchange ) для классов управляющих базами данных.

Синхронизация задач приложения (класс CSyncObject)

Библиотека MFC позволяет создавать многозадачные приложения. Для синхронизации отдельных задач приложения предусмотрен ряд специальных классов. Все они наследуются от класса CSyncObject , представляющего собой абстрактный класс (рис. 2.8).

Рис. 2.8. Класс CSyncObject

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

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

Объекты класса CMutex позволяют в данный момент времени представить ресурс в пользование только одной задачи. Остальным задачам доступ к ресурсу запрещается.

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

Сокеты (классы CAsyncSocket и CSocket)

Для тех, кто занимается сетевыми коммуникациями, в состав библиотеки MFC включены классы CAsyncSocket и наследованный от него класс CSocket (рис. 2.9). В класс CAsyncSocket включен программный интерфейс Windows Socket.

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

Программирование на уровне программного интерфейса Windows с использованием сокетов описано в двадцать третьем томе серии “Библиотека системного программиста”, который называется “Глобальные сети компьютеров”.

Рис. 2.9. Класс CAsyncSocket

Классы, не имеющие базового класса

Кроме классов, наследованных от базового класса CObject, библиотека MFC включает ряд самостоятельных классов. У них нет общего базового класса и они имеют различное назначение.

Несколько классов, которые не наследуются от базового класса CObject, мы уже описали. К ним относятся класс CCmdUI, CFileStatus, CDataExchange, CFieldExchange и CDaoFieldExchange.

Простые классы

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

Класс Описание
CPoint Объекты класса описывают точку
CRect Объекты класса описывают прямоугольник
CSize Объекты класса определяют размер прямоугольника
CString Объекты класса представляют собой текстовые строки переменной длинны
CTime Объекты класса служат для хранения даты и времени. Большое количество методов класса позволяют выполнять над объектами класса различные преобразования
CTimeSpan Объекты класса определяют период времени

Архивный класс (класс CArchive)

Класс CArchive используется для сохранения и восстановления состояния объектов в файлах на диске. Перед использованием объекта класса CArchive он должен быть привязан к файлу – объекту класса CFile.

Более подробно о процессе сохранения и восстановления объектов вы можете прочитать в разделе “Сохранение и восстановление объектов”. Пример использования класса CArchive для записи и восстановления документов в файлах представлен в разделе “Простейший графический редактор” главы “Однооконный интерфейс”.

Информация о классе объекта (структура CRuntimeClass)

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

Отладка приложения (классы CDumpContext, CMemoryState)

В отладочной версии приложения вы можете использовать класс CDumpContext. Он позволяет выдавать состояние различных объектов в текстовом виде.

Класс CMemoryState позволяет локализовать проблемы, связанные с динамическим выделением оперативной памяти. Такие проблемы обычно возникают, когда пользователь выделяет память, используя оператор new, а затем забывает ввернуть эту память операционной системе.

Печать документа (класс CPrintInfo)

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

Кроме описанных нами классов библиотека MFC включает большое количество классов, предназначенных для организации технологии OLE. Из-за ограниченного объема книги мы не будем рассматривать приложения, поддерживающие OLE технологию.

Первое приложение MFC

Первое приложение MFHello, которое мы создадим с использованием библиотеки классов MFC будет очень простое. Единственное, что оно будет делать – это отображать на экране маленькую диалоговую панель, содержащую строку “Hello, MFC!”.

Исходный текст приложения, представленный в листинге 2.1, состоит всего из двенадцати строк, не считая строк комментариев. В нашем первом приложении мы использовали единственный класс библиотеки MFC, наследованный от базового класса CWinApp.

Чтобы создать новый проект, выберите из меню File строку New. На экране появится диалоговая панель New, содержащая одноименный список New и две кнопки. Выберите из списка New строку Project Workspace. Откроется диалоговая панель New project workspace (рис. 4.1 из главы “Приложение с главной диалоговой панелью”). В ней вы должны указать тип приложения, который будет разрабатываться, имя проекта и расположение каталога для записи в него файлов проекта.

Самые простые приложения с использованием библиотеки классов MFC мы будем создавать без использования автоматизированных средств разработки приложений MFC AppWizard. Поэтому в качестве типа приложения выберите из списка Type строку Application.

В поле Name введите имя нового проекта. Наш первый проект мы назвали именем MFHello. Расположение каталога для размещения файлов проекта отображается в поле Location. По умолчанию каталог проекта называется точно также как сам проект и будет размещен в каталоге Projects среды разработки Visual C++. Вы можете выбрать для проекта любой другой каталог, если нажмете на кнопку Browse.

Теперь нажмите кнопку Create. Будут созданы служебные файлы проекта. Они получат названия MFHello.mak, MFHello.ncb и MFHello.mdp. Файл MFHello.mdp является основным файлом проекта. В этих файлах определяется, какие исходные файлы содержит проект, указываются характеристики создаваемого приложения, конфигурация самой среды разработки Visual C++.

Окно Project Workspace

Microsoft Visual C++ версии 4.0 имеет удобные средства для просмотра исходных текстов файлов проекта, кодов классов приложения, ресурсов, а также для получения справочной информации.

Откройте окно Project Workspace. Обычно оно расположено в левой части экрана, но вы можете переместить его в другое место и даже закрыть. Если окно закрыто, откройте его. Для этого выберите из меню View строку Project Workspace. Окно Project Workspace состоит из нескольких страниц. Вы можете открыть их, нажимая на соответствующие закладки. Количество страниц зависит от того, установлена ли справочная система и открыт ли проект.

ClassView. Средство для просмотра и редактирования классов приложения

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

FileView. Выполняет просмотр файлов приложения

InfoView. Справочная система Microsoft Visual C++. В нее включена информация о языке Си, Си++, библиотеки классов MFC, функций програмного интерфейса Windows

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

Чтобы создать новый файл, вы можете нажать кнопку New Source File( ) в стандартной панели управления или выбрать из меню File строку New, а затем из списка в открывшейся панели New выбрать строку Text File. Откроется новое окно текстового редактора. В нем надо набрать исходный текст приложения, представленного листингом 2.1. Сохраните набранный текст в файле под именем MFHello.cpp в каталоге проекта. Для этого выберите из меню File строку Save As.

Листинг 2.1. Файл MFHello.cpp

// Наследуем от базового класса CWinApp главный

class CMFHelloApp : public CWinApp <

// Мы будем переопределять метод InitInstance,

// предназначенный для инициализации приложения

// Создаем объект приложение класса CMFHelloApp

// Метод InitInstance класса CMFHelloApp

// Переопределяем виртуальный метод InitInstance

// класса CWinApp. Он вызывается каждый раз при запуске

Единственный файл с исходным текстом приложения создан и его надо включить в проект. Выберите из меню Insert строку Files into Project. На экране появится диалоговая панель Insert Files into Project. Выберите файл MFHello.cpp и нажмите кнопку Add. Диалоговая панель закроется. Просмотрите еще раз папку с файлами проекта. Теперь в ней расположен файл MFHello.cpp (рис. 2.10).

Рис. 2.10. Файлы проекта MFHello

Откройте страницу ClassView в окне Project Workspace. В ней отображаются все классы, определенные в приложении и все глобальные переменные. Для каждого класса приложения можно видеть входящие в него элементы (рис. 2.11).

На странице ClassView отображается древовидная структура классов вашего приложения. Когда вы в первый раз открываете ClassView, структура классов отображается в виде закрытой папки . Чтобы ее открыть, щелкните два раза левой кнопкой мыши по изображению папки или один раз по символу , расположенному левее папки. В открытой папке символом представлены классы приложения и еще одним символом папки глобальные объекты приложения. Папку с глобальными объектами можно открыть также как папку с классами. Вы можете открыть и сами классы. Так вы сможете просмотреть элементы класса – методы и данные. Методы обозначаются символом , а данные символом . Если методы или данные объявлены как protected, перед ними отображается символ , а если как private – символ .

В нашем проекте определен только один класс CMFHelloApp. В класс CMFHelloApp входит метод InitInstance. Кроме того, определена одна глобальная переменная MFHelloApp.

Рис. 2.11. Классы проекта MFHello

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

Откройте страницу General. Мы привели внешний вид этой страницы на рисунке 2.12. Обратите внимание на список Microsoft Foundation Classes. По умолчанию из этого списка выбрана строка No Using MFC. Она означает, что приложение не будет использовать библиотеку MFC. Так как в приложении MFHello и всех остальных приложениях, описанных в этой книге, задействованы классы MFC, выберите из списка Microsoft Foundation Classes строку Use MFC in a Shared Dll (mfc40(d).dll) или строку Use MFC in a Static Library.

Что же выбрать – Use MFC in a Shared Dll или Use MFC in a Static Library? Оказывается программные коды библиотеки классов MFC могут использоваться приложением двумя способами. Код библиотеки MFC либо непосредственно записывается в выполнимый файл приложения, либо вызывается по мере необходимости из отдельной dll-библиотеки.

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

Для MFC версии 4.0 dll-библиотека хранится в файлах Mfc40d.dll и Mfc40.dll. В файле Mfc40d.dll находится отладочная версия MFC, а в файле Mfc40.dll отладочная информация отсутствует. В ходе установки Visual C++ эти dll-библиотеки записываются в системный каталог операционной системы.

Если вы забудете указать, что приложение использует MFC, то во время построения проекта на этапе установления связи (Linking…) будут обнаружены ошибки:

error LNK2001: unresolved external symbol __endthreadex

error LNK2001: unresolved external symbol __beginthreadex

Когда для создания нового приложения используется MFC AppWizard, библиотека MFC подключается автоматически. Вам не надо вручную вносить изменения в диалоговой панели Project Settings. Более подробно об использовании MFC AppWizard вы можете прочитать в следующих разделах книги.

Рис. 2.12. Диалоговая панель Project Settings

Если вы все сделали, постройте проект. Для этого вы можете выбрать из меню Build строку Build MFHello.exe – создать выполнимый файл MFHello.exe или строку Rebuild All – заново оттранслировать все исходные файлы проекта. Если в ходе построения выполнимого файла приложения нашего проекта возникли ошибки, исправьте их и заново оттранслируйте проект. После успешного построения проекта запустите полученное приложение, выбрав из меню Build строку Execute MFHello.exe.

На экране появится маленькая диалоговая панель (рис. 2.13). Название этой диалоговой панели соответствует названию выполнимого файла приложения MFHELLO. В диалоговой панели отображается текстовое сообщение “Hello, MFC!”, пиктограмма с восклицательным знаком внутри треугольника и кнопка OK. Как только вы нажмете кнопку OK, диалоговая панель закрывается и приложение завершит свою работу.

Рис. 2.13. Приложение MFHello

Посмотрим, как работает приложение MFHello на уровне исходного текста. Первая строка, не считая строки комментария, содержит директиву препроцессора #include, которая включает файл afxwin.h :

В этом файле определены классы, методы, константы и другие структуры для библиотеки классов MFC. Кроме того включаемый файл afxwin.h автоматически подключает другой включаемый файл windows.h уже известный вам по предыдущим томам серии библиотеки системного программиста. Поэтому даже если из приложения будут вызываться функции стандартного программного интерфейса Windows файл windows.h включать не надо.

В предыдущих томах серии “Библиотека системного программиста”, посвященных программированию в среде операционных систем Windows и Windows 95, мы рассказывали о функции WinMain , которая является главной функцией приложения. Эта функция вызывается, когда пользователь или операционная система запускает приложение. Все приложения, которые мы рассматривали до сих пор содержали функцию WinMain:

// Самое простое приложение Windows

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd) <

// Отображаем на экране небольшую панель с сообщением

MessageBox(NULL,»Hello, world», «Text Message», MB_OK);

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

Оказывается, в приложениях, основанных на классах MFC, функция WinMain скрыта от программиста в определении класса CWinApp. В каждом приложении определяется главный класс приложения, наследуемый от базового класса CWinApp. Обычно этот класс называют CProjectApp, где в качестве Project указывают имя проекта. Приложение должно иметь только один объект главного класса приложения, наследованного от класса CWinApp.

Класс CWinApp выполняет все действия, которые обычно выполняла функция WinMain – инициализирует приложение, обрабатывает сообщения и завершает приложение. Для этого класс CWinApp включает виртуальные методы InitApplication, InitInstance, Run и ExitInstance.

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

Затем функция WinMain начинает обрабатывать цикл сообщений. Для этого вызывается метод Run. Вы можете переопределить этот метод, чтобы реализовать собственный цикл обработки сообщений.

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

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

// Наследуем от базового класса CWinApp главный

class CMFHelloApp : public CWinApp <

// Мы будем переопределять метод InitInstance,

// предназначенный для инициализации приложения

Мы наследуем класс CMFHelloApp от базового класса CWinApp. При этом базовый класс указан как public. Это означает, что в программе доступны все элементы базового класса CWinApp, объявленные как public. Мы можем вызывать методы класса CWinApp для объектов класса CMFHelloApp и обращаться к элементам данных класса CWinApp.

В определении класса CMFHelloApp мы объявляем виртуальный метод InitInstance. Он будет нами переопределен. Изначально метод InitInstance определен в классе CWinApp. Метод InitInstance отвечает за инициализацию приложения. Он вызывается каждый раз, когда пользователь запускает приложение. Если пользователь запустит приложение несколько раз, то метод InitInstance будет вызываться каждый раз.

Метод InitInstance обязательно должен быть переопределен в вашем главном классе приложения. Остальные виртуальные методы можно оставить без изменения.

Сразу после объявления главного класса приложения мы создаем объект этого класса – MFHelloApp. Вы должны определить объект главного класса приложения как глобальный. В этом случае он будет создан сразу при запуске приложения и сможет управлять всей работой приложения. После создания глобальных объектов вызывается функция WinMain, определенная в классе CWinApp. Она выполняет свои обычные функции – регистрирует классы окон, создает окно, и т. д.

Нельзя создавать два и более объектов класса, наследованного от базового класса CWinApp. Каждое приложение должно иметь один и только один объект главного класса приложения:

// Создаем объект приложение класса CMFHelloApp

Метод InitInstance главного класса приложения CMFHelloApp служит для инициализации. Он вызывается автоматически каждый раз, когда запускается очередная копия приложения. Мы используем метод InitInstance чтобы вывести на экран компьютера диалоговую панель с сообщением “Hello, MFC!”. Для этого вызываем функцию AfxMessageBox:

// Метод InitInstance класса CMFHelloApp

// Переопределяем виртуальный метод InitInstance

// класса CWinApp. Он вызывается каждый раз при запуске

Функция AfxMessageBox определена в библиотеке классов MFC. Вместо функции AfxMessageBox вы можете воспользоваться хорошо известной вам функцией MessageBox программного интерфейса Windows.

Когда вы вызываете из приложения, созданного с использованием классов MFC, функции программного интерфейса Windows, необходимо указывать перед именем функции символы . Так, вызов функции MessageBox мог бы выглядеть следующим образом:

В конце метода InitInstance мы вызываем оператор return и возвращаем значение FALSE. Приложение сразу завершается. Если метод InitInstance вернет значение TRUE, приложение продолжит работу и приступит к обработке очереди сообщений. Более подробно о методе InitInstance и свойствах базового класса CWinApp вы узнаете позже, когда мы будем рассматривать средства автоматизированной разработки приложений.

Средства ClassView

Конечно, вы можете продолжать набирать исходные тексты приложения вручную непосредственно в текстовом редакторе. Но во многих случаях среда VIsual C++ может оказать вам значительную помощь. Одним из средств, способных оказать вам такую помощь уже сейчас, является ClassView.

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

А сейчас приступим к описанию возможностей ClassView. Выберите из списка ClassView название класса, который вы желаете просмотреть или изменить, и нажмите правую клавишу мыши. На экране появится временное меню, представленное на рисунке 2.14.

Рис. 2.14. Временное меню класса

Строки этого меню позволяют выполнять над классами все основные действия. Строка Go to Definition позволяет просмотреть в окне редактирования исходный текст класса. Вы можете редактировать класс непосредственно, но для добавления в класс новых методов и данных удобнее пользоваться строками Add Function и Add Variable.

Добавление к классу нового метода

Чтобы добавить в класс новый метод, выберите из временного меню строку Add Function. На экране появится диалоговая панель Add Member Function, представленная на рисунке 2.15.

Рис. 2.15. Диалоговая панель Add Member Function

В поле Function Type следует ввести тип значения, возвращаемого методом. Объявление метода запишите в поле Function Declaration. В этой же диалоговой панели можно определить область видимости метода. Для этого предназначен переключатель с зависимой фиксацией Access. Он может находиться в трех положениях: Public, Protected и Private. Переключатели Static и Virtual позволяют определить, что добавляемый метод должен быть объявлен, соответственно, как статический или виртуальный.

Когда все поля диалоговой панели заполнены, нажмите кнопку OK. В объявлении класса будет добавлен новый метод. Название метода также появится в списке элементов класса в окне ClassView.

Добавление к классу нового элемента данных

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

Рис. 2.16. Диалоговая панель Add Member Variable

В поле Variable Type надо ввести тип данных, а в поле Variable Declaration – название соответствующей переменной. Область видимости переменной определяется переключателем Access.

С помощью ClassView можно просмотреть список названий файлов в которых используется данный класс. Для этого надо выбрать из временного меню строку References. На экране появится диалоговая панель Definitions and References.

Просмотр дерева наследования классов

ClassView предоставляет очень интересную и полезную возможность просмотра дерева наследования классов приложения. Для этого выберите название интересующего вас класса из списка классов и откройте временное меню, нажав правую кнопку мыши. Строки Derived Classes и Base Classes позволяют просмотреть последовательность классов, порожденных от данного класса или последовательность базовых классов.

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

Рис. 2.17. Порядок наследования, диалоговая панель Base Classes and Members

Диалоговая панель Base Classes and Members не имеет кнопок OK и Cancel. Она закрывается в том случае, если вы выберите из нее элемент класса или переключитесь на другое окно. Иногда удобно, чтобы диалоговая панель постоянно присутствовала на экране. Вы можете “прикрепить” ее к главному окну Microsoft Visual C++. Нажмите кнопку , она изменится на . Теперь в любой момент времени вы сможете открыть панель Base Classes and Members.

В левой части этой панели отображается список классов в порядке наследования. Базовые классы расположены ниже и правее наследуемых классов. Вы наглядно можете определить, что основным базовым классом для CMFHelloApp является класс CObject. Из этого класса наследуются классы CCmdTarget, CWinThread, CWinApp и только затем класс CMFHelloApp, определенный в приложении.

В правой части экрана отображаются элементы класса, выбранного из списка классов. Вы можете просмотреть не только элементы классов, определенных в приложении, но также и элементы классов из библиотеки MFC. Все элементы класса разделены на три группы в зависимости от их области видимости – Public, Protected и Private.

Панель Base Classes and Members позволяет легко перейти к редактированию любого элемента класса. Для этого выберите название этого элемента из списка и сделайте по нему двойной щелчок левой кнопкой мыши.

Чтобы вам было легче отличить методы от данных класса, перед методами располагается символ f, а перед данными d. Непосредственно перед именем метода или данных расположен символ, позволяющий отличить статические и виртуальные методы. Перед названиями статических методов расположен символ , а перед виртуальными – .

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

Тип метода Отображать
All Все методы
Virtual Виртуальные методы
Static Статические методы
Non–Static Все методы, кроме статических
Non–Virtual Все методы, кроме виртуальных
Non–Static Non-Virtual Все методы, кроме статических и виртуальных
None Не отображать методы класса

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

Тип элементов данных Отображать
All Все элементы данных
Static Статические элементы данных
Non–Static Все данные, кроме статических
None Не отображать элементы данных

В нижней правой части диалоговой панели Base Classes and Members отображаются названия файлов в которых определен (группа Definitions), и в которых используется (группа References) выбранный элемент. Двойной щелчок левой кнопкой мыши позволяет открыть в редакторе соответствующий файл. Курсор при этом сразу устанавливается в то место, где объявляется или используется выбранный элемент класса.

Редактирование методов класса

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

Рис. 2.18. Временное меню метода

Чтобы открыть в редакторе файл, в котором объявляется метод и перейти к его редактированию, выберите из временного меню метода строку Go to Definition. После того как вы добавите в класс новый метод, ClassWizard создаст шаблон метода. Строка Go to Declaration из временного меню метода позволяет изменить этот шаблон по вашему усмотрению.

Возможности ClassView можно использовать даже на этапе отладки приложения. Так, из временного меню метода можно установить точку прерывания непосредственно на начало метода. Для этого выберите из меню строку Set Breakpoint.

Редактирование элементов данных класса

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

Рис. 2.19. Временное меню метода

Приложение с единственным окном

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

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

Точно так же как в приложении MFHello, в нашем втором приложении мы будем использовать класс CWinApp в качестве главного класса приложения. Для управления окном приложения мы создадим еще один класс, наследуемый от базового класса CFrameWnd , входящего в библиотеку MFС.

Создайте новый проект, как мы рассказывали выше, и назовите его именем MFStart. В качестве типа приложения выберите из списка Type строку Application (рис. 4.1 из главы “Приложение с главной диалоговой панелью”). Автоматизированные средства разработки приложений MFC AppWizard мы рассмотрим позже.

Наберите в редакторе исходный текст приложения и сохраните его в файле MFStart.cpp (листинг 2.2). Наш пример без учета строк комментариев состоит всего из двадцати строк исходного текста, поэтому набор текста не займет у вас много времени. Включите набранный файл в проект.

Листинг 2.2. Файл MFStart.cpp

// Наследуем от базового класса CWinApp главный

class CMFStartApp : public CWinApp <

// Мы будем переопределять метод InitInstance,

// предназначенный для инициализации приложения

// Создаем объект приложение класса CMFStartApp

// Наследуем от базового класса CFrameWnd класс

// CMFStartWindow. Он будет представлять главное

class CMFStartWindow : public CFrameWnd <

// Объявляем конструктор класса CMFStartWindow

// Метод InitInstance класса CMFStartApp

// Переопределяем виртуальный метод InitInstance

// класса CWinApp. Он вызывается каждый раз при запуске

// Создаем объект класса CMFStartWindow

// Отображаем окно на экране. Параметр m_nCmdShow

// определяет режим в котором оно будет отображаться

// Конструктор класса CMFStartWindow

// Создаем окно приложения, соответствующее

// данному объекту класса CMFStartWindow

Просмотрите папку с файлами проекта. Теперь в ней расположен файл MFStart.cpp. Затем откройте страницу ClassView в окне Project Workspace (рис. 2.20). В ней отображаются два класса CMFStartApp и CMFStartWindow. В класс CMFStartApp входит метод InitInstance, а в класс CMFStartWindow конструктор CMFStartWindow. Кроме того, определена глобальная переменная MFStartApp.

Рис. 2.20. Классы проекта MFStart

Постройте проект и запустите полученное приложение, выбрав из меню Build строку Execute MFStart.exe. На экране появится главное окно приложения, представлене нами на рисунке 2.21. Оно имеет стандартный заголовок с надписью Hello MFC, системное меню и кнопки для изменения размера окна. Чтобы завершить приложение, вы можете выбрать строку Close из системного меню главного окна или нажать на кнопку .

Рис. 2.21. Приложение MFStart

Приложение MFStart очень простое. Оно состоит из одного главного окна и не содержит ни меню, ни каких либо других органов управления. Тем не менее, окно приложения MFStart обладает всеми возможностями окон Windows. Оно имеет заголовок, системное меню и кнопки управления. Вы можете изменить размер этого окна, увеличить его на весь экран и даже уменьшить до размера пиктограммы.

Так же как и у приложения MFHello, первая строка исходного текста приложения MFStart, не считая строки комментария, содержит директиву препроцессора #include, которая включает файл afxwin.h. Этот файл включается в исходные тексты всех приложений, использующих библиотеку классов MFC.

Затем мы определяем главный класс приложения, который наследуется от базового класса CWinApp . Главный класс приложения MFHello, который называется CMFStartApp, определяется следующим образом:

// Наследуем от базового класса CWinApp главный

class CMFStartApp : public CWinApp <

// Мы будем переопределять метод InitInstance,

// предназначенный для инициализации приложения

Как видите главный класс приложения MFStart определяется точно так же как у приложения MFHello. Класс CMFStartApp наследуется от базового класса CWinApp. При этом базовый класс указан как public. Мы можем вызывать методы класса CWinApp для объектов класса CMFStartApp и обращаться к элементам данных класса CWinApp. В определении класса CMFStartApp объявлен виртуальный метод InitInstance. Он будет переопределен нами несколько позже, после объявления класса окна приложения.

После объявления главного класса приложения мы создаем объект этого класса – MFStartApp:

// Создаем объект приложение класса CMFStartApp

Второй класс, определенный в нашем приложении, наследуется от базового класса CFrameWnd как public и будет представлять главное окно приложения. В классе главного окна мы определили только конструктор, который будет описан ниже:

// Наследуем от базового класса CFrameWnd класс

// CMFStartWindow. Он будет представлять главное

class CMFStartWindow : public CFrameWnd <

// Объявляем конструктор класса CMFStartWindow

Метод InitInstance главного класса приложения CMFStartApp служит для инициализации. Он вызывается автоматически каждый раз, когда запускается очередная копия приложения.

Мы используем метод InitInstance, чтобы отобразить на экране окно приложения. Для этого мы создаем объект класса CMFStartWindow и записываем указатель на этот объект в элемент данных m_pMainWnd класса CWinThread (класс CWinThread является базовым для класса CWinApp). Таким образом, объект приложения и объект окна приложения связываются вместе.

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

Окно появится на экране только после того, как будет вызван метод ShowWindow. В качестве параметра методу ShowWindow передается параметр m_nCmdShow. Переменная m_nCmdShow является элементом класса CWinApp. Его назначение соответствует параметру nCmdShow функции WinMain, то есть определяет, как должно отображаться главное окно приложения сразу после его запуска.

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

В конце метода InitInstance мы вызываем оператор return и возвращаем значение TRUE, означающее, что инициализация приложения завершилась успешно и можно приступать к обработке очереди сообщений.

Если метод InitInstance вернет значение FALSE, приложение немедленно завершится. Мы использовали эту возможность в приложении MFHello, описанном выше.

// Метод InitInstance класса CMFStartApp

// Переопределяем виртуальный метод InitInstance

// класса CWinApp. Он вызывается каждый раз при запуске

// Создаем объект класса CMFStartWindow

// Отображаем окно на экране. Параметр m_nCmdShow

// определяет режим в котором оно будет отображаться

Чтобы создать окно, мы создаем объект класса CMFStartWindow. Такой объект не является собственно окном, которое пользователь видит на экране компьютера, а представляет собой внутреннее представление окна. Для создания окна предназначается метод Create, определенный в классе CFrameWnd. Он создает окно и связывает его с объектом Си++, в нашем случае с объектом класса CMFStartWindow:

// Конструктор класса CMFStartWindow

// Создаем окно приложения, соответствующее

// данному объекту класса CMFStartWindow

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

Например, мы могли бы поместить описание классов CMFStartApp и CMFStartWindow в файлы MFStartApp.h и MFStartWindow.h. Метод InitInstance класса CMFStartApp и определение глобальной переменной MFStartApp можно поместить в файл MFStartApp.cpp, а определение конструктора класса CMFStartWindow – в файл MFStartWindow.cpp.

Так как в методе InitInstance класса CMFStartApp мы создаем новый объект класса CMFStartWindow, то мы должны включить в файл MFStartApp.cpp не только файл MFStartApp.h но еще и файл MFStartWindow.h. В проект MFStart мы должны записать оба программных файла MFStartApp.cpp и MFStartWindow.cpp. Листинги, представленные ниже содержат проект MFStart, разделенный на несколько файлов. Для того, чтобы сократить размер файлов, мы убрали из них комментарии.

Файл MFStartApp.h содержит описание главного класса приложения CMFStartApp. Этот файл представлен в листинге 2.3.

Листинг 2.3. Файл MFStartApp.h

class CMFStartApp : public CWinApp <

Виртуальный метод InitInstance переопределен нами в файле MFStartApp.cpp. В этом же файле создается объект класса CMFStartApp, представляющий само приложение. Файл MFStartApp.cpp показан в листинге 2.4.

Листинг 2.4. Файл MFStartApp.cpp

Класс окна приложения CMFStartWindow определяется в файле MFStartWindow.h, представленном листингом 2.5. Мы наследуем класс CMFStartWindow от базового класса CFrameWnd.

Листинг 2.5. Файл MFStartWindow.h

class CMFStartWindow : public CFrameWnd <

И наконец, последний файл MFStartWindow.cpp модифицированного проекта MFStart показан в листинге 2.6. В этом файле определяется конструктор класса CMFStartWindow.

Листинг 2.6. Файл MFStartWindow.cpp

Обработка сообщений

Как вы знаете из предыдущих томов серии “Библиотека системного программиста”, работа приложений операционной системы Windows основана на обработке сообщений. Когда пользователь работает с устройствами ввода/вывода компьютера, например клавиатурой или мышью, драйверы этих устройств создают сообщения, описывающие его действия. Каждое нажатие на клавиши клавиатуры вызывает генерацию ряда сообщений, определяющих, какая клавиша нажата. Перемещение мыши вызывает сообщения, описывающие траекторию перемещения указателя мыши и т. д. Другие сообщения могут вырабатываться операционной системой или самими приложениями.

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

Приложение в цикле, который называется циклом обработки сообщений, получает сообщения из очереди приложения и направляет их соответствующей функции окна, которая и выполняет обработку сообщения. Цикл обработки сообщений обычно состоял из оператора while в котором циклически вызывались функции GetMessage и DispatchMessage:

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

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

Функция обработки, сообщения опознает, какое именно сообщение поступило для обработки и выполняет соответствующие действия. Сообщения распознаются по его коду. Обычно функция окна содержит оператор switch, который служит для определения кода сообщений. Вот пример типичной функции окна:

long FAR PASCAL _export WndProc(HWND hWnd, UINT message, UINT wParam, LONG lParam) <

return DefWindowProc(hwnd, message, wParam, lParam);

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

Чтобы “избавиться” от длинного оператора switch, применялись всевозможные ухищрения. Например, в приложении создавался массив, каждый элемент которого содержал код сообщения и указатель на функцию для его обработки. В функции окна помещался только небольшой программный код, который при получении сообщения просматривал массив, искал для него соответствующий элемент массива и вызывал определенную в нем функцию.

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

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

• сообщения от органов управления;

Оконные сообщения

Эта группа включает сообщения, предназначенные для обработкой функцией окна. Практически все сообщения, идентификаторы которых начинаются префиксом WM_, за исключением сообщения WM_COMMAND, относятся к этой группе.

Оконные сообщения предназначаются для обработки объектами, представляющими окна. Это могут быть практически любые объекты класса CWnd или классов, наследованных от него, например CFrameWnd, CMDIFrameWnd, CMDIChildWnd, CView, CDialog. Характерной чертой этих классов является то, что они включают идентификатор окна.

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

Сообщения от органов управления

Эта группа включает в себя сообщения WM_COMMAND от дочерних окон (включая окна стандартных классов), передаваемые их родительскому окну. Сообщения от органов управления обрабатываются точно таким же образом, что и оконные сообщения.

Исключение составляет сообщение WM_COMMAND с кодом извещения BN_CLICKED. Это сообщение передается кнопкой, когда пользователь на нее нажимает. Обработка сообщений с кодом извещения BN_CLICKED от органов управления происходит аналогично обработке командных сообщений.

Командные сообщения

Сообщения WM_COMMAND от меню, кнопок панели управления и клавиш акселераторов. В отличие от оконных сообщений и сообщений от органов управления, командные сообщения могут быть обработаны более широким спектром объектов. Эти сообщения обрабатывают не только объекты, представляющие окна, но также объекты классов, представляющих приложение, документы и шаблон документов.

Характерной особенностью командных сообщений является идентификатор. Идентификатор командного сообщения определяет объект, который вырабатывает (посылает) данное сообщение.

В приложении MFMenu строка Beep меню Test имеет идентификатор ID_TEST_BEEP. Когда пользователь выберет данную строку, в очередь приложения поступит сообщение WM_COMMAND с идентификатором ID_TEST_BEEP или другими словами, командное сообщение ID_TEST_BEEP.

Таблица сообщений

В библиотеке классов MFC для обработки сообщений используется специальный механизм, который получил название Message Map – таблица сообщений .

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

Макрокоманда BEGIN_MESSAGE_MAP представляет собой заголовок таблицы сообщений. Она имеет два параметра. Первый параметр содержит имя класса таблицы сообщений. Второй параметр указывает его базовый класс.

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

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

• Стандартные сообщения Windows обрабатываются функцией “default window procedure”

• Командные сообщения передаются по цепочке следующему объекту, который может обработать командное сообщение. Более подробно мы расскажем об этой цепочке в главах “Однооконный интерфейс” и “Многооконный интерфейс”

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

Макрокоманда Устанавливает методы для обработки сообщений
ON_WM_ Стандартных сообщений операционной системы Windows
ON_REGISTERED_MESSAGE Зарегистрированные сообщения операционной системы Windows
ON_MESSAGE Сообщений, определенных пользователем
ON_COMMAND, ON_COMMAND_RANGE Командных сообщений
ON_UPDATE_COMMAND_UI, ON_UPDATE_COMMAND_UI_RANGE Сообщений, предназначенных для обновления пользовательского интерфейса
ON_ , ON_CONTROL_RANGE Сообщений от органов управления

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

Обрабатывает стандартные сообщения операционной системы Windows. Вместо указывается имя сообщения без префикса WM_. Так, например для обработки сообщения WM_SIZE предназначена макрокоманда ON_WM_SIZE.

Для обработки сообщений, определенных в таблице сообщений макрокомандами ON_WM_ , вызываются одноименные методы. Имя метода обработчика соответствует названию сообщения, без учета префикса WM_.

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

Сообщение Макрокоманда Метод обработчик
WM_CHAR ON_WM_CHAR() afx_msg void OnChar(UINT, UINT, UINT);
WM_CREATE ON_WM_CREATE() afx_msg int OnCreate(LPCREATESTRUCT);
WM_HSCROLL ON_WM_HSCROLL() afx_msg void OnHScroll(UINT, UINT, CWnd*);
WM_KEYDOWN ON_WM_KEYDOWN() afx_msg void OnKeyDown(UINT, UINT, UINT);
WM_KEYUP ON_WM_KEYUP() afx_msg void OnKeyUp(UINT, UINT, UINT);
WM_LBUTTONDOWN ON_WM_LBUTTONDOWN() afx_msg void OnLButtonDown(UINT, CPoint);
WM_LBUTTONUP ON_WM_LBUTTONUP() afx_msg void OnLButtonUp(UINT, CPoint);
WM_PAINT ON_WM_PAINT() afx_msg void OnPaint();
WM_SIZE ON_WM_SIZE() afx_msg void OnSize(UINT, int, int);
WM_TIMER ON_WM_TIMER() afx_msg void OnTimer(UINT);
WM_VSCROLL ON_WM_VSCROLL() afx_msg void OnVScroll(UINT, UINT, CWnd*);

Все методы-обработчики определены с ключевым словом afx_msg. Оно позволяет отличить эти методы от остальных методов класса. На этапе препроцессорной обработки ключевое слово afx_msg удаляется. Определение afx_msg вы можете найти в файле afxwin.h:

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

Когда вы определяете обработчик стандартного сообщения Windows в своем классе, он будет использоваться вместо обработчика определенного в классе CWnd (или другом базовом классе). В любом случае вы можете вызвать метод обработчик базового класса из своего метода обработчика.

Макрокоманда ON_REGISTERED_MESSAGE обслуживает сообщения операционной системы Windows, зарегистрированные с помощью функции RegisterWindowMessage. Параметр nMessageVariable указывает идентификатор сообщения, для которого будет вызываться метод memberFxn.

Макрокоманда ON_MESSAGE обрабатывает сообщения, определенные пользователем. Идентификатор сообщения (его имя) указывается параметром message. Метод, который вызывается для обработки сообщения, указывается параметром memberFxn.

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

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

В общем случае командные сообщения не имеют обработчиков, используемых по умолчанию. Существует только небольшая группа стандартных командных сообщений, имеющих методы обработчики, вызываемые по умолчанию. Эти сообщения соответствуют стандартным строкам меню приложения. Так, например, если вы (или MFC AppWizard) присвоите строке Open меню File идентификатор ID_FILE_OPEN, то для его обработки будет вызван метод OnFileOpen, определенный в классе CWinApp. Список стандартных командных сообщений и их описание представлены в главах “Однооконный интерфейс” и “Многооконный интерфейс”.

Принято, что методы обработчики командных сообщений (как и методы обработчики всех других сообщений) должны быть определены с ключевым словом afx_msg.

Макрокоманда ON_COMMAND ставит в соответствие одному командному сообщению один метод-обработчик. В некоторых случаях более удобно, когда один и тот же метод-обработчик применяется для обработки сразу нескольких командных сообщений с различными идентификаторами. Для этого предназначена макрокоманда ON_COMMAND_RANGE .

Она назначает один метод memberFxn для обработки ряда командных сообщений, идентификаторы которых лежат в интервале от id1 до id2.

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

Параметр id указывает идентификатор сообщения, а параметр memberFxn имя метода для его обработки.

Методы, предназначенные для обработки данного класса сообщений, должны быть определены с ключевым словом afx_msg и иметь один параметр – указатель на объект класса CCmdUI . Для удобства, имена методов, предназначенных для обновления пользовательского интерфейса, начинаются с OnUpdate:

afx_msg void OnUpdate (CCmdUI* pCmdUI);

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

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

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

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

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

Макрокоманда ON_UPDATE_COMMAND_UI_RANGE обеспечивает обработку сообщений, предназначенных для обновления пользовательского интерфейса, идентификаторы которых лежат в интервале от id1 до id2. Параметр memberFxn указывает метод используемый для обработки.

ON_UPDATE_COMMAND_UI_RANGE(id1, id2, memberFxn)

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

Все макрокоманды ON_ имеют два параметра. В первом параметре id указывается идентификатор органа управления. Сообщения от этого органа управления будут обрабатываться методом memberFxn.

Макрокоманда ON_CONTROL_RANGE обрабатывает сообщения, идентификаторы которых находятся в интервале от id1 до id2. Параметр wNotifyCode содержит код извещения. Метод-обработчик указывается параметром memberFxn.

ON_CONTROL_RANGE(wNotifyCode, id1, id2, memberFxn)

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

Однако ClassWizard не всесилен. Так он не позволяет определить один метод для обработки нескольких сообщений. Как вы уже знаете, для этих целей предназначены макрокоманды ON_COMMAND_RANGE и ON_CONTROL_RANGE. Если вы решите воспользоваться этими макрокомандами, вам придется редактировать таблицу сообщений непосредственно, без использования ClassWizard.

Более подробно об использовании ClassWizard для создания обработчиков сообщений вы можете прочитать в разделе “Средства ClassWizard” главы “Приложение с главной диалоговой панелью”. А сейчас мы рассмотрим механизм обработки сообщений, используемый MFC, на примере нескольких приложений.

Приложение MFMenu

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

Сейчас мы рассмотрим приложение MFMenu, которое имеет меню и содержит обработчики сообщений, передаваемых приложению, когда пользователь открывает меню и выбирает из него строки. Для создания приложения MFMenu мы также не станем пользоваться средствами автоматизированной разработки MFC AppWizard, и наберем текст приложения вручную. Этот позволит вам лучше разобраться с механизмом сообщений.

Создайте новый проект под названием MFMenu. В качестве типа приложения выберите из списка Type строку Application (рис. 4.1 из главы “Приложение с главной диалоговой панелью”). Наберите в редакторе исходный текст приложения и сохраните его в файле MFMenu.cpp (листинг 2.7). Чтобы быстрее набрать текст приложения, вы можете получить его, изменив исходный текст приложения MFStart. Затем включите этот файл в проект.

Листинг 2.7. Файл MFMenu.cpp

// Класс CMFMenuApp – главный класс приложения

class CMFMenuApp : public CWinApp <

// Мы будем переопределять метод InitInstance,

// предназначенный для инициализации приложения

// Создаем объект приложение класса CMFMenuApp

// Класс CMFMenuWindow – представляет главное окно

class CMFMenuWindow : public CFrameWnd <

// Объявляем конструктор класса CMFMenuWindow

// Объявляем методы для обработки команд меню

// Макрокоманда необходима, так как класс

// CMFMenuWindow обрабатывает сообщения

// Обрабатывает команду ID_TEST_BEEP

// Таблица сообщений класса CMFMenuWindow

// Метод InitInstance класса CMFMenuApp

// Создаем объект класса CMFMenuWindow

// Конструктор класса CMFMenuWindow

// Создаем окно приложения, соответствующее

// данному объекту класса CMFMenuWindow

Create(NULL, «Hello MFC», WS_OVERLAPPEDWINDOW, rectDefault, NULL, MAKEINTRESOURCE(IDR_MENU));

Добавить в проект новый ресурс очень просто. Вы можете для этого воспользоваться кнопками панели управления Progect или установить указатель мыши на название типа ресурса и нажать правую кнопку мыши. На экране появится временное меню свойств данного ресурса.

Если у вас уже есть ресурсы, которые разработаны ранее и записаны в отдельных файлах на диске, вы можете подключить их к своему проекту. Для этого надо выбрать из временного меню свойств ресурса строку Import. На экране появится диалоговая панель Import Resource с приглашением ввести имя файла подключаемого вами ресурса. Новый ресурс проекта будет записан в подкаталог RES, расположенный в каталоге проекта.

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

Среда Visual C++ версии 4.0 не только позволяет просматривать и редактировать ресурсы приложения, она позволяет сразу после создания ресурса вызвать ClassWizard и подключить к ресурсу управляющий программный код. Пока мы не будем использовать ClassWizard, а код, управляющий ресурсами приложения, создадим вручную.

Создание меню для приложения MFMenu

Так как наше приложение будет содержать меню, мы приступим к созданию ресурсов приложения. Для этого создайте новый файл ресурсов. Выберите из меню File строку New, а затем из открывшейся диалоговой панели выберите строку Resource Script и нажмите кнопку OK.

Теперь надо создать меню. Выберите из меню Insert строку Resource. На экране появится диалоговая панель Insert Resource. Выберите из нее строку Menu и нажмите кнопку OK. Вы сможете в диалоговом режиме разработать меню. Чтобы быстрее перейти к редактированию меню, вы можете нажать кнопку New Menu ( ) из панели управления Project или просто нажать комбинацию кнопок .

Создайте меню, содержащее единственную строку Test, при выборе которой открывается меню, содержащее три строки – Beep и Exit. Внешний вид меню во время разработки представлен на рисунке 2.22.

Рис. 2.22. Разработка меню приложения

Когда вы создаете новое меню верхнего уровня или определяете строки, входящие в это меню, на экране появляется диалоговое окно Menu Item Properties (рис. 2.23). В нем полностью описывается выбранный элемент меню. В поле Caption задается название меню или строки меню. В названии вы можете вставить символ &. Он будет означать, что символ, следующий за ним, можно будет использовать для быстрого выбора данного элемента меню. Например, если перед названием строки меню Beep поставить символ &, то во время работы приложения символ B будет отображаться с подчеркиванием, и строку B eep можно будет выбрать, нажав комбинацию клавиш .

Рис. 2.23. Диалоговая панель Menu Item Properties

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

Редактор ресурсов сам предлагает вам название идентификатора, создавая его из названия главного меню и строки меню. Так например строке Beep меню Test по умолчанию будет присвоен идентификатор ID_TEST_BEEP.

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

Если вы разрабатываете приложение с помощью средств MFC AppWizard, то при выборе пользователем строк меню их описание будет появляться в панели состояния StatusBar. Что интересно, для этого вам не потребуется написать ни одной строки текста программы. Это будет сделано автоматически благодаря возможностям библиотеки классов MFC и MFC AppWizard.

Остальные переключатели диалоговой панели Menu Item Properties описаны в следующей таблице.

Переключатель Описание
Break Этот переключатель может принимать три различных значения – None, Column и Bar. Он позволяет задать структуру меню. По умолчанию выбрано значение None оно соответствует нормальному виду меню без деления на колонки. Если выбрать значение Column, тогда пункт меню будет размещен в новом столбце. Значение Bar соответствует Column, за исключением меню верхнего уровня. Если указать Bar для меню верхнего уровня, то новая колонка будет отделена от старой вертикальной линией
Checked Если установить переключатель, то строка меню будет выделена символом √. Потом, обращаясь к специальным методам, вы сможете удалять или отображать этот символ
Grayed Если включить переключатель Grayed, тогда пункт меню будет отображаться серым цветом и будет недоступен для выбора пользователем. Такая возможность удобна, если вам надо сделать недоступным какие-либо возможности приложения. Впоследствии приложение может сделать пункт меню доступным. Для этого надо вызвать соответствующий метод
Help Если установить переключатель Help, тогда для него будет установлено выравнивание по правому краю. Обычно этот переключатель устанавливают для меню верхнего уровня, которое управляет справочной системной приложения
Inactive Если включен переключатель Grayed, тогда переключатель недоступен. В противном случае вы можете установить переключатель Inactive. В этом случае пункт меню будет неактивен
Pop-up Вы можете создавать многоуровневые меню. Если вы включите переключатель Pop-up, то данный пункт меню будет являться меню верхнего уровня, которое можно открыть. По умолчанию, все пункты главного меню имеют установленный переключатель Pop-up. Так как меню верхнего уровня служит только для объединения других пунктов меню, то оно не имеет идентификатора
Separator Если переключатель установлен, тогда в меню вставляется разделитель. Для разделителя все остальные поля и переключатели диалоговой панели не используются

Сохраните файл ресурсов в файле с именем MFMenu.rc. Редактор ресурсов создает кроме самого файла ресурсов еще включаемый файл, в котором определяются константы, используемые в файле ресурсов. В нашем случае в нем определяются идентификаторы меню приложения. По умолчанию этот файл сохраняется под именем resource.h . Вы можете изменить его, выбрав из меню View строку Resource Includes. Для нашего приложения мы изменили имя включаемого файла для ресурсов на MFMenuRes.h. Содержимое этого файла представлено листингом 2.8.

Листинг 2.8. Файл MFMenuRes.h

// Включаемый файл, созданный Microsoft Developer Studio

Пример использования MFC в Visual C++

Раздел: Информатика, программирование Тип: статья Дата добавления: 13.01.2014 Размер: 3 кб Короткая ссылка: Оценить работу: Просмотров: 178

В этой статье будет показано как включить потдержку MFC в Visual C++ на примере двух типов приложений:

1. Консольное приложение

2. Приложение типа Windows Application

1. Консольное приложение

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

int main( int argc, char* argv[] )

if ( !AfxWinInit( ::GetModuleHandle( NULL ), NULL, ::GetCommandLine( ), 0 ) )

cerr » ( Вам надо выбрать «Dialog based»).

5. MFC AppWizard — Step 2. Нажмите кнопку «Next>».

6. MFC AppWizard — Step 3. Нажмите кнопку «Finish».

7. New Project Information. Нажмите кнопку «OK».

Ну вот и всё, у Вас есть уже готовая программа, потдерживающая MFC

Visual C++ для начинающих.

8. Пример использования MFC в Visual C++.

В этой главе будет показано как включить потдержку MFC в Visual C++ на примере двух типов приложений:

1. Консольное приложение

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

Что бы создать приложение типа Windows Application с использованиеи MFC нужно сделать следующие шаги( создадим для простоты приложение основанное на диалогах ):

    1. Запустите Visual C++.
    2. Выберите File / New.
    3. Выберите закладку «Projects» / «MFC AppWizard( exe )», введите имя проекта( Project name ) и место для проекта( Location ) и нажмите кнопку «OK». В ответ будут выводится диалоговые панели.
    4. MFC AppWizard — Step 1. Выберите интересующий тип проекта( простой документ, мулти-документ или документ, основанный на диалогах ) и нажмите кнопку «Next>» ( Вам надо выбрать «Dialog based»).
    5. MFC AppWizard — Step 2. Нажмите кнопку «Next>».
    6. MFC AppWizard — Step 3. Нажмите кнопку «Finish».
    7. New Project Information. Нажмите кнопку «OK».

Ну вот и всё, у Вас есть уже готовая программа, потдерживающая MFC.

7 Пример использования MFC в Visual C++

В этой главе будет показано как включить потдержку MFC в Visual C++ на примере двух типов приложений:

Консольное приложение

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

После того, как Вы набрали код, обязательно сделайте следующее:

Запустите программу — Build / Rebuild all ( будут ошибки ), выберите Build / Set active configuration — Win 32 Realise, выберите пункт меню «Project», далее «Settings. «, закладку «C/C++», Category — Code Generation и в пункте «Use run-time library» выберите «Multithreaded». После этого сделайте опять Build / Rebuild all и программа будет работать.

Если MFC инициализировалась правильно, то будет выполняться код вашей программы, если нет — выведется сообщение «MFC Failed to initialize.» Если что то не так, проверте наличие библиотеки «afxwin.h» и правильность написания кода или возьмите готовую программу отсюда.

Приложение типа Windows Application

Что бы создать приложение типа Windows Application с использованиеи MFC нужно сделать следующие шаги( создадим для простоты приложение основанное на диалогах ):

  1. Запустите Visual C++.
  2. Выберите File / New.
  3. Выберите закладку «Projects» / «MFC AppWizard( exe )», введите имя проекта( Project name ) и место для проекта( Location ) и нажмите кнопку «OK». В ответ будут выводится диалоговые панели.
  4. MFC AppWizard — Step 1. Выберите интересующий тип проекта( простой документ, мулти-документ или документ, основанный на диалогах ) и нажмите кнопку «Next>» ( Вам надо выбрать «Dialog based»).
  5. MFC AppWizard — Step 2. Нажмите кнопку «Next>».
  6. MFC AppWizard — Step 3. Нажмите кнопку «Finish».
  7. New Project Information. Нажмите кнопку «OK».

Ну вот и всё, у Вас есть уже готовая программа, потдерживающая MFC.

Илон Маск рекомендует:  Что такое код fbsql_select_db
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL