Стандартная библиотека компиляторов содержит специальные функции управления памятью – malloc, free, а также другие разновидности этих функций. Они позволяют получить для использования блок оперативной памяти, и затем отдать его обратно операционной системе.
   В Си++ встроены специальные операторы для управления памятью – оператор 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;
   Прямоугольные скобки указывают на то, что надо удалить массив элементов.

   В программах, написанных на языке С, данные и функции, предназначенные для их обработки определяются отдельно. Такое разделение затрудняет структурированное программирование и создает дополнительные возможности для ошибок, которые трудно обнаружить.
   В С++ введено новое понятие – класс. Класс позволяет объединить данные и оперирующие ими функции в одной структуре. Такое объединение обычно называют инкапсуляцией данных и связанных с ними функций. Инкапсуляция позволяет скрыть конкретную реализацию класса, облегчая отладку и модификацию программ.
   Объявление класса имеет следующий вид:
   class [<tag>]
   {
   <member-list>
   } [<declarators>];
   Когда вы определяете класс, то сначала указывается ключевое слово class, а затем в качестве аргумента <tag> имя самого класса. Это имя должно быть уникальным среди имен других классов, определенных в вашей программе.
   Затем в фигурных скобках следует список элементов класса <member-list>. В качестве элементов класса могут фигурировать данные (переменные), битовые поля, функции, вложенные классы, а также некоторые другие объекты. Вы можете включить качестве элемента класса указатель на другие объекты этого класса.
   Классы образуют собственное пространство имен. Имена элементов одного класса могут совпадать с именами элементов другого класса и даже с именами других переменных и функций определенных в программе.
   Функции входящие в класс, называются функциями-элементами, или следуя терминологии объектно-ориентированного подхода, методами. Далее мы будем называть такие функции методами. Внутри класса вы можете свободно обращаться ко всем его элементам функциям и данным, без указания имени класса или имени объекта этого класса.
   После закрывающей фигурной скобки в аргументе <declarators> можно объявить один или несколько объектов данного класса. Объекты класса можно объявить и позже, точно так же как объявляются переменные простых типов:
   [class] tag declarators;
   Ключевое слово class перед именем класса можно опустить.
   Для динамического создания и удаления объектов классов можно пользоваться операторами new и delete. Эти операторы позволяют легко строить списки классов, деревья и другие сложные структуры.

   Ключевое слово 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;}
   };

   Языки программирования С и Си++ обеспечивают строгую проверку типов данных. Некоторые языки не обеспечивают такой проверки и она полностью ложится на плечи программиста. Например в языке PL1 вы можете сравнивать значение строковой и числовой переменных. Это не будет ошибкой с точки зрения компилятора. Если вы случайно допустите ошибку, то обнаружить ее будет достаточно сложно.
   Однако строгая типизация, присущая некоторым языкам, не всегда удобна. Если вам надо выполнять одинаковые вычисления над переменными различных типов, придется создавать две фактически одинаковые функции, которые оперируют с различными типами данных.
   Аналогичная ситуация возникает, если вам надо создать класс, для работы с различными типами данных. Допустим вам надо создать список из элементов. Удобнее всего это сделать при помощи классов. Но если вам надо, чтобы в качестве элементов списка фигурировали различные типы данных, то вам наверняка придется написать несколько одинаковых классов, различающихся только типом элементов.
   Естественно такая ситуация усложняет работу программиста, увеличивают объем исходных текстов программы, и наконец просто может стать причиной ошибок и несоответствий. Так, если в вашей программе содержится несколько функций или классов, отличающихся только типом данных, которыми они оперируют, то когда вы вносите исправления в одну функцию, надо будет точно также исправлять и все остальные.
   Чтобы облегчить программисту работу, в стандарт языка Си++ было включено понятие шаблона. В Visual C++ шаблоны реализованы начиная с версии 2.0. Ранние версии Visual C++ с ними работать не могли.
   Шаблоны предназначены для создания ряда классов и функций, отличающихся только типом обрабатываемых ими данных. Для определения шаблона предназначено ключевое слово template (шаблон). Общий синтаксис определения шаблона имеет следующий вид:
   template <template-argument-list> declaration;
   Аргумент template-argument-list представляет собой список условных имен для определения типов, по которым будут различаться различные реализации классов или функций данного шаблона.

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

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

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

   Непосредственно от класса 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

   Для реализации механизма исключений в 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.

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

   Для отображения информации в окне или на любом другом устройстве приложение должно получить так называемый контекст отображения. Основные свойства контекста отображения определены в классе 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

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

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

   Практически каждое приложение имеет собственное меню. Оно как правило отображается в верхней части главного окна приложения. Для управления меню в состав 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 ) для классов управляющих базами данных.

   Библиотека MFC позволяет создавать многозадачные приложения. Для синхронизации отдельных задач приложения предусмотрен ряд специальных классов. Все они наследуются от класса CSyncObject , представляющего собой абстрактный класс (рис. 2.8).
   Рис. 2.8. Класс CSyncObject
 
   В некоторых случаях требуется, чтобы участок программного кода мог выполняться только одной задачей. Такой участок называют критической секцией кода. Для создания и управления критическими секциями предназначены объекты класса CCriticalSection.
   Объекты класса CEvent представляют событие. При помощи событий одна задача приложения может передать сообщение другой.
   Объекты класса CMutex позволяют в данный момент времени представить ресурс в пользование только одной задачи. Остальным задачам доступ к ресурсу запрещается.
   Объекты класса CSemaphore представляют собой семафоры. Семафоры позволяют ограничить количество задач, которые имеют доступ к какому-либо ресурсу.

   Для тех, кто занимается сетевыми коммуникациями, в состав библиотеки 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 он должен быть привязан к файлу – объекту класса CFile.
   Более подробно о процессе сохранения и восстановления объектов вы можете прочитать в разделе “Сохранение и восстановление объектов”. Пример использования класса CArchive для записи и восстановления документов в файлах представлен в разделе “Простейший графический редактор” главы “Однооконный интерфейс”.

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

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

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

   Первое приложение 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++.

   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 вы узнаете позже, когда мы будем рассматривать средства автоматизированной разработки приложений.

   Конечно, вы можете продолжать набирать исходные тексты приложения вручную непосредственно в текстовом редакторе. Но во многих случаях среда 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. Временное меню метода

   Как вы знаете из предыдущих томов серии “Библиотека системного программиста”, работа приложений операционной системы 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 мы также не станем пользоваться средствами автоматизированной разработки 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.

   Очень удобным средством для организации взаимодействия пользователя и приложения являются диалоговые панели. Более того, многие приложения могут успешно работать и без главного окна, взаимодействуя с пользователем только через диалоговые панели. Примером такого приложения может служить приложение 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 .

   Подавляющее большинство классов из библиотеки 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 или классу наследованному от него. В противном случае метод возвращает нулевое значение.

   В предыдущих томах серии “Библиотека системного программиста” мы рассматривали структуру 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 создан на основе структуры SIZE, предназначенной для определения относительных координат точек в двумерном пространстве. Так как CSize наследуется от структуры SIZE, он включает все ее поля. Вы можете непосредственно обращаться к элементам SIZE. Элементы данных cx и cy объявлены как доступные. Объекты класса CSize можно использовать вместо переменных типа SIZE – их можно указывать в качестве параметров функций. Вы можете передавать объекты CSize функциям, которые принимают параметры типа SIZE. Объявление класса CSize расположено во включаемом файле #include <afxwin.h>.

   Практически ни одно приложение не обходится без использования текстовых строк. Язык Си и Си++ не имеет специального строкового типа. Обычно для хранения строк используют массивы символов. 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 входят специальные классы для хранение и обработки групп переменных или объектов. Они позволяют быстро создавать массивы и списки объектов. Облегчается создание небольших словарей, позволяющих по ключевому полю получить ранее записанное в словарь значение. Класс словарей реализует эффективный механизм хеширования. С использованием таких классов отпадает необходимость в самостоятельной разработке и длительной отладке. Программист сможет уделить больше времени прикладной части своего приложения.

   Библиотека 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 (см. раздел “Простейший графический редактор” главы “Однооконный интерфейс”).

   В состав MFC входят классы, предназначенные для организации двунаправленных списков указателей, строк, состоящих из объектов CString, указателей на объекты класса CObject. В MFC версии 4.0 добавлен шаблон класса списка CList. С помощью этого шаблона можно создавать списки, состоящие из любых объектов.
   Списковый класс имеет методы для вставки и удаления элементов в начало, конец и середину списка. Вы можете получить предыдущий и следующий элемент из списка.
   Ниже представлен прототип шаблона CList.
   template <class TYPE, class ARG_TYPE>
   class CList : public CObject

   Словарь, это таблица переменной длины, состоящая из двух колонок. Первая колонка содержит ключевые поля, а вторая – соответствующие им значения. Пользуясь объектами этого класса, вы можете по ключевому полю получить связанное с ним значение. Для поиска по ключу используется алгоритм хеширования, реализация которого вручную заняла бы слишком много времени.
   В 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.

   Библиотека 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х.

   Когда вы используете метод 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 должен содержать указатель на строку символов, содержащую путь файла. Эта строка должна оканчиваться двоичным нулем.

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

   Теперь мы представим вам приложение, которое использует класс 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

   Как мы рассказывали в главе “Обработка исключительных ситуаций”, язык Си++ позволяет вызывать и обрабатывать исключения любого типа. Однако эта возможность практически не используются классами, определенными в библиотеке 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 включает два виртуальных метода 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.

   Когда приложение заказывает у операционной системы новый блок оперативной памяти, может случиться, что вся память уже используется и больше памяти отдано приложению быть не может.
   Когда приложение пытается создать новую переменную или объект, вызывая оператор new, то в том случае, если память под него не может быть выделена, создается объект класса CMemoryException и вызывается соответствующее исключение.
   Функции malloc не вызывают исключение CMemoryException, но вы можете проверять значение, возвращаемое функцией malloc, и если оно равно нулю, вызывать его сами.
   Чтобы самому вызвать исключение, воспользуйтесь функцией AfxThrowMemoryException:
   void AfxThrowMemoryException();
   Эта функция не пытается получить у операционной системы дополнительную память, а использует память полученную ранее. В противном случае, возможно, вы не смогли бы создать даже объекта CMemoryException, так как свободная память уже кончилась.
   Приведем небольшой пример использования этой функции. Допустим, вы пытаетесь получить область оперативной памяти для хранения данных с помощью функции GlobalAlloc. Если операционная система не может выделить область памяти такого размера, она возвращает NULL и вы можете вызвать функцию AfxThrowMemoryException:
   if (GlobalAlloc(GMEM_FIXED, 1000000) == NULL) AfxThrowMemoryException();

   Класс 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.
   Причина, по которой было вызвано исключение, определяется элементом данных 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 вручную и передавать его оператору throw, воспользуйтесь функцией AfxThrowNotSupportedException:
   void AfxThrowNotSupportedException();

   Если в процессе работы возникают проблемы с ресурсами, например приложение пытается загрузить несуществующий ресурс, тогда вызывается исключение CResourceException. Вы можете вызвать это исключение сами. Для этого воспользуйтесь функцией AfxThrowResourceException:
   void AfxThrowResourceException();

   Если какая-либо операция при работе приложения закончилась с ошибкой, оно может вызвать функцию 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.

   Названия файлов, входящих в проект 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 начинаются с заглавной буквы 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
    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

   Разработка приложения не заканчивается, когда 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. Более подробно об этой возможности мы расскажем в одной из следующих книг серии.

   В этом разделе мы рассмотрим однооконное приложение, созданное с использованием средств 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. Если командное сообщение, поступившее объекту диалоговой панели, не может быть обработано, оно передается его родительскому окну.
   Если родительское окно диалоговой панели также не может обработать командное сообщение, оно передается главному объекту приложения.

   Большинство командных сообщений от элементов меню и панели управления поступают для обработки главному окну приложения, представленному объектом класса 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