КулЛиб - Классная библиотека! Скачать книги бесплатно 

Microsoft Visual C++ и MFC. Программирование для Windows 95 и Windows NT [Александр Вячеславович Фролов] (fb2) читать онлайн


 [Настройки текста]  [Cбросить фильтры]
  [Оглавление]

Фролов А.В., Фролов Г.В. Библиотека системного программиста Том 24 Microsoft Visual C++ и MFC. Программирование для Windows 95 и Windows NT

Введение

В предыдущих томах серии “Библиотеки системного программиста” мы ориентировались в первую очередь на язык программирования Си. Даже если некоторые программы были написаны на Си++, то богатые возможности этого языка практически не использовались.

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

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

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

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

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

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

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

Microsoft Visual C++

Существует несколько версий компилятора Microsoft Visual C++. Наибольшее распространение получили версии 1.51, 2.0 и 2.2. В начале 1996 года появилась новая версия Visual C++ 4.0.

Microsoft Visual C++ версии 1.51 содержит только 16-разрядный компилятор. Он позволяет разрабатывать программы для операционной системы MS-DOS и Windows 3.1. Эта версия компилятора не позволяет создавать приложения, предназначенные специально для 32-х разрядных операционных систем Windows NT и Windows 95.

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

На этом различия между Visual C++ версий 1.51 и 2.0 заканчиваются. В Visual C++ версии 1.51 используется 16-и разрядная библиотека классов MFC версии 2.5, а Visual C++ 2.0 поставляется с 32-разрядной библиотекой MFC версии 3.0.

При переходе к 32-разрядным приложениям фирма Microsoft отказалась поддерживать элементы управления VBX. Вместо них MFC 3.0 позволяет работать с элементами управления OLE. Новый стандарт на элементы управления получил название OCX (OLE Custom Controls).

Фирма Microsoft приложила большие усилия, чтобы организовать совместимость своего компилятора с различными архитектурами компьютеров. Специальные версии Visual C++ работают на компьютерах с MIPS архитектурой, на компьютерах с процессорами Alpha, Motorola PowerPC. Это позволяет легко переносить разработанные приложения с одной аппаратной платформы на другую.

Популярность библиотеки классов MFC настолько высока, что такие фирмы, как Watcom и Symantec, известные своими компиляторами Си и Си++, приобрели у Microsoft лицензии на эту библиотеку. Практически единственной широко известной в России фирмой, которая поставляет компиляторы Си++ с собственной библиотекой классов является Borland. Компиляторы Borland C++ включают библиотеку классов OWL (Object Windows Library). Эта библиотека совершенно не совместима с библиотекой MFC, поэтому программы, построенные с ее использованием, нельзя транслировать компилятором Visual C++. Компилятор Borland C++ версии 5.0 позволяет транслировать приложения, созданные с использованием библиотеки классов MFC.

Microsoft Visual C++ версия 4.0

В конце 1995 года появилась новая версия Microsoft Visual C++ – 4.0. Этот компилятор интегрирован в среду Microsoft Developer Studio , в состав которого могут входить другие программные продукты Microsoft.

Интегрированная среда разработчика объединяет одной оболочкой Microsoft Visual C++ версии 4.0, Microsoft Visual Test, Microsoft Fortran PowerStation, Microsoft Development Library и Microsoft Visual SourceSafe

Для программистов, работающих в среде Visual C++, наиболее интересна возможность интегрирования с базой данных Microsoft Development Library. После того как вы установите в компьютере Microsoft Development Library, вы сможете осуществлять поиск интересующей вас информации не только в справочной базе Visual C++, но и в базе данных Microsoft Development Library. При этом вам не придется переключаться на другое приложение, достаточно выбрать справочную систему в панели Info Viewer.

Следующие версии Microsoft Visual C++

Весной 1996 года вышла новая версия Microsoft Visual C++ 4.1. В состав этой версии продукта включены дополнительные средства для разработки приложений, поддерживающих глобальную сеть Internet, язык моделирования виртуальной реальности (Virtual Reality Modeling Language – VRML), игровое SDK (Windows 95 Games SDK ) и большое количество OCX объектов, которые вы можете включать в свои приложения.

Поддержка сети Internet
Последние версии Microsoft Internet Information Server, используемого в качестве серверов WWW и FTP, имеют программный интерфейс (Internet Server application programming interface – ISAPI ). Используя этот интерфейс, вы можете разрабатывать собственные модули, взаимодействующие с сервером.

Чтобы облегчить программистам создание таких модулей, Microsoft Visual C++ версии 4.1 содержит “волшебник” ISAPI Extention Wizard, работающий на тех же принципах, что и MFC AppWizard. ISAPI Extention Wizard использует новые классы библиотеки MFC – CHttpServer , CHttpFilter, CHttpServerContext, CHttpFilterContext и CHtmlStream.

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

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

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

С появлением операционной системы Windows 95 ситуация начала изменяться к лучшему. В Windows 95 встроен специальный набор функций, обеспечивающий приложениям высокоэффективный доступ к видеоадаптеру. Вышли первые игры для Windows 95. Так фирма idSoftware выпустила специальную версию популярной игры Doom 2, предназначенную для работы исключительно в среде Windows 95.

Для создания программ, поддерживающих этот набор функций, необходимо использовать специальной средство разработки Games SDK. Ранее оно поставлялось отдельно, а начиная с версии 4.1 компилятора Microsoft Visual C++, вошло в состав этого пакета.

Набор OCX объектов
По сравнению с Microsoft Visual C++ версии 4.0 в версии 4.1 значительно расширен набор органов управления OLE (OCX). В него Microsoft включила органы управления OCX, разработанные другими фирмами.

Как связаться с авторами

Авторы имеют почтовый адрес в сети GlasNet. Все свои замечания и предложения по содержанию книг серий "Библиотека системного программиста", а также "Персональный компьютер – шаг за шагом" вы можете присылать нам по следующему адресу:

frolov@glas.apc.org

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

Глобальная сеть Наш адрес
CompuServe >internet:frolov@glas.apc.org
GlasNet frolov@glas.apc.org
Internet frolov@glas.apc.org
Relcom frolov@glas.apc.org
UUCP uunet!cdp!glas!frolov
Вы также можете присылать свои пожелания почтой по адресу:

Издательский отдел АО "ДИАЛОГ-МИФИ".

Индекс 115409, город Москва, улица Москворечье, дом 31, корпус 2.

Приносим свои извинения за то, что не можем ответить на каждое письмо. Мы также не занимаемся рассылкой дискет и исходных текстов к нашим книгам. По этому вопросу обращайтесь непосредственно в издательство “Диалог-МИФИ”.

Благодарности

Авторы выражают благодарность Фроловой Ольге Викторовне, Кустову Виктору. Мы также благодарим всех сотрудников издательского отдела АО "ДИАЛОГ-МИФИ": Голубева Олега Александровича, Дмитриеву Наталью, Виноградову Елену, Кузьминову Оксану.

1. Немного о C++

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

Затем вы можете использовать все новые и новые особенности Си++, постепенно отходя от стандартного Си к Си++. На момент написания книги окончательный стандарт Си++ еще не был разработан. Компиляторы различных фирм, например Microsoft и Borland имеют различия в реализации Си++. Наша книга ориентирована в первую очередь на компиляторы Microsoft Visual C++ версий 1.5, 2.0, 4.0 и 4.1.

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

Ввод/вывод

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

Если с левой стороны от оператора << расположен символ cout, то этот оператор осуществляет вывод на экран информации, указанной справа от оператора. Форма, в которой выполняется вывод на экран, зависит от типа выводимого значения. Используя оператор <<, вы можете отображать на экране текстовые строки, а также значения переменных различных типов. В качестве левого параметра оператора << можно использовать не только cout, но также результат работы предыдущего оператора <<. Это позволяет строить цепочки из операторов <<. Чтобы перейти к отображению следующей строки, вы можете передать cout значение \n.

Так, например, следующий фрагмент кода отображает на экране значения переменных iInt, cChar и szString с соответствующими комментариями:

cout << “Значение переменной iInt = ”;

cout << iInt;

cout << “\n”;


cout << “Значение переменной cChar = ” << cChar << “\n”;

cout << “Строка szString = ” << szString << “\n”;

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

int iNum;


cout << "Введите целочисленное значение:";

cin >> iNum;

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

Забегая вперед, скажем, что символы inp и outp, которые иногда называют потоками, представляют собой объекты специального класса, предназначенного для ввода и вывода информации. Операторы << и >> переопределены в этом классе и выполняют новые функции. О переопределении операторов вы можете прочитать в разделе “Перегрузка операторов”.

Константы

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

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

В программе, приведенной ниже, объявляются две константы. Одна типа int, другая типа char:

// Включаемый файл для потокового ввода/вывода

#include <stdio.h>


int main(void) {

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

 const int max_nuber = 256;

 // Выводим текстовую строку на экран

 printf("Const Number is %d \n", max_nuber);

 return 0;

}

Ключевое слово const можно указывать при объявлении постоянных указателей, которые не могут менять своего значения. Заметим, что объект (переменная), определяемый постоянным указателем, может быть изменен:

int iNumber;

int *const ptrNumber = &iNumber;

Ссылки

В языке Си++ вы можете определить ссылку на объект – переменную или объект класса. Ссылка содержит адрес объекта, но вы можете использовать ее, как будто она представляет сам объект. Для объявления ссылки используется оператор &.

В следующей программе мы определили переменную iVar типа int и ссылку iReferenceVar на нее. Затем мы отображаем и изменяем значение переменной iVar используя ее имя и ссылку.

// Включаемый файл для потокового ввода/вывода

#include <iostream.h>


void main(void) {

 // Определяем переменную iVar

 int iVar = 10;


 // Определяем ссылку iReferenceVar на переменную iVar

 int& iReferenceVar = iVar;


 // Отображаем значение переменной и ссылки

 cout << "iVar = " << iVar << ";

 iReferenceVar = " << iReferenceVar << '\n';


 // Изменяем значение переменной iVar пользуясь ссылкой

 iReferenceVar = 20;


 // Отображаем значение переменной и ссылки

 cout << "iVar = " << iVar << ";

 iReferenceVar = " << iReferenceVar << '\n';

}

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

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

Распределение памяти

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

В Си++ встроены специальные операторы для управления памятью – оператор new и оператор delete . Эти операторы очень удобны для динамического создания переменных, массивов и объектов классов, поэтому мы остановимся на них более подробно.

Операторы new и delete

Оператор new создает объект заданного типа. При этом он выделяет память, необходимую для хранения объекта и возвращает указатель, указывающий на него. Если по каким-либо причинам получить память не удается, оператор возвращает нулевое значение. Оператор new позволяет сразу инициализировать созданную переменную. Приведем формат оператора new:

new type-name [initializer];

new (type-name) [initializer];

В качестве аргумента type-name надо указать имя типа создаваемого объекта. Дополнительный аргумент initializer позволяет присвоить созданному объекту начальное значение. Вот простой пример вызова оператора new:

char *litera;

int *pi;

litera = new char;

pi = new int(3,1415);

В этом примере оператор new используется для создания двух объектов – одного типа char, а другого типа int. Указатели на эти объекты записываются в переменные litera и pi. Заметим, что объект типа int сразу инициализируется значением 3,1415.

Чтобы освободить память, полученную оператором new, надо вызвать оператор delete. Вы должны передать оператору delete указатель pointer, ранее полученный оператором new:

delete pointer;

Оператор new позволяет создавать объекты не только простых типов, он может использоваться для динамического создания массивов. Следующий фрагмент кода создает массив из ста элементов типа long. Указатель на первый элемент массива записывается в переменную pData:

long *pData = new long[100];

Чтобы удалить массив, созданный оператором new, надо воспользоваться другой формой вызова оператора delete:

delete [] pointer;

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

Перегрузка имен функций

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

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

В качестве примера рассмотрим функции Sqware, предназначенные для вычисления площади прямоугольников и квадратов:

int Sqware(int a, int b);

int Sqware(int a);

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

int Sqware(int a, int b) {

 return (a * b);

}

int Sqware(int a) {

 return (a * a);

}

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

void main() {

 int value;

 value = Sqware(10, 20);

 print(“Площадь прямоугольника равна %d”, value);

 value = Sqware(10);

 print(“Площадь квадрата равна %d”, value);

}

Задание параметров функции по умолчанию

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

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

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

int Summa(int first, int second, int third=0, int fourth=0) {

 return(first + second + third + fourth);

}

Функцию Summa можно использовать для сложения четырех, трех или двух чисел. Если складываются два числа, то третий и четвертый параметр можно опустить:

void main() {

 int value1 = 10, value2 = 20, value3 = 30, value4 = 40;

 int result;


 // Вызываем функцию с четырьмя параметрами

 result = Summa(value1, value2, value3, value4);

 print(“Сумма четырех чисел равна %d”, result);

 // Вызываем функцию с тремя параметрами

 result = Summa(value1, value2, value3);

 print(“Сумма трех чисел равна %d”, result);

 // Вызываем функцию с двумя параметрами,

 // последний параметр задается по умолчанию

 result = Summa(value1, value2);

 print(“Сумма первых двух чисел равна %d”, result);

}

Встраивание

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

Си++ предусматривает специальный механизм для встраивания функций. Чтобы указать компилятору, что данную функцию необходимо встраивать, перед ее объявлением или определением надо указать ключевое слово inline:

inline unsigned int Invert(unsigned int number) {

 return (~number);

}

Классы

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

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

Объявление класса имеет следующий вид:

class [<tag>]

{

<member-list>

} [<declarators>];

Когда вы определяете класс, то сначала указывается ключевое слово class, а затем в качестве аргумента <tag> имя самого класса. Это имя должно быть уникальным среди имен других классов, определенных в вашей программе.

Затем в фигурных скобках следует список элементов класса <member-list>. В качестве элементов класса могут фигурировать данные (переменные), битовые поля, функции, вложенные классы, а также некоторые другие объекты. Вы можете включить качестве элемента класса указатель на другие объекты этого класса.

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

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

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

[class] tag declarators;

Ключевое слово class перед именем класса можно опустить.

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

Ключевое слово this

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

Разграничение доступа к элементам класса

Определив класс, вы можете создавать объекты этого класса и манипулировать ими, используя методы. Некоторые данные и методы, объединенные одним классом, можно сделать недоступными вне реализации класса, к другим можно будет обращаться из программы.

Для управления доступом к элементам класса предусмотрены ключевые слова public, private и protect (спецификаторы доступа). Методы и данные, определенные или описанные после ключевого слова public представляют собой интерфейс класса – они доступны для использования вне определения класса. Остальные члены класса относятся к его внутренней реализации и обычно недоступны вне класса. Различия между членами класса, описанными после ключевых слов private и protect сказываются только при наследовании от данного класса новых классов. Процедуру наследования мы рассмотрим позже.

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

Ниже представлено определение класса Sample:

class Sample {

 int iX;

 void Load();

public:

 void SetStr();

 void GetStr();

 char sDataText[80];

private:

 char sNameText[80];

 int iIndex;

public:

 void ConvertStr();

 int iLevel;

};

В классе описаны элементы данных iX, sDataText, sNameText, iIndex, iLevel и методы Load, SetStr, GetStr, ConvertStr.

Элементы данных и методы SetStr, GetStr, sDataText, ConvertStr, iLevel объявлены public. К ним можно обращаться как из методов класса Sample, так и из программы. Остальные элементы класса объявлены как private. Доступ к ним открыт только для методов самого класса, а также дружественных функций и дружественных методов других классов. Дружественные функции и дружественные классы описаны в следующем разделе.

Методы, входящие в класс

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

class line {

public:

 void SetLength(int newLength) { length = newLength; }

 int GetLength() { return length; }

private:

 int length;

};

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

class convert {

public:

 void GetString() { scanf(sText, "%s"); }

 void ShowString() { puts(sText); }

 int ConvertString();

 void DummyString();

private:

 char sText[80];

};

void convert::ConvertString(void) {

 int i;

 for (i = 0; sText[i] != ‘\0’; i++ ) {

  sText[i] = tolower(sText[i]);

 }

 return i;

}

inline void convert::DummyString(void) {

 int i = 0;

 while (sText[i++]) sText[i] = 0;

}

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

Следующий пример демонстрирует вызов методов класса convert, исходный текст которого приведен выше:

void main() {

 convert ObjectA;

 ObjectA.GetString();

 ObjectA.ConvertString();

 ObjectA.ShowString();

 convert *pObjectB = new convert;

 pObjectB->GetString();

 pObjectB->ConvertString();

 pObjectB->ShowString();

}

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

Конструкторы и деструкторы класса

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

Язык С++ предоставляет удобное средство для инициализации и удаления объектов класса. Для этого предусмотрены специальные методы. Они называются конструкторами и деструкторами.

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

Класс BookList, представленный ниже, имеет два конструктора BookList. Первый конструктор не имеет параметров, второй конструктор имеет один параметр типа int:

class BookList {

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

void BookList();

void BookList(int);

// Остальные члены класса

};

// Первый конструктор класса

BookList::BookList(void) { }

// Второй конструктор класса

BookList::BookList(int iList) { }

Когда вы создаете объекты класса, вы можете указать параметры для конструктора. Ниже создаются два объекта класса BookList – FirstBook и SecondBook:

BookList FirstBook;

BookList SecondBook(100);

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

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

Ниже представлен класс Object, для которого определен деструктор ~Object:

class Object {

void ~Object();

// Остальные члены класса

};


Object::~Object(void) { }

Методы, не изменяющие объекты класса

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

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

В библиотеке классов MFC вы встретите много методов, объявленных как const. Их использование повышает надежность приложения, так как компилятор сможет обнаружить ошибки, связанные с непреднамеренным изменением элементов класса.

Ниже мы привели пример класса, для которого метод GetWeight определен как const. Если вы попытаетесь модифицировать элемент данных weight непосредственно из метода GetWeight, компилятор сообщит об ошибке.

#include <iostream.h>


void main(void);


// Класс ClassMen включает элемент данных и два метода для

// обращения к нему

class ClassMen {

public:

 void SetWeight(int newWeight);

 int GetWeight() const;

private:

 int weight;

};


// Метод GetWeight позволяет определить значение элемента

// weight. Этот метод объявлен как const и не может

// модифицировать объекты класса ClassMen

int ClassMen::GetWeight() const {

 return weight ;

}


// Метод SetWeight позволяет изменить значение weight.

// Такой метод нельзя объявлять как const

void ClassMen::SetWeight(int newWeight) {

 weight = newWeight;

}


// Главная функция программы

void main(void) {

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

 ClassMen alex;


 // Устанавливаем значение элемента weight объекта alex

 alex.SetWeight(75);


 // Отображаем значение элемента weight объекта alex

 cout << alex.GetWeight() << "\n";

}

Статические методы

Вы можете объявить некоторые методы класса статическими методами. Для этого вы должны воспользоваться ключевым словом static. Статические методы не принимают параметр this. На использование статических методов накладывается ряд ограничений.

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

• Статический метод не может быть объявлен как виртуальный метод.

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

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

Ниже представлен класс Circle, в котором определена статический метод GetPi. Он используется для получения значения статического элемента класса fPi.

class Circle {

public:

static void GetPi() { return fPi; }


private:

static float fPi;

};

float Circle::fPi = 3.1415;

Вы можете вызвать метод GetPi следующим образом:

float fNumber;

fNumber = Circle::GetPi();

Обратите внимание, что объект класса Circle не создается.

Общие члены объектов класса

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

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

class CWindow {

public:

 int xLeftTop, xRightBottom;

 int yLeftTop, yRightBottom;

 static char title[80];

 void SetTitle(char*);

};

char Cwindow::title[80] = "заголовок окна";

Каждый объект класса Cwindow будет иметь уникальные координаты, определяемые элементами данных xLeftTop, xRightBottom, yLeftTop, yRightBottom и одинаковый заголовок, хранимый элементом данных title.

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

void SetTitle(char* sSource) {

 strcpy(title, sSource);

}

Чтобы получить доступ к общим элементам из программы, надо объявить их как public. Для обращения к такой переменной перед ее именем надо указать имя класса и оператор ::.

printf(Cwindow::title);

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

Дружественные функции
В Си++ вы можете определить для класса так называемую дружественную функцию, воспользовавшись ключевым словом friend. В классе содержится только объявление дружественной функции. Ее определение расположено вне класса. Вы можете объявить дружественную функцию в любой секции класса – public, private или protect.

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

В следующем примере определена функция Clear, дружественная для класса point. Дружественная функция Clear используется для изменения значения элементов данных m_x и m_y, объявленных как private:

//==========================================================

// Класс point

class point {

public:

// Функция Clear объявляется дружественной классу point

 friend void point::Clear(point*);


 // Интерфейс класса…

 private:

 int m_x;

 int m_y;

};


//==========================================================

// Функция Clear

void Clear(point* ptrPoint) {

 // Обращаемся к элементам класса, объявленным как private

 ptrPoint->m_x = 0;

 ptrPoint->m_y = 0;

 return;

}


//==========================================================

// Главная функция

void main() {

 point pointTestPoint;


 // Вызываем дружественную функцию

 Clear(&pointTestPoint);

}

С помощью ключевого слова friend вы можете объявить некоторые методы одного класса дружественными для другого класса. Такие методы могут обращаться ко всем элементам класса, даже объявленным как private и protect, несмотря на то, что сами они входят в другой класс.

В следующем примере мы определяем два класса – line и point. В классе point определяем метод Set и объявляем его в классе line как дружественный. Дружественный метод Set может обращаться ко всем элементам класса line:

// Предварительное объявление класса line

class line;


//==========================================================

// Класс point

class point {

public:

 // Метод Set класса point

 void Set(line*);


 // …

};


//==========================================================

// Класс line

class line {

public:

 // Метод Set класса point объявляется дружественной

 // классу point

 friend void point::Set(line*);


private:

 int begin_x, begin_y;

 int end_x, end_y;

};


//==========================================================

// Функция Clear

void point::Set(line* ptrLine) {

 // Обращаемся к элементам класса line, объявленным как

 // private

 ptrLine->begin_x = 0;

 ptrLine->begin_y = 0;

 // …


 return;

}


//==========================================================

// Главная функция

void main() {

 point pointTestPoint;

 line lineTestPoint;


// Вызываем дружественный метод

 pointTestPoint.Set(&lineTestPoint);

}

Дружественные классы
По аналогии с дружественными функциями и методами, можно объявить дружественный класс. Все методы дружественного класса, могут обращаться ко всем элементам класса, включая элементы, объявленные как private и protect.

Так, например, в предыдущем примере вы могли бы определить, что класс point является дружественным классу line. Все методы класса point могут обращаться к любым элемента класса line.

//==========================================================

// Класс point

class point {

 // …

};


//==========================================================

// Класс line

class line {

public:

 // Класс point объявляется дружественным классу line

 friend class point;

};

Наследование

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

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

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

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

На рисунке 1.1 мы привели пример структуры наследования классов. От единственного базового класса BaseClass наследуются три класса DerivedClassOne, DerivedClassSecond и DerivedClassThird. Первые два из них сами выступают в качестве базовых классов.

Рис. 1.1. Наследование


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

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

Единичное наследование

В случае единичного наследования порожденный класс наследуется только от одного базового класса. Рисунок 1.1 отражает единичное наследование классов. Единичное наследование является наиболее распространенным методом наследования. Библиотека классов MFC использует только единичное наследование.

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

class [<tag>[:<base>]]

{

<member-list>

} [<declarators>];

Перед названием базового класса может быть указан спецификатор доступа public, private или protect. Назначение этих спецификаторов мы рассмотрим в разделе “Разграничение доступа к элементам базового класса”. Сейчас же мы скажем только, что если вы не укажите спецификатор доступа, то по умолчанию будет подразумеваться спецификатор private.

Ниже мы определили базовый класс Base, содержащий несколько элементов, а затем наследовали от него два новых класса DerivedFirst и DerivedSecond. В каждом из порожденных классов мы определили различные дополнительные методы и элементы данных.

// Класс Base

class Base {

 // Элементы класса Base

};


// Класс DerivedFirst, наследованный от базового класса Base

class DerivedFirst : Base {

 // Элементы класса DerivedFirst

};


// Класс DerivedSecond, наследованный от базового класса Base

class DerivedSecond : Base {

 // Элементы класса DerivedSecond

};

Классы DerivedFirst и DerivedSecond сами могут выступать в качестве базовых классов.

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

В качестве примера приведем базовый класс Base и производный от него класс Derived. В обоих классах определен элемент данных iNumber. Чтобы получить доступ из порожденного класса к элементу iNumber базового класса указывается его полное имя Base::iNumber.

// Класс Base

class Base {

public:

 int iNumber;

 // Другие элементы класса

};


// Класс Derived, наследованный от базового класса Base

class Derived : Base {

public:

 // Это объявление скрывает элемент iNumber базового класса

 int iNumber;

 int GetNumber(void) { return iNumber + Base::iNumber; }

};

Указатель на объект базового класса можно присвоить указатель на объект класса порожденного от него. Эта возможность будет широко использоваться в библиотеке классов MFC.

Множественное наследование

Множественное наследование выполняется подобно единичному наследованию. В отличие от единичного наследования у порожденного класса может быть несколько базовых классов. На рисунке 1.2 представлен пример множественного наследования классов. Класс DerivedClaass имеет два базовых класса BaseClassOne и BaseClassSecond. Класс DerivedClaass и еще один класс BaseClass используются при множественном наследовании класса DerivedClaassSecond.

Рис. 1.2. Множественное наследование


Вместо имени единственного базового класса указывается список <base-list> имен базовых классов, разделенный запятыми. Непосредственно перед названиями базовых классов могут быть указаны спецификаторы доступа public, private и protect. Их назначение мы рассмотрим в разделе “Разграничение доступа к элементам базового класса”.

class [<tag>[:[<base-list>]]

{

<member-list>

} [<declarators>];

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

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

В следующем примере определены два базовых класса BaseFirst и BaseSecond. От них наследован один новый класс Derived. Результирующий класс Derived объединяет элементы обоих базовых классов и добавляет к ним собственные элементы.

// Класс BaseFirst

class BaseFirst {

// Элементы класса BaseFirst

};


// Класс BaseSecond

class BaseSecond {

// Элементы класса BaseSecond

};

// Класс Derived, наследованный от базового класса Base

class Derived : BaseFirst, BaseSecond {

// Элементы класса Derived

};

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

Разграничение доступа к элементам базового класса

Мы уже рассказывали, что можно управлять доступом к элементам класса, указывая спецификаторы доступа для элементов класса. Элементы класса, объявленные с спецификаторами protected и private доступны только из методов самого класса. Элементы с спецификаторами public доступны не только из методов класса, но и извне.

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

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

Спецификатор доступа базового класса
Спецификатор доступа элемента базового класса public protected private
public Доступны как public Доступны как protected Доступны как private
protected Доступны как protected Доступны как protected Доступны как private
private Недоступны Недоступны Недоступны

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

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

Виртуальные методы

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

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

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

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

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

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

В программе создается объект класса Rectangle, а затем несколько раз вызываются методы PrintName и PrintDimention. В зависимости от того, как вызывается метод, будет работать метод, определенный в классе Figure или Rectangle.

#include <iostream.h>

// Базовый класс Figure

class Figure {

public:

 // Виртуальный метод

 virtual void PrintName(void) {cout << Figure PrintName << ‘\n’}

 // Невиртуальный метод

 void PrintDimention(void) {cout << Figure PrintDimention << ‘\n’}

};


// Порожденный класс Rectangle

class Rectangle : public Figure {

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

 virtual void PrintName(void) {cout << Rectangle PrintName << ‘\n’}


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

 void PrintDimention(void) {cout << Rectangle PrintDimention << ‘\n’}

};


// Главная функция

void main(void) {

 // Определяем объект порожденного класса

 Rectangle rectObject;


 // Определяем указатель на объект порожденного класса

 // и инициализируем его

 *Rectangle ptrRectObject = &rectObject;


 // Определяем указатель на объект базового класса Figure

 // и записываем в него адрес объекта порожденного класса.

 *Figure ptrFigObject = &rectObject;


 // Вызываем методы класса Rectangle, используя имя объекта

 rectObject.PrintName;

 rectObject.PrintDimention;

 cout << '\n';


 // Вызываем методы класса базового класса Figure

 rectObject.Figure::PrintName;

 rectObject.Figure::PrintDimention;

 cout << '\n';


 // Вызываем методы класса Rectangle, используя указатель на

 // объекты класса Rectangle

 ptrRectObject->PrintName;

 ptrRectObject->PrintDimention;

 cout << '\n';


 // Вызываем методы класса Rectangle, используя указатель на

 // объекты класса Figure

 ptrFigObject->PrintName;

 ptrFigObject->PrintDimention;

}

Если вы запустите приведенную выше программу, она выведет на экран следующую информацию:

Rectangle PrintName

Rectangle PrintDimention


Figure PrintName

Figure PrintDimention


Rectangle PrintName

Rectangle PrintDimention


Figure PrintName

Figure PrintDimention

Абстрактные классы

Виртуальные методы могут быть объявлены как чисто виртуальные. Для этого после описания метода указывается специальный спецификатор (= 0). Он означает, что описанные методы не определены.

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

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

В качестве примера абстрактного класса мы приведем класс Abstract, в котором описан чисто виртуальный метод PureFunc. Обратите внимание, что этот метод не определен в классе Abstract. Определение метода содержится только в порожденном классе Fact.

// Абстрактный класс Abstract

class Abstract {

public:

 // Чисто виртуальный метод, не имеет определения

 virtual int PureFunc(void) = 0;

 void SetValue(int i) {iValue = i;}

 int iValue;

};


// Класс Fact

class Fact : public Abstract {

 int PureFunc(void) {return iValue * iValue;}

};

Структуры

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

Различие между структурами и обычными классами заключается только в управлении доступом к их элементам. Так, если элементы класса по умолчанию объявлены как private, то все элементы структуры по умолчанию объявлены как public.

Ниже мы привели пример объявления структуры StructData и класса ClassData, которые содержат одинаковые элементы с одинаковыми правами доступа к ним. Фактически, структура StructData и класс ClassData совершенно равнозначны.

//====================================================

// Класс ClassData

class ClassData {

 int iPrivateValue;

public:

 int iPublicValue;

};


//====================================================

// Структура StructData

struct StructData {

 int iPublicValue;

private:

 int iPrivateValue;

};

Еще одно различие между структурами и классами проявляется в разграничении доступа к элементам базового класса (см. раздел “Разграничение доступа к элементам базового класса”). Если вы наследуете новый класс от базового класса и не указываете спецификатор доступа, по умолчанию используется спецификатор private. Когда же вы наследуете от базового класса структуру, по умолчанию используется спецификатор public.

Шаблоны

Языки программирования С и Си++ обеспечивают строгую проверку типов данных. Некоторые языки не обеспечивают такой проверки и она полностью ложится на плечи программиста. Например в языке PL1 вы можете сравнивать значение строковой и числовой переменных. Это не будет ошибкой с точки зрения компилятора. Если вы случайно допустите ошибку, то обнаружить ее будет достаточно сложно.

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

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

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

Чтобы облегчить программисту работу, в стандарт языка Си++ было включено понятие шаблона. В Visual C++ шаблоны реализованы начиная с версии 2.0. Ранние версии Visual C++ с ними работать не могли.

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

template <template-argument-list> declaration;

Аргумент template-argument-list представляет собой список условных имен для определения типов, по которым будут различаться различные реализации классов или функций данного шаблона.

Шаблоны в MFC

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

Перегрузка операторов

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

В Си++ вы можете переопределить большинство операторов языка для работы с вашими типами данных. Вот список операторов, которые вы можете переопределить:

! = < > += –= != , –> –>* & | ( ) [ ] new delete >> <<= ^= &= |= << >>= == ~ *= /= %= % ^ + - * / ++ -- <= >= && ||

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

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

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

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

Существует ряд ограничений, которые вы должны учитывать при переопределении операторов:

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

• Нельзя изменять старшинство операторов

• Нельзя определять новые операторы

• Нельзя переопределять операторы принимающие в качестве параметров стандартные типы данных языка, такие как int или char

• Переопределенные операторы не могут иметь параметров, используемых по умолчанию

• Нельзя переопределять следующие операторы: (.), (.*), (::), (?:), а также символы, обрабатываемые препроцессором (символы комментария и т. д.).

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

Обработка исключительных ситуаций

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

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

В языке Си++ реализованы специальные операторы try, throw и catch, предназначенные для обработки ошибочных ситуаций, которые называются исключениями.

Операторы try, throw и catch

Оператор try открывает блок кода, в котором может произойти ошибка. Если ошибка произошла, то оператор throw вызывает исключение. Исключение обрабатывается специальным обработчиком исключений. Обработчик исключения представляет собой блок кода, который начинается оператором catch.

Допустим ваше приложение должно вычислять значение выражения res = 100 / (num * (num – 7)). Если вы зададите значение переменной num, равное 0 или 7, то произойдет ошибка деления на нуль. Участок программы, в котором может случиться ошибка, объединим в блок оператора try. Вставим перед вычислением выражения проверку переменной nem на равенство нулю и семи. Если переменная num примет запрещенные значения, вызовем исключение, воспользовавшись оператором throw.

Сразу после блока try поместите обработчик исключения catch. Он будет вызываться в случае ошибки.

Пример такой программы, получившей название Exception, мы привели в листинге 1.1. Программа Exception принимает от пользователя значение переменной num, а затем вычисляет выражение res = 100 / (num * (num – 7)) и отображает полученный результат на экране.

В случае, если пользователь введет число 0 или 7, тогда вызывается исключение throw. В качестве параметра оператору throw указывается переменная num. Заметим, что так как переменная num имеет тип long, считается что данное исключение также будет иметь тип long.

После вызова оператора throw управление сразу передается обработчику исключения соответствующего типа. Определенный нами обработчик отображает на экране строку "Exception, num = ", а затем выводит значение переменной num.

После обработки исключения, управление не возвращается в блок try, а передается оператору, следующему после блока catch данного обработчика исключения. Программа выведет на экран строку “Stop program” и завершит свою работу.

Если пользователь введет разрешенные значения для переменной num, тогда исключение не вызывается. Программа вычислит значение res и отобразит его на экране. В этом случае обработчик исключения не выполнится и управление перейдет на оператор, следующий за блоком обработки исключения. Программа выведет на экран строку “Stop program” и завершит работу.

Листинг 1.1. Файл Exception.cpp
#include <iostream.h>


int main() {

 long num = 7;

 long res = 0;


 // Введите число num

 cout << "Input number: ";

 cin >> num;


 // Блок try, из которого можно вызвать исключение

 try {

 if ((num == 7) || (num == 0))


   // Если переменная num содержит значение 0 или 7,

   // тогда вызываем исключение типа float

   throw num;


  // Значения num равные 0 или 7 вызовут ошибку

  // деления на нуль в следующем выражении

  res = 100 / (num * (num – 7));


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

  cout << "Result = " << res << endl;

 }


 // Обработчик исключения типа float

 catch(long num) {

  // Отображаем на экране значение переменной num

  cout << "Exception, num = " << num << endl;

 }


 cout << "Stop program" << endl;

 return 0;

}

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

catch(long) {

 // Отображаем на экране значение переменной num

 cout << "Exception, num = " << num << endl;

}

Универсальный обработчик исключений

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

catch(…) {

 …

}

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

Тип исключения

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

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

#include <eh.h>

#include <iostream.h>

#include <process.h>


void FastExit(void);


int main() {

 // Устанавливаем функцию term_func

 set_terminate(FastExit);


 try {

  // …


  // Вызываем исключение типа int

  throw (int) 323;


  // …

 }


 // Определяем обработчик типа char. Обработчик исключений

 // типа int и универсальный обработчик не определены

 catch(char) {

  cout << "Exception " << endl;

 }

 return 0;

}


// Определение функции FastExit

void FastExit() {

 cout << "Exception handler not found" << endl;

 exit(-1);

}

Среда Visual C++ версии 4.0 позволяет запретить или разрешить обработку исключений языка Си++. Для управления исключениями выберите из меню Build строку Settings. На экране появится диалоговая панель Project Settings, в которой определяются все режимы работы. Выберите страницу C/C++. Затем из списка Category выберите строку C++ Language. Чтобы включить обработку исключительных ситуаций установите переключатель Enable exception handling.

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

#define _MFC_VER 0x0400

Мы будем рассматривать библиотеку 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
// Включаемый файл для MFC

#include <afxwin.h>


//=====================================================

// Класс CMFHelloApp

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

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

//=====================================================

class CMFHelloApp : public CWinApp {

public:

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

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

 virtual BOOL InitInstance();

};


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

CMFHelloApp MFHelloApp;


//=====================================================

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

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

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

// приложения

//=====================================================

BOOL CMFHelloApp::InitInstance() {

 AfxMessageBox("Hello, MFC!");

 return FALSE;

}

Единственный файл с исходным текстом приложения создан и его надо включить в проект. Выберите из меню 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 или нажмите комбинацию клавиш <Alt+F7>. На экране появится диалоговая панель 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

#include <afxwin.h>

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

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

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

#include <windows.h>


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

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

 MessageBox(NULL,"Hello, world", "Text Message", MB_OK);

 // Завершаем приложение

 return 0;

}

Взгляните на исходные тексты приложения. Вы нигде не обнаружите хорошо знакомой функции 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, определяется следующим образом:

//=====================================================

// Класс CMFHelloApp

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

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

//=====================================================

class CMFHelloApp : public CWinApp {

public:

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

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

 virtual BOOL InitInstance();

};

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

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

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

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

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

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

CMFStartApp MFHelloApp;

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

//=====================================================

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

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

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

// приложения

//=====================================================

BOOL CMFHelloApp::InitInstance() {

 AfxMessageBox("Hello, MFC!");


 return FALSE;

}

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

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

::MessageBox(NULL,"Hello, world!", "Message", MB_OK);

В конце метода 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
// Включаемый файл для MFC

#include <afxwin.h>


//=====================================================

// Класс CMFStartApp

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

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

//=====================================================

class CMFStartApp : public CWinApp {

public:

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

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

 virtual BOOL InitInstance();

};


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

CMFStartApp MFStartApp;


//=====================================================

// Класс CMFStartWindow

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

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

// окно нашего приложения

//=====================================================

class CMFStartWindow : public CFrameWnd {

public:

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

 CMFStartWindow();

};


//=====================================================

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

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

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

// приложения

//=====================================================

BOOL CMFStartApp::InitInstance() {

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

 m_pMainWnd = new CMFStartWindow();


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

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

 m_pMainWnd–>ShowWindow(m_nCmdShow);


 // Обновляем содержимое окна

 m_pMainWnd–>UpdateWindow();

 return TRUE;

}


//=====================================================

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

//=====================================================

CMFStartWindow::CMFStartWindow() {

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

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

 Create(NULL, "Hello MFC");

}

Просмотрите папку с файлами проекта. Теперь в ней расположен файл 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, определяется следующим образом:

//=====================================================

// Класс CMFStartApp

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

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

//=====================================================

class CMFStartApp : public CWinApp {

public:

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

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

 virtual BOOL InitInstance();

};

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

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

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

CMFStartApp MFStartApp;

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

//=====================================================

// Класс CMFStartWindow

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

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

// окно нашего приложения

//=====================================================

class CMFStartWindow : public CFrameWnd {

public:

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

 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. Он вызывается каждый раз при запуске

// приложения

//=====================================================

BOOL CMFStartApp::InitInstance() {

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

 m_pMainWnd = new CMFStartWindow();


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

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

 m_pMainWnd–>ShowWindow(m_nCmdShow);


 // Обновляем содержимое окна

 m_pMainWnd–>UpdateWindow();

 return TRUE;

}

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

//=====================================================

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

//=====================================================

CMFStartWindow::CMFStartWindow() {

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

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

 Create(NULL, "Hello MFC");

}

Для упрощения мы поместили описание классов, определения их методов и определения глобальных переменных в одном файле. На практике описания различных классов размещают в отдельных включаемых файлах. А определения методов записывают в программные файлы, имеющие расширение 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
#include <afxwin.h>

class CMFStartApp : public CWinApp {

public:

 virtual BOOL InitInstance();

};

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

Листинг 2.4. Файл MFStartApp.cpp
#include <afxwin.h>

#include "MFStartApp.h"

#include "MFStartWindow.h"


CMFStartApp MFStartApp;


BOOL CMFStartApp::InitInstance() {

 m_pMainWnd = new CMFStartWindow();

 m_pMainWnd–>ShowWindow(m_nCmdShow);

 m_pMainWnd–>UpdateWindow();

 return TRUE;

}

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

Листинг 2.5. Файл MFStartWindow.h
#include <afxwin.h>


class CMFStartWindow : public CFrameWnd {

public:

 CMFStartWindow();

};

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

Листинг 2.6. Файл MFStartWindow.cpp
#include <afxwin.h>

#include "MFStartWindow.h"


CMFStartWindow::CMFStartWindow() {

 Create(NULL, "Hello MFC");

}

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

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

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

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

MSG message;

while(GetMessage(&message, 0, 0, 0)) {

 DispatchMessage(&message);

}

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

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

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

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

 HDC hdc;

 PAINTSTRUCT ps;

 RECT rect;


 switch(message) {

 case WM_PAINT:

  hdc = BeginPaint(hWnd, &ps);


  GetClientRect(hWnd, &rect);


  DrawText(hdc, "Hello, Windows!", –1, &rect, DT_SINGLELINE | DT_CENTER);


  EndPaint(hWnd, &ps);

  return 0;


 case WM_DESTROY:

  PostQuitMessage(0);

  return 0;

 }


 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_<name> Стандартных сообщений операционной системы Windows
ON_REGISTERED_MESSAGE Зарегистрированные сообщения операционной системы Windows
ON_MESSAGE Сообщений, определенных пользователем
ON_COMMAND, ON_COMMAND_RANGE Командных сообщений
ON_UPDATE_COMMAND_UI, ON_UPDATE_COMMAND_UI_RANGE Сообщений, предназначенных для обновления пользовательского интерфейса
ON_<name>, ON_CONTROL_RANGE Сообщений от органов управления
Перечисленные в таблице макрокоманды имеют различное количество параметров в зависимости от типа обрабатываемых ими сообщений.

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

Для обработки сообщений, определенных в таблице сообщений макрокомандами ON_WM_<name>, вызываются одноименные методы. Имя метода обработчика соответствует названию сообщения, без учета префикса 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:

#define afx_msg

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

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

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

ON_REGISTERED_MESSAGE(nMessageVariable, memberFxn)

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

ON_MESSAGE(message, memberFxn)

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

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

ON_COMMAND(id, memberFxn)

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

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

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

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

ON_COMMAND_RANGE(id1, id2, memberFxn)

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

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

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

ON_UPDATE_COMMAND_UI_RANGE(id1, id2, memberFxn)

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

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

ON_BN_CLICKED(id, memberFxn)

Макрокоманда ON_CONTROL_RANGE
Макрокоманда 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
// Включаемый файл для MFC

#include <afxwin.h>

#include "MFMenuRes.h"


//=====================================================

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

//=====================================================

class CMFMenuApp : public CWinApp {

public:

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

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

 virtual BOOL InitInstance();

};


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

CMFMenuApp MFMenuApp;


//=====================================================

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

//=====================================================

class CMFMenuWindow : public CFrameWnd {

public:

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

 CMFMenuWindow();


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

 afx_msg void MenuCommand();

 afx_msg void ExitApp();


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

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

 DECLARE_MESSAGE_MAP()

};


//=====================================================

// Метод MenuCommand

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

//=====================================================

void CMFMenuWindow::MenuCommand() {

 MessageBeep(0);

}


//=====================================================

// Метод ExitApp

//=====================================================

void CMFMenuWindow::ExitApp() {

 DestroyWindow();

}


//=====================================================

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

//=====================================================

BEGIN_MESSAGE_MAP(CMFMenuWindow, CFrameWnd)

 ON_COMMAND(ID_TEST_BEEP, MenuCommand)

 ON_COMMAND(ID_TEST_EXIT, ExitApp)

END_MESSAGE_MAP()


//=====================================================

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

//=====================================================

BOOL CMFMenuApp::InitInstance() {

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

 m_pMainWnd = new CMFMenuWindow();


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

 m_pMainWnd–>ShowWindow(m_nCmdShow);


 // Обновляем содержимое окна

 m_pMainWnd–>UpdateWindow();

 return TRUE;

}


//=====================================================

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

//=====================================================

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 или просто нажать комбинацию кнопок <Ctrl+2>.

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

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


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

Рис. 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
//{{NO_DEPENDENCIES}}

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

// Используется в файле ресурсов MFMenu.rc

//

#define IDR_MENU 101

#define ID_TEST_BEEP 40001

#define ID_TEST_EXIT 40002


// Следующие значения идентификаторов используются по

// умолчанию для новых объектов

#ifdef APSTUDIO_INVOKED

 #ifndef APSTUDIO_READONLY_SYMBOLS

  #define _APS_NEXT_RESOURCE_VALUE 102

  #define _APS_NEXT_COMMAND_VALUE  40003

  #define _APS_NEXT_CONTROL_VALUE  1000

  #define _APS_NEXT_SYMED_VALUE    101

 #endif

#endif

В листинге 2.9 мы привели файл ресурсов MFMenuRes.rc приложения. Этот файл был подготовлен редактором ресурсов Visual C++. Однаиз первых строк файла содержит директиву #include которой подключается файл MFMenuRes.h, содержащий описание идентификаторов ресурсов (листинг 2.8).

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

Листинг 2.9. Файл MFMenuRes.rc
// Файл описания ресурсов приложения, созданный

// Microsoft Developer Studio

#include "MFMenuRes.h"


#define APSTUDIO_READONLY_SYMBOLS

//////////////////////////////////////////////////////////////

// Включаем файл afxres.h, содержащий определения стандартных

// идентификаторов

#include "afxres.h"


//////////////////////////////////////////////////////////////

#undef APSTUDIO_READONLY_SYMBOLS


//////////////////////////////////////////////////////////////

// Руссификацированные ресурсы

#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_RUS)

 #ifdef _WIN32

  LANGUAGE LANG_RUSSIAN, SUBLANG_DEFAULT

 #pragma code_page(1251)

 #endif //_WIN32


 ////////////////////////////////////////////////////////////

 // Меню

 //

 IDR_MENU MENU DISCARDABLE

 BEGIN

  POPUP "Test"

  BEGIN

   MENUITEM "Beep", ID_TEST_BEEP

   MENUITEM SEPARATOR

   MENUITEM "Exit", ID_TEST_EXIT

  END

 END


 #ifdef APSTUDIO_INVOKED


  ////////////////////////////////////////////////////////

  // Ресурсы TEXTINCLUDE

  //

  1 TEXTINCLUDE DISCARDABLE

  BEGIN

   "MFMenuRes.h\0"

  END


  2 TEXTINCLUDE DISCARDABLE

  BEGIN

   "#include ""afxres.h""\r\n"

   "\0"

  END


  3 TEXTINCLUDE DISCARDABLE

  BEGIN

   "\r\n"

   "\0"

  END


 #endif // APSTUDIO_INVOKED


#endif // Руссификацированные ресурсы


//////////////////////////////////////////////////////////////

#ifndef APSTUDIO_INVOKED

#endif


Когда вы создадите ресурсы приложения и включите файл ресурсов в проект обратите внимание на окно Project Workspace. В нем появится еще одна, четвертая страница ResourceView (рис. 2.24). Эта страница показывает все ресурсы, входящие в проект. В приложении MFMenu определен только один ресурс – меню, имеющее идентификатор IDR_MENU.

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

Рис. 2.24. Страница ResourceView окна Project Workspace


Теперь проект готов. Вы можете построить его и запустить полученное приложение MFMenu. Внешний вид приложения представлен на рисунке 2.25. Как видите окно приложения имеет меню Test, состоящее из двух строк – Beep и Exit.

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

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

Рис. 2.25. Приложение MFMenu


Чтобы объекты класса могли обрабатывать сообщения, в определении этого класса необходимо поместить макрокоманду DECLARE_MESSAGE_MAP. По принятым соглашениям эта макрокоманда должна записываться в конце определения класса в секции public.

//=====================================================

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

//=====================================================

class CMFMenuWindow : public CFrameWnd {

public:

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

 CMFMenuWindow();


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

 afx_msg void MenuCommand();

 afx_msg void ExitApp();


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

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

 DECLARE_MESSAGE_MAP()

};

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

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

Приложение MFMenu обрабатывает только две команды от меню приложения. Первая команда имеет идентификатор ID_TEST_BEEP и передается, когда пользователь выбирает из меню Test строку Beep. Для обработки этой команды вызывается метод MenuCommand. Вторая команда с идентификатором ID_TEST_EXIT передается приложению, когда пользователь выбирает из меню Test строку Exit. Обработка этого сообщения выполняется методом ExitApp.

//=====================================================

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

//=====================================================

BEGIN_MESSAGE_MAP(CMFMenuWindow, CFrameWnd)

 ON_COMMAND(ID_TEST_BEEP, MenuCommand)

 ON_COMMAND(ID_TEST_EXIT, ExitApp)

END_MESSAGE_MAP()

Конечно, приложению MFMenu может поступать гораздо больше сообщений и команд, чем указано в таблице сообщений класса CMFMenuWindow. Необработанные сообщения передаются для обработки базовому классу CMFMenuWindow – классу CFrameWnd . Класс, который будет обрабатывать сообщения, не указанные в таблице сообщений, указывается во втором параметре макрокоманды BEGIN_MESSAGE_MAP.

Долгий путь сообщения

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

Создайте новый проект под названием MFMessage. В качестве типа приложения выберите из списка Type строку Application (рис. 4.1). Наберите в редакторе исходный текст приложения и сохраните его в файле MFMessage.cpp (листинг 2.10). Чтобы быстрее набрать текст приложения, вы можете модифицировать исходный текст приложения MFMenu.

Листинг 2.10. Файл MFMessage.cpp
// Включаемый файл для MFC

#include <afxwin.h>

#include "resource.h"


//=====================================================

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

//=====================================================

class CMFMessageApp : public CWinApp {

public:

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

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

 virtual BOOL InitInstance();


 afx_msg void AppMessageCommand();


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

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

 DECLARE_MESSAGE_MAP()

};


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

CMFMessageApp MFMessageApp;


//=====================================================

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

//=====================================================

class CMFMessageWindow : public CFrameWnd {

public:

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

 CMFMessageWindow();


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

 afx_msg void FrameMessageCommand();

 afx_msg void ExitApp();


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

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

 DECLARE_MESSAGE_MAP()

};


//=====================================================

// Метод MessageCommand

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

//=====================================================

void CMFMessageWindow::FrameMessageCommand() {

 ::MessageBox(NULL, "Command received in CMFMessageWindow Message Map", "Message", MB_OK);

}


//=====================================================

// Метод MessageCommand

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

//=====================================================

void CMFMessageApp::AppMessageCommand() {

 ::MessageBox(NULL, "Command received in CMFMessageApp Message Map", "Message", MB_OK);

}


//=====================================================

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

//=====================================================

BEGIN_MESSAGE_MAP(CMFMessageWindow, CFrameWnd)

 ON_COMMAND(ID_TEST_INFRAMECLASS, FrameMessageCommand)

 ON_COMMAND(ID_TEST_INBOTHCLASS, FrameMessageCommand)

END_MESSAGE_MAP()



//=====================================================

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

//=====================================================

BEGIN_MESSAGE_MAP(CMFMessageApp, CWinApp)

 ON_COMMAND(ID_TEST_INAPPCLASS, AppMessageCommand)

 ON_COMMAND(ID_TEST_INBOTHCLASS, AppMessageCommand)

END_MESSAGE_MAP()


//=====================================================

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

//=====================================================

BOOL CMFMessageApp::InitInstance() {

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

 m_pMainWnd = new CMFMessageWindow();


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

 m_pMainWnd–>ShowWindow(m_nCmdShow);


 // Обновляем содержимое окна

 m_pMainWnd–>UpdateWindow();

 return TRUE;

}


//=====================================================

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

//=====================================================

CMFMessageWindow::CMFMessageWindow() {

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

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

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

}

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

Строка меню Test Идентификатор
In Frame Class ID_TEST_INFRAMECLASS
In App Class ID_TEST_INAPPCLASS
In Both Class ID_TEST_INBOTHCLASS
Exit ID_APP_EXIT
В листинге 2.11 представлен фрагмент файла ресурсов MFMessage.rc, в котором определяется меню приложения. Чтобы ускорить разработку меню, вы можете скопировать меню приложения MFMenu и изменить его соответствующим образом.

Листинг 2.11. Фрагмент файла MFMessage.rc
//////////////////////////////////////////////////////////////

// Меню

//

IDR_MENU MENU DISCARDABLE

BEGIN

 POPUP "Test"

 BEGIN

  MENUITEM "In Frame Class", ID_TEST_INFRAMECLASS

  MENUITEM "In App Class", ID_TEST_INAPPCLASS

  MENUITEM "In Both Class", ID_TEST_INBOTHCLASS

  MENUITEM "Exit", ID_APP_EXIT

 END

END

Идентификаторы, необходимые для файла ресурсов, записываются в файл resource.h, показанный в листинге 2.12. Этот файл создается автоматически редактором ресурсов. Все что вы должны сделать – это включить его в исходный текст приложения – файл MFMessage.cpp.

Листинг 2.12. Файл resource.h
//{{NO_DEPENDENCIES}}

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

// Используется в файле ресурсов MFMessage.rc

//

#define IDR_MENU 101

#define ID_TEST_BEEP 40001

#define ID_TEST_EXIT 40002

#define ID_TEST_INAPPCLASS 40003

#define ID_TEST_INFRAMECLASS 40004

#define ID_TEST_INBOTHCLASS 40006


// Следующие значения идентификаторов используются по

// умолчанию для новых объектов

#ifdef APSTUDIO_INVOKED

 #ifndef APSTUDIO_READONLY_SYMBOLS

  #define _APS_3D_CONTROLS 1

  #define _APS_NEXT_RESOURCE_VALUE 102

  #define _APS_NEXT_COMMAND_VALUE 40007

  #define _APS_NEXT_CONTROL_VALUE 1000

  #define _APS_NEXT_SYMED_VALUE 101

 #endif

#endif

Укажите в проекте MFMessage, что приложение использует библиотеку классов MFC и постройте проект. Запустите полученный выполнимый файл. На экране появится главное окно приложение, имеющее меню Test (рис. 2.26).

Рис. 2.26. Приложение MFMessage


Когда вы выбираете строки из меню Test, приложению передаются команды с соответствующими идентификаторами. Обратите внимание, что команда ID_TEST_INFRAMECLASS обрабатывается в классе окна CMFMessageWindow, команда ID_TEST_INAPPCLASS в главном классе приложения CMFMessageApp. Команда ID_TEST_INBOTHCLASS содержит два обработчика – один в классе окна, другой в классе приложения, зато команда ID_APP_EXIT не имеет обработчика совсем.

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

Поэкспериментируйте с приложением MFMessage. Очень скоро вы обнаружите, что команды обрабатываются не только классом окна, как это было в приложении MFMenu, но также и главным классом приложения. Те команды которые не имеют обработчика в таблице сообщений класса окна, передаются для обработке в класс приложения.

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

Широкие возможности для управления обработкой сообщений предоставляет ClassWizard. Мы расскажем более подробно об обработке сообщений и средствах ClassWizard в следующей главе.

Диалоговая панель

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

Библиотека классов MFC содержит класс CDialog, специально предназначенный для управления диалоговыми панелями. Как мы рассказывали в предыдущих томах серии “Библиотека системного программиста”, посвященных программированию для операционных систем Windows и Windows 95, диалоговые панели бывают двух типов – модальные и немодальные.

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

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

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

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


В библиотеке MFC версии 1.0 для немодальных диалоговых панелей был предназначен отдельный класс CModalDialog. Однако, начиная с MFC версии 2.0 он включен в класс CDialog. Для совместимости класс CModalDialog также оставлен, но он определен макрокомандой #define как CDialog (файл Afxwin.h):

#define CModalDialog CDialog

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

Следующим этапом создается класс для управления диалоговой панелью. Этот класс наследуется непосредственно от базового класса CDialog.

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

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

Чтобы создать модальную диалоговую панель, сначала необходимо создать объект определенного вами класса диалоговой панели, а затем вызвать метод DoModal, определенный в классе CDialog.

Процедура создания немодальной диалоговой панели несколько другая. Для этого используется метод Create класса CDialog. Мы рассмотрим создание немодальных диалоговых панелей позже.

Приложение с модальной диалоговой панелью

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

Создайте новый проект под названием MFDialog. В качестве типа приложения выберите из списка Type строку Application (рис. 4.1). Наберите в редакторе исходный текст приложения и сохраните его в файле MFDialog.cpp (листинг 2.13).

Листинг 2.13. Файл MFDialog.cpp
// Включаемый файл для MFC

#include <afxwin.h>

#include "resource.h"


//=====================================================

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

//=====================================================

class CMFDialogApp : public CWinApp {

public:

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

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

 virtual BOOL InitInstance();

};


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

CMFDialogApp MFDialogApp;


//=====================================================

// Класс CMyDialog – класс диалоговой панели

//=====================================================

class CMyDialog : public CDialog {

public:

 CMyDialog();


 CString m_Text;


protected:

 virtual void DoDataExchange(CDataExchange* pDX);


 // Обработчики сообщений от кнопок диалоговой панели

 afx_msg void OnDefault();

 virtual void OnCancel();

 virtual void OnOK();


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

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

 // управления диалоговой панели

 DECLARE_MESSAGE_MAP()

};


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

CMyDialog::CMyDialog() : CDialog(CMyDialog::IDD) {

 // Инициализируем переменную m_Text

 m_Text = "";

}


//=====================================================

// Метод DoDataExchange класса CMyDialog

//=====================================================

void CMyDialog::DoDataExchange(CDataExchange* pDX) {

 CDialog::DoDataExchange(pDX);


 DDX_Text(pDX, IDC_EDIT, m_Text);

}


//=====================================================

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

//=====================================================

BEGIN_MESSAGE_MAP(CMyDialog, CDialog)

 ON_BN_CLICKED(IDC_DEFAULT, OnDefault)

END_MESSAGE_MAP()


//=====================================================

// Метод OnDefault класса CMyDialog

//=====================================================

void CMyDialog::OnDefault() {

 // TODO:

 m_Text = "Start Text";

 UpdateData(FALSE);

 MessageBeep(0);

}


//=====================================================

// Метод OnCancel класса CMyDialog

//=====================================================

void CMyDialog::OnCancel() {

 // Подаем звуковой сигнал

 MessageBeep(0);


 // Вызываем метод OnCancel базового класса

 CDialog::OnCancel();

}


//=====================================================

// Метод OnOK класса CMyDialog

//=====================================================

void CMyDialog::OnOK() {

 // Вызываем метод OnOK базового класса

 CDialog::OnOK();


 // Подаем звуковой сигнал

 MessageBeep(0);

}


//=====================================================

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

//=====================================================

BOOL CMFDialogApp::InitInstance() {

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

 CMyDialog dlgTest;


m_pMainWnd = &dlgTest;


 // Отображаем на экране модельную диалоговую панель

 dlgTest.DoModal();


 // Отображаем на экране значение переменной m_Text,

 // ввходящей в класс CMyDialog

 AfxMessageBox(dlgTest.m_Text);

 return FALSE;

}


Создайте файл ресурсов MFDlgRes.rc и добавьте в него новую диалоговую панель. На экране откроется окно редактора диалоговой панели и панель с инструментами Controls (рис. 2.28). По умолчанию новая диалоговая панель называется Dialog и содержит две кнопки OK и Cancel.

Вы можете добавлять в диалоговую панель другие органы управления – кнопки, переключатели, поля редактирования, статические текстовые поля, рисунки. Более того в Visual C++ версии 4.0 вам становятся доступны новые органы управления – многостраничные диалоговые панели, поля для просмотра видеоинформации и т. д.

Рис. 2.28. Создание диалоговой панели


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


Кнопка Название Описание

Select Если вы нажмете эту кнопку, то сможете выбрать органы управления, которые уже расположены в диалоговой панели

Picture Рисунок

Static Text Статическое текстовое поле

Edit Box Поле редактирования

Group Box Прямоугольник, объединяющий группу органов управления

Button Кнопка

Check Box Переключатель в виде прямоугольника

Radio Button Переключатель круглой формы (радиопереключатель)

Combo Box Список с окном редактирования

List Box Список

Horizontal Scroll Bar Горизонтальная полоса просмотра

Vertical Scroll Bar Вертикальная полоса просмотра

Animate Окно просмотра видео

Tab Control Позволяет размещать в диалоговой панели несколько страниц органов управления, каждая из которых имеет “закладку”. Пользователь одновременно видит закладки всех страниц и может выбрать любую из них.

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

List Control Может использоваться для отображения списка пиктограмм

Hot Key Орган управления Hot Key предназначен для ввода комбинации клавиш акселераторов

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

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

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

Custom Control Орган управления, внешний вид и назначение которого определяется пользователем


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

Сначала добавьте кнопку. Для этого щелкните по изображению кнопки в панели Controls. Затем переместите указатель мыши в то место диалоговой панели, где вы желаете разместить кнопку и нажмите левую клавишу мыши. В диалоговой панели появится изображение кнопки, названное по умолчанию Button1. Выполните по ней двойной щелчок левой клавишей мыши. На экране появится панель Push Button Propeties, определяющая различные характеристики кнопки. В первую очередь вас будут интересовать поля Caption и ID. В поле Caption введите название кнопки Default, а в поле ID ее идентификатор IDC_DEFAULT. Остальные характеристики кнопки оставьте без изменения.

Находясь в редакторе ресурсов вы можете сразу попробовать как работает диалоговая панель. Найдите диалоговую панель Dialog (рис. 2.29). Если ее нет на экране, выберите из меню View строку Toolbars и в открывшейся диалоговой панели Toolbars установите переключатель Dialog. Диалоговая панель Dialog содержит ряд кнопок. Первая кнопка, на которой нарисован тумблер, позволяет проверить, как будет работать диалоговая панель.

Рис. 2.29. Панель управления Dialog


Остальные кнопки диалоговой панели Dialog позволяют задавать выравнивание органов управления друг относительно друга и относительно границ панели. Последние две кнопки устанавливают разметку на диалоговой панели. Разметка поможет вам ровнее разместить органы управления.

Вы можете изменить заголовок диалоговой панели, ее идентификатор и многие другие параметры, если сделаете двойной щелчок левой кнопкой мыши по заголовку диалоговой панели. На экране появится панель Dialog Properties, содержащая несколько страниц. Выберите страницу General (рис. 2.30).

Рис. 2.30. Характеристики диалоговой панели


В поле ID вы можете изменить идентификатор диалоговой панели, в поле Caption – заголовок диалоговой панели. В полях Font name и Font size отображается тип и размер шрифта, который используется для всех текстов в диалоговой панели. Изменить параметры шрифта можно, нажав кнопку Font. Поля X Pos и Y Pos позволяют указать начальное положение диалоговой панели на экране. Если X Pos и Y Pos содержат нулевые значения, начальное положение диалоговой панели определяется операционной системой.

Диалоговая панель может иметь собственное меню. Это меню будет отображаться непосредственно под заголовком диалоговой панели. Если вы желаете подключить к диалоговой панели меню, сначала разработайте меню и запишите его в файл ресурсов. Затем выберите в диалоговой панели Dialog Properties идентификатор данного меню из списка Menu.

Для приложения MFDialog вам надо поменять только идентификатор диалоговой панели и ее название. Измените идентификатор диалоговой панели с IDD_DIALOG1 на “DIALOGPANEL”, а ее заголовок – с Dialog на My Dialog. Остальные характеристики диалоговой панели оставьте без изменения.

Итак, диалоговая панель “DIALOGPANEL” приложения MFDialog содержит три кнопки, одно статическое текстовое поле и одно поле редактирования. В листинге 2.14 представлен фрагмент файла ресурсов в котором определяется диалоговая панель приложения.

Листинг 2.14. Фрагмент файла MFDlgRes.rc
//////////////////////////////////////////////////////////////

// Диалоговая панель

//

DIALOGPANEL DIALOG DISCARDABLE 0, 0, 186, 46

STYLE DS_MODALFRAME|DS_CENTER|WS_POPUP|WS_CAPTION|WS_SYSMENU

CAPTION "My Dialog"

FONT 8, "MS Sans Serif"

BEGIN

 DEFPUSHBUTTON "OK",IDOK,129,7,50,14

 PUSHBUTTON "Cancel",IDCANCEL,129,24,50,14

 PUSHBUTTON "Default",IDC_DEFAULT,70,7,50,14

 EDITTEXT IDC_EDIT,7,24,113,14,ES_AUTOHSCROLL

 LTEXT "Line Editor",IDC_STATIC,9,10,34,8

END

Идентификаторы, задействованные в файле ресурсов приложения по умолчанию, определяются во включаемом файле resource.h. Мы привели этот файл в листинге 2.15. Вы можете изменить название включаемого файла, выбрав из меню View строку Resource Includes.

Листинг 2.15. Файл resource.h
//{{NO_DEPENDENCIES}}

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

// Используется в файле ресурсов MFDlgRes.rc

//

#define IDR_MENU 101

#define IDC_DEFAULT 1000

#define IDC_EDIT 1001

#define ID_TEST_DIALOG 40001

#define ID_TEST_EXIT 40002


// Следующие значения идентификаторов используются по

// умолчанию для новых объектов

#ifdef APSTUDIO_INVOKED

 #ifndef APSTUDIO_READONLY_SYMBOLS

  #define _APS_NEXT_RESOURCE_VALUE 103

  #define _APS_NEXT_COMMAND_VALUE 40003

  #define _APS_NEXT_CONTROL_VALUE 1003

  #define _APS_NEXT_SYMED_VALUE 101

 #endif

#endif

Обратите внимание, что включаемый файл resource.h содержит не только определения идентификаторов, но также дополнительную служебную информацию. Она расположена после директивы #ifdef APSTUDIO_INVOKED и представляет собой ряд макроопределений. Данные макроопределения используются редактором ресурсов при создании новых идентификаторов.

Откройте страницу ClassView в окне Project Workspace. Обратите внимание, что если вы переместите окно Project Workspace к границе главного окна Visual C++, его заголовок пропадет и окно станет похоже на обычную панель управления. Если горизонтальный размер окна Project Workspace уменьшится, тогда исчезнут названия в закладках страниц и останутся только маленькие пиктограммы (рис. 2.31).

В ней отображаются два класса CMFDialogApp и CMyDialog. В главный класс приложения CMFDialogApp входит метод InitInstance. В класс CMyDialog входит конструктор CMyDialog, метод DoDataExchange , предназначенный для обмена данными между органами управления диалоговой панели и привязанных к ним переменных, а также методы OnOK , OnCancel и OnDefault. Последние три метода вызываются когда пользователь нажимает на кнопки OK, Cancel и Default, расположенные в диалоговой панели. Кроме того, определена глобальная переменная MFDialogApp.

Рис. 2.31. Классы проекта MFDialog


Страница ResourceView окна Project Workspace показывает все ресурсы, входящие в проект (рис. 2.32). В приложении MFDialog определен только один ресурс – диалоговая панель, имеющая идентификатор “DIALOGPANEL”.

Рис. 2.32. Ресурсы проекта MFDialog


Постройте проект и запустите полученный выполнимый файл. На экране появится диалоговая панель My Dialog, определенная в файле ресурсов нашего проекта (рис. 2.33). Вначале поле редактирования Line Editor пустое. В нем вы можете ввести любой текст. Если вы нажмете на кнопку Default, тогда все, что вы ввели в поле редактирования Line Editor, пропадает и в нем отображается строка Start Text.

Кроме кнопки Default в диалоговой панели My Dialog находятся еще две кнопки OK и Cancel. Если вы нажмете кнопку OK, тогда диалоговая панель закрывается, а на экране появляется текстовое сообщение, содержащее текст, введенный вами в поле Line Editor. Если нажать кнопку Cancel, то диалоговая панель My Dialog также закроется, но сообщение с введенным вами текстом не появится.

Рис. 2.33. Приложение MFDialog


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

Главный класс приложения
Теперь приступим к рассмотрению исходного текста приложения, представленного в листинге 1.1.

Сначала мы определяем главный класс приложения CMFDialogApp, наследованный от базового класса CWinApp . Класс CMFDialogApp и его методы используются аналогично приложению MFHello. Отличие заключается в том, что переопределенный метод InitInstance вместо отображения на экране сообщения при помощи функции AfxMessageBox , отображает полноценную модальную диалоговую панель.

//=====================================================

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

//=====================================================

BOOL CMFDialogApp::InitInstance() {

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

 CMyDialog dlgTest;


 m_pMainWnd = &dlgTest;


 // Отображаем на экране модельную диалоговую панель

 dlgTest.DoModal();


 // Отображаем на экране значение переменной m_Text,

 // входящей в класс CMyDialog

 AfxMessageBox(dlgTest.m_Text);

 return FALSE;

}

Сначала создается объект dlgTest класса CMyDialog, который будет представлять диалоговую панель. Когда объект dlgTest создан, диалоговая панель еще не появляется на экране, для этого надо воспользоваться методом DoModal, определенным в классе CDialog.

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

Чтобы отобразить диалоговую панель на экране, мы вызываем для объекта dlgTest метод DoModal . На этом выполнение метода InitInstance приостанавливается, пока пользователь не закроет диалоговую панель.

Когда диалоговая панель закрыта, мы отображаем на экране состояние переменной dlgTest.m_Text, которая соответствует полю ввода Edit диалоговой панели. Последний оператор метода return возвращает значение FALSE и приложение завершается.

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

//=====================================================

// Класс CMyDialog – класс диалоговой панели

//=====================================================

class CMyDialog : public CDialog {

public:

 CMyDialog();


 CString m_Text;


protected:

 virtual void DoDataExchange(CDataExchange* pDX);


 // Обработчики сообщений от кнопок диалоговой панели

 afx_msg void OnDefault();

 virtual void OnCancel();

 virtual void OnOK();


 DECLARE_MESSAGE_MAP()

};

Обратите внимание на то, как мы определяем конструктор класса CMyDialog. После названия конструктора стоит символ двоеточие и название конструктора класса CDialog. При этом в качестве параметра, конструктору CDialog передается идентификатор диалоговой панели "DIALOGPANEL":

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

CMyDialog::CMyDialog() : CDialog("DIALOGPANEL") {

 // Инициализируем переменную m_Text

 m_Text = "";

}

Основное назначение конструктора CMyDialog – вызвать конструктор класса CDialog, указав ему в качестве параметра идентификатор диалоговой панели "DIALOGPANEL". Именно конструктор класса CDialog выполняет создание диалоговой панели.

В конструкторе также инициализируется переменная m_Text, входящая в класс CMyDialog. В нее записывается пустая строка.

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

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

Названия всех функций, обеспечивающих обмен данными, начинаются символами DDX_. Например определены функции DDX_Text, DDX_Radio, DDX_Check, DDX_Scroll и т. д. Практически каждый тип органов управления диалоговой панели имеет собственную функцию для выполнения процедуры обмена данными.

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

Ниже представлен прототип функции DDX_, предназначенной для обмена информацией между полем редактирования диалоговой панели и элементом данных, входящим в класс диалоговой панели. Этот элемент имеет класс CString:

void AFXAPI DDX_Text(CDataExchange* pDX, int nIDC, CString& value);

Метод DoDataExchange позволяет выполнять проверку данных, которые пользователь вводит в диалоговой панели. Для этого предназначен ряд функций DDV_. Эти функции позволяют гарантировать, что данные, введенные пользователем в диалоговой панели, соответствуют определенным условиям.

Если вы используете функцию DDV_ для проверки ввода в данном органе управления, вы должны вызвать ее сразу после вызова функции DDX_ для этого же органа управления.

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

В отличие от функций DDX_, функции DDV_, в зависимости от их предназначения, имеют различное количество параметров. Первый параметр, как и в случае функций DDX_, содержит указатель на объект класса CDataExchange . Остальные параметры имеют различное назначение в зависимости от функции. Так, например, прототип функции, которая проверяет максимальную длину введенной текстовой строки, выглядит следующим образом:

void AFXAPI DDV_MaxChars(CDataExchange* pDX, CString const& value, int nChars);

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

Другие функции DDV_ имеют больше параметров. Так, функция DDV_MinMaxInt, проверяющая, что введенное значение находится в определенных границах, имеет 4 параметра:

void AFXAPI DDV_MinMaxInt(CDataExchange* pDX, int value, int minVal, int maxVal);

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

Приложение не должно напрямую вызывать метод DoDataExchange. Он вызывается через метод UpdateData, определенный в классе CWnd (рис. 2.34). Если вам надо выполнить обмен данными, между органами управления и элементами данных класса диалоговой панели, используйте метод UpdateData . Приведем прототип метода UpdateData:

BOOL UpdateData(BOOL bSaveAndValidate = TRUE);

Рис. 2.34. Вызов метода DoDataExchange


Необязательный параметр bSaveAndValidate, определяет, как будет происходить обмен данными. Если метод UpdateData вызывается с параметром FALSE, выполняется инициализация диалоговой панели. Информация из элементов данных класса отображается в органах управления диалоговой панели.

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

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

При создании модальной диалоговой панели перед тем как панель появится на экране, вызывается виртуальный метод OnInitDialog класса CDialog . По умолчанию OnInitDialog вызывает метод UpdateData и выполняет инициализацию органов управления. Если вы переопределили метод OnInitDialog в своем классе диалоговой панели, в первую очередь вызовите метод OnInitDialog класса CDialog.

Метод UpdateData также вызывается некоторыми другими методами класса CDialog. Так, метод UpdateData вызывается, когда пользователь закрывает модальную диалоговую панель, нажимая кнопку OK. Заметим, что кнопка OK должна иметь идентификатор IDOK. Если пользователь нажмет на кнопку Cancel, имеющую идентификатор IDCANCEL, то диалоговая панель также закрывается, но метод UpdateData не вызывается и обмен данными не происходит.

//=====================================================

// Метод DoDataExchange класса CMyDialog

//=====================================================

void CMyDialog::DoDataExchange(CDataExchange* pDX) {

 CDialog::DoDataExchange(pDX);

 DDX_Text(pDX, IDC_EDIT, m_Text);

}

Методу DoDataExchange передается указатель pDX на объект класса CDataExchange. Этот объект создается, когда вы инициируете процесс обмена данными, вызывая метод UpdateData . Элементы данных класса CDataExchange определяют процедуру обмена данными, в том числе определяют, в каком направлении будет происходить этот обмен. Обратите внимание, что указатель pDX передается функциям DDX_ и DDV_.

В библиотеку MFC входит большое количество функций DDX_ и DDV_. Чтобы облегчить задачу написания метода DoDataExchange для класса вашей диалоговой панели, используйте ClassWizard. Он позволяет привязать к органам диалоговой панели элементы данных класса. При этом метод DoDataExchange создается ClassWizard автоматически. ClassWizard сам выбирает, какие функции DDX_ и DDV_ надо использовать для данного органа управления и связанного с ним элемента данных класса диалоговой панели. Подробно об использовании ClassWizard для разработки диалоговых панелей вы можете прочитать в главе “Приложение с главной диалоговой панелью”.

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

//=====================================================

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

//=====================================================

BEGIN_MESSAGE_MAP(CMyDialog, CDialog)

 ON_BN_CLICKED(IDC_DEFAULT, OnDefault)

END_MESSAGE_MAP()

Таблица сообщений содержит только одну строку, в которой обрабатывается сообщение с кодом извещения ON_BN_CLICKED от кнопки “Default”. Когда пользователь нажимает кнопку, вырабатывается данное сообщение и вызывается его обработчик – метод OnDefault, определенный в классе CMyDialog:

//=====================================================

// Метод OnDefault класса CMyDialog

//=====================================================

void CMyDialog::OnDefault() {

 // TODO:

 m_Text = "Start Text";

 UpdateData(FALSE);

 MessageBeep(0);

}

Две другие кнопки диалоговой панели "DIALOGPANEL", OK и Cancel не представлены в таблице сообщений, но тем не менее в приложении определены методы OnOK и OnCancel, которые вызываются при нажатии на них. Оказывается для диалоговых панелей определены две стандартные кнопки OK и Cancel, которым присвоены специальные идентификаторы IDOK и IDCANCEL.

Базовый класс CDialog, также как и класс CMyDialog, содержит таблицу сообщений. Если вы установили библиотеку MFC вместе с исходными текстами, вы можете изучить реализацию класса CDialog в файле Dlgcore.cpp. Сам класс CDialog определен во включаемом файле Afxwin.h. Ниже представлена выдержка из таблицы сообщений, определенной в файле Dlgcore.cpp:

BEGIN_MESSAGE_MAP(CDialog, CWnd)

 //{{AFX_MSG_MAP(CDialog)

 ON_WM_CTLCOLOR()

 ON_COMMAND(IDOK, OnOK)

 ON_COMMAND(IDCANCEL, OnCancel)

 ON_MESSAGE(WM_COMMANDHELP, OnCommandHelp)

 ON_MESSAGE(WM_HELPHITTEST, OnHelpHitTest)

 ON_MESSAGE(WM_QUERY3DCONTROLS, OnQuery3dControls)

 ON_MESSAGE(WM_INITDIALOG, HandleInitDialog)

 ON_MESSAGE(WM_SETFONT, HandleSetFont)

 //}}AFX_MSG_MAP

END_MESSAGE_MAP()

Среди прочих сообщений, в этой таблице определены командные сообщения с идентификаторами IDOK и IDCANCEL. Для обработки этих командных сообщений определены виртуальные методы OnOK и OnCancel. Данные методы также определены в MFC (файл Dlgcore.cpp). Поэтому когда диалоговая панель содержит кнопки с идентификаторами IDOK и IDCANCEL, как правило нет необходимости создавать для них обработчики.

Так как в таблице сообщений класса CMyDialog отсутствуют макрокоманды для обработки сообщений от кнопок OK и Cancel, они передаются для обработки базовому классу CDialog. Здесь они обрабатываются виртуальными методами OnOK и OnCancel.

Метод OnOK, определенный в классе CDialog, копирует данные из полей диалоговой панели в связанные с ними переменные. Для этого вызывается метод UpdateData с параметром TRUE. Затем выполняется вызов метода EndDialog, который закрывает диалоговую панель и возвращает значение IDOK. После того как диалоговая панель закрыта, метод DoModal возвращает значение IDOK и продолжает работать метод InitInstance.

void CDialog::OnOK() {

 if (!UpdateData(TRUE)) {

  // В процессе обмена данными произошла ошибка

  TRACE0("UpdateData failed during dialog termination.\n");

  return;

 }

 EndDialog(IDOK);

}

Метод OnCancel, определенный в классе CDialog, еще проще, чем OnOK. Он только закрывает диалоговую панель и возвращает значение IDCANCEL. Копирование данных из полей диалоговой панели не происходит, так как пользователь отменил изменения, нажав кнопку Cancel.

void CDialog::OnCancel() {

 EndDialog(IDCANCEL);

}

Так как методы OnOK и OnCancel определены в классе CDialog как виртуальные, вы можете переназначить их в своем классе CMyDialog. В этом случае управление получат переопределенные вами методы, а не методы класса CDialog. Методы базового класса CDialog можно вызвать, явно указав класс.

//=====================================================

// Метод OnCancel класса CMyDialog

//=====================================================

void CMyDialog::OnCancel() {

 // Подаем звуковой сигнал

 MessageBeep(0);


 // Вызываем метод OnCancel базового класса

 CDialog::OnCancel();

}

Переопределенный нами метод OnCancel вызывает функцию программного интерфейса MessageBeep, которая подает звуковой сигнал, а затем вызываем метод OnCancel базового класса CDialog. Метод OnCancel базового класса CDialog вызывается в конце, так как он закрывает саму диалоговую панель.

Аналогично методу OnCancel мы переопределили метод OnOK.

//=====================================================

// Метод OnOK класса CMyDialog

//=====================================================

void CMyDialog::OnOK() {

 // Вызываем метод OnOK базового класса

 CDialog::OnOK();


 // Подаем звуковой сигнал

 MessageBeep(0);

}

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

Приложение с немодальной диалоговой панелью

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

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

Следующие шаги выполняются только для немодальных диалоговых панелей. Для класса диалоговой панели надо определить конструктор, объявив его как public. Чтобы открыть немодальную диалоговую панель, создайте объект класса диалоговой панели, обратившись к определенному вами конструктору. В этот момент диалоговая панель еще не появляется на экране. Для этого надо вызвать метод Create класса CDialog.

Вы можете вызывать метод Create либо непосредственно из конструктора класса диалоговой панели, либо уже после создания объекта. Если диалоговая панель имеет стиль WS_VISIBLE, она сразу появится на экране. В противном случае для этого надо вызвать метод ShowWindow. Как видите, для отображения немодальной диалоговой панели мы не использовали метод DoModal.

В классе CDialog определены два прототипа метода Create. Один позволяет указать диалоговую панель через ее текстовое имя, а другой через числовой идентификатор:

BOOL Create(LPCTSTR lpszTemplateName, CWnd* pParentWnd = NULL);

BOOL Create(UINT nIDTemplate, CWnd* pParentWnd = NULL);

Параметр lpszTemplateName должен содержать указатель на строку, закрытую нулем, содержащую имя ресурса диалоговой панели. Если вы используете метод Create, имеющий второй прототип, вместо имени шаблона, надо указать в параметре nIDTemplate его идентификатор.

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

Метод Create возвращает управление сразу после того, как диалоговая панель отобразилась на экране. Он возвращает ненулевое значение, если создание диалоговой панели завершилось успешно и нуль в противном случае.

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

Теперь вам остается удалить объект, управляющий диалоговой панелью. Для этого в классе диалоговой панели можно переопределить виртуальный метод PostNcDestroy (этот метод первоначально определен в базовом классе CWnd). В нем вы можете вызвать оператор delete, передав ему в качестве параметра указатель на данный объект this .

3. Некоторые классы MFC

В этом разделе мы опишем несколько классов, которые вы будете использовать при создании собственных приложений.

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

Класс CObject – основной класс MFC

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

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

Для объектов, порожденных от CObject, можно получить информацию во время работы программы. Такая возможность используется при динамическом создании объектов. MFC версии 4.0 позволяет также определить имя типа объекта во время работы программы. Эта особенность называется Run-Time Type Information (RTTI). Кроме того возможности класса CObject используются для вывода диагностических сообщений объектами, порожденными от этого класса.

Класс CObject не позволяет осуществлять множественное наследование. Ваш класс должен иметь только один базовый класс CObject.

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

Например, чтобы получить возможность во время выполнения приложения определять название класса и его базовый класс, следует включить в объявление и определение вашего класса макрокоманды DECLARE_DYNAMIC и IMPLEMENT_DYNAMIC. А если вам надо, чтобы состояние объектов класса можно было сохранять и восстанавливать из архивного класса, следует включить в объявление и определение класса макрокоманды DECLARE_SERIAL и IMPLEMENT_SERIAL.

Конструкторы класса

Для класса CObject определены два конструктора. Первый конструктор используется по умолчанию и не имеет параметров. Именно этот конструктор вызывается конструкторами классов, наследованных от CObject:

CObject();

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

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

В случае, если бы конструктор копирования класса CObject не был описан, компилятор создал бы его автоматически. Таким образом описание конструктора копирования как private, принуждает вас явно определить конструктор копирования для порожденных классов (конечно если конструктор копирования необходим):

private:

 CObject(const CObject& objectSrc);

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

Оператор присваивания

Для класса CObject описан оператор присваивания. Он описан с ключевым словом private и не имеет реализации:

private:

void operator=(const CObject& src);

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

Диагностика

Класс CObject содержит методы AssertValid и Dump, которые могут помочь на этапе отладки приложения. Оба эти методы определены как виртуальные. Вы можете переопределить их в своем классе.

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

virtual void AssertValid() const;

Если вы наследуете класс от базового класса CObject и желаете использовать возможности метода AssertValid, вы должны переопределить его. Переопределенный метод AssertValid должен вызывать метод AssertValid базового класса, чтобы проверить целостность соответствующей части объекта. Затем необходимо выполнить проверку элементов порожденного класса. Для этого используйте макрокоманду ASSERT:

ASSERT(booleanExpression)

Макрокоманда ASSERT проверяет свой параметр booleanExpression. Если параметр макрокоманды имеет нулевое значение (FALSE), она отображает диагностическое сообщение и прерывает работу приложения. Если параметр booleanExpression не равен нулю (TRUE) работа приложения продолжается и макрокоманда не выполняет никаких действий.

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

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

Вот пример переопределения метода AssertValid для класса CFigure, наследованного от базового класса CObject:

// Класс CFigure наследуется от базового класса CObject

class CFigure : public CObject {

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

 int m_area = 0;


 // Остальные элементы класса…

}


// Переопределяем виртуальный метод AssertValid класса CObject

void CFigure::AssertValid() const {

 // Сначала проверяем целостность элементов базового класса

 CObject::AssertValid();


 // Проверяем элемент m_area.

 // Он должен быть больше или равен нулю

 ASSERT(m_area >= 0);

}

Получение дампа объекта класса
Виртуальный метод Dump позволяет получить дамп объекта данного класса:

virtual void Dump(CDumpContext& dc) const;

Метод Dump имеет единственный параметр dc, определяющий контекст отображения для вывода дампа объекта. Часто в качестве параметра dc используется предопределенный объект afxDump. Он позволяет передавать информацию в окно отладчика Visual C++. Объект afxDump определен только для отладочной версии приложения.

Вы можете переопределить метод Dump для своего класса. Переопределенный метод должен сначала вызывать метод Dump базового класса, а затем выводить значения элементов самого класса. Для вывода значений элементов объекта класса в контекст dc можно использовать операторы <<, переопределенные для класса CDumpContext.

Если класс определен с макрокомандами IMPLEMENT_DYNAMIC или IMPLEMENT_SERIAL, то метод Dump класса CObject будет отображать также имя самого класса.

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

void CFigure::Dump(CDumpContext &dc) const {

 // Вызываем метод Dump базового класса

 CObject::Dump(dc);


 // Выводим в контекст dc значение элемента m_area

 // класса CFigure

 dc << "Площадь = " << m_area;

}

Сохранение и восстановление состояния объекта

В классе CObject определены метод IsSerializable и виртуальный метод Serialize, которые используются для сохранения и восстановления состояния объектов в файлах на диске. Чтобы объекты класса можно было сохранять в файлах на диске с возможностью их последующего восстановления, объявление класса объекта должно содержать макрокоманду DECLARE_SERIAL, а реализация класса макрокоманду IMPLEMENT_SERIAL. Более подробно об сохранении и восстановлении объектов можно прочитать в разделе “Запись и восстановление объектов”.

Метод IsSerializable
Метод IsSerializable позволяет определить, можно ли записать состояние объекта в файле, а потом восстановить его. Если это возможно, метод IsSerializable возвращает ненулевое значение.

BOOL IsSerializable() const;

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

virtual void Serialize(CArchive& ar);

throw(CMemoryException);

throw(CArchiveException);

throw(CFileException);

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

Информация о классе

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

Виртуальный метод GetRuntimeClass
Виртуальный метод GetRuntimeClass возвращает указатель на структуру CRuntimeClass, описывающую класс объекта, для которого метод был вызван:

virtual CRuntimeClass* GetRuntimeClass() const;

Для каждого класса, наследованного от CObject поддерживается своя структура CRuntimeClass. Если вы желаете использовать метод GetRuntimeClass в своем классе, наследованном от CObject, вы должны поместить в реализации класса макрокоманду IMPLEMENT_DYNAMIC или IMPLEMENT_SERIAL.

Структура CRuntimeClass содержит различную информацию о классе. Ниже перечислены несколько основные полей этой структуры.

Поле структуры CRuntimeClass Описание
const char* m_pszClassName Указатель на строку, закрытую двоичным нулем, в которой расположено имя класса
int m_nObjectSize Размер объектов класса
WORD m_wSchema Номер схемы (schema number) класса. Используется при автоматическом сохранении и восстановлении объектов класса в файле. Если объекты класса не могут быть сохранены и восстановлены (в объявлении класса отсутствует макрокоманда IMPLEMENT_SERIAL), m_wSchema содержит значение –1
void (*m_pfnConstruct) (void* p) Указатель на конструктор класса, используемый по умолчанию. Этот конструктор не имеет параметров
CRuntimeClass* m_pBaseClass Указатель на структуру CRuntimeClass, содержащую аналогичную информацию о базовом классе
Кроме перечисленных элементов структуры, она содержит метод CreateObject. Этот метод позволяет динамически создать объект соответствующего класса уже во время работы приложения. Если объект класса не создан, метод возвращает значение NULL.

CObject* CreateObject();

Метод IsKindOf
Метод IsKindOf определяет отношение объекта и класса, представленного указателем pClass на структуру CRuntimeClass. Метод правильно работает только для классов, в объявлении которых указаны макрокоманды DECLARE_DYNAMIC или DECLARE_SERIAL.

BOOL IsKindOf(const CRuntimeClass* pClass) const;

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

Класс CPoint – точка на плоскости

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

Библиотека классов MFC включает в себя класс CPoint , который можно использовать вместо структуры POINT. Класс CPoint имеет несколько конструкторов, которые вы можете использовать.

Первый конструктор класса не имеет параметров:

CPoint();

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

CPoint(int initX, int initY);

Первый параметр initX определяет х-координату точки, а параметр initY – y-координату точки. Если надо создать объект CPoint и записать в него координаты из переменной типа POINT или другого объекта класса CPoint, используйте другой конструктор:

CPoint(POINT initPt);

Можно создать объект CPoint и записать в него данные из объекта класса CSize или структуры SIZE:

CPoint(SIZE initSize);

Если у вас есть переменная типа DWORD, в младшем слове которой записана x-координата точки, а в старшем слове y-координата, то можно создать объект класса CPoint и записать в него данные из этой переменной:

CPoint(DWORD dwPoint);

Объекты класса CPoint можно сравнивать друг с другом, пользуясь обычными операторами равенства == (равно) и != (не равно). Результатом действия этих операторов является значение типа BOOL. Если условие определенное операторами равенства выполняется, возвращается ненулевое значение. В противном случае результат равен нулю.

Класс CSize – относительные координаты

Класс CSize создан на основе структуры SIZE, предназначенной для определения относительных координат точек в двумерном пространстве. Так как CSize наследуется от структуры SIZE, он включает все ее поля. Вы можете непосредственно обращаться к элементам SIZE. Элементы данных cx и cy объявлены как доступные. Объекты класса CSize можно использовать вместо переменных типа SIZE – их можно указывать в качестве параметров функций. Вы можете передавать объекты CSize функциям, которые принимают параметры типа SIZE. Объявление класса CSize расположено во включаемом файле #include <afxwin.h>.

Класс CString – текстовые строки

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

Строки CString состоят из символов, типа TCHAR. Тип TCHAR определяется по разному в зависимости от того, определен или нет символ _UNICODE. Если символ _UNICODE не определен, TCHAR соответствует обычному типу char. В противном случае он представляет символы, определяемые двумя байтами.

При использовании класса CString отпадает необходимость постоянно следить за тем, чтобы длина строки не превысила объем выделенной для нее памяти. Строки CString автоматически расширяются и сокращаются в зависимости от фактической длины строки.

В класс CString входят методы, выполняющие все основные операции над строками – копирование, сравнение, присваивание и т. д. Над объектами класса CString определены такие операции как +, –, облегчающие работу со строками. Строки, представленные объектами CString, можно сравнивать, используя обычные операторы сравнения <, >, <=, >=, ==. Объекты класса CString можно записывать на диск – для них работает механизм сохранения и восстановления объектов класса. Фактически вы можете работать со стоками как с другими простыми типами данных.

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

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

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

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

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

CString();

Для класса CString определен конструктор копирования. Он позволяет создать строку на основе другой, ранее определенной строки. Этот и все остальные конструкторы могут вызвать исключение CMemoryException, если для создания строки недостаточно оперативной памяти.

CString(const CString& stringSrc) throw(CMemoryException);

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

CString(TCHAR ch, int nRepeat = 1) throw(CMemoryException);

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

CString(LPCTSTR lpch, int nLength) throw(CMemoryException);

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

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

CString(const unsigned char* psz) throw(CMemoryException);

CString(LPCWSTR lpsz) throw(CMemoryException);

CString(LPCSTR lpsz) throw(CMemoryException);

Коллекции

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

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

Массивы – шаблон CArray

Библиотека MFC включает классы для организации массивов байт, слов, двойных слов, указателей, объектов класса CString и указателей на объекты класса CObject. В MFC версии 4.0 добавлен шаблон класса массива, позволяющий создавать на его основе собственные массивы переменных любых типов и массивы объектов любых классов. Для доступа к элементам массива можно использовать оператор [].

Ниже представлен прототип шаблона CArray.

template <class TYPE, class ARG_TYPE>

class CArray : public CObject

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

Мы будем использовать шаблон CArray для организации массива в приложении Single (см. раздел “Простейший графический редактор” главы “Однооконный интерфейс”).

Списки – шаблон CList

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

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

Ниже представлен прототип шаблона CList.

template <class TYPE, class ARG_TYPE>

class CList : public CObject

Словари – шаблон CMap

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

В MFC включены классы для создания словарей отображающих значения слов, указателей, указателей на объекты типа CObject и объектов CString. Библиотека MFC версии 4.0 содержит шаблоны для организации словарей. Шаблоны позволяют создать класс словарей, основанных на объектах любых типов.

Ниже представлен прототип шаблона CMap.

template <class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>

class CMap : public CObject

Параметр шаблона KEY определяет тип ключевого поля словаря. Параметр ARG_KEY является типом данных, используемых в качестве аргумента KEY. Параметр VALUE соответствует типу элементов, хранящихся в словаре, а параметр ARG_VALUE используется в качестве аргумента VALUE.

Класс CTime – дата и время

Для работы с календарными датами и временем в состав библиотеки классов MFC включен класс CTime. Класс основан на элементе типа time_t, в котором будет храниться дата и время. Элемент типа time_t объявлен как private, поэтому вы не можете обращаться непосредственно к этому элементу. Для этого в состав класса CTime входит набор методов.

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

Если вам требуется создать массив, состоящий из объектов класса CTime, используйте конструктор без указания параметров:

CTime();

Объекты, созданные этим конструктором не инициализированы. Перед тем как ими пользоваться, запишите в них дату и время:

CTime(const CTime& timeSrc);

Параметр timeSrc определяет уже существующий объект класса CTime. Новый объект класса инициализируется значением даты и времени, взятым из существующего объекта.

Если в программе уже существует переменная типа time_t, в которой хранится значение, то можно создать новый объект класса CTime, основываясь на этой переменной:

CTime(time_t time);

Параметр time определяет переменную типа time_t, значение которой будет записано в создаваемый объект.

Если существует несколько переменных, в которых отдельно хранятся год, месяц, день, часы, минуты и секунды, то можно создать объект класса CTime, сразу же записав в него значения из этих переменных:

CTime(int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec, int nDST = –1);

Первые 6 параметров метода определяют время и дату. Параметр nYear должен содержать год, nMonth – месяц, nDay – день, nHour – час, nMin – минуты, nSec – секунды. NYear может принимать значения от 1900 до 2038, nMonth – от 1 до 12 и nDay от 1 до 31.

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

Следующий конструктор позволяет создать объект класса CTime и записать в него дату и время, определенные в формате, принятом в операционной системе MS-DOS:

CTime(WORD wDosDate, WORD wDosTime, int nDST = –1);

Параметры wDosDate и wDosTime должны содержать, соответственно, дату и время в формате MS-DOS. Параметр nDST управляет режимом перехода на летнее время. Мы уже рассматривали его выше.

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

typedef struct _SYSTEMTIME {

 WORD wYear; // год

 WORD wMonth; // месяц

 WORD wDayOfWeek; // день недели

 WORD wDay; // календарная дата

 WORD wHour; // часы

 WORD wMinute; // минуты

 WORD wSecond; // секунды

 WORD wMilliseconds; // миллисекунды

} SYSTEMTIME;

Если необходимо создать объект класса CTime, сразу записав в него текущие значения времени и даты, используйте конструктор, представленный ниже:

CTime(const SYSTEMTIME& sysTime, int nDST = –1);

Параметр sysTime является указателем на структуру типа SYSTEMTIME. Необязательный параметр nDST управляет режимом отсчета даты и описан нами выше.

Вторая структура, в которой хранятся значения даты и времени, называется FILETIME. Она служит для хранения 64-битового числа, представляющего дату и время как количество 100 наносекундных интервалов времени, прошедших с первого января 1601 года.

typedef struct _FILETIME {

 DWORD dwLowDateTime; // младшие 32 бита

 DWORD dwHighDateTime; // старшие 32 бита

} FILETIME, *PFILETIME, *LPFILETIME;

Конструктор имеет следующий прототип:

CTime(const FILETIME& fileTime, int nDST = –1);

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

Библиотека MFC включает класс CFile, предназначенный для обеспечения работы с файлами. Он позволяет упростить использование файлов, представляя файл как объект, который можно создать, читать, записывать и т. д. Класс CFile наследуется непосредственно от класса CObject:

CFile←CObject

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

Открытие и создание файлов

После создания объекта класса CFile можно открыть файл, вызвав метод Open. Методу Open надо указать путь к открываемому файлу и режим его использования. Прототип метода Open имеет следующий вид:

virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags, CFileException* pError = NULL);

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

Второй параметр nOpenFlags определяет действие, выполняемое методом Open с файлом, а также атрибуты файла. Ниже представлен список возможных значений параметра nOpenFlags:

Возможные значения nOpenFlags Описание
CFile::modeCreate Создается новый файл. Если указанный файл существует, то его содержимое стирается и длина устанавливается равной нулю
CFile::modeNoTruncate Этот флаг предназначен для использования совместно с флагом CFile::modeCreate. Если создается уже существующий файл, то его содержимое не будет удалено
CFile::modeRead Файл открывается только для чтения
CFile::modeReadWrite Файл открывается для чтения и записи
CFile::modeWrite Файл открывается только для записи
CFile::modeNoInherit Указывает, что файл не должен наследоваться порожденным процессом
CFile::shareCompat Открывает файл в режиме совместимости. Любой другой процесс может открыть этот файл несколько раз. Операция вызывает ошибку, если файл уже открыт другим процессом в любом другом режиме кроме режима совместимости
CFile::shareDenyNone Не запрещается доступ к открываемому файлу ни на чтение, ни на запись. Вызывает ошибку, если файл уже открыт в режиме совместимости любым другим процессом
CFile::shareDenyRead После того как файл открыт, другим процессам запрещается его чтение. Вызывает ошибку, если уже открыт в режиме совместимости или для чтения другим процессом
CFile::shareDenyWrite После того как файл открыт, другим процессам запрещается запись в него. Вызывает ошибку, если уже открыт в режиме совместимости или для записи другим процессом
CFile::shareExclusive После того как файл открыт, другим процессам запрещается запись и чтение из этого файла. Вызывает ошибку, если файл уже открыт для чтения или для записи любым процессом
CFile::typeText Используется классами, порожденными от класса CFile, например CStdioFile, для работы с файлами в текстовом режиме. Текстовый режим обеспечивает преобразование комбинации символа возврата каретки и символа перевода строки.
CFile::typeBinary Используется классами, порожденными от класса CFile, например CStdioFile, для работы с файлами в двоичном режиме
Необязательный параметр pError, который является указателем на объект класса CFileException, используется только в том случае, если выполнение операции с файлом вызывает ошибку. Если вы указали параметр pError и случилась ошибка, то в объект будет записана дополнительная информация.

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

Идентификатор открытого файла

В состав класса CFile входит элемент данных m_hFile типа UINT. В нем хранится идентификатор открытого файла. Если вы создали объект класса CFile, но еще не открыли никакого файла, то в m_hFile записана константа hFileNull.

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

Закрытие файлов

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

virtual void Close() throw(CFileException);

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

Чтение и запись файлов

Для доступа к файлам предназначены пять различных методов класса CFile: Read, ReadHuge, Write, WriteHuge, Flush. Методы Read и ReadHuge предназначены для чтения данных из предварительно открытого файла. В 16-разрядной операционной системе Windows функция Read может считать не больше, чем 65535 байт. На метод ReadHuge такие ограничения не накладываются. В 32-разрядных операционных системах оба метода могут одновременно считать из файла больше, чем 65535 байт.

virtual UINT Read(void* lpBuf, UINT nCount) throw(CFileException);

Данные, прочитанные из файла, записываются в буфер lpBuf. Параметр nCount определяет количество байт, которое надо считать из файла. Фактически из файла может быть считано меньше байт, чем запрошено параметром nCount. Это происходит, если во время чтения достигнут конец файла. Метод Read возвращает количество байт, прочитанных из файла:

DWORD ReadHuge(void* lpBuffer, DWORD dwCount) throw(CFileException);

Назначение параметров метода ReadHuge аналогично назначению параметров метода Read. Спецификация ReadHuge считается устаревшей и оставлена только для обратной совместимости с 16-разряднымми операционными системами.

Для записи в файл предназначены методы Write и WriteHuge. Метод WriteHuge не накладывает ограничения на количество одновременно записываемых байт. В 16-разрядных версиях операционной системы Windows метод Write позволяет записать не больше 65535 байт. Это ограничение снято в операционных системах Windows NT и Windows 95.

virtual void Write(const void* lpBuf, UINT nCount) throw(CFileException);

Метод Write записывает в открытый файл nCount байт из буфера lpBuf. В случае возникновения ошибки записи, например, переполнения диска, метод Write вызывает исключение.

Не смотря на то, что спецификация WriteHuge считается устаревшей, вы можете использовать ее для создания 16-разрядных приложений в среде Visual C++ версии 1.5х.

Метод Flush

Когда вы используете метод Write или WriteHuge для записи данных на диск, они некоторое время могут находится во временном буфере. Чтобы удостоверится, что необходимые изменения внесены в файл на диске, используйте метод Flush:

virtual void Flush() throw(CFileException);

Операции с файлами

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

Операционная система MS-DOS содержит команду REN, позволяющую переименовывать файлы. Класс CFile включает статический метод Rename, выполняющий функции этой команды:

static void PASCAL Rename(LPCTSTR lpszOldName, LPCTSTR lpszNewName) throw(CFileException);

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

Для удаления файлов предназначена команда DEL операционной системы MS-DOS. Класс CFile включает статический метод Remove, позволяющий удалить указанный файл:

static void PASCAL Remove(LPCTSTR lpszFileName) throw(CFileException);

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

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

Виртуальная версия метода GetStatus определяет состояние открытого файла, связанного с данным объектом класса CFile. Вызывайте этот метод только тогда, когда объект класса CFile создан и файл открыт:

BOOL GetStatus(CFileStatus& rStatus) const;

Статическая версия метода GetStatus позволяет определить характеристики файла, не связанного с объектом класса CFile. Чтобы воспользоваться этим методом, не обязательно предварительно открывать файл.

static BOOL PASCAL GetStatus(LPCTSTR lpszFileName, CFileStatus& rStatus);

Параметр lpszFileName должен содержать путь к файлу. Путь может быть полным или не полным – относительно текущего каталога.

Параметр rStatus должен содержать указатель на структурутипа CFileStatus, в которую заносится информация о файле.

Структура типа CFileStatus имеет элементы, описанные в следующей таблице:

Поле структуры CFileStatus Описание
CTime m_ctime Дата и время создания файла. Описание класса CTime представлено нами в главе “Дата и время”
CTime m_mtime Дата и время последней модификации файла
CTime m_atime Дата и время, когда последний раз выполнялось чтение из файла
LONG m_size Размер файла в байтах
BYTE m_attribute Атрибуты файла
char m_szFullName[_MAX_PATH] Полное имя файла в стандарте операционной системы Windows. Виртуальная версия метода не заполняет это поле
Атрибуты файла, указанные в поле m_attribute структуры CFileStatus, определяются как переменная перечислимого типа Attribute. Этот тип определен в классе CFile следующим образом:

enum Attribute {

 normal = 0x00,

 readOnly = 0x01,

 hidden = 0x02,

 system = 0x04,

 volume = 0x08,

 directory = 0x10,

 archive = 0x20

};

Атрибут Описание
normal Нормальный файл
readOnly Файл, который можно открыть только для чтения
hidden Скрытый файл
system Системный файл
volume Метка тома
directory Каталог
archive Архивный
Метод GetStatus возвращает ненулевое значение при нормальном завершении и нуль в случае ошибки. Ошибка обычно возникает, если вы указываете несуществующий файл.

Блокировка

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

Установить блокировку можно с помощью метода LockRange:

virtual void LockRange(DWORD dwPos, DWORD dwCount) throw(CFileException);

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

Чтобы снять установленные блокировки, надо воспользоваться методом UnlockRange. Если в одном файле установлено несколько блокировок, то каждая из них должна сниматься отдельным вызовом метода UnlockRange:

virtual void UnlockRange(DWORD dwPos, DWORD dwCount) throw(CFileException);

Как и для метода LockRange, параметры dwPos и dwCount должны указывать начало фрагмента и его размер. Размер фрагмента должен соответствовать размеру фрагмента, указанному при вызове метода LockRange.

Позиционирование

Чтобы переместить указатель текущей позиции файла в новое положение, можно воспользоваться одним из следующих методов класса CFile – Seek, SeekToBegin, SeekToEnd. В состав класса CFile также входят методы, позволяющие установить и изменить длину файла – GetLength, SetLength.

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

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

virtual LONG Seek(LONG lOff, UINT nFrom) throw(CFileException);

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

Параметр nFrom определяет, относительно чего задано это смещение. В качестве nFrom можно указать три различные константы, также определенные в классе CFile:

Константа Параметр lOff задает смещение относительно
CFile::begin Начала файла
CFile::current Текущей позиции файла
CFile::end Конца файла
В случае успешного перемещения указателя файла в новую позицию метод Seek возвращает новое смещение указателя относительно начала файла. Если новая позиция указателя задана неправильно, например, вы пытаетесь переместить указатель в позицию перед началом файла, вызывается исключение.

Чтобы переместить указателя файла в начало или конец файла, наиболее удобно использовать специальные методы. Метод SeekToBegin перемещает указатель в начало файла, а метод SeekToEnd – в его конец. Приведем прототип метода SeekToBegin:

void SeekToBegin() throw(CFileException);

Фактически вызов метода SeekToBegin эквивалентен вызову метода Seek с параметром lOff, содержащим нуль и параметром nFrom, содержащим константу CFile::begin.

Метод SeekToEnd имеет почти такой же прототип как метод SeekToBegin, но перемещает указатель в конец файла:

DWORD SeekToEnd() throw(CFileException);

Метод SeekToEnd возвращает длину файла в байтах. Если вам надо определить длину открытого файла, совсем не обязательно перемещать его указатель. Можно воспользоваться методом GetLength. Этот метод также возвращает длину открытого файла в байтах:

virtual DWORD GetLength() const throw(CFileException);

Метод SetLength позволяет изменить длину открытого файла:

virtual void SetLength(DWORD dwNewLen) throw(CFileException);

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

Вы можете определить текущую позицию указателя файла с помощью метода GetPosition. Возвращаемое методом GetPosition 32-разрядное значение определяет смещение указателя от начала файла:

virtual DWORD GetPosition() const throw(CFileException);

Характеристики открытого файла

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

virtual CString GetFilePath() const;

Если требуется определить только имя и расширение открытого файла, можно воспользоваться методом GetFileName. Он возвращает объект класса CString, в котором находится имя файла:

virtual CString GetFileName() const;

В случае, когда надо узнать только имя открытого файла без расширения, воспользуйтесь методом GetFileTitle:

virtual CString GetFileTitle() const;

Последний метод класса CFile позволяет установить путь файла. Этот метод не создает, не копирует и не изменяет имени файла, он только заполняет соответствующий элемент данных в объекте класса CFile:

virtual void SetFilePath(LPCTSTR lpszNewName);

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

Файловая система – классы CMemFile и CStdioFile

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

CMemFile←CFile←CObject

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

Для создания объектов класса CMemFile предназначены два различных конструктора. Первый конструктор CMemFile имеет всего один необязательный параметр nGrowBytes:

CMemFile(UINT nGrowBytes = 1024);

Этот конструктор создает в оперативной памяти пустой файл. После создания файл автоматически открывается. Вы не должны специально вызывать метод Open.

Когда вы начинаете запись в такой файл, автоматически выделяется блок памяти. Для получения памяти методы класса CMemFile вызывают стандартные функции malloc, realloc и free. Если выделенного блока памяти недостаточно, его размер увеличивается. Увеличение блока памяти файла происходит частями по nGrowBytes байт. После удаления объекта класса CMemFile используемая им память автоматически возвращается системе.

Второй конструктор класса CMemFile имеет более сложный прототип. Этот конструктор используется в тех случаях, когда вы сами выделяете память для файла:

CMemFile(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes = 0);

Параметр lpBuffer указывает на буфер, который будет использоваться для файла. Размер буфера определяется параметром nBufferSize.

Необязательный параметр nGrowBytes используется более комплексно, чем в первом конструкторе класса. Если nGrowBytes содержит нуль, то созданный файл будет содержать данные из буфера lpBuffer. Длина такого файла будет равна nBufferSize.

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

Для получения указателя на буфер файла вы можете воспользоваться методом Detach:

BYTE * Detach();

Перед эти полезно определить длину файла и соответственно, размер буфера памяти, вызвав метод GetLength.

Метод Detach закрывает данный файл и возвращает указатель на используемый им блок памяти. Если вам требуется опять открыть файл и связать с ним блок оперативной памяти, вызовите метод Attach:

void Attach(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes = 0);

Параметры метода Attach соответствуют параметрам второго конструктора класса CMemFile, рассмотренному выше. Параметр lpBuffer указывает на буфер размера nBufferSize, который будет связан с файлом.

Если необязательный параметр nGrowBytes равен нулю, то созданный файл будет содержать данные из буфера lpBuffer. Если nGrowBytes больше нуля, то содержимое буфера lpBuffer игнорируется. Если вы запишете в такой файл больше данных, чем помещается в отведенном вами буфере, его размер автоматически увеличивается на nGrowBytes байт. Для управления буфером файла класс CMemFile вызывает стандартные функции malloc, calloc и free. Поэтому, чтобы не нарушать механизм управления памяти, буфер lpBuffer должен быть создан функциями malloc или calloc.

Модификация класса CMemFile

Вы можете наследовать от класса CMemFile собственные классы. При этом вы можете реализовать свой механизм выделения памяти для файла, чтения и записи данных. Для этого в состав CMemFile входят виртуальные методы Alloc, Free, Realloc, Memcpy и GrowFile.

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

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

BYTE * Alloc(DWORD nBytes);

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

BYTE * Realloc(BYTE* lpMem, DWORD nBytes);

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

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

void Free(BYTE * lpMem);

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

Виртуальные методы класса CFile Read и Write, переназначенные в классе CMemFile, вызывают метод Memcpy. Метод Memcpy предназначен для обмена данными. Вы можете переопределить этот метод в своем классе:

BYTE * Memcpy(BYTE* lpMemTarget, BYTE* lpMemSource, UINT nBytes);

Переменная lpMemSource указывает на область памяти размера nBytes байт, которая должна быть записанная по адресу lpMemTarget. Метод Memcpy возвращает значение соответствующее параметру lpMemTarget.

Если происходит изменение длины файла, вызывается метод GrowFile. В качестве параметра dwNewLen указывается новый размер файла. Вы можете переназначить этот метод в своем классе:

void GrowFile(DWORD dwNewLen);

Файловая система – класс CStdioFile

Если вы привыкли пользоваться функциями потокового ввода/вывода из стандартной библиотеки трансляторов Си и Си++, обратите внимание на класс CStdioFile , наследованный от базового класса CFile. Этот класс позволяет выполнять буферизованный ввод/вывод в текстовом и двоичном режиме.

CStdioFile←CFile←CObject

В текстовом режиме выполняется специальная обработка символов возврата каретки и перевода строки. Когда в файл, открытый в текстовом режиме, записывается символ перевода строки \n (код 0x0A), он преобразуется в два символа – символ перевода строки (код 0x0A) и символ возврата каретки (код 0x0D). И наоборот, когда из файла считывается пара символов перевода строки и возврата каретки, они преобразуются в один символ перевода строки.

Для объектов класса CStdioFile можно вызывать все методы его базового класса CFile, кроме методов Duplicate, LockRange и UnlockRange. Напомним, что класс CMemFile, также наследованный от базового класса CFile, тоже работает с этими методами.

В класс CStdioFile входит элемент данных m_pStream, который содержит указатель на открытый файл. Если объект CStdioFile создан, но файл либо еще не открыт, либо закрыт, тогда m_pStream содержит константу NULL.

Класс CStdioFile имеет три различных конструктора. Первый конструктор класса CStdioFile не имеет параметров:

CStdioFile();

Этот конструктор только создает объект класса, но не открывает никаких файлов. Чтобы открыть файл, надо вызвать метод Open базового класса CFile.

Второй конструктор класса CStdioFile можно вызывать, если файл уже открыт и вам надо создать новый объект класса и связать с ним открытый файл:

CStdioFile(FILE* pOpenStream);

Этот конструктор можно использовать, если файл был открыт стандартной функцией fopen.

Параметр pOpenStream должен содержать указатель на файл, полученный вызовом стандартной функции fopen.

Третий, последний конструктор можно использовать, если надо создать объект класса CStdioFile, открыть новый файл и связать его с только что созданным объектом:

CStdioFile(LPCTSTR lpszFileName, UINT nOpenFlags) throw(CFileException);

Если указанный файл не может быть открыт, вызывается исключение CFileException.

Параметр lpszFileName должен содержать указатель на строку с именем файла. Можно указать полный путь файла, а не только его имя. Параметр nOpenFlags определяет режим, в котором будет открыт файл. Возможные значения этого параметра были описаны ранее (см. Метод Open класса CFile).

Для чтения и записи в текстовый файл класс CStdioFile включает два новых метода ReadString и WriteString. Метод ReadString позволяет прочитать из файла строку символов, а метод WriteString – записать.

Метод ReadString имеет две формы. Первая используется для чтения строк из файла в буфер памяти, а вторая для чтения строк и записи их в объект класса CString.

Вот описание первой формы метода ReadString:

virtual LPTSTR ReadString(LPTSTR lpsz, UINT nMax) throw(CFileException);

Из открытого файла считывается текстовая строка и записывается в буфер lpsz. Считается, что строка файла оканчивается символами перевода строки и возврата каретки. В конец строки, записанной в буфер lpsz, заносится символ двоичного нуля (\0).

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

Вторая форма метода ReadString не намного отличается от первой. Вместо двух параметров lpsz и nMax указывается один параметр rString, указывающий на объект класса CString, в который будет записана строка, прочитанная из файла:

BOOL ReadString(CString& rString) throw(CFileException);

Еще одно отличие второй формы метода ReadString заключается в типе возвращаемого им значения. Если достигнут конец файла, то вторая форма метода ReadString возвращает константу FALSE.

Для записи в файл текстовой строки предназначен метод WriteString:

virtual void WriteString(LPCTSTR lpsz) throw(CFileException);

В качестве параметра lpsz этого метода надо указать адрес буфера с текстовой строкой, закрытой символом \0. Символ \0 не записывается в файл. Если в текстовой строке lpsz есть символы перевода строки, они записываются как пара символов возврата каретки и перевода строки.

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

Приложение TestFile

Теперь мы представим вам приложение, которое использует класс CStdioFile для записи в файл информации о файловой системе компьютера. Для определения характеристик файловой системы мы воспользовались функцией GetVolumeInformation из программного интерфейса Win32.

Эта функция позволяет определить различные характеристики файловой системы, установленной на данном томе. Ниже представлен прототип функции GetVolumeInformation:

BOOL GetVolumeInformation(LPCTSTR lpRootPathName, LPTSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPTSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize);

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

Параметр lpVolumeNameBuffer должен содержать указатель на буфер, в который будет записано имя тома. Длина буфера определяется параметром nVolumeNameSize. Если вас не интересует имя тома, вы можете указать для параметра lpVolumeNameBuffer значение NULL. В этом случае значение nVolumeNameSize не используется.

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

Параметр lpMaximumComponentLength должен содержать адрес переменной, в которую будет записана максимальная длина файла, для данной файловой системы. Для операционной системы Windows 95 эта переменная будет содержать значение 255, несмотря на то, что тип файловой системы остался FAT.

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

Константа Описание
FS_CASE_IS_PRESERVED При записи файлов на диск сохраняется написание (заглавные и прописные символы) имени файла
FS_CASE_SENSITIVE Файловая система различает заглавные и прописные символы в именах файлов
FS_UNICODE_STORED_ON_DISK Файловая система обеспечивает кодировку имен файлов Unicode
FS_FILE_COMPRESSION Обеспечивается возможность сжатия отдельных файлов, расположенных на томе. Эта константа не может быть использована вместе с другими
FS_VOL_IS_COMPRESSED Данный том является компрессованным. Такой том может быть создан системами типа DoubleSpace. Эта константа не может быть использована вместе с другими
Параметр lpFileSystemNameBuffer содержит указатель на буфер, в который будет записан тип файловой системы. В зависимости от типа файловой системы, установленной на данном томе, это может быть FAT, NTFS или HPFS.

Размер буфера определяется параметром nFileSystemNameSize. Если вас не интересует тип файловой системы, запишите в параметр lpFileSystemNameBuffer значение NULL.

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

В листинге 3.1 представлен исходный текст приложения TestFile. В этом приложении используются всего несколько классов библиотеки классов MFC. Для организации самого приложения мы наследовали от базового класса CWinApp главный класс приложения CMFStartApp. Класс CWinApp был описан нами ранее в разделе “Приложение MFStart”.

В классе CMFStartApp определены два метода: InitInstance и FileSystemInfo. Метод InitInstance является переопределением виртуального метода InitInstance базового класса CWinApp. Этот метод вызывается каждый раз при запуске приложения. Мы используем метод InitInstance для того, чтобы вызвать метод FileSystemInfo и сразу завершить работу приложения.

Метод FileSystemInfo получает данные о файловой системе текущего тома и записывает их в файл fsystem.dat в текущем каталоге. Для получения информации о файловой системе используется функция GetVolumeInformation, описанная выше.

Данные, полученные функцией FileSystemInfo, временно заносятся в строку strTmpOut класса CString. При этом используется метод Format, чтобы получить форматированную запись, содержащую дополнительное текстовое описание.

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

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

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

Чтобы закрыть файл, мы используем метод Close базового класса CFile. В случае успешного завершения на экране отображается сообщение с именем файла fsystem.dat и управление возвращается методу InitInstance.

Если при работе с файлом возникла ошибка, управление передается блоку catch. В нем отображается сообщение об ошибке, а затем управление сразу возвращается методу InitInstance. Невыполненная часть блока try игнорируется.

Листинг 3.1. Файл TestFile.cpp
// Включаемый файл для MFC

#include <afxwin.h>


//=====================================================

// Главный класс приложения CMFStartApp

//=====================================================

class CMFStartApp : public CWinApp {

public:

 virtual BOOL InitInstance();

 void FileSystemInfo();

};


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

CMFStartApp MFStartApp;


//=====================================================

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

// класса CWinApp

//=====================================================

BOOL CMFStartApp::InitInstance() {

 // Определяем характеристики файловой системы

 FileSystemInfo();


 // Завершаем приложение

 return FALSE;

}


//=====================================================

// Метод FileSystemInfo главного класса приложения

// Определяет характеристики текущего тома и записывает

// их в файл

//=====================================================

void CMFStartApp::FileSystemInfo() {


 // Метка тома

 CString VolumeNameBuffer;


 // Максимальная длина метки тома

 DWORD nVolumeNameSize = 100;


 // Серийный номер тома

 DWORD VolumeSerialNumber;


 // Максимальная длина имени файла

 DWORD MaximumComponentLength;


 // Характеристики файловой системы

 DWORD FileSystemFlags;


 // Тип файловой системы

 CString FileSystemNameBuffer;


 // Максимальная длина строки типа файловой системы

 DWORD nFileSystemNameSize = 100;


 // Получаем данные о файловой системе и текущем устройстве

 GetVolumeInformation(NULL, VolumeNameBuffer.GetBuffer(nVolumeNameSize), nVolumeNameSize, &VolumeSerialNumber, &MaximumComponentLength, &FileSystemFlags, FileSystemNameBuffer.GetBuffer(nFileSystemNameSize), nFileSystemNameSize);


 // Снимаем блокировку буферов

 VolumeNameBuffer.ReleaseBuffer();

 FileSystemNameBuffer.ReleaseBuffer();


 // Обрабатываем ошибочные ситуации, которые могут

 // возникнуть при работе с файлами

 try {

  // Создаем файл fsystem.dat и открываем его для записи

  CStdioFile file("fsystem.dat", CFile::modeCreate | CFile::modeWrite | CFile::typeText);


  // Временная строка, используемая для записи в файл

  CString strTmpOut;


  // Увеличиваем размер буфера до 512 байт

  strTmpOut.GetBuffer(512);


  // Записываем в файл метку тома

  strTmpOut.Format("Метка тома: %s \n", VolumeNameBuffer);

  file.WriteString(strTmpOut);


  // Записываем в файл серийный номер

  strTmpOut.Format("Серийный номер: %X \n", VolumeSerialNumber);

  file.WriteString(strTmpOut);


  // Записываем в файл тип файловой системы

  strTmpOut.Format("Тип файловой системы: %s \n", FileSystemNameBuffer);

  file.WriteString(strTmpOut);


  // Записываем в файл максимальную длину имени файла

  strTmpOut.Format("Максимальная длина имени файла: %d \n", MaximumComponentLength);

  file.WriteString(strTmpOut);


  // Записываем в файл свойства файловой системы

  strTmpOut = "Свойства файловой системы \n";

  if (FileSystemFlags & FS_CASE_IS_PRESERVED) strTmpOut += " FS_CASE_IS_PRESERVED\n";

  if (FileSystemFlags & FS_CASE_SENSITIVE) strTmpOut += " FS_CASE_SENSITIVE\n";

  if (FileSystemFlags & FS_UNICODE_STORED_ON_DISK) strTmpOut += " FS_UNICODE_STORED_ON_DISK\n";

  if (FileSystemFlags & FS_PERSISTENT_ACLS) strTmpOut += " FS_PERSISTENT_ACLS\n";

  if (FileSystemFlags & FS_FILE_COMPRESSION) strTmpOut += " FS_FILE_COMPRESSION\n";

  if (FileSystemFlags & FS_VOL_IS_COMPRESSED) strTmpOut += " FS_VOL_IS_COMPRESSED\n";

  file.WriteString(strTmpOut);


  // Закрываем файл

  file.Close();

  // Отображаем сообщение об успешном завершении приложения

  MessageBox(NULL, "File fsystem.dat", "Message", MB_OK);

 }


 // Обработчик исключения. Вызывается при ошибках

 // работы с файлами

 catch(...) {

  // Отображаем сообщение о возникшей ошибке

  MessageBox(NULL, "File I/O Error", "Error", MB_OK);

 }


 return;

}

Файл fsystem.dat, созданный приложением, можно просмотреть в любом текстовом редакторе, например Notepad или WordPad. В листинге 3.2 приведен пример файла, полученного при помощи приложения TestFile на нашем компьютере, на котором установлена операционная система Windows 95.

Листинг 3.2. Файл fsystem.dat
Метка тома: LIBRARY

Серийный номер: 1D794E8D

Тип файловой системы: FAT

Максимальная длина имени файла: 255

Свойства файловой системы

 FS_CASE_IS_PRESERVED

 FS_UNICODE_STORED_ON_DISK

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

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

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

CMemoryException      ←|←CException

CFileException        ←|

CArchiveException     ←|

CNotSupportedException←|

CResourceException    ←|

CDaoException         ←|

CDBException          ←|

COleException         ←|

COleDispatchException ←|

CUserException        ←|

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

Если вы желаете обрабатывать исключения, которые вызываются методами классов MFC, вы должны определить обработчики для этих исключений. Каждый такой обработчик должен представлять собой блок catch, в качестве аргумента которого надо использовать указатель на объект класса CException или указатель на объект класса, наследованного от класса CException:

try {

 // Здесь может находится код, который вызывает исключение

}

// Обработчик для исключения типа CMemoryException

catch(CMemoryException* ptrException) {

 // Обработка исключения …


 // В конце удаляем объект исключения

 ptrException–>Delete;

}

Еще раз подчеркнем, что обработчик исключений MFC должен принимать указатель на объект класса CException (или класса, наследованного от CException). Этот объект создается при возникновении исключительных ситуаций внутри методов MFC. После того как этот объект окажется не нужен, ваш обработчик должен его удалить. Для этого предназначен метод Delete, определенный в классе CException. Не используйте для удаления объектов класса CException и объектов классов, наследованных от него, обыкновенный оператор delete.

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

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

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

Класс CException

Класс CException включает два виртуальных метода GetErrorMessage и ReportError. Эти методы позволяют получить словесное описание причины, которая привела к вызову исключения. Заметим, что методы GetErrorMessage и ReportError чисто виртуальные, поэтому они должны быть переопределены в наследуемом классе:

virtual BOOL GetErrorMessage(LPTSTR lpszError, UINT nMaxError, PUINT pnHelpContext = NULL);

Когда вы вызываете в обработчике исключения метод GetErrorMessage, он записывает в буфер lpszError сообщение об ошибке, вызвовшей исключение. Размер буфера надо указать в параметре nMaxError. В конце сообщения всегда записывается символ двоичного нуля. Если сообщение не помещается в буфер lpszError (оно больше чем nMaxError – 1 байт), тогда в буфер записываются только nMaxError – 1 символов сообщения. В последний байт записывается двоичный нуль.

Необязательный параметр pnHelpContext может содержать указатель на переменную типа UINT, в которую будет записан идентификатор контекстной подсказки (help context ID).

Метод GetErrorMessage возвращает ненулевое значение, если сообщение об ошибке доступно, и нуль в противном случае.

Вы можете вызывать метод ReportError из обработчика исключений:

virtual int ReportError(UINT nType = MB_OK, UINT nMessageID = 0);

Метод ReportError отображает в диалоговой панели на экране сообщение об ошибке, вызвавшей данное исключение. Параметр nType определяет внешний вид диалоговой панели сообщения. В качестве параметра nType можно указать любую комбинацию стилей панелей сообщения, таких как MB_OK, MB_OKCANCEL, MB_RETRYCANCEL, MB_ICONEXCLAMATION, MB_ICONINFORMATION, MB_ICONQUESTION, MB_ICONSTOP. Если вы не укажите этот параметр, тогда подразумевается стиль MB_OK, то есть панель сообщения с одной кнопкой OK.

Иногда исключение может не иметь текстового описания. Вы можете указать методу ReportError, чтобы он отображал в этом случае определенное сообщение. Текст этого сообщения надо сохранить в строковом ресурсе, а соответствующий идентификатор передать методу ReportError в качестве второго параметра nMessageID. Если вы не укажите этот параметр, тогда отображается сообщение “No error message is available”.

Метод ReportError возвращает значение типа AfxMessageBox. Оно определяет, какая кнопка была нажата в диалоговой панели с сообщением.

Методы GetErrorMessage и ReportError используют данные из ресурсов, созданных AppWizard. Поэтому они могут работать неправильно, если приложение создано без использования AppWizard.

Класс CMemoryException

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

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

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

Чтобы самому вызвать исключение, воспользуйтесь функцией AfxThrowMemoryException:

void AfxThrowMemoryException();

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

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

if (GlobalAlloc(GMEM_FIXED, 1000000) == NULL) AfxThrowMemoryException();

Класс CFileException

Класс CFileException предназначен для обработки исключительных ситуаций, возникающих во время создания или вызова методов класса CFile и порожденных от него классов. Этот класс описан нами в разделе “Класс CFile” и предназначается для работы с файловой системой. Естественно, при работе с файловой системой могут возникнуть самые разнообразные ошибки (исключительные ситуации): попытка открыть несуществующий файл, переполнение диска во время операции записи, ошибка чтения с диска и т. д.

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

Константа Причина ошибки
CFileException::none Без ошибки
CFileException::generic Неопределенная ошибка
CFileException::fileNotFound Файл не найден
CFileException::badPath Задан несуществующий путь
CFileException::tooManyOpenFiles Открыто слишком много файлов
CFileException::accessDenied Доступ к файлу закрыт
CFileException::invalidFile Использование неправильного идентификатора (дескриптора) файла
CFileException::removeCurrentDir Попытка удалить текущий каталог
CFileException::directoryFull Переполнение структуры каталогов. Невозможно создать новый каталог
CFileException::badSeek Ошибка во время перемещения указателя файлов
CFileException::hardIO Ошибка аппаратного обеспечения компьютера
CFileException::sharingViolation Программа SHARE.EXE не загружена или общая область заблокирована (locked)
CFileException::lockViolation Попытка заблокировать область файла, которая уже была заблокирована ранее
CFileException::diskFull Нет свободного пространства на диске
CFileException::endOfFile Достигнут конец файла
Так как за взаимодействие приложения с файловой системной компьютера отвечает прежде всего операционная система, то в случае ошибки она возвращает соответствующий код. В состав класса CFileException входит элемент данных m_lOsError. В него заносится код ошибки, который вернула операционная система.

Приложение Except
Приложение Except, исходный текст которого представлен в листинге 3.3, показывает как можно выполнить обработку исключительных ситуаций. Оно содержит блок try и несколько обработчиков исключений для объектов типа CMemoryException, CFileException, CException, а также универсальный обработчик. Если в блоке try вызывается исключение, связанное с ошибкой в файловой системе или системе распределения памяти, оно обрабатывается соответствующими блоками catch. Если исключение вызвано с объектом другого типа, но наследованным от класса CException, например CArchiveException, CNotSupportedException или CResourceException, тогда оно обрабатывается блоком catch для объектов CException. И наконец, если объект исключения не имеет базовым классом CException, оно обрабатывается в последнем блоке catch.

Листинг 3.3. Файл Except.cpp
#include "stdafx.h"


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

 try {

  CFile file("This file is absent", CFile::modeRead);

  // Здесь могут быть операторы, вызывающие другие

  // исключения

 }


 // Обработчик для исключения типа CMemoryException

 catch(CMemoryException* ptrException) {

  MessageBox(NULL,"Memory Exception", "Exception", MB_OK | MB_ICONSTOP);

  ptrException–>Delete();

 }


 // Обработчик для исключения типа CFileException

 catch(CFileException* ptrException) {

  if (ptrException–>m_cause == CFileException::fileNotFound) MessageBox(NULL,"File Not Found", "Exception", MB_OK | MB_ICONSTOP);

  else if (ptrException–>m_cause == CFileException::diskFull) MessageBox(NULL,"The disk is full", "Exception", MB_OK | MB_ICONSTOP);

  else MessageBox(NULL, "File Exception", "Exception", MB_OK | MB_ICONSTOP);

  ptrException–>Delete();

 }


 // Обработчик для исключений класса CException и

 // классов наследованных от него

 catch (CException* ptrException) {

  MessageBox(NULL,"Exception", "Exception", MB_OK | MB_ICONSTOP);

  ptrException–>Delete();

 }


 // Все остальные исключения обрабатываются здесь

 catch(...) {

  MessageBox(NULL,"Another Exception", "Exception", MB_OK | MB_ICONSTOP);

 }


 return 0;

}

В блоке try мы пытаемся открыть для чтения файл с именем This file is absent. Длинные имена файлов, содержащие символы пробелов, разрешены в операционных системах Windows 95 и Windows NT. Если файла This file is absent нет на диске, тогда создается объект класса CFileException и вызывается исключение.

Обработчик исключений, связанных с ошибками при работе с файловой системой, проверяет, вызвано ли оно тем, что приложение пытается открыть несуществующий файл. Если это так, на экране отображается сообщение File Not Found.

После обработки исключения, управление передается первому оператору за последним блоком catch. В нашем примере это оператор return. Он завершает работу приложения.

Вы можете сами создать объект класса CFileException и вызвать исключение. Для этого рекомендуется использовать функцию AfxThrowFileException:

void AfxThrowFileException(int cause, LONG lOsError = –1);

Параметр cause должен определять причину исключения. В качестве этого параметра можно задавать возможные значения для элемента данных m_cause из класса CFileException (см. таблицу выше). Необязательный параметр lOsError может содержать код ошибки, определенной операционной системой.

Класс CArchiveException

Исключительные ситуации, возникающие во время записи и восстановления объектов из файла, вызывают исключение CArchiveException.

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

Константа Причина ошибки
CArchiveException::none Без ошибки
CArchiveException::generic Неопределенная ошибка
CArchiveException::readOnly Попытка записи в архивный объект, открытый для чтения
CArchiveException::endOfFile Обнаружен конец файла при чтении объекта
CArchiveException::writeOnly Попытка читать из архивного объекта, открытого для записи
CArchiveException::badIndex Неправильный формат файла
CArchiveException::badClass Попытка прочитать объект в объект неправильного типа
CArchiveException::badSchema Попытка чтения объекта с несоответствующей версией класса
Чтобы создать объект CArchiveException и вызвать исключение воспользуйтесь функцией AfxThrowArchiveException:

void AfxThrowArchiveException(int cause);

Параметр cause должен определять причину вызова исключения. Возможный список значений этого параметра представлен в таблице выше (см. элемент данных m_cause класса CArchiveException).

Класс CNotSupportedException

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

CNotSupportedException();

Однако если вы сами желаете вызвать из своего кода исключение этого типа, то вместо того, чтобы создавать объект класса CNotSupportedException вручную и передавать его оператору throw, воспользуйтесь функцией AfxThrowNotSupportedException:

void AfxThrowNotSupportedException();

Класс CResourceException

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

void AfxThrowResourceException();

Класс CUserException

Если какая-либо операция при работе приложения закончилась с ошибкой, оно может вызвать функцию AfxMessageBox, чтобы сообщить об этом пользователю, а затем вызвать исключение с объектом класса CUserException. Чтобы создать объект класса CUserException и вызвать исключение, воспользуйтесь функцией AfxThrowUserException:

void AfxThrowUserException();

Запись и восстановление объектов

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

Чтобы облегчить программисту решение этой задачи, библиотека классов MFC определяет механизм записи и восстановления объектов (serialization). Поддержка механизма записи и восстановления объектов осуществляется средствами класса CObject.

Классы, наследованные от CObject также могут обеспечивать работу механизма записи и восстановления объектов. Для этого при объявлении класса надо указать макрокоманду DECLARE_SERIAL, а при определении – макрокоманду IMPLEMENT_SERIAL.

Макрокоманду DECLARE_SERIAL надо поместить перед описанием вашего класса во включаемом файле. Непосредственно после имени макрокоманды надо указать имя класса – class_name:

DECLARE_SERIAL(class_name)

Макрокоманду IMPLEMENT_SERIAL надо указать перед определением класса в файле исходного текста приложения, имеющего расширение CPP. Прототип макрокоманды IMPLEMENT_SERIAL представлен ниже:

IMPLEMENT_SERIAL(class_name, base_class_name, wSchema)

Параметр class_name определяет имя вашего класса, base_class_name – имя базового класса из которого непосредственно наследуется ваш класс. Последний параметр wSchema – это число типа UINT, определяющее версию программы. Если вы разработаете новую версию своего приложения и измените набор данных, которые необходимо записать в файл, измените параметр wSchema.

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

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

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

virtual void Serialize(CArchive& ar) throw(CMemoryException) throw(CArchiveException) throw(CFileException);

В качестве параметра ar, методу передается указатель на объект класса CArchive , используемый для записи и восстановления его состояния из файла. Чтобы узнать, какую операцию должен выполнить метод Serialize, воспользуйтесь методами CArchive::IsLoading или CArchive::IsStoring.

Новая реализация метода Serialize должна первым делом вызвать метод Serialize базового класса. Это гарантирует, что при сохранении и восстановлении объекта будут обработаны все элементы всех базовых классов.

Метод Serialize вызывается объектами класса CArchive когда приложение читает или записывает этот объект, вызывая методы CArchive::ReadObject или CArchive::WriteObject. Сразу отметим, что с методами CArchive::ReadObject и CArchive::WriteObject непосредственно связаны операторы записи << и чтения >>.

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

Конструктор класса CArchive имеет следующий вид:

CArchive(CFile* pFile, UINT nMode, int nBufSize = 512, void* lpBuf = NULL) throw(CMemoryException, CArchiveException, CFileException);

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

Параметр nMode определяет, будут данные записываться в файл или считываться из него. Параметр nMode может принимать одно из трех значений CArchive::load, CArchive::store или CArchive::bNoFlushOnDelete, описанных в следующей таблице.

Константа Описание
CArchive::load Данные считываются из файла на диске. Впоследствии они будут записаны в восстанавливаемый объект. В этом случае файл, определенный параметром pFile, должен быть открыт для чтения.
CArchive::store Данные будут записываются в файл на диске. Файл, определенный параметром pFile должен быть открыт для записи.
CArchive::bNoFlushOnDelete Когда вызывается деструктор класса CArchive, он автоматически вызывает метод Flush для файла pFile. Если вы укажите этот флаг, то метод Flush вызван не будет. Чтобы предотвратить потерю данных, вы должны будете перед вызовом деструктора закрыть данный файл.
Для операций чтения и записи в файл класс CArchive выполняет буферизацию. Размер этого буфера определяется необязательным параметром nBuf Size в байтах. Если вы не укажите размер буфера, используется буфер размером 512 байт.

Конструктор класса CArchive сам получает у операционной системы блок оперативной памяти для буфера. Однако с помощью необязательного параметра lpBuf вы можете предоставить собственный буфер. В этом случае параметр nBufSize должен указывать размер этого буфера.

Созданный вами объект класса CArchive можно будет использовать только для записи или только для чтения. Если вам надо сначала считать данные, а потом записать, следует создать для этого два отдельных объекта класса CArchive.

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

Когда созданный объект класса CArchive передается функции Serialize, вы можете определить, предназначен он для записи или для чтения, вызвав метод CArchive::IsLoading или CArchive::IsStoring.

Метод IsStoring возвращает ненулевое значение, если данный объект предназначен для записи в файл и нуль в противном случае:

BOOL IsStoring() const;

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

Основное предназначение объекта класса CArchive заключается в том, что объекты вашего класса могут посредством него записать свое состояние в файл, а затем при необходимости восстановить его. Для этого в классе CArchive определены операторы записи в файл << и чтения из файла >>. Вы также можете использовать методы WriteString, Write, ReadString и Read. Опишем эти операторы и методы более подробно.

Запись в архивный файл

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

В этом случае реализация метода Serialize должна сохранить в файле все элементы данных, которые потом потребуется восстановить. Для этого необходимо воспользоваться оператором << или методами WriteString и Write, определенными в классе CArchive.

Оператор << можно использовать для записи в архивный файл переменных простых типов, например long, int, char и объектов других классов, которые наследованы от класса CObject.

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

Для записи в архивный файл массивов удобнее использовать метод Write класса CArchive:

void Write(const void* lpBuf, UINT nMax) throw(CFileException);

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

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

Если требуется сохранить строку символов, закрытую нулем, то гораздо удобнее вместо метода Write использовать метод WriteString. Метод WriteString записывает в архивный файл строку lpsz:

void WriteString(LPCTSTR lpsz) throw(CFileException);

Чтение из архивного файла

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

Реализация метода Serialize должна восстановить из файла все элементы данных, которые были в него записаны. Для этого можно воспользоваться оператором >> или методами ReadString и Read, определенными в классе CArchive.

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

Оператор >> можно использовать для чтения из архивного файла переменных простых типов, например long, int, char и объектов других классов, которые наследованы от класса CObject. В одной строке программы можно использовать оператор >> несколько раз.

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

UINT Read(void* lpBuf, UINT nMax) throw(CFileException);

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

Если требуется прочитать из архивного файла строку, записанную в него методом WriteString, воспользуйтесь методом ReadString. В состав класса CArchive входят два метода ReadString, которые предназначены для записи прочитанной из файла строки в объект класса CString или в строку Си.

Первый метод имеет более простой прототип. Единственный параметр rString определяет объект класса CString, в который будет записана полученная информация. Если метод ReadString успешно завершит чтение, он возвращает значение TRUE, в противном случае – значение FALSE:

BOOL ReadString(CString& rString);

Если вам надо записать прочитанную из архивного файла строку в массив символов, воспользуйтесь другим прототипом метода ReadString:

LPTSTR ReadString(LPTSTR lpsz, UINT nMax) throw(CArchiveException);

Параметр lpsz должен указывать на буфер памяти, в который будет записана информация. Параметр nMax определяет максимальное количество символов, которое метод может прочитать из файла. Размер буфера lpsz должен быть как минимум на единицу больше, чем значение nMax (в конец строки lpsz будет записан символ \0).

Когда метод Serialize завершит работу по восстановлению или записи объекта из архивного файла, вы должны закрыть используемый для этого объект класса CArchive. Для этого необходимо вызвать метод Close:

void Close() throw(CArchiveException, CFileException);

После вызова этого метода закройте файл, связанный с объектом CArchive, вызвав метод CFile::Close, и удалите сам объект класса CFile.

Многозадачные приложения

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

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

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

Приложения Windows 95 и Windows NT могут быть многозадачными. Такие приложения состоят из нескольких независимых задач. Дополнительные задачи могут использоваться, чтобы выполнять фоновую работу. Класс CWinApp представляет основную задачу приложения. Если вам надо создать дополнительные задачи, вы должны воспользоваться классом CWinThread.

Приложение Pview 95 позволяет просмотреть список процессов, загруженных в памяти и остановить любой процесс.

4. Приложение с главной диалоговой панелью

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

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

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

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

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

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

Но даже когда шаблон приложения полностью готов, Microsoft Visual C++ не оставляет вас один на один с его текстом. Встроенный в среду Visual C++ редактор ресурсов позволяет быстро создавать новые меню, диалоговые панели, добавлять кнопки к панели управления (панели toolbar).

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

Создание приложения средствами MFC AppWizard

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

Выберите из меню File строку New. На экране появится диалоговая панель New, содержащая меню. Выберите из него тип объекта, который надо создать. Для создания нового проекта выберите из этого меню строку Project Workspace. Теперь на экране откроется диалоговая панель New Project Workspace, показанная нами на рисунке 4.1.

Рис. 4.1. Диалоговая панель New Project Workspace


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

Тип приложения Описание
MFC AppWizard (exe) Приложение, создаваемое с использованием библиотеки классов MFC. С помощью AppWizard вы можете автоматически создать основные классы необходимые для приложения
MFC AppWizard (dll) Библиотека динамической компоновки – DLL, создаваемая с помощью библиотеки классов MFC. AppWizard позволяет автоматически создать все основные файлы, необходимые для DLL
OLE ControlWizard Органы управления OLE, созданные с использованием библиотеки классов MFC. Компилятор автоматически создает базовый набор файлов для проекта этого типа
Application Приложение, созданное на основе библиотеки классов MFC или с использованием только вызовов функций программного интерфейса Windows
Dynamic-Link Library Библиотека динамической компоновки, созданная с использованием только вызовов функций программного интерфейса Windows
Console Application Приложение, разработанное с использованием функций консольного ввода/вывода. Этот тип приложений можно использовать для создания небольших программ, работающих в пакетном режиме
Static Library Библиотека функций
Makefile Предоставляет дополнительные возможности для использования MAKE-файла
Custom AppWizard Позволяет создать собственный “волшебник” Custom AppWizard, который можно будет использовать для разработки шаблонов приложений с заданными вами свойствами
Список типов приложений, которые может создавать Microsoft Visual C++ версии 4.1, расширен. В него включен “волшебник” ISAPI Extension Wizard, который облегчает создание приложений для Microsoft Internet Information Server.

В этой книге мы расскажем о создании собственных приложений с использованием средств AppWizard. Поэтому выберите из списка Type строку MFC AppWizard (exe).

Теперь определите расположение базового каталога, в котором будут размещены проекты. Путь каталога можно ввести непосредственно в поле Location или выбрать, из списка, нажав на кнопку Browse. Затем введите в поле Name имя создаваемого проекта. В базовом каталоге создается одноименный подкаталог и в него записываются все файлы проекта. Имена файлов, составляющих проект, и названия классов приложения также присваиваются AppWizard на основе имени проекта.

В группе переключателей Platforms надо выбрать, для какой платформы создается приложение. Если вы работаете в среде операционных систем Windows NT или Windows 95, установите переключатель Win32.

После того как вы заполнили все поля диалоговой панели, нажмите кнопку Create. На экране появится первая диалоговая панель MFC AppWizard. Внешний вид этой панели зависит от того, какой тип приложения вами создается. Если вы создаете выполнимое приложение, то на экране появится диалоговая панель, показанная на рисунке 4.2.

Рис. 4.2. Первый шаг MFC AppWizard


На первом шаге вам предлагается определить, какой тип пользовательского интерфейса должно иметь приложение. Вы можете выбирать между многооконным интерфейсом (Multiple documents), однооконным интерфейсом (Single document) и интерфейсом основанном на диалоговой панели без главного окна (Dialog based).

После того как вы определите тип пользовательского интерфейса приложения, в заголовке диалоговой панели MFC AppWizard будет указано, сколько еще шагов (диалоговых панелей AppWizard) надо будет заполнить, чтобы определить все свойства приложения. Для приложений, имеющих интерфейс на основе главной диалоговой панели, процесс создания приложения будет состоять из 4 шагов, а для приложений, имеющих однооконный и многооконный интерфейс – 6 шагов.

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

Заполнив первую диалоговую панель MFC AppWizard, нажмите кнопку Next >. На экране появится следующая диалоговая панель MFC AppWizard. В зависимости от того, какой тип интерфейса пользователя вы выбрали для приложения, вид этой диалоговой панели может несколько отличаться.

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

Рис. 4.3. Второй шаг MFC AppWizard


Если включить переключатель About box, то приложение будет иметь небольшую информационную панель About. В ней обычно содержится краткая информация о приложении – его название, номер версии, авторские права, небольшая пиктограмма. Чтобы вызвать эту панель, пользователь должен будет выбрать из системного меню главной диалоговой панели приложения строку About App…

Операционная система Windows имеет хорошо развитую справочную систему. Обычно каждое приложение имеет собственный справочный файл данных, содержащий разнообразную информацию о приложении. MFC AppWizard позволяет легко создать заготовку такого файла и подключить ее к приложению. Для этого следует включить переключатель Context sensitive Help. Теперь главная диалоговая панель приложения будет иметь кнопку Help, с помощью которой можно запустить справочную систему приложения.

Современный дизайн интерфейса приложений предполагает, что все органы управления, например кнопки и переключатели, должны выглядеть объемными. Чтобы получить эффект трехмерных органов управления, включите переключатель 3D controls.

Средства автоматизированного создания приложений легко позволяют создавать приложения, использующие OLE технологию. Для приложений, интерфейс пользователя которых основан на диалоговой панели, вы можете использовать технологию OLE automation. Эта технология позволяет приложению работать с объектами, созданными в других приложениях.

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

Библиотека классов MFC версии 4.0 позволяет создавать приложения, взаимодействующие друг с другом через сетевой протокол TCP/IP. Чтобы включить поддержку этого протокола, включите переключатель Windows Sockets.

По умолчанию название главной диалоговой панели приложения совпадает с именем проекта. Вы можете изменить это название в поле Please enter a title for your dialog.

После того, как вы заполнили диалоговую панель, нажмите кнопку Next >. На экране появится следующая диалоговая панель, предназначенная для определения основных свойств приложения. Мы представили ее на рисунке 4.4.

Рис. 4.4. Третий шаг MFC AppWizard


В этой диалоговой панели вы можете попросить MFC AppWizard немного приподнять завесу тайны над волшебством автоматического создания приложения. Если вы переместите переключатель Would you like to generate source file comments в положение Yes, please, то исходный текст приложения будет снабжен комментариями.

Приложение может использовать библиотеку классов MFC двумя способами – вызывая библиотеки DLL или включая код классов непосредственно в приложение.

В первом случае приложение будет иметь меньший размер, но вместе с ним вы должны будете распространять dll-библиотеки MFC. Описание dll-библиотек MFC вы можете найти в разделе “Первое приложение MFC” главы “Введение в MFC”.

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

Способ подключения библиотеки MFC определяется положением переключателя How would you like to use the MFC library. Если он находится в положении As a shared DLL, то используется dll-библиотека MFC, а если в положении As a statically linked library, то код классов MFC включается непосредственно в выполнимый файл приложения.

Теперь вы можете перейти к последнему этапу определения свойств приложения. Нажмите кнопку Next >. На экране появится диалоговая панель для выбора названий классов приложения. Внешний вид этой панели представлен на рисунке 4.5.

Рис. 4.5. Четвертый шаг MFC AppWizard


В списке AppWizard creates the following classes for you перечислены названия всех классов, которые создает MFC AppWizard для вашего приложения. Названия этих классов являются производными от названия проекта. Ниже этого списка расположены четыре поля Class name, Base class, Header file, Implementation file. Когда вы выбираете из списка AppWizard creates the following classes for you название класса приложения в этих полях отображаются следующая информация:

Имя поля Описание
Class name Имя класса приложения, выбранное вами из списка. Вы можете изменить его по вашему усмотрению или оставить как есть
Base class Имя базового класса MFC, из которого наследуется класс выбранный из списка Class name. Для ряда классов базовый класс можно изменить. Более подробно об этом мы расскажем позже
Header file, Implementation file Эти два поля определяют названия включаемого файла, в котором описан класс, и файла, содержащего исходный код методов класса. Вы можете изменить их по своему усмотрению
Теперь все готово к созданию исходных текстов приложения. Для этого достаточно нажать кнопку Finish. На экране появится панель, содержащая информацию о свойствах приложения: тип интерфейса пользователя, названия классов приложения, а также другие особенности, определенные вами с помощью диалоговых панелей MFC AppWizard. Если все правильно, нажмите кнопку OK. MFC AppWizard сразу приступит к построению проекта, полностью создаст все файлы проекта и загрузит их в среду Microsoft Visual C++.

MFC AppWizard создаст проект, который сразу можно оттранслировать и получить приложение, полностью готовое к запуску. Запустите полученное приложение. На экране появится главная диалоговая панель приложения (рис. 4.6).

Рис. 4.6. Приложение Dialog


Полученное приложение имеет только две кнопки OK и Cancel. Нажав на любую из них, вы можете завершить приложение. Взяв за основу полученный проект, измените его в соответствии с вашими потребностями. Вы можете добавить в диалоговую панель новые органы управления, подключить к ним программный код, создать другие ресурсы, и т. д. Все эти задачи легко решаются в среде Microsoft Visual C++ версии 2.0 и 4.0.

Приложение Dialog

Названия файлов, входящих в проект Dialog, вы можете просмотреть на странице FileView в окне Project Workspace. В состав нашего проекта входят следующие основные файлы:

Имя файла Описание
Dialog.h Основной включаемый файл приложения. В нем описан главный класс приложения CDialogApp, а также подключены другие включаемые файлы, необходимые для библиотеки MFC
Dialog.cpp Основной файл приложения. В нем определены методы главного класса приложения и глобальные объекты
Dialog.rc Файл ресурсов. В этом файле описаны все ресурсы приложения. Сами ресурсы могут быть записаны в каталоге RES, расположенном в главном каталоге проекта
Resource.h Файл содержит определения идентификаторов ресурсов приложения, например идентификаторы строк меню
res\Dialog.ico Пиктограмма приложения
res\Dialog.rc2 В этом файле определены ресурсы, которые нельзя редактировать с помощью редактора ресурсов среды Visual C++
DialogDlg.h Файл, в котором определен класс главной диалоговой панели приложения
DialogDlg.cpp В этом файле определены методы класса главной диалоговой панели
ReadMe.txt Текстовый файл, содержащий описание проекта. В нем кратко рассмотрен каждый файл, входящий в проект, перечислены классы приложения, а также представлена некоторая другая дополнительная информация
Dialog.clw Файл содержит информацию, необходимую для правильной работы ClassWizard
StdAfx.h, StdAfx.cpp Использование этих файлов позволяет ускорить процесс повторного построения проекта. Более подробное описание файлов представлено ниже

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

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

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

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

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

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

В процессе создания приложения MFC AppWizard и ClassWizard могут определять идентификаторы ресурсов, идентификаторы для справочной системы и т. д. При этом, для идентификаторов различного типа используются разные префиксы:

Префикс Представляет идентификаторы
HID_ Контекстной подсказки для команд
HIDD_ Контекстной подсказки для диалоговых панелей
ID_ Строк меню и кнопок панелей управления
IDB_ Растровых изображений bitmap
IDC_ Курсоров
IDC_ Органов управления диалоговых панелей
IDD_ Шаблонов диалоговых панелей
IDI_ Пиктограмм
IDP_ Строковых ресурсов, используемые в диалоговых панелях message box для отображения приглашения
IDR_ Приложение может иметь несколько ресурсов различного типа с одинаковыми идентификаторами. Для таких идентификаторов используют префикс IDR_
IDS_ Строковых ресурсов
IDOK, IDCANCEL Стандартные идентификаторы для кнопок OK и Cancel диалоговых панелей

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

//{{AFX_

 …

//}}AFX_

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

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

Блок Включает
//{{AFX_DATA //}}AFX_DATA Объявление элементов данных класса. Используется в описании классов диалоговых панелей
//{{AFX_DATA_INIT //}}AFX_DATA_INIT Инициализация элементов данных класса. Используется в файле реализации классов диалоговых панелей
//{{AFX_DATA_MAP //}}AFX_DATA_MAP Макрокоманды DDX, предназначенные для связывания элементов данных класса и органов управления диалоговых панелей. Используется в файле реализации классов диалоговых панелей
//{{AFX_MSG //}}AFX_MSG Описание методов, которые предназначены для обработки сообщений. Этот блок используется при описании класса
//{{AFX_MSG_MAP //}}AFX_MSG_MAP Макрокоманды таблицы сообщений класса. Используются совместно с AFX_MSG
//{{AFX_VIRTUAL //}}AFX_VIRTUAL Описание переопределенных виртуальных методов класса. Блок AFX_VIRTUAL используется при описании класса
Мы перечислили далеко не все блоки //{{AFX_. Существует еще целый ряд блоков, относящихся к реализации технологии OLE и использованию баз данных.

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

Комментарий После комментария размещаются
// Constructors Конструкторы класса и методы, используемые для инициализации объектов класса. Как правило, элементы класса размещенные в этой секции определены с ключевым словом public
// Attributes Элементы данных класса, и методы для доступа к ним (свойства класса). Как правило, элементы класса размещенные в этой секции определены с ключевым словом public
// Operations Виртуальные и невиртуальные методы, используемые для выполнения операций над объектами класса. Как правило элементы класса размещенные в этой секции определены с ключевым словом public
// Overridables Здесь расположены виртуальные методы, которые вы можете переопределить в порожденных классах. Как правило, элементы класса размещенные в этой секции определены с ключевым словом protected. В большинстве случаев, названия виртуальных методов класса начинается с символов On
// Implementation Методы и элементы данных, относящиеся к внутреннему устройству класса – реализации класса. Как правило, элементы класса размещенные в этой секции определены с ключевым словом protected или private
// Dialog Data Элементы данных, класса диалоговой панели, связанные с органами управления
Для некоторых классов, используются и другие комментарии, например, // Advanced Overridables и т. д.

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

Ресурсы приложения

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

Все ресурсы приложения хранятся в отдельном каталоге. Этот каталог называется RES и располагается в главном каталоге проекта. Однако нет необходимости каждый раз вручную открывать файлы с ресурсами. Для этого надо использовать средства, предоставляемые средой Visual C++.

Просмотреть ресурсы приложения можно в окне Project Workspace на странице ResourceView. Ресурсы приложения представлены в виде дерева и разделяются по типам. Чтобы просмотреть ресурсы определенного типа, надо установить курсор на символ и нажать левую кнопку мыши. Символ изменится на и вам откроется список ресурсов данного типа, включенных в проект. Около имени каждого ресурса размещается небольшая пиктограмма. Чтобы загрузить выбранный ресурс в редактор, сделайте двойной щелчок левой кнопкой мыши по имени ресурса или по его пиктограмме. Вот список ресурсов, доступных для использования в приложении:

Ресурс Описание

 Accelerators Акселераторы

 Bitmaps Растровые изображения в формате BMP

src="/i/60/112860/any2fbimgloader89"> Cursors Курсоры

 Dialogs Диалоговые панели

 Icons Пиктограммы

 Menus Меню

 String tables Таблицы текстовых строк

 Toolbars Панели управления

 Version information Сведения о версии приложения

 Имя определяется программистом Ресурс, определяемый самим пользователем

MFC AppWizard автоматически создает несколько различных ресурсов для приложения Dialog. Вы можете просмотреть эти ресурсы в окне Project Workspace, выбрав страницу ResourceView. Как видите ресурсы приложения включают две диалоговые панели, пиктограмму, таблицу строк и информацию о версии приложения. Рассмотрим эти ресурсы подробнее.

Диалоговые панели приложения Dialog
Диалоговые панели имеют идентификаторы IDD_DIALOG_DIALOG и IDD_ABOUTBOX. Диалоговая панель IDD_DIALOG_DIALOG – это и есть главная диалоговая панель приложения. Она будет отображаться на экране монитора сразу после запуска приложения.

Просмотрите внешний вид диалоговой панели IDD_DIALOG_DIALOG в редакторе ресурсов. Для этого сделайте двойной щелчок по ее названию в окне Project Workspace. Изначально эта панель содержит только две кнопки OK и Cancel, а также короткую текстовую строку. Впоследствии вы можете изменять эту панель, добавляя к ней новые органы управления.

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

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

Ниже мы привели фрагменты из файла ресурсов приложения Dialog, в которых определяются шаблоны диалоговых панелей IDD_ABOUTBOX и IDD_DIALOG_DIALOG.

//////////////////////////////////////////////////////////////

// Шаблоны диалоговых панелей приложения


IDD_ABOUTBOX DIALOG DISCARDABLE 0, 0, 217, 55

STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU

CAPTION "About Dialog"

FONT 8, "MS Sans Serif"

BEGIN

 ICON IDR_MAINFRAME,IDC_STATIC,11,17,20,20

 LTEXT "Dialog Version 1.0", IDC_STATIC,40,10,119,8,SS_NOPREFIX

 LTEXT "Copyright © 1996", IDC_STATIC, 40, 25, 119, 8

 DEFPUSHBUTTON "OK",IDOK,178,7,32,14,WS_GROUP

END


IDD_DIALOG_DIALOG DIALOGEX 0, 0, 185, 92

STYLE DS_MODALFRAME|WS_POPUP|WS_VISIBLE|WS_CAPTION|WS_SYSMENU

EXSTYLE WS_EX_APPWINDOW

CAPTION "Dialog"

FONT 8, "MS Sans Serif"

BEGIN

 PUSHBUTTON "Cancel",IDCANCEL,128,23,50,14

 DEFPUSHBUTTON "OK",IDOK,128,7,50,14

 LTEXT "TODO: Place dialog controls here.", IDC_STATIC,5,34,113,8

END

Пиктограмма
В файле ресурсов приложения указана единственная пиктограмма, имеющая идентификатор IDR_MAINFRAME. Эта пиктограмма содержится в файле Dialog.ico, в каталоге res.

//////////////////////////////////////////////////////////////

// Пиктограмма


IDR_MAINFRAME ICON DISCARDABLE "res\\Dialog.ico"

Пиктограмма IDR_MAINFRAME содержит два цветных изображения с разрешением 32×32 и 16×16 пикселов (рис. 4.7). Вы можете изменить эти пиктограммы по своему усмотрению.

Рис. 4.7. Пиктограммы приложения Dialog


Таблица текстовых строк
В таблице текстовых строк проекта Dialog определена только одна текстовая строка &About Dialog…, имеющая идентификатор IDS_ABOUTBOX. Эта строка содержит текст нового элемента, который будет добавлен к системному меню главной диалоговой панели приложения. Если пользователь выберет эту строку меню, приложение выведет на экран небольшую диалоговую панель, с краткой информацией о приложении.

//////////////////////////////////////////////////////////////

// Таблица строк


STRINGTABLE DISCARDABLE

BEGIN

 IDS_ABOUTBOX "&About Dialog…"

END

Версия
Во всех приложениях, созданных с использованием MFC AppWizard, определен специальный ресурс, содержащий различные сведения о версии приложения (4.8). Приложение Dialog также содержит такой ресурс, который имеет идентификатор VS_VERSION_INFO.

Рис. 4.8. Информация о версии приложения


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

Исходные тексты приложения

Рассмотрим исходные тексты приложения более подробно. Из главы “Введение в MFC” вы уже знаете, что приложения, созданные на основе библиотеки MFC, как правило, не имеют главной функции приложения WinMain.

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

Главный класс приложения dialog
Главный класс приложения CDialogApp, наследованный от базового класса CWinApp, определен во включаемом файле Dialog.h. Исходный текст этого файла содержится в листинге 4.1.

Первые строки файла содержат директиву #ifndef, которая проверяет, определен ли символ __AFXWIN_H__. Символ __AFXWIN_H__ определен в файле afxwin.h. Если на этапе обработки файла Dialog.h символ не определен, то при построении проекта выдается сообщение об ошибке. Это гарантирует, что включаемый файл afxwin.h будет обработан до Dialog.h.

Следующая директива #include включает файл resource.h. Этот файл создается MFC AppWizard и содержит определение идентификаторов, задействованных для ресурсов приложения.

Листинг 4.1. Файл Dialog.h
// Dialog.h : Главный включаемый файл для приложения Dialog

//


#ifndef __AFXWIN_H__

#error include 'stdafx.h' before including this file for PCH

#endif


#include "resource.h" // включаемый файл содержащий

// идентификаторы ресурсов приложения


//////////////////////////////////////////////////////////////

// Класс CDialogApp:

// Методы класса CDialogApp определены в файле Dialog.cpp

//

class CDialogApp : public CWinApp {

public:

 CDialogApp();


 // Overrides

 // В следующем блоке ClassWizard помещает описания

 // переопределенных виртуальных методов класса

 //{{AFX_VIRTUAL(CDialogApp)

public:

 virtual BOOL InitInstance();

 //}}AFX_VIRTUAL


 // Implementation


 //{{AFX_MSG(CDialogApp)

 // В этом блоке ClassWizard размещает описания методов

 // класса. Не редактируйте содержимое этого блока вручную

 //}}AFX_MSG

 DECLARE_MESSAGE_MAP()

};

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

Кроме конструктора, в классе CDialogApp, переопределяется виртуальный метод InitInstance базового класса CWinApp. Как видите, метод InitInstance находится, после комментария // Overrides, который обозначает секцию переопределения виртуальных методов.

В принципе вы можете удалить комментарий // Overrides, это ни как не повлияет на работу приложения. Все комментарии типа // Overrides и // Implementation вставляются MFC AppWizard для программиста, чтобы ему было легче определить назначение метода или элемента данных класса.

MFC AppWizard поместил объявление метода InitInstance внутри блока комментариев AFX_VIRTUAL. Первая и последняя строка, обозначающая этот блок, не влияют на работу программы, так как они являются комментариями (расположены после символов комментария //). Блок AFX_VIRTUAL нужен ClassWizard, чтобы выделить методы класса, которые им управляются. Вы не должны вручную вносить изменения в этот блок и другие блоки AFX_.

Более подробно о блоках AFX_ и других комментариях, вставляемых MFC AppWizard и ClassWizard, мы рассказывали в разделе “Имена, используемые MFC” данной главы книги.

Основной файл приложения имеет имя, совпадающее с именем проекта – Dialog.cpp. Текст этого файла приведен нами в листинге 4.2. Файл содержит реализацию методов главного класса приложения CDialogApp.

Листинг 4.2. Файл Dialog.cpp
// Dialog.cpp : Определяет главный класс приложения

//


// Включаемые файлы

#include "stdafx.h"

#include "Dialog.h"

#include "DialogDlg.h"


// Для отладочной версии приложения включается дополнительные

// определения

#ifdef _DEBUG

#define new DEBUG_NEW

#undef THIS_FILE

static char THIS_FILE[] = __FILE__;

#endif


//////////////////////////////////////////////////////////////

// CDialogApp

BEGIN_MESSAGE_MAP(CDialogApp, CWinApp)

 //{{AFX_MSG_MAP(CDialogApp)

 // ClassWizard размещает в данном блоке макрокоманды для

 // обработки сообщений. Не изменяйте содержимое этого блока

 // вручную

 //}}AFX_MSG

 ON_COMMAND(ID_HELP, CWinApp::OnHelp)

END_MESSAGE_MAP()


//////////////////////////////////////////////////////////////

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


CDialogApp::CDialogApp() {

 // TODO: здесь вы можете добавить собственный код

}


//////////////////////////////////////////////////////////////

// Создаем один объект класса CDialogApp. Это будет главный

// объект приложения


CDialogApp theApp;


//////////////////////////////////////////////////////////////

// Инициализация приложения


BOOL CDialogApp::InitInstance() {

 // Стандартная инициализация приложения. Вы можете сократить

 // размер выполняемого модуля приложения, если удалите

 // инициализацию, которая вам не нужна

#ifdef _AFXDLL

 Enable3dControls();

#else

 Enable3dControlsStatic();

#endif


 CDialogDlg dlg;

 m_pMainWnd = &dlg;

 int nResponse = dlg.DoModal();

 if (nResponse == IDOK) {

  // TODO: Здесь вы можете разместить код приложения,

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

  // в диалоговой панели приложения

 } else if (nResponse == IDCANCEL) {

  // TODO: Здесь вы можете разместить код приложения,

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

  // Cancel в диалоговой панели приложения

 }


 // Так как диалоговая панель закрыта, возвращаем значение

 // FALSE чтобы завершить приложение

 return FALSE;

}

В начале файла Dialog.cpp подключены три файла stdafx.h, Dialog.h и DialogDlg.h. Файл stdafx.h будет описан нами ниже. Сейчас отметим, что он содержит определения, необходимые для библиотеки классов MFC.

Файл Dialog.h содержит описание главного класса приложения CDialogApp. Файл DialogDlg.h включает описание класса диалоговой панели приложения. Именно эта панель будет представлять пользовательский интерфейс нашего приложения.

Далее директива #ifdef проверяет, был ли определен символ _DEBUG. Вы не найдете определение _DEBUG ни в одном исходном файле проекта. Этот символ определяется самой средой VIsual C++, если вы создаете отладочную версию приложения.

#ifdef _DEBUG

#define new DEBUG_NEW

#undef THIS_FILE

static char THIS_FILE[] = __FILE__;

#endif

Для отладочной версии приложения определяется символ DEBUG_NEW и переопределяется статическая переменная THIS_FILE. Если такой символ уже был определен, он предварительно отменяется директивой #undef, а затем определяется снова.

THIS_FILE определяется как символьная строка, в которую записывается имя исходного файла данного модуля, определенное специальным символом __FILE__ (то, есть Dialog.cpp).

Исходные тексты приложений, подготовленных с использованием средств автоматизированного проектирования MFC AppWizard и ClassWizard, активно используют символы, определенные в среде VIsual C++. Чтобы просмотреть их список, выберите из меню Build строку Settings. На экране появится диалоговая панель Project Settings, содержащая несколько страниц. Выберите страницу C/C ++ (рис. 4.9).

В поле Settings For приложение Dialog представлено двумя строками. Одна выбирает параметры проекта для отладочной версии приложения, а вторая для законченной, не отладочной, версии.

В поле Preprocessor definitions отображается список символов, определенных для данного проекта. Вы можете добавить в этот список новые символы, или убрать символы, которые уже определены.

Рис. 4.9. Настройка проекта


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

Таблица сообщений класса CDialogApp
Таблица сообщений класса CDialogApp состоит из макрокоманд BEGIN_MESSAGE_MAP и END_MESSAGE_MAP. Между ними расположены макрокоманды, определяющие сообщения, обрабатываемые данным классом. В таблице определено только одно командное сообщение, имеющее идентификатор ID_HELP. Для его обработки вызывается метод OnHelp базового класса CWinApp.

Необработанные сообщения передаются базовому классу CWinApp, так как он указан во втором параметре макрокоманды BEGIN_MESSAGE_MAP.

//////////////////////////////////////////////////////////////

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

BEGIN_MESSAGE_MAP(CDialogApp, CWinApp)

 //{{AFX_MSG_MAP(CDialogApp)

 // ClassWizard размещает в данном блоке макрокоманды для

 // обработки сообщений. Не изменяйте содержимое этого блока

 //}}AFX_MSG

 ON_COMMAND(ID_HELP, CWinApp::OnHelp)

END_MESSAGE_MAP()

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

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

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

Непосредственно после таблицы сообщений главного класса приложения расположено определение конструктора CDialogApp. Этот конструктор вызывается в момент создания объекта приложения. Конструктор, созданный MFC AppWizard, пустой и не выполняет никаких дополнительных действий. Для инициализации приложения используются методы InitInstance и InitApplication.

Главный объект приложения
В файле Dialog.cpp объявляется глобальный объект главного класса приложения. Именно с создания этого объекта и начинается работа приложения.

CDialogApp theApp;

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

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

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

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

BOOL CDialogApp::InitInstance() {

 // …

}

Если вы указали, что ваше приложение должно иметь трехмерный графический интерфейс, то метод InitInstance вызывает метод Enable3dControls или Enable3dControlsStatic , определенные в классе CWinApp. Эти методы разрешают использование трехмерных органов управления. Какой из этих методов будет использоваться определяется на этапе работы препроцессора в зависимости от того, определен или нет символ _AFXDLL.

// Использовать для приложения трехмерный интерфейс

#ifdef _AFXDLL

Enable3dControls();

#else

Enable3dControlsStatic();

#endif

Символ _AFXDLL определяется средой Visual C++, если вы используете библиотеку классов MFC как библиотеку DLL. Если же код MFC подключается к приложению как статическая библиотека, этот символ не определен.

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

Затем метод InitInstance создает диалоговую панель, которая и будет выполнять роль пользовательского интерфейса приложения. Для этого сначала создается объект dlg класса CDialogDlg, который управляет диалоговой панелью. Затем адрес этого объекта присваивается элементу данных m_pMainWnd главного класса приложения.

CDialogDlg dlg;

m_pMainWnd = &dlg;

Только после этого вызывается метод DoModal для объекта dlg класса CDialogDlg. Он создает модальное диалоговое окно и отображает его на экране. Диалоговая панель, которую создает MFC AppWizard, показана нами на рисунке 2.2. Она имеет всего две кнопки OK и Cancel. Когда пользователь нажимает на одну из этих кнопок, метод DoModal возвращает идентификатор этой кнопки. По умолчанию кнопка OK имеет идентификатор IDOK, а кнопка Cancel – IDCANCEL.

int nResponse = dlg.DoModal();

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

if (nResponse == IDOK) {

 // Поместите здесь код, который будет выполняться

 // когда пользователь нажмет кнопку OK

} else if(nResponse == IDCANCEL) {

 // Поместите здесь код, который будет выполняться

 // когда пользователь нажмет кнопку Cancel

}

Все! Теперь диалоговое окно закрыто и вам надо завершить приложение. Для этого достаточно, чтобы метод InitInstance вернул значение FALSE.

return FALSE;

Класс главной диалоговой панели приложения
Большой интерес представляет файл DialogDlg.h, показанный в листинге 4.3. Этот класс содержит объявление класса главной диалоговой панели приложения CDialogDlg.

Класс CDialogDlg наследуется от базового класса CDialog , определенного в библиотеке классов MFC. Конструктор класса имеет один необязательный параметр pParent, используемый для передачи индекса главного окна приложения. Приложение Dialog не имеет главного окна. Роль главного окна выполняет сама диалоговая панель, поэтому параметр pParent не используется.

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

После блока AFX_DATA следует блок AFX_VIRTUAL. В этом блоке MFC AppWizard и ClassWizard добавляют объявления переопределенных виртуальных методов базового класса.

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

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

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

После создания проекта в классе CDialogDlg объявлены 4 обработчика сообщений OnInitDialog, OnSysCommand, OnPaint и OnQueryDragIcon. Эти методы определены в файле DialogDlg.cpp, описанном ниже.

Листинг 4.3. Файл DialogDlg.h
//////////////////////////////////////////////////////////////

// Класс CDialogDlg главной диалоговой панели приложения

class CDialogDlg : public CDialog {

 // Construction

public:

 // Стандартный конструктор

 CDialogDlg(CWnd* pParent = NULL);


 // Dialog Data

 //{{AFX_DATA(CDialogDlg)

 enum { IDD = IDD_DIALOG_DIALOG };

 // В этом блоке ClassWizard размещает новые элементы данных

 // класса

 //}}AFX_DATA


 // В следующем блоке ClassWizard выполняет переопределение

 // виртуальных методов

 //{{AFX_VIRTUAL(CDialogDlg)

protected:

 // Поддержка DDX/DDV

 virtual void DoDataExchange(CDataExchange* pDX);

 //}}AFX_VIRTUAL


 // Implementation

protected:

 HICON m_hIcon;


 // В следующем блоке перечислены методы обработчики

 // сообщений класса CDialogDlg

 //{{AFX_MSG(CDialogDlg)

 virtual BOOL OnInitDialog();

 afx_msg void OnSysCommand(UINT nID, LPARAM lParam);

 afx_msg void OnPaint();

 afx_msg HCURSOR OnQueryDragIcon();

 //}}AFX_MSG

 DECLARE_MESSAGE_MAP()

};

Методы класса диалогового окна определены в файле DialogDlg.cpp. Исходный текст этого файла представлен в листинге 4.4. В нем содержатся определение конструктора и методов класса CDialogDlg.

Листинг 4.4. Файл DialogDlg.cpp
#include "stdafx.h"

#include "Dialog.h"

#include "DialogDlg.h"


#ifdef _DEBUG

#define new DEBUG_NEW

#undef THIS_FILE

static char THIS_FILE[] = __FILE__;

#endif


//////////////////////////////////////////////////////////////

// Описание класса CAboutDlg, который используется для

// управления диалоговой панелью About. Методы этого класса

// определены ниже

class CAboutDlg : public CDialog {

public:

 CAboutDlg();


 // Dialog Data

 //{{AFX_DATA(CAboutDlg)

 enum { IDD = IDD_ABOUTBOX };

 //}}AFX_DATA


 // В следующем блоке ClassWizard размещает переопределение

 // виртуальных методов

 //{{AFX_VIRTUAL(CAboutDlg)

protected:

 // Поддержка DDX/DDV

 virtual void DoDataExchange(CDataExchange* pDX);

 //}}AFX_VIRTUAL


 // Implementation

protected:

 //{{AFX_MSG(CAboutDlg)

 //}}AFX_MSG

 DECLARE_MESSAGE_MAP()

};


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

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD) {

 //{{AFX_DATA_INIT(CAboutDlg)

 //}}AFX_DATA_INIT

}


// Метод DoDataExchange класса CAboutDlg

void CAboutDlg::DoDataExchange(CDataExchange* pDX) {

 CDialog::DoDataExchange(pDX);

 //{{AFX_DATA_MAP(CAboutDlg)

 //}}AFX_DATA_MAP

}


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

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)

 //{{AFX_MSG_MAP(CAboutDlg)

 // Класс CAboutDlg не обрабатывает никаких сообщений

 //}}AFX_MSG_MAP

END_MESSAGE_MAP()


//////////////////////////////////////////////////////////////

// Ниже определены различные методы класса CDialogDlg


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

CDialogDlg::CDialogDlg(CWnd* pParent /*=NULL*/) : CDialog(CDialogDlg::IDD, pParent) {

 //{{AFX_DATA_INIT(CDialogDlg)

 // В этом блоке ClassWizard размещает инициализацию

 // элементов данных класса

 //}}AFX_DATA_INIT


 // Вызов LoadIcon не требует последующего вызова

 // DestroyIcon, если вы используете программный интерфейс

 // Win32

 m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);

}


// Метод DoDataExchange класса CDialogDlg

void CDialogDlg::DoDataExchange(CDataExchange* pDX) {

 CDialog::DoDataExchange(pDX);

 //{{AFX_DATA_MAP(CDialogDlg)

 // Здесь ClassWizard размещает вызовы методов DDX и DDV

 //}}AFX_DATA_MAP

}


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

BEGIN_MESSAGE_MAP(CDialogDlg, CDialog)

 //{{AFX_MSG_MAP(CDialogDlg)

 ON_WM_SYSCOMMAND()

 ON_WM_PAINT()

 ON_WM_QUERYDRAGICON()

 //}}AFX_MSG_MAP

END_MESSAGE_MAP()


// Метод OnInitDialog класса CDialogDlg

BOOL CDialogDlg::OnInitDialog() {

 CDialog::OnInitDialog();


 // Добавление строки "About…" к системному меню приложения


 // Проверяем, что идентификатор IDM_ABOUTBOX относится к

 // системным командам

 ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);

 ASSERT(IDM_ABOUTBOX < 0xF000);


 CMenu* pSysMenu = GetSystemMenu(FALSE);

 CString strAboutMenu;

 strAboutMenu.LoadString(IDS_ABOUTBOX);

 if (!strAboutMenu.IsEmpty()) {

  pSysMenu->AppendMenu(MF_SEPARATOR);

  pSysMenu->AppendMenu(MF_STRING,  IDM_ABOUTBOX, strAboutMenu);

 }


 // Выбираем пиктограмму для диалоговой панели. Если главное

 // окно приложения не является диалоговой панелью, этот код

 // не нужен

 SetIcon(m_hIcon,TRUE); // выбираем пиктограмму большого

                        // размера


 SetIcon(m_hIcon,FALSE); // выбираем пиктограмму маленького

                         // размера


 // TODO: Здесь вы можете выполнить дополнительную

 // инициализацию


 return TRUE;

}


// Метод OnSysCommand класса CDialogDlg

void CDialogDlg::OnSysCommand(UINT nID, LPARAM lParam) {

 if ((nID & 0xFFF0) == IDM_ABOUTBOX) {

  CAboutDlg dlgAbout;

  dlgAbout.DoModal();

 } else {

  CDialog::OnSysCommand(nID, lParam);

 }

}


// Если вы добавили кнопку минимизации к диалоговой панели,

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


// Метод OnPaint класса CDialogDlg

void CDialogDlg::OnPaint() {

 if (IsIconic()) {

  CPaintDC dc(this); // контекст устройства


  SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);


  // Выравниваем по центру пиктограмму

  int cxIcon = GetSystemMetrics(SM_CXICON);

  int cyIcon = GetSystemMetrics(SM_CYICON);


  CRect rect;

  GetClientRect(&rect);

  int x = (rect.Width() – cxIcon + 1) / 2;

  int y = (rect.Height() – cyIcon + 1) / 2;


  // Отображаем пиктограмму

  dc.DrawIcon(x, y, m_hIcon);

 } else {

  CDialog::OnPaint();

 }

}


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

// отображаемого, когда пользователь переносит

// минимизированное окно


// Метод OnQueryDragIcon класса CDialogDlg

HCURSOR CDialogDlg::OnQueryDragIcon() {

 return (HCURSOR) m_hIcon;

}

Таблица сообщений класса CDialogDlg
Файл DialogDlg.cpp содержит таблицу сообщений класса CDialogDlg. Таблица включает три макрокоманды. Как видите, они расположены в блоке AFX_MSG_MAP, поэтому для управления ими используется ClassWizard.

BEGIN_MESSAGE_MAP(CDialogDlg, CDialog)

 //{{AFX_MSG_MAP(CDialogDlg)

 ON_WM_SYSCOMMAND()

 ON_WM_PAINT()

 ON_WM_QUERYDRAGICON()

 //}}AFX_MSG_MAP

END_MESSAGE_MAP()

При помощи ClassWizard вы можете обнаружить, что макрокоманды выполняют обработку сообщений WM_SYSCOMMAND, WM_PAINT, WM_QUERYDRAGICON, вызывая для этого методы OnSysCommand, OnPaint и OnQueryDragIcon.

Конструктор класса CDialogDlg
Конструктор класса CDialogDlg вызывает конструктор базового класса CDialog. При этом ему передается идентификатор диалоговой панели IDD и идентификатор главного окна приложения pParent. При создании объекта класса CDialogDlg не указываются никакие параметры. Поэтому pParent по умолчанию принимается равным NULL.

//////////////////////////////////////////////////////////////

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

CDialogDlg::CDialogDlg(CWnd* pParent /*=NULL*/) : CDialog(CDialogDlg::IDD, pParent) {

 //{{AFX_DATA_INIT(CDialogDlg)

 // В этом блоке ClassWizard размещает инициализацию

 // элементов данных класса

 //}}AFX_DATA_INIT


 // Вызов LoadIcon не требует последующего вызова

 // DestroyIcon, если вы используете программный интерфейс

 // Win32

 m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);

}

В теле конструктора расположен блок AFX_DATA_INIT . В него ClassWizard будет добавлять код инициализации элементов данных класса CDialogDlg. Конструктор также инициализирует m_hIcon, записывая в него идентификатор пиктограммы IDR_MAINFRAME.

Функция AfxGetApp возвращает указатель на объект главного класса приложения. Такой объект для данного приложения всегда один. В нашем случае AfxGetApp определяет указатель на объект theApp. Вот прототип этой функции:

CWinApp* AfxGetApp();

Метод DoDataExchange
Диалоговая панель приложения содержит только две кнопки и не имеет связанных с ними переменных. Однако метод DoDataExchange переопределен. Фактически он не выполняет ни какой работы. Единственное что он делает, это вызывает метод DoDataExchange базового класса CDialog.

Если вы добавите к диалоговой панели новые органы управления и свяжете их средствами ClassWizard с элементами данных класса CDialogDlg, то в блоке AFX_DATA_MAP будут размещены вызовы методов DDE и DDV , необходимые для выполнения обмена данными.

void CDialogDlg::DoDataExchange(CDataExchange* pDX) {

 CDialog::DoDataExchange(pDX);

 //{{AFX_DATA_MAP(CDialogDlg)

 // Здесь ClassWizard размещает вызовы методов DDX и DDV

 //}}AFX_DATA_MAP

}

Метод OnInitDialog
Когда вы отображаете диалоговую панель на экране, вызывая методы DoModal, Create или CreateIndirect, функции диалоговой панели передается сообщение WM_INITDIALOG. Вы не имеете доступа непосредственно в функции диалога. Ее реализация содержится в базовом классе CDialog.

В ответ на сообщение WM_INITDIALOG вызывается метод OnInitDialog, объявленный как виртуальный метод класса CDialog. Метод OnInitDialog вызывается непосредственно перед выводом панели на экран.

Таблица сообщений класса CDialogDlg не содержит макрокоманд для обработки сообщения WM_INITDIALOG. Метод OnInitDialog вызывается непосредственно MFC.

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

Для приложения Dialog MFC AppWizard уже переопределил метод OnInitDialog. В реализации метода добавляется новая строка к системному меню диалоговой панели для вызова краткой справки о приложении. Затем вызывая метод SetIcon, определенный в базовом классе CWnd, мы выбираем пиктограммы для приложения.

Метод OnInitDialog возвращает значение TRUE. Это означает, что фокус ввода будет установлен на первый орган управления диалоговой панели. Первый орган диалоговой панели можно выбрать в редакторе диалоговой панели, выбрав из меню Layout строку Tab Order.

Если во время инициализации диалоговой панели метод OnInitDialog устанавливает фокус ввода другому органу управления, метод должен вернуть значение FALSE.

BOOL CDialogDlg::OnInitDialog() {

 CDialog::OnInitDialog();


 // Добавление строки "About…" к системному меню приложения


 // Проверяем, что идентификатор IDM_ABOUTBOX относится к

 // системным командам

 ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);

 ASSERT(IDM_ABOUTBOX < 0xF000);


 CMenu* pSysMenu = GetSystemMenu(FALSE);

 CString strAboutMenu;

 strAboutMenu.LoadString(IDS_ABOUTBOX);

 if (!strAboutMenu.IsEmpty()) {

  pSysMenu->AppendMenu(MF_SEPARATOR);

  pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);

 }


 // Выбираем пиктограмму для диалоговой панели. Если главное

 // окно приложения не является диалоговой панелью этот код

 // не нужен

 SetIcon(m_hIcon,TRUE); // Выбираем пиктограмму большого

                        // размера

 SetIcon(m_hIcon,FALSE); // Выбираем пиктограмму маленького

                         // размера


 // TODO: Здесь вы можете выполнить дополнительную

 // инициализацию

 return TRUE;

}

Метод OnSysCommand (системное меню)
Разрабатывая приложение с помощью MFC AppWizard, мы указали, что оно должно иметь возможность отображения краткой справочной информации. Для этого в системное меню приложения была добавлена строка About.

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

afx_msg void OnSysCommand(UINT nID, LPARAM lParam);

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

Параметр nID Описание
SC_CLOSE Закрывает объект CWnd
SC_HOTKEY Активизирует объект CWnd, связанный с комбинацией клавиш, определенной приложением. Младшее слово параметра lParam содержит идентификатор активизируемого окна
SC_HSCROLL Свертка по горизонтали
SC_KEYMENU Выбор из меню при помощи комбинации клавиш
SC_MAXIMIZE, SC_ZOOM Максимизировать объект CWnd
SC_MINIMIZE, SC_ICON Минимизировать объект CWnd
SC_MOUSEMENU Выбор из меню при помощи мыши
SC_MOVE Перемещение окна CWnd
SC_NEXTWINDOW Переключение на следующее окно
SC_PREVWINDOW Переключение на предыдущее окно
SC_RESTORE Восстановление нормального расположения и размера окна
SC_SCREENSAVE Запустить приложение, предохраняющее экран монитора, указанное в секции [boot] файла SYSTEM.INI
SC_SIZE Изменить размер окна CWnd
SC_TASKLIST Запустить или активизировать приложение Task Manager
SC_VSCROLL Свертка по вертикали
Если строка системного меню выбрана с использованием мыши, параметр lParam содержит координаты курсора. Младшее слово определяет х-координату, а старшее y-координату.

Виртуальный метод OnSysCommand определен в классе CDialog и выполняет обработку сообщений WM_SYSCOMMAND в соответствии с их идентификаторами. Естественно, он не может правильно обработать сообщения от строк меню добавленных вами.

Чтобы обработать сообщения от новых строк системного меню (для нашего приложения это строка About), необходимо переопределить виртуальный метод OnSysCommand.

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

void CDialogDlg::OnSysCommand(UINT nID, LPARAM lParam) {

 // Пользователь выбрал строку About системного меню

 if ((nID & 0xFFF0) == IDM_ABOUTBOX) {

  CAboutDlg dlgAbout;

  dlgAbout.DoModal();

 }

 // Все другие сообщение передаем для обработки методу

 // OnSysCommand базового класса CDialog

 else {

  CDialog::OnSysCommand(nID, lParam);

 }

}

Реализация метода OnSysCommand, созданная MFC AppWizard для класса CDialogDlg, определяет причину вызова. Если метод OnSysCommand вызван потому что пользователь выбрал из системного меню строку About, создается объект класса CAboutDlg. Класс CAboutDlg представляет собой класс для управления диалоговой панелью About. Затем вызывается метод DoModal, который и отображает диалоговую панель About на экране.

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

Описание класса CAboutDlg, а также определение его методов, содержится в файле DialogDlg.cpp (листинг 4.4). Мы не будем подробно описывать класс CAboutDlg, так как он фактически представляет собой упрощенный вариант класса CDialogDlg.

Метод OnPaint (отображение пиктограммы приложения)
Диалоговая панель может иметь кнопку минимизации. Нажав эту кнопку или выбрав строку Minimaze из системного меню, пользователь может свернуть диалоговую панель (приложение) до размера пиктограммы.

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

void CDialogDlg::OnPaint() {

 // Определяем размер диалоговой панели

 if (IsIconic()) {

  // Если диалоговая панель минимизирована, отображаем

  // пиктограмму

  CPaintDC dc(this); // получаем контекст устройства


  SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);


  int cxIcon = GetSystemMetrics(SM_CXICON);

  int cyIcon = GetSystemMetrics(SM_CYICON);


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

  CRect rect;

  GetClientRect(&rect);


  // Выравниваем пиктограмму по центру

  int x = (rect.Width() – cxIcon + 1) / 2;

  int y = (rect.Height() – cyIcon + 1) / 2;


  // Отображаем пиктограмму

  dc.DrawIcon(x, y, m_hIcon);

 } else {

  // Выполняем обработку по умолчанию

  CDialog::OnPaint();

 }

}

После вызова метода OnPaint он проверяет состояние диалоговой панели. Для этого вызывается метод IsIconic, определенный в классе CWnd. Если окно, или в нашем случае диалоговая панель, связанная с объектом, для которого вызывается метод IsIconic, минимизировано, возвращается ненулевое значение, в противном случае – нуль.

BOOL IsIconic() const;

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

Если вызов OnPaint произошел в следствии минимизации диалоговой панели, тогда определяются размеры внутренней области минимизированного окна и размеры пиктограммы. Затем пиктограмма отображается в центре минимизированного окна.

Метод OnQueryDragIcon
Пользователь может перетащить пиктограмму минимизированного приложения с места на место. При этом, как правило, форма курсора меняется. Если пользователь перетаскивает пиктограмму окна для класса которого не определена пиктограмма, вызывается метод OnQueryDragIcon. Этот метод должен вернуть идентификатор курсора, который будет отображаться в момент перетаскивания пиктограммы окна.

MFC AppWizard определяет метод OnQueryDragIcon для класса CDialogDlg, просто возвращая идентификатор пиктограммы приложения.

HCURSOR CDialogDlg::OnQueryDragIcon() {

 // Возвращаем идентификатор пиктограммы

 return (HCURSOR) m_hIcon;

}

Файлы StdAfx.cpp и StdAfx.h
Самый маленький файл проекта StdAfx.cpp . Исходный текст файла StdAfx.cpp представлен в листинге 4.5.

Листинг 4.5. Файл StdAfx.cpp
#include "stdafx.h"

Фактически файл StdAfx.cpp содержит только директиву #include, предназначенную для подключения файла StdAfx.h. Включаемый файл StdAfx.h, представлен нами в листинге 4.6.

Включаемый файл StdAfx.h предназначен для включения стандартных системных включаемых файлов afxwin.h, afxext.h и afxcmn.h. Если в вашем проекте определены редко изменяемые включаемые файлы, которые используются во многих модулях приложения, вы можете также подключить их в этом файле.

Листинг 4.6. Файл StdAfx.h
// Исключить редко используемые директивы из файлов windows.h

// и afxv_w32.h

#define VC_EXTRALEAN


// Файл afxwin.h необходим при использовании MFC

#include <afxwin.h>


// Файл afxwin.h определяет некоторые расширения MFC

#include <afxext.h>

#ifndef _AFX_NO_AFXCMN_SUPPORT

// Файл afxcmn.h используется для органов управления

// операционной системы Windows 95

#include <afxcmn.h>

#endif // _AFX_NO_AFXCMN_SUPPORT

Средства ClassWizard

Разработка приложения не заканчивается, когда MFC AppWizard создаст для вас исходные файлы проекта. Теперь вы должны добавить к приложению собственный программный код, выполняющий основные функции приложения. Среда Microsoft Visual C++ версии 4.0 позволяет максимально облегчить дальнейшую разработку приложения. Для этого предназначены такие средства как ClassView и ClassWizard. Они позволяют с минимальными усилиями добавлять в классы новые методы и данные, быстро высвечивать в окне редактирования интересующие вас объявления и определения классов, методов, данных.

Мы уже изучили возможности ClassView, предназначенные для работы с классами в разделе “Средства ClassView ” главы “Введение в mfc”. По сравнению с ClassView, “волшебник” ClassWizard предоставляет более полные услуги. Он позволяет не только добавлять к классу новые методы и данные. Вы можете использовать ClassWizard, чтобы добавить к классу новый метод, служащий для обработки сообщений, переменную, предназначенную для обмена информацией с полями диалоговой панели.

Запустить ClassWizard очень просто, для этого можно нажать кнопку  из стандартной панели управления (окно Standard) или выбрать из меню View строку ClassWizard. На экране появится главная диалоговая панель ClassWizard. Мы привели внешний вид этой панели на рисунке 4.10.

Рис. 4.10. Главная панель ClassWizard


Главная панель ClassWizard содержит пять страниц – Message Maps, Member Variables, OLE Automation, OLE Events и Class Info. Страница Message Maps позволяет просмотреть сообщения, вырабатываемые объектами, и создать методы дляих обработки. Вторая страница Member Variables позволяет управлять данными, записанными в классе. Следующие две страницы OLE Automation и OLE Events отвечают за поддержку вашим приложением технологии OLE. Эти страницы будут рассмотрены позже. Последняя страница Class Info позволяет получить различную информацию о классе.

Когда вы просматриваете исходный текст приложения, в верхней части окна редактора может отображаться панель WizardBar (рис. 4.11). Органы управления этой панели позволяют получить быстрый доступ к некоторым возможностям ClassWizard. WizardBar позволяет управлять методами, обрабатывающими сообщения от органов управления.

Рис. 4.11. Панель WizardBar

Создание нового класса

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

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

Чтобы создать класс, нажмите кнопку Add Class из любой страницы главной диалоговой панели ClassWizard. Откроется временное меню, содержащее три строки: New, From a file, From an OLE TypeLib. Для создания нового класса выберите из этого меню строку New. Если вы уже имеете исходные тексты класса и их просто требуется подключить к проекту, выберите из меню строку From a file. Последняя строка меню From an OLE TypeLib используется для подключения классов из библиотеки OLE.

Когда вы создаете новый класс, на экране появляется диалоговая панель Create New Class. В поле Name введите имя создаваемого класса. Рекомендуется начинать названия классов с символа “C”. Для создаваемого класса организуются два файла реализации класса, имеющие расширения CPP и H. В них будут помещаться объявления класса, а также определения его методов и данных. Имя файлов реализации отображается в левой части группы File. По умолчанию файлы реализации имеют имена, соответствующие имени класса. Однако их можно изменить, воспользовавшись кнопкой Change из группы File.

Теперь выберите из списка Base Class имя базового класса. Список Base Class достаточно велик. В нем содержатся не только основополагающие классы типа CCmdTarget, CDialog, CDocument, CFrameWnd, CView, CWinThread, CWnd. Список базовых классов включает классы большинства органов управления, например CAnimateCtrl, CButton, CColorDialog, CComboBox, CDragListBox, CEdit, CEditView, CFileDialog, CFontDialog, CHeaderCtrl, CHotKeyCtrl, CListBox, CListCtrl, CListView, CProgressCtrl, CStatic и многие многие другие. Доступны также базовые классы, предназначенные для работы с базами данных: CDaoRecordSet, CDaoRecordView, CRecordset, CRecordView, классы обеспечивающие технологию OLE: COleDocument, COleLinkingDoc, COleServerDoc.

Так, например, вы можете создать новый класс CNewClass, наследованный от базового класса окна просмотра CEditView. Определение класса помещается во включаемый файл NewClass.h (листинг 4.7).

Листинг 4.7. Файл NewClass.h
// Класс окна просмотра CNewClass

class CNewClass : public CEditView {

protected:

 CNewClass();

 DECLARE_DYNCREATE(CNewClass)


 // Attributes

public:


 // Operations

public:


 // Overrides

 //{{AFX_VIRTUAL(CNewClass)

protected:

 virtual void OnDraw(CDC* pDC);

 //}}AFX_VIRTUAL


 // Implementation

protected:

 virtual ~CNewClass();

#ifdef _DEBUG

 virtual void AssertValid() const;

 virtual void Dump(CDumpContext& dc) const;

#endif


 // Методы, предназначенные для обработки сообщений

protected:

 //{{AFX_MSG(CNewClass)

 //}}AFX_MSG

 DECLARE_MESSAGE_MAP()

};

Определение методов класса размещается в другом файле, имеющем расширение CPP (листинг 4.8).

Листинг 4.8. Файл NewClass.cpp
#include "stdafx.h"

#include "Single.h"

#include "NewClass.h"


#ifdef _DEBUG

#define new DEBUG_NEW

#undef THIS_FILE

static char THIS_FILE[] = __FILE__;

#endif


//////////////////////////////////////////////////////////////

// Реализация класса CNewClass


IMPLEMENT_DYNCREATE(CNewClass, CEditView)


CNewClass::CNewClass() {}


CNewClass::~CNewClass() {}


BEGIN_MESSAGE_MAP(CNewClass, CEditView)

 //{{AFX_MSG_MAP(CNewClass)


 //}}AFX_MSG_MAP

END_MESSAGE_MAP()


//////////////////////////////////////////////////////////////

// Метод OnDraw класса CNewClass

void CNewClass::OnDraw(CDC* pDC) {

 CDocument* pDoc = GetDocument();

 // TODO: здесь можно расположить код, выполняющий вывод в

 // окно

}


//////////////////////////////////////////////////////////////

// Диагностические методы класса CNewClass

#ifdef _DEBUG

void CNewClass::AssertValid() const {

 CEditView::AssertValid();

}


void CNewClass::Dump(CDumpContext& dc) const {

 CEditView::Dump(dc);

}

#endif //_DEBUG

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

Включение в класс новых методов

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

Выберите из списка Class name имя класса, к которому надо добавить новый метод. Теперь из списка Object IDs выберите идентификатор объекта, для которого надо создать метод. Если вам надо переопределить виртуальный метод базового класса, выберите из этого списка имя самого класса.

Обратите внимание на список Messages. Если вы выбрали в списке Object IDs идентификатор объекта, то в списке Messages отображаются сообщения, которые этот объект может вырабатывать. Например, если в качестве объекта фигурирует строка меню, то в списке сообщений отображаются два сообщения – COMMAND и UPDATE_COMMAND_UI. Сообщение COMMAND передается, когда данная строка выбирается из меню, а сообщение UPDATE_COMMAND_UI – когда открывается меню, содержащее эту строку.

Выберите из списка Messages то сообщение, для которого надо создать обрабатывающий его метод и нажмите кнопку Add Function. Откроется диалоговая панель Add Member Function. В ней надо определить название нового метода. По умолчанию вам будет предложено название, построенное на основе имени объекта и имени самого сообщения. Нажмите кнопку OK. ClassWizard добавит описание нового метода в класс, а также сформирует шаблон для этого метода, учитывающий все особенности объекта и сообщения.

Название сообщения, для которого создан метод, или имя переопределенного метода из списка Messages выделяется жирным шрифтом. Название нового метода появится в списке методов класса – Member Function, расположенном в нижней части диалоговой панели ClassWizard. Перед названием методов размещаются символы или . Символ располагается перед виртуальными методами, а символ перед методами, обрабатывающими сообщения Windows.

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

ClassWizard не только позволяет добавить в класс новые методы, но и удалить их. ClassWizard самостоятельно удалит объявление метода из класса. Чтобы удалить метод, выберите его название из списка Member Function и нажмите кнопку Delete Function.

Включение в класс новых элементов данных

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

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

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

Откройте ClassWizard и выберите из списка Class name имя класса, к которому надо добавить новый элемент данных. Теперь из списка Control IDs выберите идентификатор органа управления диалоговой панели, к которому надо привязать элемент данных класса. Если из списка Class name выбрать имя класса, не соответствующего диалоговой панели, форме просмотра, форме просмотра записей или набору записей, то список Control IDs остается пустым.

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

Чтобы добавить новый элемент данных, связанный с органом управления, выберите его из списка и нажмите кнопку Add Variable. На экране появится диалоговая панель Add Member Variable (рис. 4.12).

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


В поле Member variable name введите имя нового элемента данных. Рекомендуется начинать имена данных класса с символов m_.

Список Category определяет, будет ли новый элемент данных значением – Value или органом управления – Control. Первая категория обычно охватывает органы управления, которые могут принимать различные значения. К ним, например, относятся поля редактирования, переключатели, списки. Вторая категория охватывает органы управления, принимающие дискретные значения, например кнопки.

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

Обычно программист должен заполнить в диалоговой панели Add Member Variable только поле названия элемента данных Member variable name. Значения для списков Category и Variable type выбираются автоматически, и как правило не требуют изменения, играя скорее информационную роль.

Добавленные элементы данных можно легко удалить. Для этого надо выбрать из списка идентификатор соответствующего органа управления и нажать кнопку Delete Variable.

Мы предлагаем вам самостоятельно попробовать ClassWizard для связывания переменных с органами управления диалоговых панелей. За основу вы можете взять приложение Dialog, описанное нами в предыдущих разделах.

Просмотр характеристик класса

Последняя страница Class Info диалоговой панели ClassWizard позволяет просмотреть основные характеристики класса, изменить фильтр сообщений Windows, изменить внешний класс и внешние переменные.

Выберите из списка Class name имя интересующего вас класса. В группе File details отображается справочная информация о выбранном классе. Поле Header содержит название включаемого файла, в котором определен класс, поле Source – имя файла реализации класса (в нем размещаются определения методов класса и некоторых данных класса). В поле Base class отображается название базового класса, а в поле Resource – идентификатор ресурса (если он есть), обслуживаемого классом. Например, если вы исследуете класс, наследованный от класса CDialog, который обслуживает диалоговую панель, то в поле Base class выводится CDialog, а в поле Resource идентификатор диалоговой панели.

Основные характеристики классов, отображаемые в полях группы File details, нельзя изменить в автоматическом режиме. Вы можете редактировать только характеристики класса, расположенные в группе Advanced options.

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

Список сообщений, для которых класс может содержать методы-обработчики, отображается в списке Messages на странице Message Map главной диалоговой панели ClassWizard. Так как операционная система Windows имеет очень много различных сообщений, то ClassWizard помещает в этот список только часть этих сообщений.

Список сообщений формируется в соответствии с типом объекта Windows, обслуживаемом данным классом. Отбор сообщений происходит по фильтру, который отображается в поле Message filter страницы Class Info диалоговой панели ClassWizard. Вы можете поменять этот фильтр. Вам доступны следующие фильтры сообщений:

Список Message filter Объект, сообщения от которого должны обрабатываться
Child Window Дочернее окно
Dialog Диалоговое окно
MDI Child Frame Дочернее окно MDI
Not a Window Не окно
Topmost Frame Окно frame window – главное окно приложения
Window Окно
ClassWizard позволяет отобразить (привязать) органы управления на диалоговой панели или форме к внешним (foreign) объектам классов CRecordset or CDaoRecordset. Для этого можно использовать список Foreign class и поле Foreign variable. Более подробно об этой возможности мы расскажем в одной из следующих книг серии.

5. Однооконный интерфейс

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

В этой главе мы остановимся на приложениях с однооконным интерфейсом. Приложения с многооконным интерфейсом будут рассмотрены в следующей главе, которая называется “Многооконный интерфейс”.

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

Модель “документ – окно просмотра ”

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

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

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

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

Процедура создания однооконного приложения

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

Теперь надо определить, какой тип пользовательского интерфейса будет иметь приложение. Выберите приложение с однооконным интерфейсом (Single document). Начиная с этого момента процедура создания приложений с разными пользовательскими интерфейсами будет отличаться от описанной нами в предыдущем разделе.

Нажмите кнопку Next. На экране появится следующая диалоговая панель MFC AppWizard. Если вы создаете приложение с однооконным интерфейсом, диалоговая панель будет иметь внешний вид, показанный на рисунке 5.1.

Рис. 5.1. Второй шаг MFC AppWizard


Если приложение будет работать с базами данных, то вам надо указать AppWizard, на каком уровне создаваемый шаблон приложения будет поддерживать базы данных. Сейчас мы не будем подробно останавливаться на работе с базами данных. Наше первое приложение с однооконным интерфейсом не будет работать с базами данных, поэтому переведите переключатель What database support would you like to include? в положение None. Затем нажмите кнопку Next >. На экране появится следующая диалоговая панель MFC AppWizard (рис. 5.2).

Рис. 5.2. Третий шаг MFC AppWizard


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

Первый переключатель What OLE compound document support would you like to include? определяет как приложение будет поддерживать технологию OLE. Мы описали использование этого переключателя в следующей таблице.

Переключатель Описание
None Приложение не использует технологию OLE
Container Приложение сможет включать в свои документы, другие объекты и ссылки на них, то есть будет выступать в качестве клиента OLE
Mini-server Обеспечивается работа основных возможностей сервера OLE. Документы или объекты, подготовленные в приложении, можно будет включать в другие приложения. Однако приложение нельзя будет использовать автономно. Объекты, подготовленные в приложении, можно будет встраивать, однако нельзя будет встроить ссылку на объект, записанный в отдельном файле
Full-server Обеспечивается работа всех возможностей сервера OLE. Объекты, подготовленные в приложении, можно будет включать в другие приложения или встраивать ссылку на объект, записанный в отдельном файле. Приложение можно будет использовать автономно
Both container and server Приложение сможет работать и как сервер и как клиент OLE
Следующий переключатель в диалоговой панели называется Would you like support for OLE compound files? Положение переключателя определяет в каком формате будет сохранятся документ, подготовленный в приложении. Если переключатель находится в положении Yes, please, и документ содержит несколько OLE объектов, то остается возможность индивидуального доступа к этим объектам.

В нижней части диалоговой панели расположены еще два переключателя – OLE automation и OLE controls. Переключатель OLE automation следует включить, если вы желаете, чтобы приложение было доступно для других приложений, поддерживающих OLE automation. Переключатель OLE controls надо включить, если вы предполагаете использовать в приложение органы управления OLE.

Установив все переключатели как вам надо, нажмите кнопку Next >. На экране появится следующая диалоговая панель MFC AppWizard (рис. 5.3).

Рис. 5.3. Третий шаг MFC AppWizard


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

Переключатель Docking toolbar определяет, будет ли приложение иметь панель управления. Если вы включите этот переключатель, то приложение будет иметь панель управления с кнопками (рис. 5.4).

Рис. 5.4. Панель управления


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

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

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

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

Переключатель Initial status bar управляет панелью состояния status bar. Эта панель размещается в нижней части главного окна приложения. По умолчанию в этой панели отображается краткую подсказку о режиме работы приложения и о положении клавиш <CapsLock>, <NumLock> и <ScrollLock>. На рисунке 5.5 мы привели примерный вид панели состояния.

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

Рис. 5.5. Панель состояния


Переключатель Printing and print preview определяет, сможет ли приложение распечатать подготовленный в нем документ и будет ли доступен режим предварительного просмотра распечатки на экране.

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

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

Библиотека классов MFC позволяет создавать приложения, поддерживающие технологию WOSA. Эта поддержка позволяет создавать приложения, способные непосредственно работать с почтовой системой, а также взаимодействовать с другими приложениями в локальной или глобальной сети через протокол TCP/IP.

Переключатель MAPI (Messaging API) управляет поддержкой почтового API. Если вы желаете, чтобы ваше приложение могло передавать и принимать почтовые сообщения (MS Mail, MS Exchenge), включите этот переключатель.

Переключатель Windows Sockets управляет поддержкой сокетов Windows. Если включить этот переключатель, созданное приложение сможет взаимодействовать с другими приложениями по протоколу TCP/IP.

Большинство приложений позволяют сохранять документы в файлах на диске. Впоследствии эти файлы можно снова открыть и продолжить с ними работать. Названия нескольких файлов, с которыми ваше приложение работало позже остальных, отображаются в меню File главного окна приложения. Чтобы открыть один из этих файлов надо выбрать его имя из меню File. По умолчанию приложение будет сохранять названия четырех файлов. Вы можете изменить это число, выбрав его в поле How many files would you like on your recent file list?.

В диалоговой панели MFC AppWizard – Step 4 of 6 располагается кнопка Advanced, позволяющая указать дополнительные характеристики приложения, такие как название главного окна приложения, расширение файлов, в которые приложение будет сохранять свои документы и т. д. Все эти характеристики можно будет настроить непосредственно в исходном тексте приложения, но гораздо удобнее сделать этой сейчас, во время работы MFC AppWizard.

Нажмите кнопку Advanced. На экране появится диалоговая панель Advanced Options, которая содержит две страницы: Document Template Strings и Window Styles. Рассмотрим их более подробно.

Страница Document Template Strings представлена нами на рисунке 5.6 и определяет характеристики документов с которыми будет работать приложение. В верхней части этой страницы расположена группа Non-localized strings. В поле File extension вы можете указать расширение, которое будет по умолчанию присваиваться файлам, созданным приложением. Мы указали в этом поле строку lis. В поле File type ID отображается идентификатор, под которым данный тип документов заносятся в регистрационную базу Windows 95.

Рассмотрим группу Localized strings. Наибольший интерес представляет поле Main frame caption. В нем можно указать заголовок главного окна приложения. По умолчанию это поле содержит имя проекта. В поле Doc type name отображается название типа документов, создаваемых приложением.

Когда вы создаете новый документ и сохраняете его в файле и когда вы открываете файл, чтобы загрузить содержащийся в нем документ, на экране появляются стандартные диалоговые панели для ввода имени файла. Чтобы в этих панелях по умолчанию отображались только имена файлов с определенным расширением, введите в поле Filter name название фильтра для имен файлов, а в поле File extension само расширение. Обычно имя фильтра формируют на основе названия данного типа документа и расширения имени файлов документа (см. поле File extension). Так, в нашем случае, используется имя фильтра Single Files (*.lis).

Рис. 5.6. Диалоговая панель Advanced Options, страница Document Template Strings


Если в приложении определено несколько шаблонов документов, тогда при создании нового документа на экране появляется диалоговая панель File New. Из этой панели можно выбрать шаблон для создания нового документа. Строка из поля File new name (OLE short name) будет показана в этой панели. В случае, если приложение поддерживает технологию OLE как сервер, то строка File new name используется в качестве короткого имени объекта OLE.

В поле File type name (OLE long name) вы можете ввести имя типа файлов. Это имя будет использоваться в стандартных панелях Open и Save As, в качестве типа файлов документов. Для приложений использующих технологию OLE поле File type name также определяет длинное имя объекта OLE.

Теперь выберите страницу Window Style диалоговой панели Advanced Options. Для этого достаточно нажать на соответствующую закладку (рис. 5.8).

Иногда при редактировании документа бывает удобно одновременно просматривать различные участки одного документа. Для этого можно открыть его в двух окнах одновременно. Однако еще удобнее разделить окно на несколько частей (рис. 5.7). Такая возможность реализована, например, в текстовом процессоре Microsoft Word for Windows.

MFC AppWizard упрощает программисту разработку таких приложений. Чтобы главное окно приложения с однооконным интерфейсом, или MDI окна многооконных приложений можно было разделить на несколько частей достаточно включить переключатель Use split window.

Рис. 5.7. Разделение окна на несколько частей


В группе Main frame styles расположены переключатели, определяющие вид главного окна приложения. Ниже приведена таблица, в которой описаны эти переключатели.

Переключатель Описание
Thick frame Главное окно имеет рамку, позволяющую изменить его размер
Minimize box Главное окно содержит кнопку для сворачивания его в пиктограмму
Maximize box Главное окно содержит кнопку для увеличения его размера до максимально возможного
System menu Главное окно приложения будет иметь системное меню
Minimized При запуске приложения его главное окно будет уменьшено до пиктограммы. Потом вы сможете открыть окно
Maximized При запуске приложения его главное окно принимает максимально возможный размер
Рис. 5.8. Диалоговая панель Advanced Options, страница Window Styles


Если вы разрабатываете приложение, имеющее многооконный интерфейс, то вам становятся доступны переключатели из группы MDI child frame styles. Они позволяют выбрать внешний вид дочерних окон приложения. Вот краткое описание этих переключателей:

Переключатель Описание
Thick frame Все MDI окна приложения имеют рамку, позволяющую изменить их размер
Minimize box MDI окна содержат кнопку для сворачивания их в пиктограмму
Maximize box MDI окна содержат кнопку для увеличения их размера до максимально возможного
Minimized Открываемые окна MDI будут уменьшены до пиктограммы
Maximized Открываемые окна MDI будут иметь максимально возможный размер
Конечно, если вы не укажете в диалоговых панелях MFC AppWizard, что приложение должно иметь панель состояния status bar или справочную систему, то их можно будет добавить потом. Но для этого вам потребуется непосредственно исправлять исходный текст приложения. Значительно легче сделать это, включив несколько переключателей в панели MFC AppWizard, чем непосредственно изменять исходный текст.

Теперь вы можете перейти к следующей диалоговой панели MFC AppWizard. Для этого нажмите кнопку Next >. На экране появится панель, аналогичная панели, представленной на рисунке 1.4. В этой диалоговой панели, вы можете попросить MFC AppWizard снабдить исходный текст приложения комментариями, а также выбрать, как приложение будет использовать библиотеку классов MFC – вызывая библиотеки DLL или включая код классов непосредственно в приложение.

Теперь перейдите к последнему этапу определения свойств приложения, нажав кнопку Next >. На экране появится диалоговая панель для выбора названий классов приложения. Внешний вид этой панели уже был представлен на рисунке 5.9. Но теперь список классов будет значительно больше. Имена классов образуются от имени проекта. В нашем примере проект называется Single.

Если вы создаете приложение, имеющее однооконный интерфейс, то в списке классов будут класс приложения с именем CSingleApp, класс главного окна CMainFrame, класс документа CSingleDoc и класс для просмотра документа CSingleView.

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

Рис. 5.9. Выбор базового класса для класса CSingleView


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

Например, если вам надо создать редактор текста, который может воспринимать файлы в формате RTF, то вам достаточно наследовать класс CSingleView от базового класса CRichEditView. И все! Откомпилируйте проект и текстовый редактор готов. Вы можете открывать файлы в текстовом формате и формате RTF, редактировать их и сохранять измененные файлы.

Если вы создаете многооконное приложение, то проект будет содержать еще один класс – CChildFrame. Этот класс управляет дочерними MDI окнами приложения.

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

Теперь, когда вы закончили заполнять диалоговые панели MFC AppWizard, нажмите кнопку Finish. На экране появится диалоговая панель New Project Information. В этой панели приводится описание приложения. Если вас что-то не устраивает, вы можете нажать кнопку Cancel и создать проект заново.

Чтобы продолжить разработку приложения, нажмите кнопку OK. MFC AppWizard приступит к построению проекта и создаст все файлы проекта. Полученный проект сразу можно оттранслировать и запустить на выполнение. Для этого вы можете воспользоваться меню Build или нажать комбинацию клавиш <Ctrl + F5>.

Приложение Single

В этом разделе мы рассмотрим однооконное приложение, созданное с использованием средств MFC AppWizard и расскажем, как его можно совершенствовать.

Создайте новое приложение с однооконным интерфейсом и назовите его Single. При определении свойств приложения оставьте все предложения по умолчанию. Наше приложение не будет поддерживать ни технологию OLE, ни базу данных, ни сетевые технологии. За счет этого оно будет меньше размером, что позволит лучше понять структуру приложений MFC. Процедура создания приложений с использованием MFC AppWizard описана в разделе “Приложение с оконным интерфейсом” и сейчас мы на ней останавливаться не будем.

В состав проекта Single входят следующие основные файлы:

Имя файла Описание
Single.h В этом файле перечислены другие включаемые файлы и описан главный класс приложения CSingleApp
Single.cpp Основной файл приложения. В нем определены методы основного класса приложения CSingleApp
MainFrm.h Содержит описание класса frame, который называется CMainFrame. Класс CMainFrame наследуется от базового класса CFrameWnd определенного в библиотеке классов MFC
MainFrm.cpp Файл содержит определения методов класса CMainFrame
SingleDoc.h Содержит описание класса документов приложения – CSingleDoc
SingleDoc.cpp Включает определение методов класса CSingleDoc
SingleView.h Содержит описание класса окна просмотра приложения – CSingleView
SingleView.cpp Включает определение методов класса CSingleView
Single.rc Файл ресурсов. В этом файле описаны все ресурсы приложения. Сами ресурсы могут быть записаны в каталоге RES, расположенном в главном каталоге проекта
Resource.h Файл содержит определения идентификаторов ресурсов приложения, например, идентификаторы строк меню
res\Single.ico Пиктограмма приложения
res\Single.rc2 В этом файле определены ресурсы, которые нельзя редактировать с помощью редактора ресурсов среды Visual C++
res\Toolbar.bmp Файл содержит изображение кнопок панели управления toolbar
StdAfx.h, StdAfx.cpp Использование этих файлов позволяет ускорить процесс повторного построения проекта. Более подробное описание файлов представлено ниже
Single.clw Файл содержит информацию, необходимую для правильной работы ClassWizard
ReadMe.txt Текстовый файл, содержащий описание проекта. В нем кратко рассмотрен каждый файл, входящий в проект, перечислены классы приложения, а также представлена другая дополнительная информация
Постройте проект Single и запустите полученное приложение. На экране появиться главное окно приложения (рис. 5.10). Как видите, оно имеет меню, панели управления и состояния. Попробуйте выбрать различные строки из меню приложения.

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

Рис. 5.10. Приложение Single

Ресурсы приложения

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

Шаблон меню
Большой интерес для нас представляет ресурс, описывающий меню приложения. В ресурсах приложения определен только один шаблон меню, имеющий идентификатор IDR_MAINFRAME.

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

//////////////////////////////////////////////////////////////

// Меню

IDR_MAINFRAME MENU PRELOAD DISCARDABLE

BEGIN

 POPUP "&File"

 BEGIN

  MENUITEM "&New\tCtrl+N", ID_FILE_NEW

  MENUITEM "&Open…\tCtrl+O", ID_FILE_OPEN

  MENUITEM "&Save\tCtrl+S", ID_FILE_SAVE

  MENUITEM "Save &As…", ID_FILE_SAVE_AS

  MENUITEM SEPARATOR

  MENUITEM "&Print…\tCtrl+P",ID_FILE_PRINT

  MENUITEM "Print Pre&view", ID_FILE_PRINT_PREVIEW

  MENUITEM "P&rint Setup…", ID_FILE_PRINT_SETUP

  MENUITEM SEPARATOR

  MENUITEM "Recent File", ID_FILE_MRU_FILE1,GRAYED

  MENUITEM SEPARATOR

  MENUITEM "E&xit", ID_APP_EXIT

 END

 POPUP "&Edit"

 BEGIN

  MENUITEM "&Undo\tCtrl+Z", ID_EDIT_UNDO

  MENUITEM SEPARATOR

  MENUITEM "Cu&t\tCtrl+X", ID_EDIT_CUT

  MENUITEM "&Copy\tCtrl+C", ID_EDIT_COPY

  MENUITEM "&Paste\tCtrl+V", ID_EDIT_PASTE

 END

 POPUP "&View"

 BEGIN

  MENUITEM "&Toolbar", ID_VIEW_TOOLBAR

  MENUITEM "&Status Bar", ID_VIEW_STATUS_BAR

 END

 POPUP "&Help"

 BEGIN

  MENUITEM "&About Single…", ID_APP_ABOUT

 END

END

Большая часть строк меню IDR_MAINFRAME имеет стандартные идентификаторы, описанные в библиотеке MFC. Некоторые из команд, соответствующих этим идентификаторам полностью обрабатываются MFC. Список стандартных команд с их описанием представлен в разделе “Стандартные команды”.

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

//////////////////////////////////////////////////////////////

// Панель управления Toolbar

IDR_MAINFRAME TOOLBAR DISCARDABLE 16, 15

BEGIN

 BUTTON ID_FILE_NEW

 BUTTON ID_FILE_OPEN

 BUTTON ID_FILE_SAVE

 SEPARATOR

 BUTTON ID_EDIT_CUT

 BUTTON ID_EDIT_COPY

 BUTTON ID_EDIT_PASTE

 SEPARATOR

 BUTTON ID_FILE_PRINT

 BUTTON ID_APP_ABOUT

END

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

Образ кнопок панели управления расположен в файле Toolbar.bmp, записанном в подкаталоге res каталога проекта.

//////////////////////////////////////////////////////////////

// Изображение Bitmap, определяющее кнопки приложения

IDR_MAINFRAME BITMAP MOVEABLE PURE "res\\Toolbar.bmp"

Пиктограмма
В файле ресурсов приложения Single определены две пиктограммы IDR_SINGLETYPE и IDR_MAINFRAME. Каждая из этих пиктограмм содержит по два изображения различного размера 32×32 и 16×16 пикселов.

//////////////////////////////////////////////////////////////

// Пиктограммы

IDR_MAINFRAME ICON DISCARDABLE "res\\Single.ico"

IDR_SINGLETYPE ICON DISCARDABLE "res\\SingleDoc.ico"

Пиктограмма IDR_MAINFRAME представляет минимизированное приложение (рис. 5.11). Эта же пиктограмма отображается в левом верхнем углу главного окна приложения.

Рис. 5.11. Пиктограмма IDR_MAINFRAME


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

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

Рис. 5.12. Пиктограмма IDR_SINGLETYPE


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

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

//////////////////////////////////////////////////////////////

// Таблица текстовых строк

STRINGTABLE PRELOAD DISCARDABLE

BEGIN

 IDR_MAINFRAME "Single\n\nSingle\n\n\nSingle.Document\nSingle Document"

END

Строка описания типа документа (IDR_MAINFRAME) состоит из семи фрагментов, разделенных символами перевода строки \n. Эти фрагменты строки отвечают за различные характеристики документа.

Формирование этой строки выполняется MFC AppWizard на основании информации, которую вы указали на страница Document Template Strings диалоговой панели Advanced Options (рис. 5.6).

Фрагмент Поле панели Advanced Options Описание
Первый Main frame caption Заголовок главного окна приложения. Используется для приложений с однооконным интерфейсом
Второй Doc type name (только для приложений с многооконным интерфейсом), для приложений с однооконным интерфейсом этот фрагмент изначально пуст Имя файла, присваиваемое новому документу по умолчанию. Если этот фрагмент отсутствует, используется имя Untitled
Третий File new name (OLE short name) Название типа документа. Если в приложении определено несколько типов документов (обычно используется для приложений с многооконным интерфейсом), то при создании нового документа отображается диалоговая панель, из которой вы должны выбрать название типа создаваемого документа
Четвертый Filter name Название фильтра для имен файлов документов данного типа. Это название отображается в стандартных диалоговых панелях Open и Save As, в списке типов документов
Пятый File extension Расширение файлов документов данного типа, используемое по умолчанию
Шестой File type ID Идентификатор, под которым данный тип документов заносятся в регистрационную базу Windows 95. Вы можете просмотреть регистрационную базу Windows 95 при помощи приложения REGEDIT.
Седьмой File type name (OLE long name) Тип файлов, используемых для хранения документов данного типа. Также используется в качестве длинного имени объекта OLE, если приложение использует OLE технологию
Для получения более полной информации вы можете изучить метод GetDocString, который позволяет определить отдельные фрагменты строки, описывающий документ. Описание метода GetDocString смотрите в справочной системе Visual C++.

Второй блок таблицы текстовых строк содержит две строки с идентификаторами AFX_IDS_APP_TITLE и AFX_IDS_IDLEMESSAGE. Строка, имеющая идентификатор AFX_IDS_IDLEMESSAGE, отображается в панели состояния, когда приложение находится в состоянии ожидания.

Когда пользователь создает объект главного класса приложения, он может указать имя приложения. Если это имя не указано, как в нашем приложении, тогда в качестве имени приложения используется строка, имеющая идентификатор AFX_IDS_APP_TITLE.

STRINGTABLE PRELOAD DISCARDABLE

BEGIN

 AFX_IDS_APP_TITLE "Single"

 AFX_IDS_IDLEMESSAGE "Ready"

END

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

STRINGTABLE DISCARDABLE

BEGIN

 ID_INDICATOR_EXT "EXT"

 ID_INDICATOR_CAPS "CAP"

 ID_INDICATOR_NUM "NUM"

 ID_INDICATOR_SCRL "SCRL"

 ID_INDICATOR_OVR "OVR"

 ID_INDICATOR_REC "REC"

END

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

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

STRINGTABLE DISCARDABLE

BEGIN

 ID_FILE_NEW "Create a new document\nNew"

 ID_FILE_OPEN "Open an existing document\nOpen"

 ID_FILE_CLOSE "Close the active document\nClose"

 ID_FILE_SAVE "Save the active document\nSave"

 ID_FILE_SAVE_AS "Save the active document with a new name\nSave As"

 ID_FILE_PAGE_SETUP "Change the printing options\nPage Setup"

 ID_FILE_PRINT_SETUP "Change the printer and printing options\nPrint Setup"

 ID_FILE_PRINT "Print the active document\nPrint"

 ID_FILE_PRINT_PREVIEW "Display full pages\nPrint Preview"

 ID_APP_ABOUT " Display program information, version number and copyright\nAbout"

 ID_APP_EXIT "Quit the application; prompts to save documents\nExit"

 ID_FILE_MRU_FILE1 "Open this document"

 ID_FILE_MRU_FILE2 "Open this document"

 ID_FILE_MRU_FILE3 "Open this document"

 ID_FILE_MRU_FILE4 "Open this document"

 ID_FILE_MRU_FILE5 "Open this document"

 ID_FILE_MRU_FILE6 "Open this document"

 ID_FILE_MRU_FILE7 "Open this document"

 ID_FILE_MRU_FILE8 "Open this document"

 ID_FILE_MRU_FILE9 "Open this document"

 ID_FILE_MRU_FILE10 "Open this document"

 ID_FILE_MRU_FILE11 "Open this document"

 ID_FILE_MRU_FILE12 "Open this document"

 ID_FILE_MRU_FILE13 "Open this document"

 ID_FILE_MRU_FILE14 "Open this document"

 ID_FILE_MRU_FILE15 "Open this document"

 ID_FILE_MRU_FILE16 "Open this document"

 ID_NEXT_PANE "Switch to the next window pane\nNext Pane"

 ID_PREV_PANE "Switch back to the previous window pane\nPrevious Pane"

 ID_WINDOW_SPLIT "Split the active window into panes\nSplit"

 ID_EDIT_CLEAR "Erase the selection\nErase"

 ID_EDIT_CLEAR_ALL "Erase everything\nErase All"

 ID_EDIT_COPY "Copy the selection and put it on the Clipboard\nCopy"

 ID_EDIT_CUT "Cut the selection and put it on the Clipboard\nCut"

 ID_EDIT_FIND "Find the specified text\nFind"

 ID_EDIT_PASTE "Insert Clipboard contents\nPaste"

 ID_EDIT_REPEAT "Repeat the last action\nRepeat"

 ID_EDIT_REPLACE "Replace specific text with different text\nReplace"

 ID_EDIT_SELECT_ALL "Select the entire document\nSelect All"

 ID_EDIT_UNDO "Undo the last action\nUndo"

 ID_EDIT_REDO "Redo the previously undone action\nRedo"

 ID_VIEW_TOOLBAR "Show or hide the toolbar\nToggle ToolBar"

 ID_VIEW_STATUS_BAR "Show or hide the status bar\nToggle StatusBar"

END

Диалоговая панель
В ресурсах приложения определена только одна диалоговая панель с идентификатором IDD_ABOUTBOX. Она содержит краткую информацию о приложении и отображается на экране, когда пользователь выбирает из меню Help строку About Single.

//////////////////////////////////////////////////////////////

// Диалоговая панель

IDD_ABOUTBOX DIALOG DISCARDABLE 0, 0, 217, 55

CAPTION "About Single"

STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU

FONT 8, "MS Sans Serif"

BEGIN

 ICON IDR_MAINFRAME,IDC_STATIC,11,17,20,20

 LTEXT "Single Version 1.0",IDC_STATIC,40,10,119,8, SS_NOPREFIX

 LTEXT "Copyright \251 1996",IDC_STATIC,40,25,119,8

 DEFPUSHBUTTON "OK",IDOK,178,7,32,14,WS_GROUP

END

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

//////////////////////////////////////////////////////////////

// Таблица акселераторов

IDR_MAINFRAME ACCELERATORS PRELOAD MOVEABLE PURE

BEGIN

 "N", ID_FILE_NEW, VIRTKEY,CONTROL

 "O", ID_FILE_OPEN, VIRTKEY,CONTROL

 "S", ID_FILE_SAVE, VIRTKEY,CONTROL

 "P", ID_FILE_PRINT, VIRTKEY,CONTROL

 "Z", ID_EDIT_UNDO, VIRTKEY,CONTROL

 "X", ID_EDIT_CUT, VIRTKEY,CONTROL

 "C", ID_EDIT_COPY, VIRTKEY,CONTROL

 "V", ID_EDIT_PASTE, VIRTKEY,CONTROL

 VK_BACK, ID_EDIT_UNDO, VIRTKEY,ALT

 VK_DELETE, ID_EDIT_CUT, VIRTKEY,SHIFT

 VK_INSERT, ID_EDIT_COPY, VIRTKEY,CONTROL

 VK_INSERT, ID_EDIT_PASTE, VIRTKEY,SHIFT

 VK_F6, ID_NEXT_PANE, VIRTKEY

 VK_F6, ID_PREV_PANE, VIRTKEY,SHIFT

END

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

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

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

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

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

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

MFC AppWizard создает для приложения Single, обладающего однооконным интерфейсом, 4 основных класса. Эти классы представляют основу любого однооконного приложения, созданного MFC AppWizard.

Класс приложения Базовый класс Описание
CSingleApp CWinApp Главный класс приложения
CMainFrame CFrameWnd Класс главного окна приложения
CSingleDoc CDocument  Класс документа приложения
CSingleView CView Класс окна просмотра документа
Кроме основных классов, создается также класс CAboutDlg, наследованный от базового класса CDialog, который отвечает за диалоговую панель About. Если во время определения характеристик приложения вы включите возможность работы с базами данных или использование технологии OLE, общий список классов приложения может стать шире.

Класс CSingleApp
Главный класс приложения CSingleApp наследуется от базового класса CWinApp. Вы можете просмотреть определение класса, если выполните двойной щелчок левой клавишей мыши по его названию в окне Project Workspace. Откроется окно редактора и в него загрузится файл Single.h. Курсор будет автоматически установлен на описание класса CSingleApp.

//////////////////////////////////////////////////////////////

// Класс CSingleApp:

class CSingleApp : public CWinApp {

public:

 CSingleApp();


 // Overrides

 //{{AFX_VIRTUAL(CSingleApp)

public:

 virtual BOOL InitInstance();

 //}}AFX_VIRTUAL


 // Implementation

 //{{AFX_MSG(CSingleApp)

 afx_msg void OnAppAbout();

 //}}AFX_MSG

 DECLARE_MESSAGE_MAP()

};

Таблица сообщений класса CSingleApp
Обратите внимание, что в последней строке определения класса CSingleApp расположена макрокоманда DECLARE_MESSAGE_MAP. Загадочная макрокоманда DECLARE_MESSAGE_MAP определена в файле afxwin.h следующим образом:

#define DECLARE_MESSAGE_MAP() \

private: \

 static const AFX_MSGMAP_ENTRY _messageEntries[]; \

protected: \

 static AFX_DATA const AFX_MSGMAP messageMap; \

 virtual const AFX_MSGMAP* GetMessageMap() const; \

Таким образом, DECLARE_MESSAGE_MAP не является расширением языка Си++, а просто добавляет к вашему классу несколько новых элементов.

Так как в классе CSingleApp расположена макрокоманда DECLARE_MESSAGE_MAP, то он может обрабатывать сообщения и имеет таблицу сообщений. Таблица сообщений класса CSingleApp расположена в файле реализации Single.cpp.

//////////////////////////////////////////////////////////////

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

BEGIN_MESSAGE_MAP(CSingleApp, CWinApp)

 //{{AFX_MSG_MAP(CSingleApp)

 ON_COMMAND(ID_APP_ABOUT, OnAppAbout)

 //}}AFX_MSG_MAP

 // Стандартные команды для работы с документами

 ON_COMMAND(ID_FILE_NEW, CWinApp::OnFileNew)

 ON_COMMAND(ID_FILE_OPEN, CWinApp::OnFileOpen)

 // Стандартная команда выбора принтера

 ON_COMMAND(ID_FILE_PRINT_SETUP, CWinApp::OnFilePrintSetup)

END_MESSAGE_MAP()

Кроме команды для обработки командного сообщения ID_APP_ABOUT, расположенного в блоке AFX_MSG_MAP, таблица сообщений содержит еще три макрокоманды, предназначенные для обработки командных сообщений с идентификаторами ID_FILE_NEW, ID_FILE_OPEN, ID_FILE_PRINT_SETUP.

Командные сообщения ID_FILE_NEW, ID_FILE_OPEN, ID_FILE_PRINT_SETUP поступают, когда пользователь выбирает из меню приложения строки с соответствующими идентификаторами. Для обработки этих командных сообщений вызываются методы класса CWinApp.

Главный объект приложения
В приложении создается всего один объект класса CSingleApp. Этот объект определяется как статический, поэтому его конструктор получает управление сразу после запуска приложения.

CSingleApp theApp;

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

//////////////////////////////////////////////////////////////

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

CSingleApp::CSingleApp() {

 // TODO: Здесь вы можете разместить свой код

}

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

MFC AppWizard переопределяет метод InitInstance автоматически для приложений с любым пользовательским интерфейсом. Однако реализация этого метода может различаться. Сравните переопределенный метод InitInstance для приложений с главной диалоговой панелью (приложение Dialog) и оконным интерфейсом (приложение Single).

//////////////////////////////////////////////////////////////

// Метод CSingleApp

BOOL CSingleApp::InitInstance() {

#ifdef _AFXDLL

 Enable3dControls();

#else

 Enable3dControlsStatic();

#endif


 // Загружаем файл конфигурации

 LoadStdProfileSettings();


 // Создаем шаблон документа

 CSingleDocTemplate* pDocTemplate;

pDocTemplate = new CSingleDocTemplate(IDR_MAINFRAME, RUNTIME_CLASS(CSingleDoc), RUNTIME_CLASS(CMainFrame), RUNTIME_CLASS(CSingleView));


 // Регистрируем шаблон документа

 AddDocTemplate(pDocTemplate);


 // Выполняем стандартную обработку командной строки

 // приложения

 CCommandLineInfo cmdInfo;

 ParseCommandLine(cmdInfo);


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

 if (!ProcessShellCommand(cmdInfo)) return FALSE;


 return TRUE;

}

После вызова метода Enable3dControls, описанного ранее, вызывается метод LoadStdProfileSettings. Этот метод загружает файл конфигурации приложения, имеющий расширение INI. В INI-файле записаны имена нескольких файлов, с которыми работало приложение. Эти имена файлов будут добавлены как отдельные строки в меню File приложения. Кроме того, в INI-файле может храниться и другая информация.

Метод LoadStdProfileSettings определен в классе CWinApp следующим образом:

void LoadStdProfileSettings(UINT nMaxMRU = _AFX_MRU_COUNT);

Необязательный параметр nMaxMRU определяет, сколько имен файлов документов будет запоминаться. Если указать в качестве параметра nMaxMRU нулевое значение, список файлов запоминаться не будет. По умолчанию параметру nMaxMRU присваивается значение _AFX_MRU_COUNT. Константа _AFX_MRU_COUNT определена в файле afxwin.h.

#define _AFX_MRU_COUNT 4

Напомним вам, что количество запоминаемых имен файлов можно указать в диалоговой панели MFC AppWizard – Step 4 of 6 (рис. 5.3), во время разработки приложения средствами MFC AppWizard.

Затем начинается создание шаблона документов. Сначала создается указатель pDocTemplate на соответствующий класс. Для однооконных приложений это класс CSingleDocTemplate, а для многооконных – CMultiDocTemplate. Создается новый объект класса и в переменную pDocTemplate записывается указатель на него. Для создания шаблона документа используется оператор new.

Конструктору класса CSingleDocTemplate передаются четыре параметра.

CSingleDocTemplate(UINT nIDResource, CRuntimeClass* pDocClass, CRuntimeClass* pFrameClass, CRuntimeClass* pViewClass);

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

Остальные три параметра pDocClass, pFrameClass, pViewClass содержат указатели на объекты класса CRuntimeClass, полученные с помощью макрокоманд RUNTIME_CLASS из классов документа CSingleDoc , окна CMainFrame и окна просмотра CSingleView . Таким образом, шаблон документа объединяет всю информацию, относящуюся к данному типу документов.

Созданный шаблон документов заносится в список шаблонов с которыми работает приложение. Для этого указатель на созданный шаблон документа передается методу AddDocTemplate из класса WinApp. Указатель на шаблон документов передается через параметр pTemplate.

void AddDocTemplate(CDocTemplate* pTemplate);

Указатель pTemplate указывает на объекты класса CDocTemplate. Однако мы передаем через него указатели на объекты класса CSingleDocTemplate. Это допустимо, так как класс CDocTemplate является базовым классом для CSingleDocTemplate.

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

После создания шаблона документа, обрабатывается командная строка приложения. Для этого создается объект cmdInfo класса CCommandLineInfo.

Объект cmdInfo передается методу ParseCommandLine, определенному в классе CWinApp. Он заполняет объект cmdInfo, данными, взятыми из командной строки приложения. Подготовленный объект cmdInfo передается методу ProcessShellCommand класса CWinApp для обработки.

Если обработка завершилась успешно, метод ProcessShellCommand возвращает ненулевое значение. Если при обработке командной строки приложения возникли ошибки, метод ProcessShellCommand возвращает нуль.

После успешной инициализации приложения и обработки командной строки метод InitInstance возвращает значение TRUE. Начинается обработка цикла сообщений.

Кроме конструктора и метода InitInstance в главном классе приложения CSingleApp определен метод OnAppAbout. Он расположен в блоке AFX_MSG. Поэтому для работы с этим методом вы можете использовать ClassWizard.

Метод OnAppAbout
Метод OnAppAbout вызывается для обработки командного сообщения ID_APP_ABOUT. Это сообщение поступает в очередь приложения, когда пользователь выбирает из меню Help строку About. Он создает объект класса CAboutDlg, представляющий модальную диалоговую панель и отображает ее на экране.

// Метод OnAppAbout

void CSingleApp::OnAppAbout() {

 CAboutDlg aboutDlg;

 aboutDlg.DoModal();

}

Описание класса CAboutDlg, а также определение его методов содержится в файле Single.cpp. Класс CAboutDlg приложения Single полностью соответствует классу CAboutDlg приложения Dialog, описанного в предыдущей главе. Мы не будем повторять описание класса CAboutDlg, вы можете самостоятельно найти его в листинге 4.4.

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

Класс CSingleDoc, несколько сложнее главного класса приложения, рассмотренного выше.

class CSingleDoc : public CDocument {

protected:

 CSingleDoc();

 DECLARE_DYNCREATE(CSingleDoc)


 // Attributes

public:


 // Operations

public:


 // Overrides

 //{{AFX_VIRTUAL(CSingleDoc)

public:

 virtual BOOL OnNewDocument();

 virtual void Serialize(CArchive& ar);

 //}}AFX_VIRTUAL


 // Implementation

public:

 virtual ~CSingleDoc();

#ifdef _DEBUG

 virtual void AssertValid() const;

 virtual void Dump(CDumpContext& dc) const;

#endif


protected:


 // Методы, предназначенные для обработки сообщений

protected:

 //{{AFX_MSG(CSingleDoc)

 //}}AFX_MSG

 DECLARE_MESSAGE_MAP()

};

Просмотрите исходные тексты приложения. Вы не обнаружите кода, который бы явно создавал объекты этого класса. Объект класса CSingleDoc создается динамически шаблоном документа, во время работы приложения. Шаблон документа также динамически создает еще два объекта – класса окна и класса окна просмотра.

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

• в описании класса надо поместить макрокоманду DECLARE_DYNCREATE. В качестве параметра этой макрокоманды необходимо указать имя данного класса;

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

• разместить макрокоманду IMPLEMENT_DYNCREATE в файле реализации. Макрокоманда IMPLEMENT_DYNCREATE имеет два параметра. В первом указывается имя класса, а во втором имя его базового класса


MFC AppWizard автоматически выполняет все эти требования для класса документа приложения CSingleDoc, класса окна приложения CMainFrame и класса окна просмотра CSingleView.

Таблица сообщений класса CSingleDoc
Макрокоманда IMPLEMENT_DYNCREATE размещается в файле реализации класса. Для класса CSingleDoc этот файл называется SingleDoc.cpp. Обычно MFC AppWizard размещает макрокоманду IMPLEMENT_DYNCREATE непосредственно перед таблицей сообщений класса (если конечно данные класс обрабатывает сообщения).

// Макрокоманда необходима для динамического создания объектов

// CSingleDoc

IMPLEMENT_DYNCREATE(CSingleDoc, CDocument)


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

BEGIN_MESSAGE_MAP(CSingleDoc, CDocument)

 //{{AFX_MSG_MAP(CSingleDoc)

 //}}AFX_MSG_MAP

END_MESSAGE_MAP()

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

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

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

CSingleDoc::CSingleDoc() {

 // TODO:

}

Вместе с конструктором класса CSingleDoc, создается деструктор ~CSingleDoc. Деструктор не содержит кода и представляет собой такую же заготовку как и конструктор.

// Деструктор класса CSingleDoc

CSingleDoc::~CSingleDoc() {}

Методы OnNewDocument и Serialize
В классе CSingleDoc переопределены два виртуальных метода OnNewDocument и Serialize. Виртуальный метод OnNewDocument определен в классе CDocument, от которого непосредственно наследуется класс CSingleDoc. А вот виртуальный метод Serialize определен в классе CObject. Цепочка наследования классов в этом случае длиннее:

CSingleDoc←CDocument←CCmdTarget←CObject

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

BOOL CSingleDoc::OnNewDocument() {

if (!CDocument::OnNewDocument()) return FALSE;

 // TODO: здесь можно выполнить инициализацию

 // документа

return TRUE;

}

Если создание нового документа прошло успешно, метод OnNewDocument должен вернуть значение TRUE, а в противном случае FALSE. Когда вызывается метод OnNewDocument базового класса CDocument, следует выполнять проверку возвращаемого им значения. Если CDocument::OnNewDocument вернет FALSE, значит создание документа на уровне класса CDocument не прошло и следует прекратить дальнейшие действия.

Большой интерес представляет метод Serialize. Он вызывается в тех случаях, когда надо загрузить документ из файла на диске или наоборот, записать его в файл. Метод Serialize вызывается, когда пользователь выбирает из меню File строки Open или Save.

//////////////////////////////////////////////////////////////

// Сохранение и восстановление документа

void CSingleDoc::Serialize(CArchive& ar) {

 if (ar.IsStoring()) {

  // TODO: здесь выполняется запись документа в файл

 } else {

  // TODO: здесь выполняется чтение документа из файла

 }

}

В качестве параметра ar методу Serialize передается объект класса CArchive, связанный с файлом в который надо записать или из которого надо прочитать документ.

Метод Serialize вызывается и для загрузки и для сохранения документа. Чтобы узнать, что надо делать с документом, используется метод IsStoring класса CArchive. Если он возвращает ненулевое значение, значит вы должны сохранить состояние документа в файле. В противном случае вы должны считать документ из файла. Боле подробно использование метода Serialize для сохранения и восстановления документов, описано в разделе “Запись и восстановление объектов” главы “Некоторые классы MFC”.

Методы AssertValid и Dump
Класс CSingleDoc содержит переопределения еще двух виртуальных методов – AssertValid и Dump, входящих в базовый класс CObject. Описание методов AssertValid и Dump вы можете найти в разделе “Класс CObject – основной класс MFC” главы “Некоторые классы MFC”.

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

//////////////////////////////////////////////////////////////

// Диагностические методы класса CSingleDoc

#ifdef _DEBUG

void CSingleDoc::AssertValid() const {

 CDocument::AssertValid();

}


void CSingleDoc::Dump(CDumpContext& dc) const {

 CDocument::Dump(dc);

}

#endif //_DEBUG

Класс CSingleView
Следующий класс, который мы рассмотрим, является классом окна просмотра документа CSingleView. Этот класс наследуется от базового класса CView библиотеки MFC. Определения класса CSingleView вы можете найти в файле SingleView.h.

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

Для этого определяется конструктор класса, не имеющий параметров, в определении класса указывается макрокоманда DECLARE_DYNCREATE, а в файле реализации макрокоманда IMPLEMENT_DYNCREATE.

class CSingleView : public CView {

protected:

 CSingleView();

 DECLARE_DYNCREATE(CSingleView)


 // Attributes

public:

 CSingleDoc* GetDocument();


 // Operations

public:


 // Overrides

 //{{AFX_VIRTUAL(CSingleView)

public:

 virtual void OnDraw(CDC* pDC);

 virtual BOOL PreCreateWindow(CREATESTRUCT& cs);

protected:

 virtual BOOL OnPreparePrinting(CPrintInfo* pInfo);

 virtual void OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo);

 virtual void OnEndPrinting(CDC* pDC, CPrintInfo* pInfo);

 //}}AFX_VIRTUAL


 // Implementation

public:

 virtual ~CSingleView();

#ifdef _DEBUG

 virtual void AssertValid() const;

 virtual void Dump(CDumpContext& dc) const;

#endif


protected:


 // Методы, предназначенные для обработки сообщений

protected:

 //{{AFX_MSG(CSingleView)

 //}}AFX_MSG

 DECLARE_MESSAGE_MAP()

};

Секция Overrides в описании класса CSingleView содержит описания переопределяемых виртуальных методов базового класса CView. Два метода описаны в ней как public – OnDraw и PreCreateWindow и три как protected – OnPreparePrinting, OnBeginPrinting, OnEndPrinting. Поэтому методы OnDraw и PreCreateWindow можно вызывать и из других классов приложения, а методы OnPreparePrinting, OnBeginPrinting, OnEndPrinting только из класса CSingleView.

Таблица сообщений класса CSingleView
Таблица сообщений класса CSingleView располагается в файле SingleView.cpp. Непосредственно перед ней находится макрокоманда IMPLEMENT_DYNCREATE.

// Объекты класса CSingleView могут создаваться динамически

IMPLEMENT_DYNCREATE(CSingleView, CView)


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

BEGIN_MESSAGE_MAP(CSingleView, CView)

 //{{AFX_MSG_MAP(CSingleView)

 //}}AFX_MSG_MAP

 // Стандартные команды предназначенные для печати документа

 ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)

 ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)

 ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)

END_MESSAGE_MAP()

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

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

CSingleView::CSingleView() {

 // TODO:

}

Вместе с конструктором класса CSingleView, MFC AppWizard определяет деструктор ~CSingleView. Сразу после создания проекта деструктор не выполняет никаких действий. В дальнейшем вы можете использовать его совместно с конструктором CSingleView.

// Деструктор класса CSingleView

CSingleView::~CSingleView() {}

Метод GetDocument
В секции атрибутов класса CSingleView после комментария Attributes объявлен метод GetDocument. Этот метод возвращает указатель на документ, связанный с данным окном просмотра. Если окно просмотра не связано ни с каким документом, метод возвращает значение NULL.

Интересно, что метод GetDocument имеет две реализации. Одна используется для отладочной версии приложения, а другая для окончательной.

Окончательная версия GetDocument определена непосредственно после самого класса окна просмотра CSingleView как встраиваемый (inline) метод. Когда вы используете страницу ClassView окна Project Workspace, чтобы просмотреть определение метода GetDocument, вы увидите именно этот код.

// Окончательная версия приложения

#ifndef _DEBUG

inline CSingleDoc* CSingleView::GetDocument() { return (CSingleDoc*)m_pDocument; }

#endif

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

// Отладочная версия приложения

#ifdef _DEBUG

CSingleDoc* CSingleView::GetDocument() {

 ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CSingleDoc)));

 return (CSingleDoc*)m_pDocument;

}

#endif //_DEBUG

Макрокоманда RUNTIME_CLASS возвращает указатель на структуру CRuntimeClass, содержащую информацию о классе CSingleDoc. Метод IsKindOf, определенный в классе CObject, проверяет, принадлежит ли объект, на который указывает m_pDocument, к классу CSingleDoc или классу наследованному от CSingleDoc. Если в приложении есть ошибка и m_pDocument не указывает на документ приложения, макрокоманда ASSERT отображает соответствующее сообщение и прерывает работу приложения.

Метод PreCreateWindow
Виртуальный метод PreCreateWindow определен в классе CWnd. Он вызывается непосредственно перед созданием окна, связанного с объектом класса. В качестве параметра cs этому методу передается структура CREATESTRUCT, определяющая характеристики создаваемого окна. Приложение может изменить данные, записанные в этой структуре, чтобы повлиять на внешний вид создаваемого окна.

Классы, наследованные от CWnd, в том числе CView и CFrameWnd, переопределяют этот метод, изменяя структуру cs. В следующей таблице описано назначение полей структуры CREATESTRUCT.

Поле структуры CREATESTRUCT Описание
lpCreateParams Указатель на данные, используемые при создании окна
hInstance Идентификатор приложения
hMenu Идентификатор меню
hwndParent Идентификатор родительского окна. Содержит NULL, если окно не имеет родительского окна
cy Высота окна
cx Ширина окна
y Определяет y-координату верхнего левого угла окна. Для дочерних окон координаты задаются относительно родительского окна. Для родительского окна координаты указываются в экранной системе координат
x Определяет x-координату верхнего левого угла окна. Координаты задаются также как и для поля y
style Стиль класса
lpszName Указатель на строку, закрытую двоичным нулем, в которой находится имя окна
lpszClass Имя класса окна (смотри том 11 из серии “Библиотека системного программиста”)
dwExStyle Дополнительные стили окна

MFC AppWizard переопределяет для вас метод PreCreateWindow, но не вносит в структуру cs никаких изменений и вызывает метод PreCreateWindow базового класса CView.

BOOL CSingleView::PreCreateWindow(CREATESTRUCT& cs) {

 // TODO: Здесь вы можете внести изменения в структуру cs


 // Вызов метода PreCreateWindow базового класса CView

 return CView::PreCreateWindow(cs);

}

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

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

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

BOOL IsPrinting() const;

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

MFC AppWizard переопределяет для вас метод OnDraw класса CView следующим образом:

 void CSingleView::OnDraw(CDC* pDC) {

 CSingleDoc* pDoc = GetDocument();

 ASSERT_VALID(pDoc);


 // TODO: Здесь вы можете расположить код, для отображения

 // данных в контексте устройства pDC

}

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

Методы OnPreparePrinting, OnBeginPrinting и OnEndPrinting
Виртуальные методы OnPreparePrinting, OnBeginPrinting и OnEndPrinting, определенные в классе CView, вызываются, если пользователь желает распечатать документ, отображенный в данном окне просмотра.

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

//////////////////////////////////////////////////////////////

// Методы используемые для печати документов

BOOL CSingleView::OnPreparePrinting(CPrintInfo* pInfo) {

 // Выполняется обработка по умолчанию

 return DoPreparePrinting(pInfo);

}


void CSingleView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/) {

 // TODO: здесь можно выполнить дополнительную инициализацию

 // перед печатью документа

}


void CSingleView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/) {

 // TODO: здесь можно выполнить действия после печати

 // документа

}

Методы AssertValid и Dump
Во время отладки приложения в состав класса CSingleView включаются переопределения виртуальных методов AssertValid и Dump. Эти методы определены в базовом классе CObject и используются при отладке приложения. Когда выполняется окончательное построение приложения, эти методы не переопределяются.

//////////////////////////////////////////////////////////////

// Диагностические методы класса CSingleView

#ifdef _DEBUG

void CSingleView::AssertValid() const {

 CView::AssertValid();

}


void CSingleView::Dump(CDumpContext& dc) const {

 CView::Dump(dc);

}

#endif //_DEBUG

Класс CMainFrame
Класс CMainFrame представляет главное окно нашего приложения. Внутри этого окна отображаются окно просмотра документа, а также панели управления и состояния. Определение класса CMainFrame расположено в файле MainFrm.h.

Класс CMainFrame наследуется от базового класса CFrameWnd, определенного в библиотеке MFC. Как правило у программиста не возникает необходимости как-либо дорабатывать класс главного окна приложения, созданный MFC AppWizard.

class CMainFrame : public CFrameWnd {

protected:

 CMainFrame();

 DECLARE_DYNCREATE(CMainFrame)


 // Attributes

public:


 // Operations

public:


 // Overrides

 //{{AFX_VIRTUAL(CMainFrame)

 virtual BOOL PreCreateWindow(CREATESTRUCT& cs);

 //}}AFX_VIRTUAL


 // Implementation

public:

 virtual ~CMainFrame();

#ifdef _DEBUG

 virtual void AssertValid() const;

 virtual void Dump(CDumpContext& dc) const;

#endif


protected:

 // Панель управления и панель состояния

 CStatusBar m_wndStatusBar;

 CToolBar m_wndToolBar;


 // Методы, предназначенные для обработки сообщений

protected:

 //{{AFX_MSG(CMainFrame)

 afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);

 //}}AFX_MSG

 DECLARE_MESSAGE_MAP()

};

Шаблон документов приложения создает объекты класса CMainFrame динамически. Для этого в определении класса указана макрокоманда DECLARE_DYNCREATE, объявлен конструктор, не имеющий параметров, а в файле реализации добавлена макрокоманда IMPLEMENT_DYNCREATE.

// Объекты класса CMainFrame могут создаваться динамически

IMPLEMENT_DYNCREATE(CMainFrame, CFrameWnd)

Таблица сообщений класса CMainFrame
Класс CMainFrame может получать и обрабатывать сообщения, поэтому в определении класса указана макрокоманда DECLARE_MESSAGE_MAP, а в файле реализации класса MainFrm.cpp, расположена таблица сообщений.

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

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)

 //{{AFX_MSG_MAP(CMainFrame)

 ON_WM_CREATE()

 //}}AFX_MSG_MAP

END_MESSAGE_MAP()

Изначально в таблице сообщений расположена единственная макрокоманда ON_WM_CREATE. Эта макрокоманда устанавливает для обработки сообщения WM_CREATE метод OnCreate. Как вы знаете, сообщение WM_CREATE передается функции окна сразу после его создания, но до того, как окно появится на экране.

Конструктор и деструктор класса CMainFrame
MFC AppWizard определяет для вас конструктор и деструктор класса CMainFrame. Вы можете расположить в конструкторе и деструкторе CMainFrame код для инициализации объектов класса.

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

CMainFrame::CMainFrame() {

// TODO:

}


// Деструктор класса CMainFrame

CMainFrame::~CMainFrame() {}

Метод OnCreate
Метод OnCreate определен в классе CWnd следующим образом.

afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);

Параметр lpCreateStruct содержит указатель на объект CREATESTRUCT, содержащий характеристики создаваемого окна. Эта структура уже была нами описана ранее.

При нормальной работе OnCreate должен вернуть значение 0, чтобы продолжить создание окна. Если OnCreate возвращает –1, окно будет удалено (уничтожено).

MFC AppWizard переопределяет метод OnCreate в классе CMainFrame. Поэтому для обработки сообщения WM_CREATE будет вызван именно переопределенный метод OnCreate класса CMainFrame.

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct) {

 // Вызываем метод OnCreate базового класса

 if (CFrameWnd::OnCreate(lpCreateStruct) == –1) return –1;


 // Создаем панель управления toolbar

 if (!m_wndToolBar.Create(this) || !m_wndToolBar.LoadToolBar(IDR_MAINFRAME)) {

  // Ошибка при создании панели управления toolbar

  TRACE0("Failed to create toolbar\n");

  return –1;

 }


 // Создаем панель состояния status bar

 if (!m_wndStatusBar.Create(this) || !m_wndStatusBar.SetIndicators(indicators, sizeof(indicators)/sizeof(UINT))) {

  // Ошибка при создании панели состояния status bar

  TRACE0("Failed to create status bar\n");

  return –1;

 }


 // TODO: вы можете изменить характеристики панели

 // управления, убрав некоторыефлаги CBRS_

 m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);


 // TODO: вы можете запретить перемещение панели управления,

 // если удалите следующие три строки программы

 m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);

 EnableDocking(CBRS_ALIGN_ANY);

 DockControlBar(&m_wndToolBar);


 return 0;

}

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

Метод OnCreate базового класса CFrameWnd выполняет обработку сообщения WM_CREATE по умолчанию и возвращает нулевое значение если обработка прошла без ошибок.

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

Панель управления и панель состояния
Наиболее интересная задача, которую выполняет метод OnCreate, заключается в отображении панелей управления и состояния. Для панели управления и панели состояния в библиотеке классов MFC предусмотрены два класса CStatusBar и CToolBar.

Классы CStatusBar и CToolBar имеют длинную цепочку наследования.

CStatusBar←|←CControlBar←CWnd←CmdTarget←CObject

CToolBar  ←|

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

Панель управления
Класс CToolBar представляет панель управления toolbar. Обычно панель управления содержит несколько кнопок и разделителей между ними. Для панели управления определен специальный ресурс типа Toolbar.

Чтобы создать панель управления toolbar, следует выполнить следующие действия.

• Создать ресурс, описывающий панель toolbar

• Создать объект класса CToolBar. Он будет представлять панель управления

• Вызвать метод Create класса CToolBar, чтобы создать панель и связать ее с объектом представляющим панель управления

• Вызвать метод LoadToolBar класса CToolBar. Он загрузит ресурс диалоговой панели и завершит построение панели управления

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

Объект m_wndToolBar класса CToolBar для управления этой панелью определяется в классе CMainFrame. Этот объект объявлен как protected, поэтому обращаться к нему можно только из класса главного окна приложения CMainFrame.

protected:

CToolBar m_wndToolBar;

Создание самой панели управления и отображение ее на экране выполняется во время обработки метода OnCreate класса CMainFrame. При этом методы Create и LoadToolBar вызываются в одной строке.

if (!m_wndToolBar.Create(this) || !m_wndToolBar.LoadToolBar(IDR_MAINFRAME)) {

 // Ошибка при создании панели управления toolbar

 TRACE0("Failed to create toolbar\n");

 return –1;

}

В качестве родительского окна панели управления методу Create указано ключевое слово this. Таким образом, родительским окном является главное окно приложения, представленное объектом класса CMainFrame.

После создания панели управления сразу вызывается метод LoadToolBar, загружающий ресурс панели управления IDR_MAINFRAME. Если хотя бы один метод – Create или LoadToolBar, завершится с ошибкой, метод OnCreate класса CMainFrame возвращает –1.

Панель состояния
Для управления панелью состояния используется класс CStatusBar. Чтобы создать для окна панель состояния следует выполнить следующие действия.

• Создать объект класса CStatusBar . Он будет представлять панель состояния и управлять ей

• Вызвать метод Create класса CStatusBar, чтобы создать панель и связать ее с объектом представляющим панель состояния

• Вызвать метод SetIndicators класса CStatusBar, чтобы связать каждый индикатор панели состояния с идентификатором текстовой строки


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

Объект m_wndStatusBar класса CStatusBar определяется как элемент класса CMainFrame. Это вполне естественно, так как панель состояния принадлежит именно окну класса CMainFrame.

protected:

 CStatusBar m_wndStatusBar;

Создание панели состояния и отображение ее на экране выполняется во время обработки метода OnCreate класса CMainFrame сразу после создания панели управления.

Методы Create и SetIndicators, создающие панель, вызываются в одной строке.

// Создаем панель status bar

if (!m_wndStatusBar.Create(this) || !m_wndStatusBar.SetIndicators(indicators, sizeof(indicators)/sizeof(UINT))) {

 // Ошибка при создании панели состояния status bar

 TRACE0("Failed to create status bar\n");

 return –1;

}

В качестве родительского окна панели состояния методу Create указано ключевое слово this. Таким образом, родительским окном панели состояния, также как и панели управления, является главное окно приложения, представленное объектом класса CMainFrame.

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

В нашем приложении массив indicators, описывающий панель состояния, определен в файле MainFrm.cpp непосредственно после таблицы сообщений.

static UINT indicators[] = {

 ID_SEPARATOR,

 ID_INDICATOR_CAPS,

 ID_INDICATOR_NUM,

 ID_INDICATOR_SCRL,

};

Сразу после создания панели состояния вызывается метод SetIndicators. В первом параметре ему передается массив indicators, а во втором – количество элементов в этом массиве.

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

После создания панели управления toolbar метод SetBarStyle класса CControlBar устанавливает различные стили этой панели. Стили определяются одной или несколькими константами CBRS_.

Константа Описание
CBRS_ALIGN_TOP Панель управления может закрепляться в верхней части окна
CBRS_ALIGN_BOTTOM Панель управления может закрепляться в нижней части окна
CBRS_ALIGN_LEFT Панель управления может закрепляться на левой стороне окна
CBRS_ALIGN_RIGHT Панель управления может закрепляться на правой стороне окна
CBRS_ALIGN_ANY Панель управления может закрепляться с любой стороны окна
CBRS_FLOAT_MULTI Несколько панелей управления могут объединяться вместе в одном мини-окне
CBRS_TOOLTIPS Когда пользователь устанавливает курсор на органы управления панели toolbar, их названия отображаются в маленькой прямоугольной рамке tool tips. Более подробно о tool tips вы можете прочитать в томе 22 серии “Библиотека системного программиста”
CBRS_FLYBY Текст в панели состояния изменяется, одновременно с отображением tool tips. В противном случае текст в панели состояния меняется только когда пользователь нажмет кнопку в панели управления
CBRS_SIZE_DYNAMIC Когда панель управления отображается в окне, пользователь может изменять ее размеры. При этом органы управления панели будут отображаться в нескольких строках. Этот стиль доступен только для Visual C++ версии 4.0 и выше
По умолчанию MFC AppWizard устанавливает для панели управления стили CBRS_TOOLTIPS, CBRS_FLYBY, CBRS_SIZE_DYNAMIC. Вы можете изменить их по своему усмотрению.

m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);

Чтобы панель управления могла отображаться в собственном маленьком окне, не прикрепленном ни к одной стороне родительского окна, два раза вызываются метод EnableDocking – для панели управления и для главного окна приложения. Затем вызывается метод DockControlBar для главного окна приложения.

m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);

EnableDocking(CBRS_ALIGN_ANY);

DockControlBar(&m_wndToolBar);

Метод PreCreateWindow
MFC AppWizard переопределяет для класса CMainFrame виртуальный метод PreCreateWindow, но не вносит в структуру cs никаких изменений и вызывает метод PreCreateWindow базового класса CFrameWnd.

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs) {

 // TODO: Здесь вы можете внести изменения в структуру cs

 return CFrameWnd::PreCreateWindow(cs);

}

Методы AssertValid и Dump
Когда вы выполняете построение отладочной версии приложения, в состав класса CMainFrame включаются переопределения виртуальных методов AssertValid и Dump. Эти методы определены в базовом классе CObject и используются при отладке приложения.

Когда отладочный режим отключен, символ _DEBUG не определен и поэтому методы AssertValid и Dump класса CObject не переопределяются.

//////////////////////////////////////////////////////////////

// Диагностические методы класса CMainFrame

#ifdef _DEBUG

void CMainFrame::AssertValid() const {

 CFrameWnd::AssertValid();

}


void CMainFrame::Dump(CDumpContext& dc) const {

 CFrameWnd::Dump(dc);

}

#endif //_DEBUG

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

Обработка командных сообщений

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

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

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

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

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

Порядок обработки сообщений

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

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

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

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

Окно просмотра
В отличие от объектов, представляющих окна типа frame (объекты классов CFrameWnd, CMDIFrameWnd и CMDIChildWnd) окно просмотра в первую очередь проверяет собственную таблицу сообщений. И только в том случае, если командное сообщение не может быть обработано, оно передается документу, связанному с данным окном просмотра. Последовательность обработки командных сообщений документом представлена ниже.

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

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

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

Если родительское окно диалоговой панели также не может обработать командное сообщение, оно передается главному объекту приложения.

Командные сообщения и приложение Single

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

Главное окно приложения сразу передает командное сообщение для обработки окну просмотра. Окно просмотра представлено объектом класса CSingleView.

Если класс окна просмотра не имеет метода для обработки сообщения, оно передается документу. Документ приложения Single является объектом класса CSingleDoc.

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

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

Если и главное окно приложения не может обработать поступившее командное сообщение, оно направляется объекту главного класса приложения CSingleApp.

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

Порядок обработки командных сообщений определяется виртуальным методом OnCmdMsg. Этот метод первоначально определен в классе CCmdTarget и переопределен в классах CFrameWnd, CView, CDocument и некоторых других классах MFC.

В ряде случаев может понадобиться изменить порядок, в котором командные сообщения передаются объектам приложения или ввести новый объект в цепочке стандартных объектов. В этом случае вы должны переопределить виртуальный метод OnCmdMsg соответствующим образом. В качестве примера использования метода OnCmdMsg вы можете взять класс CView. Если вы установили Visual C++ с исходными текстами библиотеки MFC, вы можете найти определение этого метода в файле Viewcore.cpp.

Стандартные команд ные сообщения

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

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

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

Ниже коротко описаны наиболее важные стандартные командные сообщения.

Командные сообщения с идентификаторами ID_FILE_
Командные сообщения с идентификаторами ID_FILE_ соответствуют элементам меню File приложений, созданных при помощи средств MFC AppWizard. Обработчики этих сообщений входят в состав различных классов MFC, в том числе CWinApp и CDocument.

Идентификатор командного сообщения Описание
ID_FILE_NEW Создать новый документ. Класс CWinApp содержит стандартный обработчик этого сообщения – метод OnFileNew. Если вы желаете его использовать, необходимо поместить в таблицу сообщений главного класса приложения соответствующую макрокоманду (см. приложение Single)
ID_FILE_OPEN Открыть документ, записанный на диске. Класс CWinApp содержит стандартный обработчик этого сообщения – метод OnFileOpen. Если вы желаете его использовать, необходимо поместить в таблицу сообщений главного класса приложения соответствующую макрокоманду (см. приложение Single)
ID_FILE_CLOSE Закрыть текущий документ. Класс CDocument содержит метод OnFileClose, предназначенный для обработки этого командного сообщения. Метод OnFileClose вызывает метод SaveModified, если документ приложения был изменен, а затем вызывает метод OnCloseDocument
ID_FILE_SAVE Сохранить текущий документ. За обработку этого командного сообщения отвечает метод OnSaveDocument класса CDocument
ID_FILE_SAVE_AS Сохранить текущий документ под новым именем. За обработку этого командного сообщения отвечает метод OnSaveDocument класса CDocument
ID_FILE_SAVE_COPY_AS Сохранить копию текущего документа под новым именем
ID_FILE_PAGE_SETUP Вызывает диалоговую панель выбора формата документа
ID_FILE_PRINT_SETUP Вызвать диалоговую панель для настройки принтера
ID_FILE_PRINT Выполнить печать текущего документа
ID_FILE_PRINT_PREVIEW Перейти в режим предварительного просмотра документа перед печатью
ID_FILE_MRU_FILE1…FILE16 Открыть один из наиболее часто используемых файлов приложения
Командные сообщения с идентификаторами ID_EDIT_
Командные сообщения с идентификаторами ID_EDIT_ соответствуют элементам меню Edit приложений, созданных при помощи средств MFC AppWizard. Это меню обычно используется для выполнения различных операций над документом, отображаемым в окне просмотра.

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

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

Идентификатор командного сообщения Описание
ID_EDIT_CLEAR Удалить выделенный объект
ID_EDIT_CLEAR_ALL Удалить содержимое документа
ID_EDIT_COPY Скопировать выделенный объект в универсальный буфер обмена clipboard
ID_EDIT_CUT Удалить выделенный объект и записать его в clipboard
ID_EDIT_FIND Отобразить на экране диалоговую панель для поиска заданного объекта в документе
ID_EDIT_PASTE Вставить в документ содержимое Clipboard
ID_EDIT_REPEAT Повторить последнюю операцию
ID_EDIT_REPLACE Отобразить диалоговую панель для поиска и замены текста
ID_EDIT_SELECT_ALL Выбрать (выделить) весь документ
ID_EDIT_UNDO Отменить последнюю операцию
ID_EDIT_REDO Выполнить последнюю отмененную операцию
Командные сообщения с идентификаторами ID_WINDOW_
Командные сообщения с идентификаторами ID_WINDOW_ соответствуют элементам меню Window многооконных приложений, созданных при помощи средств MFC AppWizard. Обработка этих командных сообщений возложена на метод OnMDIWindowCmd класса CMDIFrameWnd.

Идентификатор командного сообщения Описание
ID_WINDOW_NEW Открыть новое окно с текущим документом
ID_WINDOW_ARRANGE Выровнять пиктограммы в нижней части окна MDI
ID_WINDOW_CASCADE Выполнить каскадное размещение окон
ID_WINDOW_TILE_HORZ Расположить окна рядом по горизонтали
ID_WINDOW_TILE_VERT Расположить окна рядом по вертикали
ID_WINDOW_SPLIT Разделить окно на две части
Командные сообщения с идентификаторами ID_APP_
В MFC определены только два командных сообщения с идентификаторами ID_APP_. Они предназначены для завершения приложения и вывода информации о приложении и его авторе.

Идентификатор командного сообщения Описание
ID_APP_EXIT Завершить приложение. Данное командное сообщение обрабатывается методом OnAppExit класса CWinApp. Метод OnAppExit передает сообщение WM_CLOSE главному окну приложения
ID_APP_ABOUT Отобразить на экране краткую справку о программе – диалоговую панель About. Ни один из классов MFC не выполняет обработки этого сообщения по умолчанию, но MFC AppWizard автоматически создает необходимый для этого программный код
Командные сообщения с идентификаторами ID_HELP_
Командные сообщения с идентификаторами ID_HELP_ используются справочной системой приложения.

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

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

Идентификатор командного сообщения Описание
ID_HELP_INDEX Отобразить список статей из справочной базы данных, записанной в HLP-файле
ID_HELP_USING Отобразить подсказку об использовании справочной системы
ID_CONTEXT_HELP Перейди в режим контекстной подсказки. Передается также при нажатии комбинации клавиш <Shift+F1>
ID_HELP Получить справочную информацию по данному контексту
ID_DEFAULT_HELP Получить справочную информацию определенную по умолчанию для данного контекста
Командные сообщения с идентификаторами ID_VIEW_
Командные сообщения с идентификаторами ID_VIEW_ соответствуют элементам меню View приложений, созданных при помощи средств MFC AppWizard. За обработку командных сообщений ID_VIEW_ отвечает класс CFrameWnd.

Идентификатор командного сообщения Описание
ID_VIEW_TOOLBAR Отобразить или скрыть панель управления toolbar
ID_VIEW_STATUS_BAR Отобразить или скрыть панель состояния status bar
Описание стандартных команд и методов, предназначенных для их обработки, вы можете получить из справочной системы Visual C++. В следующих книгах серии “Библиотека системного программиста” мы изучим наиболее важные стандартные командные сообщения более подробно.

Простейший графический редактор

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

За основу нашего нового приложения мы возьмем проект Single и внесем в него все необходимые исправления и добавления. Доработаем приложение Single так, что когда пользователь нажимает левую клавишу мыши в окне отображается окружность, а когда пользователь нажимает правую кнопку – то отображается квадрат.

В момент нажатия на клавиши мыши создаются соответствующие сообщения, которые передаются классу окна просмотра. Нажатие левой клавиши мыши вызывает сообщение WM_LBUTTONDOWN, а нажатие правой – сообщение WM_RBUTTONDOWN.

Чтобы класс окна просмотра CSingleView мог отреагировать на это сообщение, вы должны создать метод для его обработки. Лучше всего для этого воспользоваться средствами ClassWizard.

Откройте страницу Message Maps на панели ClassWizard. Выберите из списков Class name и Object IDs класс CSingleView. В списке Messages появится названия виртуальных методов, которые вы можете переопределить и сообщений, для которых можно создать методы обработки.

Выберите из списка Messages сообщение WM_LBUTTONDOWN и нажмите кнопку Add Function. ClassWizard добавляет новую строку в таблицу сообщений класса CSingleView, вставляет в класс описание нового метода обработчика сообщения и создает шаблон этого метода.

Нажмите кнопку Edit Code. В окне редактирования появится шаблон метода, предназначенного для обработки сообщения WM_LBUTTONDOWN.

void CSingleView::OnLButtonDown(UINT nFlags, CPoint point) {

 // TODO: Здесь вы можете разместить код метода


 CView::OnLButtonDown(nFlags, point);

}

Название этого метода ClassWizard выбирает автоматически на основе сообщения WM_LBUTTONDOWN. Для этого префикс WM_ в названии сообщения заменяется префиксом On и происходит замена некоторых прописных букв строчными.

Шаблон метода OnLButtonDown содержит вызов метода OnLButtonDown базового класса CView. Вы должны добавить свой код перед вызовом этого метода, сразу после коментария // TODO:.

void CSingleView::OnLButtonDown(UINT nFlags, CPoint point) {

 // TODO: Здесь вы можете разместить код метода

 CClientDC dc(this);

 dc.Ellipse(point.x-10, point.y-10, point.x+10,point.y+10);


 CView::OnLButtonDown(nFlags, point);

}

Чтобы нарисовать в окне просмотра окружность, сначала необходимо получить контекст отображения. Для этого создается объект dc класса CClientDC. Конструктору передается указатель this, который указывает на объект класса CSingleView.

Затем вызывается метод Ellipse, который и отображает на экране небольшую окружность с центром, совпадающим с координатами указателя мыши.

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

void CSingleView::OnRButtonDown(UINT nFlags, CPoint point) {

 // TODO: Здесь вы можете разместить код метода

 CClientDC dc(this);

 dc.Rectangle(point.x-10, point.y-10, point.x+10,point.y+10);


 CView::OnRButtonDown(nFlags, point);

}

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

Рис. 5.13. Отображение фигур в окне приложения Single


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

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

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

Создадим новый класс CFigure, который будет представлять геометрические фигуры – окружности и квадраты. Координаты этих фигур мы будем определять по координатам их центра. Для этого в состав класса включим элемент xyFigCenter класса CPoint. Класс CPoint определяет координаты точки и содержит два элемента x и y, соответствующие координатам точки по оси ординат и абсцисс. Краткое описание класса CPoint представлено в разделе “Класс CPoint – точка на плоскости” главы “Некоторые классы MFC”.

Второй элемент cType типа char определяет форму геометрической фигуры. Если cType содержит значение 'E' значит данный объект представляет окружность, а если 'R' – квадрат.

Вы можете создать для класса CFigure отдельный файл, но сейчас мы просто добавим его в самое начало файла SingleDoc.h. Вот определение класса CFigure.

//////////////////////////////////////////////////////////////

// Класс определяет геометрическую фигуру

class CFigure {

public:

 // Координаты центра фигуры

 CPoint xyFigCenter;


 // Тип фигуры: 'E' – оокружность, 'R' – кволрат

 char cType;

};

Один объект класса CFigure представляет одну геометрическую фигуру. Так как документ нашего приложения может содержать несколько фигур, мы воспользуемся шаблоном CArray, чтобы определить массив объектов класса CFigure. Вы можете получить дополнительную информацию о шаблоне CArray в разделе “Коллекции” главы “Некоторые классы MFC”.

Определение этого массива, который получил название arrayFig, помещаем в класс документа CSingleDoc, в атрибутах класса.

//////////////////////////////////////////////////////////////

// Класс CSingleDoc

class CSingleDoc : public CDocument {

protected:

 CSingleDoc();

 DECLARE_DYNCREATE(CSingleDoc)


 // Attributes

public:

 CArray<CFigure, CFigure&> arrayFig;

Если вы используете шаблоны классов CArray, CMap или CList, вы должны включить в исходный текст приложения файл afxtempl.h. В данном файле содержатся определения этих шаблонов.

Так как мы работаем с объектами класса CArray в различных файлах, удобнее всего включить его в самом конце файла stdafx.h.

// Включаемый файл stdafx.h

// …

// Включаемый файл для шаблона CArray

#include <afxtempl.h>

Теперь у нас есть структура для хранения геометрических фигур, нарисованных в окне. Мы должны ее заполнить. Так как за взаимодействие с пользователем отвечает класс окна просмотра, мы изменяем определенные нами ранее методы OnLButtonDown и OnRButtonDown таким образом, чтобы одновременно с выводом на экран они сохраняли параметры новой фигуры в массиве arrayFig.

//////////////////////////////////////////////////////////////

// Метод OnLButtonDown класса CSingleView

// Обрабатывает сообщения левой кнопки мыши


void CSingleView::OnLButtonDown(UINT nFlags, CPoint point) {

 // Получаем указатель на документ (объект класса CSingleDoc)

 CSingleDoc* pDoc = GetDocument();


 // Проверяем указатель pDoc

 ASSERT_VALID(pDoc);


 // Отображаем на экране окружность

 CClientDC dc(this);

 dc.Ellipse(point.x-10, point.y-10, point.x+10, point.y+10);


 // Сохраняем характеристики окружности

 CFigure OneFigure;

 OneFigure.xyFigCenter = point;

 OneFigure.cType = 'E';


 // Добавляем к массиву, определяющему документ, новый

 // элемент

 pDoc->arrayFig.Add(OneFigure);


 // Вызываем метод OnLButtonDown базового класса CView

 CView::OnLButtonDown(nFlags, point);

}


//////////////////////////////////////////////////////////////

// Метод OnRButtonDown класса CSingleView

// Обрабатывает сообщения правой кнопки мыши


void CSingleView::OnRButtonDown(UINT nFlags, CPoint point) {

 // Получаем указатель на документ (объект класса CSingleDoc)

 CSingleDoc* pDoc = GetDocument();


 // Проверяем указатель pDoc

 ASSERT_VALID(pDoc);


 // Отображаем на экране квадрат

 CClientDC dc(this);

 dc.Rectangle(point.x-10, point.y-10, point.x+10, point.y+10);


 // Сохраняем характеристики квадрата

 CFigure OneFigure;

 OneFigure.xyFigCenter = point;

 OneFigure.cType = 'R';


 // Добавляем к массиву, определяющему документ, новый

 // элемент

 pDoc->arrayFig.Add(OneFigure);


 // Вызываем метод OnRButtonDown базового класса CView

 CView::OnRButtonDown(nFlags, point);

}

Теперь координаты и форма всех нарисованных фигур запоминаются в классе документа. Следующим шагом надо определить, как отображать эти фигуры на экране. Для этого следует внести изменения в метод OnDraw класса окна просмотра CSingleView.

//////////////////////////////////////////////////////////////

// Метод OnDraw класса окна просмотра


void CSingleView::OnDraw(CDC* pDC) {

 CSingleDoc* pDoc = GetDocument();

 ASSERT_VALID(pDoc);


// TODO:


 int i;

 for (i=0; i<pDoc->arrayFig.GetSize(); i++) {

  if (pDoc->arrayFig[i].cType == 'E') pDC->Ellipse(pDoc->arrayFig[i].xyFigCenter.x-10, pDoc->arrayFig[i].xyFigCenter.y-10, pDoc->arrayFig[i].xyFigCenter.x+10, pDoc->arrayFig[i].xyFigCenter.y+10);

  else if (pDoc->arrayFig[i].cType == 'R') pDC->Rectangle(pDoc->arrayFig[i].xyFigCenter.x-10, pDoc->arrayFig[i].xyFigCenter.y-10, pDoc->arrayFig[i].xyFigCenter.x+10, pDoc->arrayFig[i].xyFigCenter.y+10);

 }

}

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

Вы даже можете распечатать нарисованный документ на принтере. А ведь вы не написали для этого не единой строки кода. Перед печатью документа его можно проверить в режиме предварительного просмотра (рис. 5.14). Для этого выберите из меню File строку Print Preview.

Рис. 5.14. Режим предварительного просмотра документа перед печатью

Создание нового документа

Документ, который вы можете создать в приложении Single, можно убрать, только полностью закрыв приложение. Функция создания нового документа не работает. Когда вы выбираете из меню File строку New или нажимаете кнопку , расположенную в панели управления приложения, внешний вид документа не изменяется.

Оказывается, когда пользователь выбирает из меню File строку New, вызывается виртуальный метод OnNewDocument, определенный в классе CDocument. Если вы не переопределите этот метод, то по умолчанию он вызывает метод DeleteContents, и далее помечает его как чистый (пустой). Вы можете переопределить метод OnNewDocument в своем классе документа, чтобы выполнить его инициализацию. Требуется, чтобы вы вызывали из переопределенного метода OnNewDocument, метод OnNewDocument, определенный в базовом классе CDocument.

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

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

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

//////////////////////////////////////////////////////////////

// Метод DeleteContents

void CSingleDoc::DeleteContents() {

 // TODO:

 // Очищаем документ, удаляя все элементы массива arrayFig.

 // Метод RemoveAll определен в классе CArray

 arrayFig.RemoveAll();


 // Вызываем метод DeleteContents базового класса CDocument

 CDocument::DeleteContents();

}

Сохранение и восстановление документа на диске

Построенное вами приложение можно использовать для рисования и печати документов, но оно не позволяет сохранять и загружать документ из файла на диске. Вы можете выбрать строку Save As (сохранить под именем) из меню File. На экране появится диалоговая панель Save As. В этой панели вы можете ввести имя файла, в котором надо сохранить документ. Однако несмотря на то, что файл создается, документ в него не записывается – файл остается пустым.

Вы можете попытаться его открыть, выбрав из меню File строку Open. Однако единственным результатом будет изменение заголовка окна. Чтобы приложение обрело возможность сохранения документов в файле и последующего чтения, надо изменить метод Serialize класса документа CSingleDoc.

Метод Serialize вызывается всякий раз когда надо сохранить документ в файле на диске или загрузить его из существующего файла. В частности, метод Serialize вызывается, когда пользователь выбирает из меню File строки Save, Save As и Open. Основные принципы работы метода Serialize были рассмотрены нами в разделе “Запись и восстановление объектов”.

MFC AppWizard подготавливает шаблон метода Serialize для класса CSingleDoc, представляющего документ приложения.

//////////////////////////////////////////////////////////////

// Метод Serialize класса CSingleDoc отвечает за сохранение и

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


void CSingleDoc::Serialize(CArchive& ar) {

 if (ar.IsStoring()) {

  // TODO: Здесь выполняется сохранение документа

 } else {

  // TODO: Здесь выполняется загрузка документа

 }

}

Вы должны определить в методе Serialize, как он должен сохранять и восстанавливать документы приложения. Так как документ, с которым работает наше приложение представлен классом CSingleDoc, то все что должен делать метод Serialize – это сохранять все элементы массива arrayFig.

//////////////////////////////////////////////////////////////

// Метод Serialize класса CSingleDoc


void CSingleDoc::Serialize(CArchive& ar) {

 int i; // временная переменная

 int num; // количество фигур в документе


 // Сохранение документа

 if (ar.IsStoring()) {

  // Определяем количество элементов массива arrayFig

  num = arrayFig.GetSize();


  // Записываем полученное число в файл

  ar << num;


  // Записываем в файл координаты и тип фигур

  for (i=0; i<num; i++) {

   // Сохраняем координаты центра фигуры

   ar << arrayFig[i].xyFigCenter;

   // Сохраняем тип фигуры

   ar << arrayFig[i].cType;

  }

 }


 // Загрузка документа

 else {

  // Считываем количество элементов, составляющих документ

  ar >> num;


  // Восстанавливаем документ

  for (i=0; i<num; i++) {

   CFigure OneFigure; // описание одной фигуры


   // Считываем координаты центра фигуры

   ar >> OneFigure.xyFigCenter;

   // Считываем тип фигуры

   ar >> OneFigure.cType;


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

   arrayFig.Add(OneFigure);

  }

 }

}

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

После вызова, метод Serialize определяет, какую операцию надо выполнить – сохранить документ в файле или загрузить его из файла. Для этого используется метод IsStoring, определенный в классе CArchive. Если метод IsStoring возвращает ненулевое значение для объекта ar, переданного методу Serialize, значит надо сохранить документ в файле.

Чтобы сохранить все элементы массива, мы определяем количество элементов в нем с помощью метода GetSize. Этот метод определен в шаблоне CArray и возвращает количество элементов массива.

Мы сохраняем количество элементов массива в файле, представленном архивом ar. Это значение поможет нам при восстановлении документа с файла на диске. Затем в цикле в файл записываются все элементы массива arrayFig.

Загрузка документа из файла выполняется в том же порядке. Сначала из файла документа, представленного архивом ar считывается значение, определяющее количество фигур в документе. Потом из файла считываются по очереди все элементы документа. При этом они сразу заносятся в массив arrayFig, представляющий документ. Для этого используется метод Add шаблона CArray.

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

Для забывчивых пользователей

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

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

void SetModifiedFlag(BOOL bModified = TRUE);

Если документ изменен, установите флаг модификации, вызвав метод SetModifiedFlag с параметром bModified, равным TRUE или без параметра. В случае необходимости вы можете убрать установленный флаг. Для этого надо вызвать метод SetModifiedFlag с параметром bModified, равным FALSE.

Мы должны добавить вызов метода SetModifiedFlag в методах OnLButtonDown и OnRButtonDown, выполняющих модификацию документа. Вызов метода можно разместить в любом месте, например, сразу после добавления к массиву arrayFig, представляющему документ, нового элемента.

//////////////////////////////////////////////////////////////

// Метод OnLButtonDown класса CSingleView

void CSingleView::OnLButtonDown(UINT nFlags, CPoint point) {

 // …


 // Добавляем к массиву, определяющему документ, новый

 // элемент

 pDoc->arrayFig.Add(OneFigure);


 // Устанавливаем флаг изменения документа

 pDoc->SetModifiedFlag();


 CView::OnLButtonDown(nFlags, point);

}


//////////////////////////////////////////////////////////////

// Метод OnRButtonDown класса CSingleView

void CSingleView::OnRButtonDown(UINT nFlags, CPoint point) {

 // …


 // Добавляем к массиву, определяющему документ, новый

 // элемент

 pDoc->arrayFig.Add(OneFigure);


 // Устанавливаем флаг изменения документа

 pDoc->SetModifiedFlag();


 CView::OnRButtonDown(nFlags, point);

}

Простейший текстовый редактор

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

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

CEditView    ←|←CCtrlView←|←CView←CWnd

CRichEditView←|           |

CListView    ←|           |

CTreeView    ←|           |

                          |

    CFormView←CScrollView←|

Опишем основные характеристики этих классов.

Класс Описание
CView Наиболее общий класс, обеспечивающий отображение документа и взаимодействие с пользователем
CScrollView Класс CScrollView наследован от базового класса CView. В этом классе добавлены полосы просмотра, позволяющие перемещать документ в окне
CEditView Класс наследован от класса CView. Класс CEditView предоставляет возможности простого текстового редактора
CRichEditView Класс наследован от класса CView. Класс предоставляет возможности текстового редактора. В отличие от CEditView, он позволяет работать с текстом в формате RTF
CFormView Класс обеспечивает форматированное отображение документа на основе диалоговой панели
CListView Класс обеспечивает отображение документа с использование спискового органа управления
TreeView Класс обеспечивает отображение документа с использование древовидного органа управления
Чтобы создать простейший текстовый редактор создайте новое приложение с однооконным (или многооконным) интерфейсом. В качестве базового класса для класса окна просмотра приложения выберите класс CEditView. Завершите создание шаблона приложения.

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

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

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

Строка меню Edit Описание
Undo Отменить последнюю операцию
Cut Удалить выделенный текст и записать его в clipboard
Copy Скопировать выделенный текст в clipboard
Paste Вставить в документ содержимое clipboard

Заключение

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

В следующей книге из серии “Библиотека системного программиста” мы более подробно рассмотрим классы, составляющие основу приложений MFC, в том числе мы расскажем об элементах классов CWinApp, CView, CDocument и СDialog, для описания которых нам не хватило места в этой книге. Вы узнаете больше о классах, представляющих органы управления диалоговых панелей – CAnimateCtrl, CBitmapButton, CComboBox, CEdit, CListBox, CListCrtl, CRichEditCtrl, CTreeCtrl и некоторых других.

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

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

Литература

1. А. В. Фролов, Г. В. Фролов. Библиотека системного программиста. Тома 11-13. Операционная система Microsoft Windows 3.1 для программиста. Часть 1-3. Москва, "Диалог-МИФИ", 1994

2. А. В. Фролов, Г. В. Фролов. Библиотека системного программиста. Том 14. Графический интерфейс GDI в Microsoft Windows. Москва, "Диалог-МИФИ", 1994

3. А. В. Фролов, Г. В. Фролов. Библиотека системного программиста. Том 17. Операционная система Microsoft Windows 3.1 для программиста. Дополнительные главы, "Диалог-МИФИ", 1995

4. А. В. Фролов, Г. В. Фролов. Библиотека системного программиста. Том 22. Операционная система Microsoft Windows 95 для программиста. "Диалог-МИФИ", 1996

5. Эллис М., Строуструп В. Справочное руководство по языку программирования С++ с комментариями: Пер. с англ. М.: Мир, 1992

6. Пол Ирэ. Объектно-ориентированное программирование с использованием С++: Пер. с англ./Ире Пол. – К.: НИПФ “ДиаСофт Лтд.”, 1995

7. Том Сван. Программирование для Windows в Borland C++: Пер. с англ. – М.: БИНОМ, 1995


Оглавление

  • Введение
  •   Microsoft Visual C++
  •   Microsoft Visual C++ версия 4.0
  •   Следующие версии Microsoft Visual C++
  •   Как связаться с авторами
  •   Благодарности
  • 1. Немного о C++
  •   Ввод/вывод
  •   Константы
  •   Ссылки
  •   Распределение памяти
  •     Операторы new и delete
  •   Перегрузка имен функций
  •   Задание параметров функции по умолчанию
  •   Встраивание
  •   Классы
  •     Ключевое слово this
  •     Разграничение доступа к элементам класса
  •     Методы, входящие в класс
  •     Конструкторы и деструкторы класса
  •     Методы, не изменяющие объекты класса
  •     Статические методы
  •     Общие члены объектов класса
  •   Наследование
  •     Единичное наследование
  •     Множественное наследование
  •     Разграничение доступа к элементам базового класса
  •     Переопределение методов базового класса
  •     Виртуальные методы
  •     Абстрактные классы
  •   Структуры
  •   Шаблоны
  •     Шаблоны в MFC
  •   Перегрузка операторов
  •   Обработка исключительных ситуаций
  •     Операторы try, throw и catch
  •     Универсальный обработчик исключений
  •     Тип исключения
  • 2. Введение в MFC
  •   Классы библиотеки MFC
  •   Самый базовый класс MFC (класс CObject)
  •     Основа структуры приложения (класс CCmdTarget)
  •     Исключения (класс CException)
  •     Массивы, списки и словари
  •     Файловая система (класс CFile)
  •     Контекст отображения (класс CDC)
  •     Объекты графического интерфейса (класс CGdiObject)
  •     Меню (класс CMenu)
  •     Базы данных (классы для работы с базами данных)
  •     Синхронизация задач приложения (класс CSyncObject)
  •     Сокеты (классы CAsyncSocket и CSocket)
  •   Классы, не имеющие базового класса
  •     Простые классы
  •     Архивный класс (класс CArchive)
  •     Информация о классе объекта (структура CRuntimeClass)
  •     Отладка приложения (классы CDumpContext, CMemoryState)
  •     Печать документа (класс CPrintInfo)
  •   Первое приложение MFC
  •     Окно Project Workspace
  •   Средства ClassView
  •     Добавление к классу нового метода
  •     Добавление к классу нового элемента данных
  •     Просмотр дерева наследования классов
  •     Редактирование методов класса
  •     Редактирование элементов данных класса
  •   Приложение с единственным окном
  •   Обработка сообщений
  •     Оконные сообщения
  •     Сообщения от органов управления
  •     Командные сообщения
  •     Таблица сообщений
  •     Приложение MFMenu
  •   Долгий путь сообщения
  •   Диалоговая панель
  •     Приложение с модальной диалоговой панелью
  •     Приложение с немодальной диалоговой панелью
  • 3. Некоторые классы MFC
  •   Класс CObject – основной класс MFC
  •     Конструкторы класса
  •     Оператор присваивания
  •     Диагностика
  •     Сохранение и восстановление состояния объекта
  •     Информация о классе
  •   Класс CPoint – точка на плоскости
  •     Класс CSize – относительные координаты
  •   Класс CString – текстовые строки
  •     Конструктор класса
  •   Коллекции
  •     Массивы – шаблон CArray
  •     Списки – шаблон CList
  •     Словари – шаблон CMap
  •   Класс CTime – дата и время
  •   Файловая система – класс CFile
  •     Открытие и создание файлов
  •     Идентификатор открытого файла
  •     Закрытие файлов
  •     Чтение и запись файлов
  •     Метод Flush
  •     Операции с файлами
  •     Блокировка
  •     Позиционирование
  •     Характеристики открытого файла
  •   Файловая система – классы CMemFile и CStdioFile
  •     Модификация класса CMemFile
  •   Файловая система – класс CStdioFile
  •     Приложение TestFile
  •   Исключения – класс CException
  •     Класс CException
  •     Класс CMemoryException
  •     Класс CFileException
  •     Класс CArchiveException
  •     Класс CNotSupportedException
  •     Класс CResourceException
  •     Класс CUserException
  •   Запись и восстановление объектов
  •     Запись в архивный файл
  •     Чтение из архивного файла
  •   Многозадачные приложения
  • 4. Приложение с главной диалоговой панелью
  •   Создание приложения средствами MFC AppWizard
  •   Приложение Dialog
  •     Имена, используемые MFC
  •     Ресурсы приложения
  •     Исходные тексты приложения
  •   Средства ClassWizard
  •     Создание нового класса
  •     Включение в класс новых методов
  •     Включение в класс новых элементов данных
  •     Просмотр характеристик класса
  • 5. Однооконный интерфейс
  •   Модель “документ – окно просмотра ”
  •   Процедура создания однооконного приложения
  •   Приложение Single
  •     Ресурсы приложения
  •     Классы приложения
  •   Обработка командных сообщений
  •     Порядок обработки сообщений
  •     Командные сообщения и приложение Single
  •     Изменение порядка обработки сообщений
  •     Стандартные команд ные сообщения
  •   Простейший графический редактор
  •     Создание нового документа
  •     Сохранение и восстановление документа на диске
  •     Для забывчивых пользователей
  •     Простейший текстовый редактор
  • Заключение
  • Литература