Visual C++ для начинающих
Адресация в С++
Напишем программу, которая показывает, что одна из ячеек памяти занята под переменную iNum1 и содержит значение 2. Как программист, вы называете эту ячейку iNum1, но компьютер ссылается на эту ячейку памяти, используя определенное число. Ячейки памяти нумеруются в компьютере последовательно: 1, 2, 3, 4 и т.д. Эти числа называются адресами ячеек памяти. Как программисту, вам, вероятно, никогда не понадобится знать значение адреса этой ячейки памяти, который не всегда один и тот же. В зависимости от того, что выполнялось перед вашей программой, что уже имеется в памяти, и в зависимости от других факторов, адрес, используемый для хранения iNum1, будет меняться даже на одном и том же компьютере. Тем не менее, вы можете извлечь адрес, использующийся для ячейки памяти, посредством операции & (операция взятия адреса). Чтобы посмотреть ее в действии, сделайте следующее:void main( void )
{
int iNum1;
iNum1 = 2;
cout << "Address of iNum1 is: ";
cout << iNum1 << endl;
}
Добавленный вами блок кода выводит адрес, использующийся для ячейки памяти переменной iNumI:
Аргумент how задает действия, выполняемые при очистке системных буферов socket'а:
Аргумент type задает режим взаимодействия:
Архитектура приложения
У всех Windows-приложений фиксированная структура, определяемая функцией WinMain. Структура приложения, построенного из объектов классов библиотеки MFC, является еще более определенной.Приложение состоит из объекта theApp, функции WinMain, и некоторого количества других объектов. Сердцевина приложения - объект theApp - отвечает за создание всех остальных объектов и обработку очереди сообщений. Объект theApp является глобальным и создается еще до начала работы функции WinMain. Работа функции WinMain заключается в последовательном вызове двух методов объекта theApp: InitInstance и Run. В терминах сообщений можно сказать, WinMain посылает объекту theApp сообщение InitInstance, которое приводит в действие метод InitInstance.
Получив сообщение InitInstance, theApp создает внутренние объекты приложения. Процесс создания выглядит как последовательное порождение одних объектов другими. Набор объектов, порождаемых в начале этой цепочки, определен структурой MFC практически однозначно - это главная рамка, шаблон, документ, облик. Их роли в работе приложения будут обсуждаться позже.
Следующее сообщение, получаемое theApp, - Run - приводит в действие метод Run. Оно как бы говорит объекту: "Начинай работу, начинай процесс обработки сообщений из внешнего мира". Объект theApp циклически выбирает сообщения из очереди и инициирует обработку сообщений объектами приложения.
Некоторые объекты имеют графический образ на экране, с которым может взаимодействовать пользователь. Эти интерфейсные объекты обычно связаны с Windows-окном. Среди них особенно важны главная рамка и облик. Именно им объект прежде всего распределяет сообщения из очереди через механизм Windows-окон и функцию Dispatch.
Когда пользователь выбирает команду меню окна главной рамки, то возникают командные сообщения. Они отправляются сначала объектом theApp объекту главная рамка, а затем обходят по специальному маршруту целый ряд объектов, среди которых первыми являются документ и облик, информируя их о пришедшей от пользователя команде.
При работе приложения возникают и обычные вызовы одними объектами методов других объектов. В объектно-ориентированной терминологии такие вызовы могут называться сообщениями. В Visual C++ некоторым методам приписан именно этот статус (например, методу OnDraw).
Важное значение имеют также объекты документ, облик и главная рамка. Здесь отметим только, что документ содержит данные приложения, облик организует представление этих данных на экране, а окно главной рамки - это окно, внутри которого размещены все остальные окна приложения.
Библиотека MFC
Главная часть библиотеки MFC состоит из классов, используемых для построения компонентов приложения. С каждым MFC-приложением связывается определяющий его на верхнем уровне объект theApp, принадлежащий классу, производному от CWinApp.Как правило, структура приложения определяется архитектурой Document-View (документ-облик). Это означает, что приложение состоит из одного или нескольких документов - объектов, классы которых являются производными от класса CDocument (класс "документ"). С каждым из документов связаны один или несколько обликов - объектов классов, производных от CView (класс "облик ") и определяющих облик документа.
Класс CFrameWnd ("окна-рамки") и производные от него определяют окна-рамки на дисплее. Элементы управления, создаваемые при проектировании интерфейса пользователя, принадлежат семейству классов элементов управления. Появляющиеся в процессе работы приложения диалоговые окна - это объекты классов, производных от CDialog.
Классы CView, CFrameWnd, CDialog и все классы элементов управления наследуют свойства и поведение своего базового класса CWnd ("окно"), определяющего по существу Windows-окно. Этот класс в свою очередь является наследником базового ласса CObject ("объект").
Одна из трудностей в понимании принципов устройства MFC-приложения, заключается в том, что объекты, из которых оно строится, наследуют свойства и поведение всех своих предков, поэтому необходимо знать базовые классы.
Большинство библиотек DLL — просто
BOOL WINAPI DllMain (HANDLE hInst,DWORD dwReason, LPVOID IpReserved) { BOOL bAllWentWell=TRUE; switch (dwReason) { case DLL_PROCESS_ATTACH: // Инициализация процесса.break; case DLL_THREAD_ATTACH: // Инициализация потока.
break; case DLL_THREAD_DETACH: // Очистка структур потока.
break; case DLL_PROCESS_DETACH: // Очистка структур процесса.
break; } if(bAllWentWell) return TRUE; else return FALSE; }
BOOL CMDIDoc::OnNewDocument()
6. Инициализируем элементы данных класса представления. Для этого нужно создать функцию-элемент OnInitialUpdate() класса представления:Выберите ClassWizard в меню View. На странице Message Maps выберите следующие события:
BOOL sndPlaySound( LPCTSTR lpszSoundName; UINT fuOptions;);
Параметры функции: lpszSoundName Имя файла. Если этот параметр NULL, то проигрывание файла останавливается. fuOptions Специальные опции для проигрывания музыки. Они могут быть следующими: Значение Описание SND_SYNC Музыка играется синхронно, и функция не возвращает указатель пока не будет конца файла. SND_ASYNC Музыка играется асинхронно, и функция возвращает указатель сразу после начала проигрывания файла. Чтобы остановить проигрывание, надо вызвать функцию SndPlaySound с параметром lpszSoundName установленным в NULL. SND_NODEFAULT Если файл не найден, то функция возвращает указатель сразу и не проигрывает стандартный звуковой эффект Windows. SND_MEMORY Этот параметр нужен для проигрывания Wave-файла в виде ресурса( из памяти ). SND_LOOP Этот параметр нужен для проигрывания Wave-файла в циклическом режиме. Также при этом вы должны использовать влаг SND_ASYNC. Чтобы остановить проигрывание, надо вызвать функцию SndPlaySound с параметром lpszSoundName установленным в NULL. SND_NOSTOP Если музыка уже проигрывается, то функция возврвщает FALSE. Возвращаемое значение: Если музыка проигрывается правильно, то функция возврвщает TRUE, иначе FALSE.Пример использования:
Чтобы "вписаться" в структуру
static AFX_EXTENSION_MODULE MyExtDLL = { NULL, NULL } ; extern "C" int APIENTRY DllMain(HINSTANCE hinstance, DWORD dwReason, LPVOID IpReserved) { if (dwReason == DLL_PROCESS_ATTACH) { TRACED("MYEXT.DLL Initializing!\n") ; // Extension DLL one-time initialization AfxInitExtensionModule(MyExtDLL, hinstance) ; // Insert this DLL into the resource chain new CDynLinkLibrary(MyExtDLL); } else if (dwReason == DLL_PROCESS_DETACH) { TRACED("MYEXT.DLL Terminating!\n") ; } return 1; // ok }Class CMDIDoc : public CDocument
4. Объявляем элементы данных класса представления. Их будет тоже два : координаты круга по X и по Y. Для этого открываем файл CMDIView.h и изменяем объявление класса CMDIView следующим образом:Class CMDIView : public CView
Как вы видите, имена переменных могут совпадать( обычно так и делается ).5. Инициализируем элементы данных класса документа. Для этого откройте файл MDIDoc.cpp, найдите в нём функцию OnNewDocument() и напишите в ней следующий код:
Class neme : CMDIView Object ID : CMDIView Message : OnInitialUpdate
и нажмите на кнопку Add FunctionНапишите следующий код в функцию OnInitialUpdate():
CPage pPage pPage= new
Теперь добавим код по отображению текущей страницы и сокрытию предыдущей. Для этого добавим обработчики сообщений TCN_SELCHANGE и TCN_SELCHANGING :Допустим, имеется массив целых
#pragma data_seg(".myseg") int sharedlnts[10] ; // другие переменные общего пользования#pragma data_seg() #pragma comment(lib, "msvcrt" "-SECTION:.myseg,rws");
Файл библиотеки также несколько
MyDLL.c #includeGDI-атрибуты контекста устройства
Значениями ряда атрибутов контекста устройства являются объекты GDI. Как отмечалось ранее, в вызовах методов, рисующих фигуры на экране, многие параметры не указываются, а берутся из атрибутов контекста устройства. Чтобы эти параметры отличались от установленных в контексте устройства по умолчанию, необходимо:Сохранить старое значение атрибута. Установить новое. Выполнить необходимые действия. Восстановить старое значение атрибута.
Последовательность этих действий иллюстрируется примером:
void CMyView::OnDraw(CDC* pDC)
{
CPen Pen;
if(Pen.CreatePen(PS_SOLID,2,RGB(0,0,0))
{
// сохранение старого и установление нового значения атрибута
CPen* pOldPen=pDC->SelectObject(&Pen);
// выполнение необходимых действий
pDC->MoveTo(....); pDC->LineTo(....);
// восстановление старого значения атрибута
pDC->SelectObject(pOldPen);
}
}
Метод SelectObject в качестве результата возвращает указатель на текущее перо и делает текущим перо, указанное в качестве параметра метода.
Имена, используемые в MFC
Библиотека MFC содержит большое количество классов, структур, констант и т.д. Для того, чтобы текст MFC-приложений был более легким для понимания, принято применять ряд соглашений для используемых имен и комментариев.Названия всех классов и шаблонов классов библиотеки MFC начинаются с заглавной буквы C. При наследовании классов от классов MFC можно давать им любые имена. Рекомендуется начинать их названия с заглавной буквы C. Это сделает исходный текст приложения более ясным для понимания.
Чтобы отличить элементы данных, входящих в класс, от простых переменных, их имена принято начинать с префикса m_. Названия методов классов, как правило, специально не выделяются, но обычно их начинают с заглавной буквы.
Библиотека MFC включает в себя, помимо классов, набор служебных функций. Названия этих функций начинаются с символов Afx, например AfxGetApp. Символы AFX являются сокращением от словосочетания Application FrameworkX, означающих основу приложения, его внутреннее устройство.
Символы AFX встречаются не только в названии функций MFC. Многие константы, макрокоманды и другие символы начинаются с этих символов. В общем случае AFX является признаком, по которому можно определить принадлежность того или иного объекта (функция, переменная, ключевое слово или символ) к библиотеке MFC.
Когда приложение разрабатывается средствами MFC AppWizard и ClassWizard, они размещают в исходном тексте приложения комментарии следующего вида:
//{{AFX_ ... //}}AFX_
Такие комментарии образуют блок кода программы, который управляется только средствами MFC AppWizard и ClassWizard. Пользователь не должен вручную вносить изменения в этом блоке. Для этого необходимо употреблять средства ClassWizard.
В следующей таблице представлено краткое описание некоторых блоков //{{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 используется при описании класса. |
MFC AppWizard и ClassWizard помогают разрабатывать приложения. Они создают все классы и методы, необходимые для его работы. Программисту остается дописать к ним свой код. В тех местах, где можно вставить свой код, MFC AppWizard и ClassWizard, как правило помещают комментарии:
//TODO:
Для того что бы перейти к Visual C++, целесообразно получить некоторое представление о просто языке C++, так как он является базовым. Что бы начать обучение вам нужно сначала поставить какую-нибудь версию Visual C++. Лучше, конечно, если у вас есть место на HDD, поставить Visual C++ версии 6. Но можно поставить версию 5 или 4. Все мои примеры написаны на шестой версии, но они должны работать и на младших версиях. Многие думают, что если они поставили Visual C++, то могут писать программы только под Windows, но это не правильно. Visual C++ позволяет писать программы и на простом C++, как бы под DOS. Ну вот, я думаю, и можно начинать.
#Include "Pageh" #include "Pageh" #include "Pageh"
Продолжим в OnInitDialog:Надо последовательно создать все страницы, причём указатели на них хранятся в самом m_ctrTab !!! В этом примере мы ипользовали lParam структуры TCITEM как хранилище указателя. Теперь переменные pPage1, pPage2 и pPage3 больше не нужны - указатели хранятся в надежном месте! Для каждой страницы вызывается метод ShowWindow() - для отображения первой, и скрытия остальных страниц.
Int CMyClockCtrl::OnCreate(LPCREATESTRUCT
Введенный вами код состоит из одного оператора, который вызывает функцию SetTimer() для установки таймера с 1000-миллисекундным периодом:SetTiltier (1, 1000, NULL);
Начиная с этого момента, каждые 1000 миллисекунд Windows будет посылать элементу управления сообщение WM_TIMER.
Теперь вам нужно связать код с событием WM_TIMER:
Выберите ClassWizard в меню View. На странице Message Maps выберите следующее событие:
Class Name: CMyClockCtrl
Object ID: CMyClockCtrl
Message: WM_TIMER
Щелкните на кнопке Add Function.
В ответ Visual C++ добавит в класс CMyClockCtrl функцию-элемент OnTimer().
Щелкните на кнопке Edit Code в ClassWizard.
В ответ Visual C++ откроет файл MyClockCtrl.cpp с функцией OnTimer() в режиме редактирования.
Напишите следующий код в функции OnTimerO:
Использование класса CTabCtrl
Tab control - это мощное средство для решению многих проблем в интерфейсе приложений. Оно позволят существенно увеличить скорость работы вашего приложения, разбить на "части" диалог в удобной для пользователя форме.В MFC есть встроенный класс по работе с Tab control - класс CTabCtrl.
Для практики напишем программу, которая будет использовать класс CTabCtrl и в которой будет три "закладки" - диалога.
Шаги создания проекта:
Использование средств разработки
В состав компилятора Microsoft Developer Studio встроены средства, позволяющие программисту облегчить разработку приложений. В первую очередь к ним относятся MFC AppWisard, ClassWizard и редактор ресурсов.Благодаря MFC AppWizard среда разработчика позволяет быстро создавать шаблоны новых приложений. При этом программисту не приходится писать ни одной строчки кода. Достаточно ответить на ряд вопросов, касающихся того, какое приложение требуется создать, и исходные тексты шаблона приложения вместе с файлами ресурсов готовы. Эти тексты можно оттранслировать и получить готовый загрузочный модуль приложения.
Конечно, никакие средства автоматизированной разработки не смогут создать программу полностью без участия программиста. Прикладную часть приложения придется разрабатывать ему.
Для создания ресурсов приложения предназначен редактор ресурсов. Он позволяет быстро создавать новые меню, диалоговые панели, добавлять кнопки к панели управления toolbar и т.д.
Средство ClassWizard позволяет подключить к созданным и отредактированным ресурсам управляющий ими код. Большую часть работы по описанию и определению функций, обрабатывающих сообщения от меню, органов управления диалоговых панелей и т.д., также берет на себя средство ClassWizard.
Каркас приложений
С Visual C++ тесно связано еще одно понятие - каркас приложений, которое близко и созвучно понятию каркаса приложения, но в отличие от него относится не к одному конкретному приложению, а к библиотеке, с помощью которой строятся многие приложения. Каркас приложений - это библиотека классов, из которых программист берет не только набор классов, играющих роль дополнительных типов данных, но и классы, служащие строительными блоками приложения на самом верхнем уровне. С этой точки зрения, каркас приложения является частью каркаса приложений, относящейся к данному приложению. Примеры каркасов приложений - библиотеки классов MFC и OWL.Каркас приложения
Наследование - одна из фундаментальных идей объектно-ориентированного программирования. Именно этот механизм наследования позволяет программисту дополнять и переопределять поведение базового класса, не вторгаясь в библиотеку MFC, которая остается неизменной. Все изменения делаются в собственном производном классе. Именно в этом и заключается работа программиста.Объекты, их которых состоит приложение, являются объектами классов, производных от классов библиотеки MFC. Разработка приложения состоит в том, что программист берет из библиотеки MFC классы CWinApp, CFrameWnd, CDocument, CView и т.д. и строит производные классы. Приложение создается как совокупность объектов этих производных классов. Каждый объект несет в себе как наследуемые черты, определяемые базовыми классами, так и новые черты, добавленные программистом. Наследуемые черты определяют общую схему поведения, свойственную таким приложениям. Новые же черты позволяют реализовать специфические особенности поведения приложения, необходимые для решения стоящей перед ним задачи.
При определении производного класса программист может:
Приложение, построенное на основе библиотеки MFC, - "айсберг", большая часть которого невидима, но является основой всего приложения. Часть приложения, лежащую в библиотеке MFC, - framework - называется каркасом приложения. Рассмотрим работу приложения как процесс взаимодействия между каркасом и частью приложения, разработанной программистом. Совершенно естественно, что в методах, определенных программистом, могут встречаться вызовы методов базового класса, что вполне можно рассматривать как вызов функции из библиотеки. Важнее, однако, что и метод производного класса, определенный программистом, может быть вызван из метода родительского класса. Другими словами, каркас и производный класс в этом смысле равноправны - их методы могут вызывать друг друга. Такое равноправие достигается благодаря виртуальным методам и полиморфизму, имеющимся в арсенале объектно-ориентированного программирования.
Если метод базового класса объявлен виртуальным и разработчик переопределил его в производном классе, это значит, что при вызове данного метода в некоторой полиморфной функции базового класса в момент исполнения будет вызван метод производного класса и, следовательно, каркас вызывает метод, определенный программистом. Точнее говоря, обращение к этому методу должно производиться через ссылку на производный объект либо через объект, являющийся формальным параметром и получающий при вызове в качестве своего значения объект производного класса. Когда вызывается виртуальный метод М1, переопределенный разработчиком, то согласно терминологии Visual C++, каркас посылает сообщение М1 объекту производного класса, а метод М1 этого объекта обрабатывает это сообщение. Если сообщение М1 послано объекту производного класса, а обработчик этого сообщения не задан программистом, объект наследует метод М1 ближайшего родительского класса, в котором определен этот метод. Если же обработчик такого сообщения создан программистом, он автоматически отменяет действия, предусмотренные родительским классом в отсутствие этого обработчика.
Класс CFile
Класс CFile предназначен для обеспечения работы с файлами. Он позволяет упростить использование файлов, представляя файл как объект, который можно создать, читать, записывать и т.д.Чтобы получить доступ к файлу, сначала надо создать объект класса CFile. Конструктор класса позволяет сразу после создания такого объекта открыть файл. Но можно открыть файл и позднее, воспользовавшись методом Open.
Открытие и создание файлов
После создания объекта класса CFile можно открыть файл, вызвав метод Open. Методу надо указать путь к открываемому файлу и режим его использования. Прототип метода Open имеет следующий вид:
virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags, CFileException* pError=NULL);
В качестве параметра lpszFileName надо указать имя открываемого файла. Можно указать только имя файла или полное имя файла, включающее полный путь к нему.
Второй параметр nOpenFlags определяет действие, выполняемое методом Open с файлом, а также атрибуты файла. Ниже представлены некоторые возможеые значения параметра nOpenFlags:
Необязательный параметр pError, который является указателем на объект класса CFileException, используется только в том случае, если выполнение операции с файлом вызовет ошибку. При этом в объект, указываемый pError, будет записана дополнительная информация.
Метод Open возвращает не нулевое значение, если файл открыт и нуль в случае ошибки. Ошибка при открытии файла может случиться, например, если методу Open указан для чтения несуществующий файл.
Идентификатор открытого файла
В состав класса CFile входит элемент данных m_hFile типа UINT. В нем хранится идентификатор открытого файла. Если объект класса CFile уже создан, но файл еще не открыт, то в переменной m_hFile записана константа hFileNull.
Обычно идентификатор открытого файла непосредственно не используется. Методы класса CFile позволяют выполнять практически любые операции с файлами и не требуют указывать идентификатор файла. Так как m_hFile является элементом класса, то реализация его методов всегда имеет свободный доступ к нему.
Закрытие файлов
После завершения работы с файлом, его надо закрыть. Класс CFile имеет для этого специальный метод Close. Нужно заметить, что если был создан объект класса CFile и открыт файл, а затем объект удаляется, то связанный с ним файл закрывается автоматически с помощью деструктора.
Чтение и запись файлов
Для доступа к файлам предназначено несколько методов класса CFile: Read, ReadHuge, Write, WriteHuge, Flush. Методы Read и ReadHuge предназначены для чтения данных из предварительно открытого файла. В 32-разрядных операционных системах оба метода могут одновременно считать из файла больше 65535 байт. Спецификация ReadHuge считается устаревшей и оставлена только для совместимости с 16-разрядными операционными системами.
Данные, прочитанные из файла, записываются в буфер lpBuf. Параметр nCount определяет количество байт, которое надо считать из файла. Фактически из файла может быть считано меньше байт, чем запрошено параметром nCount. Это происходит, если во время чтения достигнут конец файла. Методы возвращают количество байт, прочитанных из файла.
Для записи в файл предназначены методы Write и WriteHuge. В 32-разрядных операционных системах оба метода могут одновременно записывать в файл больше 65535 байт. Методы записывает в открытый файл nCount байт из буфера lpBuf. В случае возникновения ошибки записи, например переполнения диска, методы вызывает обработку исключения.
Метод Flush
Когда используется метод Write или WriteHuge для записи данных на диск, они некоторое время могут находиться во временном буфере. Чтобы убедиться, что необходимые изменения внесены в файл на диске, нужно воспользоваться методом Flush.
Операции с файлами
В состав класса входят методы, позволяющие выполнять над файлами различные операции, например копирование, переименование, удаление, изменение атрибутов.
Для изменения имени файла класс CFile включает статический метод Rename, выполняющий функции этой команды. Метод нельзя использовать для переименования каталогов. В случае возникновения ошибки метод вызывает исключение.
Для удаления файлов в классе CFile включен статический метод Remove, позволяющий удалить указанный файл. Этот метод не позволяет удалять каталоги. Если удалить файл невозможно, то метод вызывает исключение.
Чтобы определить дату и время создания файла, его длину и атрибуты, предназначен статический метод GetStatus. Существует две разновидности метода - первый определен как виртуальный, а второй - как статический метод.
Виртуальная версия метода GetStatus определяет состояние открытого файла, связанного с данным объектом класса CFile. Этот метод вызывается только тогда, когда объект класса CFile создан и файл открыт.
Статическая версия метода GetStatus позволяет определить характеристики файла, не связанного с объектом класса CFile. Чтобы воспользоваться этим методом, необязательно предварительно открывать файл.
Блокировка
В состав класса включены методы LockRange и UnlockRange, позволяющие заблокировать один или несколько фрагментов данных файла для доступа из других процессов. Если приложение пытается повторно блокировать данные, уже заблокированные раньше этим или другим приложением, вызывается исключение. Блокировка представляет собой один из механизмов, позволяющих нескольким приложениям или процессам одновременно работать с одним файлом, не мешая друг другу.
Установить блокировку можно с помощью метода LockRange. Чтобы снять установленные блокировки, надо воспользоваться методом UnlockRange. Если в одном файле установлены несколько блокировок, то каждая из них должна сниматься отдельным вызовом метода UnlockRange.
Позиционирование
Чтобы переместить указатель текущей позиции файла в новое положение, можно воспользоваться одним из следующих методов класса CFile - Seek, SeekToBegin, SeekToEnd. В состав класса CFile также входят методы, позволяющие установить и изменить длину файла, - GetLength, SetLength.
При открытии файла указатель текущей позиции файла находится в самом начале файла. Когда порция данных прочитана или записана, то указатель текущей позиции перемещается в сторону конца файла и указывает на данные, которые будут читаться или записываться очередной операцией чтения или записи в файл.
Чтобы переместить указатель текущей позиции файла в любое место, можно воспользоваться универсальным методом Seek. Он позволяет переместить указатель на определенное число байт относительно начала, конца или текущей позиции указателя.
Чтобы переместить указатель в начало или конец файла, наиболее удобно использовать специальные методы. Метод SeekToBegin перемещает указатель в начало файла, а метод SeekToEnd - в его конец.
Но для определения длины открытого файла совсем необязательно перемещать его указатель. Можно воспользоваться методом GetLength. Этот метод также возвращает длину открытого файла в байтах. Метод SetLength позволяет изменить длину открытого файла. Если при помощи этого метода размер файла увеличивается, то значение последних байт не определено.
Текущую позицию указателя файла можно определить с помощью метода GetPosition. Возвращаемое методом GetPosition 32-разрядное значение определяет смещение указателя от начала файла.
Характеристики открытого файла
Чтобы определить расположение открытого файла на диске, надо вызвать метод GetFilePath. Этот метод возвращает объект класса CString, в котором содержится полный путь файла, включая имя диска, каталоги, имя файла и его расширение.
Если требуется определить только имя и расширение открытого файла, можно воспользоваться методом GetFileName. Он возвращает объект класса CString, в котором находится имя файла. В случае, когда нужно узнать только имя открытого файла без расширения, пользуются методом GetFileTitle.
Следующий метод класса CFile позволяет установить путь файла. Это метод не создает, не копирует и не изменяет имени файла, он только заполняет соответствующий элемент данных в объекте класса CFile.
Класс CMemFile
В библиотеку MFC входит класс CMemFile, наследуемый от базового класса CFile. Класс CMemFile представляет файл, размещенный, в оперативной памяти. С объектами класса CMemFile так же, как и с объектами класса CFile. Отличие заключается в том, что файл, связанный с объектом CMemFile, расположен не на диске, а в оперативной памяти компьютера. За счет этого операции с таким файлом происходят значительно быстрее, чем с обычными файлами.Работая с объектами класса CMemFile, можно использовать практически все методы класса CFile, которые были описаны выше. Можно записывать данные в такой файл или считывать их. Кроме этих методов в состав класса 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.
Если nGrowBytes больше нуля, то содержимое буфера lpBuffer игнорируется. Кроме того, если в такой файл записывается больше данных, чем помещается в отведенном буфере, то его размер автоматически увеличивается. Увеличение блока памяти файла происходит по частям по nGrowBytes байт.
Класс CMemFile позволяет получить указатель на область памяти, используемую файлом. Через этот указатель можно непосредственно работать с содержимым файла, не ограничивая себя методами класса CFile. Для получения указателя на буфер файла можно воспользоваться методом Detach. Перед этим полезно определить длину файла (и соответственно размер буфера памяти), вызвав метод GetLength.
Метод Detach закрывает данный файл и возвращает указатель на используемый им блок памяти. Если опять потребуется открыть файл и связать с ним оперативный блок памяти, нужно вызвать метод Attach.
Нужно отметить, что для управления буфером файла класс CMemFile вызывает стандартные функции malloc, realloc и free. Поэтому, чтобы не нарушать механизм управления памятью, буфер lpBuffer должен быть создан функциями malloc или calloc.
Класс CStdioFile
Тем, кто привык пользоваться функциями потокового ввода/вывода из стандартной библиотеки C и C++, следует обратить внимание на класс CStdioFile, наследованный от базового классаCFile. Этот класс позволяет выполнять буферизированный ввод/вывод в текстовом и двоичном режиме. Для объектов класса CStdioFile можно вызывать практически все методы класса CFile.
В класс CStdioFile входит элемент данных m_pStream, который содержит указатель на открытый файл. Если объект класса CStdioFile создан, но файл еще не открыт, либо закрыт, то m_pStream содержит константу NULL.
Класс CStdioFile имеет три различных конструктора. Первый конструктор класса CStdioFile не имеет параметров. Этот конструктор только создает объект класса, но не открывает никаких файлов. Чтобы открыть файл, надо вызвать метод Open базового класса CFile.
Второй конструктор класса CStdioFile можно вызвать, если файл уже открыт и нужно создать новый объект класса CStdioFile и связать с ним открытый файл. Этот конструктор можно использовать, если файл был открыт стандартной функцией fopen. Параметр метода должен содержать указатель на файл, полученный вызовом стандартной функции fopen.
Третий конструктор можно использовать, если надо создать объект класса CStdioFile, открыть новый файл и связать его с только что созданным объектом.
Для чтения и записи в текстовый файл класс CStdioFile включает два новых метода: ReadString и WriteString. Первый метод позволяет прочитать из файла строку символов, а второй метод - записать.
Классы в C++.
Одной из основных черт C++, которой нет в С, является концепция классов. По существу, классы - самое важное понятие в C++. Классы похожи на структуры языка С. Однако структура С определяет только данные, ассоциированные с этой структурой. Вот пример структуры С:struct CIRCLE
{
int radius;
int color;
{;
После того как вы объявили структуру, вы можете использовать ее в пределах вашей функции main (), как показано ниже:
void main()
CIRCLE MyCircle;
...
...
MyCircle.radius = 18;
MyCircle.color = 255; // 255 задает цвет
...
...
}
Со структурой MyCircle (представляющей окружность) ассоциируются данные radius и color (радиус и цвет). Класс в C++, с другой стороны, имеет как ассоциированные с ним данные, так и функции. Данные класса называются элементами данных, а функции класса - элементами-функциями. Следовательно, в программе, которая использует классы, можно написать следующий код:
MyCircle.radius = 20;
MyCircle.color = 255;
MyCircle.DisplayCircle() ;
Первые два оператора присваивают значения элементам данных MyCircle radius и color; третий оператор вызывает функцию-элемент DisplayCircle() для вывода окружности MyCircle. MyCircle называется объектом класса circle. Ваша программа может объявить другой объект с именем HerCircle класса circle следующим образом:
CIRCLE HerCircle;
Следующие операторы присваивают значения элементам данных HerCircle radius и color:
HerCircle.radius = 30;
HerCircle.color = 0;
Затем вы можете использовать функцию-элемент DisplayCircie () для вывода окружности HerCircle:
HerCircle.DisplayCircle();
Объявление класса
Перед тем как работать с классом, ваша программа должна его объявить (так же как перед работой со структурой mystructure вы должны были объявить ее элементы данных). В данном разделе вы познакомитесь с синтаксисом объявления класса. Вы будете и дальше практиковаться с классом circle:
class Circle (
public:
Circle () ;
void SetRadius(void) ;
void GetRadius(void) ;
~Circle () ;
private:
void CalculateArea(void);
int radius;
int color;
};
Объявление класса имеет следующее строение:
class Circle {
...
...
Здесь вы вводите объявление класса
...
...
};
Ключевое слово class показывает компилятору, что все находящееся в фигурных скобках ({}) принадлежит объявлению класса. (Не забывайте ставить точку с запятой в конце объявления.) Объявление класса содержит объявление элементов данных (например, int radius) и прототипы функций-элементов класса. В объявлении класса circle содержатся следующие элементы данных:
int radius;
int color;
Объявление также содержит пять прототипов функций-элементов:
Circle();
void SetRadius(void) ;
void GetRadius(void) ;
~Circle () ;
void CalculateArea(void);
Первый и четвертый прототипы выглядят странно. Первый из них является прототипом функции конструктора:
Circle();
Вы узнаете о роли конструктора позже в этом разделе, а пока запомните синтаксис, который используется в C++ для прототипа функции конструктора. Когда вы записываете прототип конструктора, вы должны следовать правилам, приведенным ниже:
• Каждое объявление класса должно включать прототип функции конструктора.
• Имя функции конструктора должно совпадать с именем класса, а после него должны следовать круглые скобки (). Если, например, вы объявляете класс с именем Rectangle, он должен включать объявление функции конструктора класса: Rectangle (). Следовательно, объявление класса Rectangle должно выглядеть так:
class Rectangle
{
public:
Rectangle(); // Конструктор
...
...
private:
...
...
};
• Не упоминайте никакого возвращаемого значения для функции конструктора. (Функция конструктора должна иметь тип void, но не нужно это указывать.)
• Функция конструктора должна располагаться под ключевым словом
public.
Функция конструктора всегда возвращает значение типа void (несмотря на то, что вы не указали его в прототипе). Как вы вскоре увидите, функция конструктора обычно имеет один или большее число параметров.
Функция деструктора
Функция деструктора записывается в объявлении класса следующим образом:
class Circle
(
public:
...
...
~Circle (); //Деструктор private:
...
...
};
Обратите внимание на символ тильды (~), который предшествует прототипу функции деструктора. (На большинстве клавиатур вы можете найти символ тильды слева от клавиши 1.) При записи прототипа функции деструктора соблюдайте следующие правила:
• Имя функции деструктора должно совпадать с именем класса и ему должен предшествовать символ ~. Если, например, вы объявляете класс с именем Rectangle, именем функции деструктора должно быть ~Rectangle. Следовательно, объявление класса Rectangle должно выглядеть следующим образом:
class Rectangle
{
public:
Rectangle(); // Конструктор
...
~Rectangle(); // Деструктор private:
...
...
};
• Не указывайте никакого возвращаемого значения для функции деструктора. (Функция деструктора должна иметь тип void, но не нужно это указывать.)
• Функция деструктора не имеет никаких параметров.
Ключевые слова public и private
Прототипы функций и объявления элементов данных включаются в объявлении класса в разделы public (открытый) или private (закрытый). Ключевые слова public и private говорят компилятору о доступности элементов-функций и данных. Например, функция SetRadius() определена в разделе public, и это означает, что любая функция программы может вызвать функцию SetRadius(). Функция CalculateArea() определена в разделе private, и эту функцию можно вызвать только в коде функций-элементов класса Circle.
Аналогично, поскольку элемент данных radius объявлен в разделе private, прямой доступ к нему (для установки или чтения его значения) возможен только в коде функций-элементов класса Circle. Если бы вы объявили элемент данных radius в разделе public, то любая функция программы имела бы доступ (для чтения и присваивания) к элементу данных radius.
Перегруженные функции
В C++ (но не в С) вы можете использовать одно и то же имя для нескольких функций. Например, вы можете объявить две функции с именем SetRadius() в объявлении класса CCircle. Такие функции называются перегруженными функциями.
Консольное приложение
Для того, чтобы включить использование MFC в ваше консольное приложение, вам надо написать следующий код:#include
#include
int main( int argc, char* argv[] )
{
if ( !AfxWinInit( ::GetModuleHandle( NULL ), NULL, ::GetCommandLine( ), 0 ) )
{
cerr return 1;
}
// код вашей программы
return 0;
}
После того, как Вы набрали код, обязательно сделайте следующее:
Запустите программу - Build / Rebuild all ( будут ошибки ), выберите Build / Set active configuration - Win 32 Realise, выберите пункт меню "Project", далее "Settings...", закладку "C/C++", Category - Code Generation и в пункте "Use run-time library" выберите "Multithreaded". После этого сделайте опять Build / Rebuild all и программа будет работать.
Если MFC инициализировалась правильно, то будет выполняться код вашей программы, если нет - выведется сообщение "MFC Failed to initialize." Если что то не так, проверте наличие библиотеки "afxwin.h" и правильность написания кода или возьмите готовую программу
Кроме того после удачного завершения accept:
Методы для рисования линий и фигур
Пикселы
Для установки цвета пикселя с логическими координатами (x,y) используются метод SetPixel. Получить значение цвета пикселя можно методом GetPixel.
Цвет задается функцией RGB. Как уже отмечалось выше, если в физической палитре нет данного цвета, задаваемого фактическим параметром, Windows устанавливает наиболее близкий цвет. Он-то и возвращается методом SetPixel. Следует также отметить, что, хотя координаты являются логическими, устанавливается цвет только одного пикселя, даже если единица измерения для текущей системы координат иная.
Линии
Прежде, чем описывать методы для рисования линий, рассмотрим два важных для них атрибута контекста устройства.
Первый называют текущим пером. Его значением является перо как объект GDI. Любая линия (в том числе и ограничивающая фигуру) рисуется пером. Если метод не содержит явного параметра, задающего перо, то для рисования берется текущее перо, которое можно установить методом SelectObject. Или, если в качестве параметра передать одну из констант BLACK_PEN, NULL_PEN, WHITE_PEN, то методом SelectStockObject
Второй важный атрибут - текущая позиция пера. Чтобы изменить координаты текущей позиции пера, используются метод MoveTo. Чтобы нарисовать прямую линию от текущей позиции пера до нужной точки с логическими координатами (x,y), используется метод LineTo. После выполнения метода LineTo заданная в нем точка становится текущей позицией пера.
Если имеется массив точек и требуется соединить линией каждую следующую точку с предыдущей, можно использовать метод PolyLine, в котором первый параметр - указатель на массив элементов типа POINT, а второй равен количеству точек. При выполнении этого метода текущая позиция пера не изменяется.
Следующий метод аналогичен PolyLine за исключением того, что он устанавливает текущую позицию пера равной последней точке массива - PolyLineTo.
Если же требуется соединить между собой все точки, содержащиеся в массиве, можно вызвать метод PolyPolyline.
Фигуры
В Visual C++ имеются методы для рисования: прямоугольника (Rectangle); эллипса (Ellipse); скругленного прямоугольника (RoundRect); сегмента эллипса (Chord); сектора эллипса (Pie); замкнутого многоугольника; составного замкнутого многоугольника.
Для рисования фигур важен атрибут контекста устройства, называемый текущей кистью. Он задает кисть как объект GDI, с помощью которого производится закрашивание внутренней области фигуры. Текущая кисть устанавливается методом SelectObject или SelectStockObject, если в качестве параметра передать одну из констант: BLACK_BRUSH, DKGRAY_BRUSH, GRAY_BRUSH, HOLLOW_BRUSH, LTGRAY_BRUSH, NULL_BRUSH, WHITE_BRUSH.
Методы класса CButton
HBITMAP GetBitmap() const;
Возвращает дескриптор растрового изображения, сопоставленного кнопке. Если такового не существует, то возвращается NULL.
HBITMAP SetBitmap(HBITMAP hBitmap);
Сопоставляет кнопке растровое изображение. Значением параметра должен быть дескриптор растрового изображения. Правила размещения растрового изображения такие же, как и у значка.
HCURSOR GetCursor();
Возвращает дескриптор курсора, сопоставленного кнопке методом SetCursor. Если у кнопки нет сопоставленного курсора, то возвращается NULL.
HCURSOR SetCursor(HCURSOR hCursot);
Сопоставляет кнопке курсор, изображение которого будет помещено на поверхность кнопки аналогично значку и растровому изображению.
UINT GetState() const;
Возвращает описание набора текущих состояний кнопки. Чтобы выделить из этого описания значения конкретных типов состояния, можно использовать маски:
int GetCheck() const;
Возвращает собственное состояние флажка или переключателя. Возвращаемое значение может принимать одно из значений: 0 - кнопка не выбрана; 1 - кнопка выбрана; 2 - кнопка в неопределенном состоянии. Если кнопка не является ни переключателем, ни флажком, возвращается 0.
void SetCheck(int nCheck);
Устанавливает собственное состояние флажка или переключателя. Значения задаются из набора: 0 - невыбранное; 1 - выбранное; 2 - неопределенное. Значение 2 применимо только к флажку со свойством 3State.
UINT GetButtonStyle() const;
Возвращает стиль кнопки.
void SetButtonStyle(UINT nStyle, BOOL bRedraw=TRUE);
Устанавливает стиль кнопки. Если параметр bRedraw равен TRUE, кнопка перерисовывается.
HICON GetIcon() const;
Возвращает дескриптор пиктограммы, сопоставленной кнопке. Если у кнопки нет сопоставленной пиктограммы, возвращает NULL.
HICON SetIcon(HICON hIcon);
Сопоставляет кнопке пиктограмму. Значением параметра при вызове должен быть дескриптор пиктограммы.
Пиктограмма автоматически помешается на поверхность кнопки и сдвигается в ее центр. Если поверхность кнопки меньше пиктограммы, она обрезается со всех сторон до размеров кнопки. Положение пиктограммы может быть выровнено и не по центру. Для этого нужно, чтобы кнопка имела одно из следующих свойств: BS_LEFT, BS_RIGHT, BS_CENTER, BS_TOP, BS_BOTTOM, BS_VCENTER
Данный метод устанавливает для кнопки только одну пиктограмму, которая будет наравне с текстом присутствовать при любом ее состоянии. Не надо путать ее с растровым изображением у растровой кнопки.
Методы класса CComboBox
int GetCurSel() const;Возвращает целочисленный указатель выбранной строчки.
int SetCurSel(int nSelect);;
Ставит указатель на строчку с номером nSelect.
int GetLBText(int nIndex, LPTSTR lpszText) const;
void GetLBText(int nIndex, CString& rString) const;
Записывает содержимое строчки с индексом nIndex в переменные LPTSTR lpszText или CString& rString.
int GetLBTextLen(int nIndex) const;
Возвращает длину строчки с индексом nIndex.
int AddString(LPCTSTR lpszString);
Добавляет строчку в список.
int DeleteString(UINT nIndex);
Удаление строчки с индексом nIndex.
int InsertString(int nIndex, LPCTSTR lpszString);
Заменяет строчку с индексом nIndex содержимым переменной LPCTSTR lpszString.
Методы класса CEdit
Окна редактирования могут работать в режимах однострочного и многострочного редакторов. Приведем сначала методы, общие для обоих режимов, а затем методы для многострочного редактора.Общие методы :
DWORD GetSel() const;
void GetSel(int& nStartChar, int& nEndChar) const;
Получает первую и последнюю позиции выделенного текста. Для значения типа DWORD младшее слово содержит позицию первого, старшее - последнего символа.
void SetSel(DWORD dwSelection, BOOL bNoScroll=FALSE);
void SetSel(int nStartChar, int nEndChar, BOOL bNoScroll=FALSE);
Устанавливает новое выделение текста, задавая первый и последний выделенный символ. Значение FALSE параметра bNoScroll должно отключать перемещение курсора в область видимости.
void ReplaceSel(LPCTSTR lpszNewText);
Заменяет выделенный текст на строку, передаваемую в параметре lpszNewText.
void Clear();
Удаляет выделенный текст.
void Copy();
Копирует выделенный текст в буфер.
void Cut();
Переносит (копирует и удаляет) выделенный текст в буфер обмена.
void Paste();
Вставляет текст из буфера обмена, начиная с позиции, в которой находится курсор.
BOOL Undo();
Отмена последней операции, выполненной редактором. Если редактор однострочный, возвращается всегда неотрицательное значение, иначе неотрицательное значение возвращается лишь в случае успешной замены.
BOOL CanUndo() const;
Определяет, можно ли отменить последнюю операцию редактора.
void EmptyUndoBuffer();
Сбрасывает флаг undo, сигнализирующий о возможности отмены последней операции редактора, и тем самым делает невозможным отмену. Этот флаг сбрасывается автоматически при выполнении методов SetWindowText и SetHandle.
BOOL GetModify() const;
Возвращает неотрицательное значение, если содержимое окна редактирования не модифицировалось. Информация о модификации поддерживается в специальном флаге, обнуляемом при создании окна редактирования и при вызове метода:
void SetModify(BOOL bModified=TRUE);
Устанавливает или сбрасывает флаг модификации (см. предыдущий метод). Флаг сбрасывается при вызове метода с параметром FALSE и устанавливается при модификации содержимого окна редактирования или при вызове SetModify с параметром TRUE.
BOOL SetReadOnly(BOOL bReadOnly=TRUE);
Устанавливает режим просмотра (bReadOnly=TRUE) или редактирования (bReadOnly=FALSE).
TCHAR GetPasswordChar() const;
Возвращает символ, который при выводе пароля будет появляться на экране вместо символов, набираемых пользователем. Если такой символ не определен, возвращается 0. Устанавливается этот символ методом (по умолчанию используется "*"):
void SetPasswordChar(TCHAR ch);
void LimitText(int nChars=0);
Устанавливает максимальную длину в байтах текста, который может ввести пользователь. Если значение параметра равно 0, длина текста устанавливается равной UINT_MAX.
Методы работы с многострочным редактором :
void LineScroll(int nLines, int nChars=0);
Прокручивает текст в области редактирования. Параметр nLimes задает число строк для вертикальной прокрутки. Окно редактирования не прокручивает текст дальше последней строки. При положительном значении параметра область редактирования сдвигается вдоль текста к последней строке, при отрицательной - к первой.
Параметр nChars задает число символов для горизонтальной прокрутки. Окно редактирования прокручивает текст вправо, даже если строки закончились. В этом случае в области редактирования появляются пробелы. При положительном значении параметра область редактирования сдвигается вдоль к концу строки, при отрицательном - к началу.
int GetFirstVisibleLine() const;
Возвращает номер первой видимой строки.
int GetLineCount() const;
Возвращает число строк текста, находящегося в буфере редактирования. Если текст не вводился, возвращает 1.
int GetLine(int nIndex, LPTSTR lpszBuffer) const;
int GetLine(int nIndex, LPTSTR lpszBuffer, int nMaxLength) const;
Копирует строку с номером, равным значению параметра nIndex, в буфер, заданный параметром lpszBuffer. Первое слово в буфере должно задавать его размер. При вызове второго варианта метода значение параметра nMaxLength копируется в первое слово буфера.
Метод возвращает число в действительности скопированных байтов. Если номер строки больше или равен числу строк в буфере окна редактирования, возвращает 0. Текст копируется без каких-либо изменений, нуль-символ не добавляется.
int LineIndex(int nLine=-1) const;
Возвращает номер первого символа в строке. Неотрицательное значение параметра принимается в качестве номера строки. Значение -1 задает текущую строку. Если номер строки больше или равен числу строк в буфере окна редактирования (строки нумеруются с 0), возвращается 0.
Методы класса CListBox
void ResetContent();
Очищает содержимое списка, делая его пустым.
int AddString( LPCSTR lpszItem);
Добавляет строку lpszItem в список и сортирует его, если при создании включено свойство Sort. В противном случае элемент добавляется в конец списка.
int DeleteString( UINT nIndex);
Удаляет из списка элемент с индексом nIndex. Индексация элементов начинается с 0.
int GetCurSel() const;
Получает индекс элемента, выбранного пользователем.
int SetCurSel( int nSelect);
Отмечает элемент с индексом nSelect как выбранный элемент списка. Если значение параметра равно -1, список не будет содержать отмеченных элементов.
int GetText( int nIndex, LPSTR lpszBuffer) const;
void GetText( int nIndex, CString& rString) const;
Копирует элемент с индексом nIndex в буфер.
int SetTopIndex( int nIndex);
Организует прокрутку списка в окне так, чтобы элемент с индексом nIndex был видимым.
int FindString( int nStartAfter, LPCSTR lpszItem) const;
Организует поиск в списке и возвращает в качестве результата индекс элемента списка, префикс которого совпадает со строкой lpszItem. Результат не зависит от регистра, в котором набирались символы сравниваемых строк. Параметр nStartAfter задает начало поиска, но поиск идет по всему списку. Он начинается от элемента, следующего за nStartAfter, до конца списка и затем продолжается от начала списка до элемента с индексом nStartAfter. В качестве результата выдается первый найденный элемент, удовлетворяющий условиям поиска. Если такого нет, результат получает значение LB_ERR.
int FindStringExact( int nIndexStart, LPCSTR lpszFind) const;
Этот метод отличается от предыдущего тем, что теперь не префикс элемента должен совпадать со строкой lpszFind, а сам элемент. Поиск по-прежнему не чувствителен к регистру, в котором набираются символы.
Методы класса CProgressCtrl
void SetRange(short nLower, short nUpper);void SetRange32(int nLower, int nUpper);
Устанавливает минимальное ( nLower ) и максимальное значение ( nUpper ).
void GetRange(int& nLower, int& nUpper);
Записывает в переменные nLower и nUpper минимальное и максимальное значение.
int GetPos();
Возвращает текущее значение.
int SetPos(int nPos);
Устанавливает текущее значение в nPos.
int SetStep(int nStep);
Устанавливает шаг ( nStep ) вывода.
Методы класса CSliderCtrl
int GetRangeMax() const;int GetRangeMin() const;
void GetRange(int& nMin, int& nMax) const;
Первые две функции возвращают максимальное и минимальное знанение, а третья - записывает эти значения в nMax и nMin соответственно.
void SetRangeMin(int nMin, BOOL bRedraw = FALSE);
void SetRangeMax(int nMax, BOOL bRedraw = FALSE);
void SetRange(int nMin, int nMax, BOOL bRedraw = FALSE);
Первые две функции устанавливают максимальное и минимальное знанение, а третья - устанавливает эти значения из переменных nMax и nMin соответственно. Аргумент bRedraw отвечает за перерисовку слайдера.
int GetPos() const;
Возвращает текущую позицию.
void SetPos(int nPos);
Устанавливает текущую позицию в nPos.
BOOL SetTic(int nTic);
Устанавливает шаг ( nTic ).
void SetTicFreq(int nFreq);
Устанавливает частоту засечек ( nFreq ).
Методы класса CSpinButtonCtrl
int SetPos(int nPos);Устанавливает текущую позицию в nPos.
int GetPos() const;;
Возвращает текущую позицию.
void SetRange(int nLower, int nUpper);
void SetRange32(int nLower, int nUpper);
Устанавливает максимальное и минимальное знанение из переменных nMax и nMin соответственно.
void GetRange(int &lower, int& upper) const;
void GetRange32(int &lower, int& upper) const;;
Эти две функции записывают максимальное и минимальное знанение в upper и lower соответственно.
Можно также сослаться на функцию
pfnMyFunction=(PFN_MyFunction)::GetProcAddress(hMyDll, MAKEINTRESOURCE(1));Начиная с версии MFC позволяет
if(dwReason == DLL_PROCESS_DETACH) { AfxTermExtensionModule(MyExtDLL); }Некоторые сведения о программировании Windows-приложений
MFC – это базовый набор (библиотека) классов, написанных на языке С++ и предназначенных для упрощения и ускорения процесса программирования под Windows. Перед изучением библиотеки MFC и ее использованием для создания Windows-приложений, следует вспомнить, как работает сама Windows и каковы принципы взаимодействия программ с ней, какова структура типичной Windows-программы.Объекты GDI
При рисовании фигур в Visual C++ используются специальные объекты GDI, т.е. объекты интерфейса графического устройства (GDI - Graphics Device Interface) системы Windows.Название | Класс | Тип определителя в Windows | |||
Перо | CPen | HPEN | |||
Кисть | CBrush | HBRUSH | |||
Шрифт | CFont | HFONT | |||
Растровое изображение | CBitmap | HBITMAP | |||
Палитра | CPalette | HPALETTE | |||
Область (регион) | CRgn | HRGN |
Как и любые другие объекты в Visual C++, они должны быть созданы соответствующим образом. Создание объекта должно включать в себя и связывание с соответствующим объектом системы Windows. Эта операция осуществляется методом, имя которого начинается с префикса Create. Он может быть выполнен как после создания объекта Visual C++, так и в конструкторе объекта:
CPen Pen1; Pen1.CreatePen(PS_DOT, 5, RGB(0,0,0)); // вариант 1
CPen Pen2(PS_DOT, 5, Rface="Courier New">GB(0,0,0)); // вариант 2
При завершении работы с объектом GDI необходимо обеспечить (вернее, не нарушать) его автоматическое удаление при выходе из соответствующей области видимости.
Перо
- объект для рисования линий. При создании пера можно задать его ширину, цвет и тип линии. Для создания пера используются метод CreatePen.
Кисть
представляет собой растровое изображение размером 8х8 пикселей для заполнения различных областей. Различают два варианта понятия кисти: логическая и физическая. Объект GDI задает логическую кисть, которая определяет полный набор свойств: цвет, стиль и т.п., - указываемых при ее создании. Возможно, не все эти свойства могут быть реализованы на данном компьютере. Свойства физической кисти реально воспроизводятся физическими устройствами. Они являются наиболее близким реализуемым приближением к свойствам логической кисти.
Различают четыре вида логических кистей, для создания которых используются различные методы:
Для создания сплошной кисти, все пиксели которой одного цвета, используется метод CreateSolidBrush. Стандартные кисти уже имеются в операционной системе (таких кистей 7). Чтобы их создать, используется метод CreateStockBrush. Этот метод на самом деле создает только объект класса CBrush. Сама кисть берется готовой из операционной системы. Штриховые кисти имеют цвет и штриховой рисунок. Имеется 6 видов рисунка. Кисти создаются такими методами CreateHatchBrush и GreateSysColorBrush. Шаблонные кисти могут иметь произвольный рисунок, задаваемый растровым изображением (BMP), либо аппаратно-независимым растровым изображением (DIB). Для создания кисти используются методы CreatePatternBrush, CreateDIBPatternBrush.
Растровое изображение представляет собой объект, инкапсулирующий прямоугольную область, состоящую из пикселов. Создав такой объект, можно затем задавать в этой области любое изображение, а также считывать и записывать ее в файл и производить с ней другие действия.
Палитры
появились потому, что многие типы мониторов физически могут воспроизводить очень много цветов, а видеокартам не хватает видеопамяти, чтобы поддерживать все цвета одновременно. Например, монитор воспроизводит сотни тысяч цветов, а видеокарта отводит для одного пиксела байт и тем самым может хранить 256 цветов для окраски одной точки. Для более полного использования возможностей монитора и существуют палитры. Они сопоставляют цвета числам от 0 до 2n-1, которые могут храниться в ячейке, отведенной для одного пиксела.
В Windows различают понятия физической и логической палитры. Логическая предназначена для работы самого приложения. Программист не ограничен в выборе палитры. Два приложения могут использовать две различные палитры и осуществлять вывод на один и тот же экран. При этом физическая, естественно, может быть установлена только одна.
Когда нужного цвета логической палитры нет в физической, Windows пытается добавить его, а если это невозможно, коммутирует этот цвет логической палитры с наиболее близким цветом физической.
Для создания палитры используются методы CreatePalette и CreateHalftonePalette. Созданную палитру можно изменить методом SetPaletteEntries.
В Windows существует еще один способ управления цветом - макросом RGB. Он задает функцию, возвращающую значение типа COLORREF. У нее три параметра, задающий красный, зеленый и голубой компонент устанавливаемого цвета. Каждый компонент может принимать значения от 0 до 255. Итоговый цвет получается смешением красного, зеленого и синего цветов в соответствующих пропорциях.
Обзор среды Microsoft Developer Studio
Студия разработчика фирмы Microsoft (Microsoft Developer Studio) - это интегрированная среда для разработки, позволяющая функционировать различным средам разработки, одна из которых Visual C++, другая - Visual J++. В дальнейшем будет идти речь только о среде разработки Visual C++.В студии разработчика можно строить обычные программы на C и С++, создавать статические и динамические библиотеки, но основным режимом работы является создание Windows-приложений с помощью инструмента MFC AppWizard (Application Wizard - мастер приложений) и библиотеки базовых классов MFC (Microsoft Foundation Class Library). Такие приложения называются MFC-приложениями. Главная особенность этих Windows-приложений состоит в том, что они работают как совокупность взаимодействующих объектов, классы которых определены библиотекой MFC.
Обзор возможностей ClassWizard
Средство ClassWizard предоставляет широкий спектр услуг. Он позволяет не только добавлять к существующему классу новые методы и данные.Создание нового класса.
При помощи ClassWizard можно добавить новый класс, созданный на основе базовых классов. В качестве базового класса можно использовать классы, наследованные от класса CCmdTarget или класса CRecordset. Для наследования классов от других базовых классов использовать средства ClassWizard нельзя. Такие классы надо создавать вручную, непосредственно в текстовом редакторе.
Объекты, порожденные от класса CCmdTarget, могут обрабатывать сообщения Windows и команды, поступающие от меню, кнопок, акселераторов. Класс CCmdTarget и другие наследованные от него классы имеют таблицу сообщений (Message Map) - набор макрокоманд, позволяющий сопоставить сообщения Windows и команды метода класса.
Полученная заготовка класса полностью работоспособна. Ее можно дополнить по своему усмотрению новыми методами и данными. Эту работу можно выполнить вручную, но гораздо лучше и проще воспользоваться услугами ClassWizard. За счет использования ClassWizard процедура создания собственного класса значительно ускоряется и уменьшается вероятность совершить ошибку во время объявления методов.
Включение в класс новых методов.
Очень удобно использовать ClassWizard для включения в состав класса новых методов. Можно добавлять к классу методы, служащие для обработки сообщений Windows и команд от объектов, а также методы, переопределяющие виртуальные методы базовых классов.
ClassWizard не только позволяет добавить в класс новые методы, но и удалить их. ClassWizard самостоятельно удалит объявление метода из класса.
Включение в класс новых элементов данных.
ClassWizard позволяет включать в класс не только новые методы, но и элементы данных, связанные с полями диалоговых панелей, форм просмотра и форм для просмотра записей баз данных и полей наборов записей. ClassWizard использует специальные процедуры, чтобы привязать созданные им элементы данных к класса к полям диалоговых панелей. Эти процедуры носят названия "обмен данными диалоговой панели" и "проверка данных диалоговой панели" (Dialog Data Exchange and Dialog Data Validation - DDX/DDV). Чтобы привязать поля из наборов записей к переменным, используется процедура обмена данными с полями записей (Record Field Exchange - RFX).
Процедуры DDX/DDV и RFX значительно упрощают программисту работу с диалоговыми панелями. Они позволяют связать поля диалоговых панелей и переменные. Когда пользователь редактирует поля диалоговых панелей, процедуры DDV проверяют введенные значения и блокируют ввод запрещенных значений. Затем процедуры DDX автоматически копируют содержимое полей диалоговых панелей в привязанные к ним элементы данных класса. И наоборот, когда приложение изменяет элементы данных класса, привязанные к полям диалоговой панели, процедуры DDX могут сразу отобразить новые значения полей на экране компьютера.
Описание класса CView
Объекты класса CView имеют окно, представляющее собой обычную прямоугольную область экрана, без рамки, меню и других элементов. Вывод в такое окно (в том числе и текста) производится в графическом виде. При работе с этим классом очень важны моменты, рассматриваемые ниже.Сообщение и метод OnDraw
Предположим, в окне отображен какой-либо рисунок, который затем перекрыт другим окном, а через некоторое время верхнее окно сдвигается с рисунка. Если перекрывающее окно небольшое, например, окно меню, то при его закрытии перекрытая часть восстанавливается системой Windows. В большинстве же случаев Windows обращается за помощью к владеющему окном приложению и посылает ему сообщение о необходимости восстановить окно. Дело разработчика приложения, реагировать на это сообщение или нет. Если обработка сообщения не предусмотрена, то велика вероятность исчезновения части рисунка из окна.
Итак, для обеспечения корректного отображения информации в окне нужна функция, которая будет перерисовывать содержимое окна всякий раз, когда оно потребуется. Для этого служит метод OnDraw . В качестве параметра этому методу передается указатель на контекст устройства, используя который, можно перерисовать окно.
Графическое устройство и его контекст
Работа с графическими устройствами, такими, как принтер, плоттер, дисплей в системе Windows вообще и в Visual C++ в частности является аппаратно-независимой. Это значит, что при программировании под Windows средств прямого доступа к аппаратуре нет. Все взаимодействие с ней производится через функции API (Application Program Interface). При этом для вывода на графические устройства используется один и тот же набор функций.
Для того, чтобы определить, на какое устройство осуществляется вывод, в Windows и в Visual C++ используется понятие контекста устройства (device context). Далее везде будет рассматриваться контекст устройства, реализованный в Visual C++. Контекст устройства - это объект класса CDC, содержащий все методы для построения изображения в окне. Кроме того, он содержит данные о графическом устройстве вывода. Для осуществления вывода создается контекст устройства и тем самым определяется конкретное устройство для вывода. А далее к созданному объекту можно применять все имеющиеся методы класса CDC.
При выводе многие параметры долгое время остаются неизменными, например, цвет линии и другие. Указывать все такие параметры при каждом обращении к методам вывода неудобно. Контекст устройства содержит целый ряд таких параметров, обычно их называют атрибутами контекста устройства. Методы имеют лишь те параметры, что определяют существо их действия, а остальные атрибуты для рисования берутся из контекста устройства. При создании контекста устройства его атрибуты устанавливаются по умолчанию. Затем их можно изменять методами класса CDC.
Поврежденная область и поврежденный прямоугольник
При работе с окнами обычно "повреждается" только часть окна, так что перерисовывать все окно неэкономно. Поэтому система Windows фиксирует не только необходимость перерисовки, но и информацию о поврежденной области (invalid region). Но более важным является понятие поврежденный прямоугольник (invalid rectangle) - минимальный прямоугольник, покрывающий поврежденную область. Windows и Visual C++ обеспечивают следующие возможности при работе с поврежденным прямоугольником:
Методы GetUpdateRect и GetUpdateRgn класса CWnd позволяют получить описание поврежденного прямоугольника и поврежденной области.
Если производить перерисовку стандартным путем (например, внутри метода обработки сообщения OnDraw), то рисование в окне результативно только в области поврежденного прямоугольника. В этом случае говорят, что поврежденный прямоугольник задает область усечения, вне которой содержимое окна не изменяется.
Если в момент возникновения поврежденной области сформированное ранее системой Windows сообщение WM_PAINT о необходимости перерисовки окна не было обработано приложением и стоит в очереди приложения, новое сообщение WM_PAINT в очередь не добавляется. В качестве поврежденной области берется минимальный прямоугольник, покрывающий одновременно старый и новый прямоугольники.
Методы Invalidate, InvalidateRect и InvalidateRgn класса CWnd позволяют объявить соответственно клиентскую область, некоторые прямоугольник и область окна поврежденными и послать сообщение WM_PAINT в очередь приложения.
Методы ValidateRect и ValidateRgn класса CWnd позволяют отменить объявление некоторого прямоугольника или области поврежденными. Это ведет к корректировке текущего поврежденного прямоугольника.
При создании окна поврежденный прямоугольник устанавливается равным клиентской части окна. Обработчик сообщения Update класса CView также устанавливает поврежденный прямоугольник равным клиентской части окна.
Основы программирования под Windows
Поскольку архитектура Windows-программ основана на принципе сообщений, все эти программы содержат некоторые общие компоненты. Обычно их приходится в явном виде включать в исходный код. Но, к счастью, при использовании библиотеки MFC это происходит автоматически; нет необходимости тратить время и усилия на их написание. Тем не менее, чтобы до конца разобраться, как работает Windows-программа, написанная с использованием MFC, и почему она работает именно так, необходимо в общих чертах понять назначение этих компонентов.Функция WinMain()
Все Windows-программы начинают выполнение с вызова функции WinMain(). При традиционном методе программирования это нужно делать явно. С использованием библиотеки MFC такая необходимость отпадает, но функция все-таки существует.
Функция окна
Все Windows-программы должны содержать специальную функцию, которая не используется в самой программе, но вызывается самой операционной системой. Эту функцию обычно называют функцией окна, или процедурой окна. Она вызывается Windows, когда системе необходимо передать сообщение в программу. Именно через нее осуществляется взаимодействие между программой и системой. Функция окна передает сообщение в своих аргументах. Согласно терминологии Windows, функции, вызываемые системой, называются функциями обратного вызова. Таким образом, функция окна является функцией обратного вызова.
Помимо принятия сообщения от Windows, функция окна должна вызывать выполнение действия, указанного в сообщении. Конечно, программа не обязана отвечать на все сообщения, посылаемые Windows. Поскольку их могут быть сотни, то большинство сообщений обычно обрабатывается самой системой, а программе достаточно поручить Windows выполнить действия, предусмотренные по умолчанию.
В большинстве Windows-программ задача создания функции окна лежит на программисте. При использовании библиотеки MFC такая функция создается автоматически. В этом заключается одно из преимуществ библиотеки. Но в любом случае, если сообщение получено, то программа должна выполнить некоторое действие. Хотя она может вызывать для этого одну или несколько API-функций, само действие было инициировано Windows. Поэтому именно способ взаимодействия с операционной системой через сообщения диктует общий принцип построения всех программ для Windows, написанных как с использованием MFC, так и без нее.
Цикл сообщений
Как объяснялось выше, Windows взаимодействует с программой, посылая ей сообщения. Все приложения Windows должны организовать так называемый цикл сообщений (обычно внутри функции WinMain()). В этом цикле каждое необработанное сообщение должно быть извлечено из очереди сообщений данного приложения и передано назад в Windows, которая затем вызывает функцию окна программы с данным сообщением в качестве аргумента. В традиционных Windows-программах необходимо самостоятельно создавать и активизировать такой цикл. При использовании MFC это также выполняется автоматически. Однако важно помнить, что цикл сообщений все же существует. Он является неотъемлемой частью любого приложения Windows.
Процесс получения и обработки сообщений может показаться чересчур сложным, но тем не менее ему должны следовать все Windows-программы. К счастью, при использовании библиотеки MFC большинство частных деталей скрыты от программиста, хотя и продолжают неявно присутствовать в программе.
Класс окна
Как будет показано дальше, каждое окно в Windows-приложении характеризуется определенными атрибутами, называемыми классом окна. (Здесь понятие “класс” не идентично используемому в С++. Оно, скорее, означает стиль или тип.) В традиционной программе класс окна должен быть определен и зарегистрирован прежде, чем будет создано окно. При регистрации необходимо сообщить Windows, какой вид должно иметь окно и какую функцию оно выполняет. В то же время регистрация класса окна еще не означает создание самого окна. Для этого требуется выполнить дополнительные действия. При использовании библиотеки MFC создавать собственный класс окна нет необходимости. Вместо этого можно работать с одним из заранее определенных классов, описанных в библиотеке. В этом еще одно ее преимущество.
Специфика программ для Windows
Структура Windows-программ отличается от структуры программ других типов. Это вызвано двумя обстоятельствами: во-первых, способом взаимодействия между программой и Windows, описанным выше; во-вторых, правилами, которым следует подчиняться для создания стандартного интерфейса Windows-приложения (т.е. чтобы сделать программу “похожей “ на Windows-приложение).
Цель Windows – дать человеку, который хотя бы немного знаком с системой, возможность сесть за компьютер и запустить любое приложение без предварительной подготовки. Для этого Windows предоставляет дружественный интерфейс пользователя. Теоретически, если пользователь сумел запустить одно Windows-приложение, то он сумеет запустить и любое другое. Конечно, на практике придется немного потренироваться, чтобы научиться использовать большинство программ с максимальной эффективностью. Однако это связано исключительно с тем, что программа делает, а не с тем, как ею пользоваться. Ведь, фактически, значительная часть кода Windows-приложения предназначена именно для организации интерфейса с пользователем.
Хотя создание удобного интерфейса “под Windows” является основной задачей при написании любой Windows-программы, такой интерфейс не создается автоматически. То есть вполне можно написать программу, в которой элементы интерфейса используются неэффективно. Чтобы этого избежать, необходимо целенаправленно применять методику, описанную в данной книге. Только программы, написанные таким способом, будут выглядеть и работать действительно так, как надлежит Windows-программам.
Чтобы отойти от философии создания традиционного Windows-интерфейса, должны быть достаточно веские основания. Иначе пользователи этой программы будут разочарованы. В общем, если программист собирается писать приложения для Windows, то он должен дать пользователям возможность работать с обычным интерфейсом и руководствоваться стандартной методикой разработки.
Типы данных в Windows
В Windows-программах вообще (и в использующих библиотеку MFC в частности) не слишком широко применяются стандартные типы данных из С или С++, такие как int или char*. Вместо них используются типы данных, определенные в различных библиотечных (header) файлах. Наиболее часто используемыми типами являются HANDLE, HWND, BYTE, WORD, DWORD, UNIT, LONG, BOOL, LPSTR и LPCSTR. Тип HANDLE обозначает 32-разрядное целое, используемое в качестве дескриптора. Есть несколько похожих типов данных, но все они имеют ту же длину, что и HANDLE, и начинаются с литеры Н. Дескриптор – это просто число, определяющее некоторый ресурс. Например, тип HWND обозначает 32-разрядное целое – дескриптор окна. В программах, использующих библиотеку MFC, дескрипторы применяются не столь широко, как это имеет место в традиционных программах. Тип BYTE обозначает 8-разрядное беззнаковое символьное значение, тип WORD – 16-разрядное беззнаковое короткое целое, тип DWORD – беззнаковое длинное целое, тип UNIT - беззнаковое 32-разрядное целое. Тип LONG эквивалентен типу long. Тип BOOL обозначает целое и используется, когда значение может быть либо истинным, либо ложным. Тип LPSTR определяет указатель на строку, а LPCSTR – константный (const) указатель на строку.
Панель для выполнения поиска и замены (класс CFindReplaceDialog)
Класс CFindReplaceDialog предназначен для управления диалоговыми окнами Find и Replace. Диалоговая панель Find используется для поиска известных строк в документе приложения, а панель Replace позволяет замену одной строки на другую.Важным отличием диалоговых панелей Find и Replace от других стандартных диалоговых панелей является то, что они представляют собой немодальные диалоговые панели. Поэтому процесс создания этих панелей значительно отличается от процесса создания стандартных панелей для выбора цвета, шрифта и имен файла.
Панель для вывода документов на печать (класс CPrintDialog)
Класс CPrintDialog можно использовать для создания двух видов диалоговых панелей, предназначенных для печати документов и выбора форматов документов. Кроме класса CPrintDialog можно также использовать класс CPageSetupDialog. Он позволяет создать диалоговую панель для выбора формата документа, имеющую несколько иной вид.В приложениях, подготовленных с использованием средств MFC AppWizard и построенные по модели документ-облик, по умолчанию встроена возможность вывода редактируемого документа на печать.
В меню File такого приложения находятся три строки (Print, Print Preview и Print Setup), которые управляют процессом печати документов, подготовленных в приложении. Чтобы распечатать документ, достаточно выбрать из меню File строку Print. На экране появится диалоговая панель Print. В ней можно выбрать печатающее устройство для печати документов (группа Name), указать, будет печататься весь документ либо его часть (группа Print range), а также сколько копий документа будет напечатано (группа Copies). Также можно настроить различные характеристики печатающего устройства, если нажать кнопку Properties в группе Printer.
Если требуется определить только печатающее устройство и формат документа, из меню File следует выбрать строку Printer Setup. В группе Printer можно указать печатающее устройство и настроить его соответствующим образом. Группа Paper задает формат бумаги и режим подачи бумаги в печатающее устройство. Группа Orientation включает только один переключатель, определяющий ориентацию бумаги. Он принимает положение Portrait для вертикальной ориентации изображения на бумаге (режим "портрет") или Landscape для горизонтальной ориентации изоборажения на бумаге (режим "ландшафт").
Строка Print Preview меню File выбирается для предварительного просмотра документа перед печатью. При этом главное окно приложения изменит свой внешний вид и можно будет просмотреть, как будет выглядеть документ после печати.
Если не требуется выполнять специфическую обработку документа перед печатью, то вряд ли понадобится самостоятельное добавление программного кода, отвечающего за процесс печати. Просто следует отметить, что процедура создания панелей, связанных с печатью документа, практически ничем не отличается от создания выше описанных стандартных диалоговых панелей.
Панель выбора цвета (класс CColorDialog)
Чтобы отобразить на экране стандартную диалоговую панель выбора цвета, надо создать объект класса CColorDialog, а затем вызвать метод DoModal. При создании объекта класса СColorDialog используется следующий конструктор:CColorDialog(COLORREF clrInit=0,DWORD dwFlags=0,CWnd* pParentWnd=NULL);
Все параметры конструктора необязательны, однако в некоторых случаях использование этих параметров может помочь.
Первый параметр clrInit позволяет указать цвет, выбранный по умолчанию сразу после открытия диалоговой панели. Если параметр не будет указан, в качестве цвета, выбранного по умолчанию, будет использоваться черный цвет.
Параметр dwFlags содержит набор флагов, управляющих диалоговой панелью выбора цвета. При помощи него блокировать или разрешать работу некоторых элементов управления диалоговой панели выбора цвета. Если при создании объекта класса CColorDialog не указать параметр dwFlags, тем не менее можно выполнить настройку диалоговой панели, обратившись непосредственно к элементу m_cc данного класса. Параметр dwFlags, указанный в конструкторе, используется для инициализации m_cc. Изменения в элемент m_cc должны быть внесены до того, как панель будет отображаться на экране.
Последний параметр pParentWnd можно использовать, чтобы указать родительское окно диалоговой панели.
Методы класса CСolorDialog
Чтобы вывести диалоговую панель выбора цвета на экран, необходимо использовать метод DoModal. После отображения панели на экране пользователь может выбрать из нее цвет и нажать кнопки OK или Cancel для подтверждения выбора цвета или отказа от него. Когда диалоговая панель закрывается, метод DoModal возвращается значения IDOK и IDCANCEL, в зависимости от того, какую кнопку нажал пользователь:
CColorDialog dlgColor;
int iResult=dlgColor.DoModal();
На экране появится стандартная диалоговая панель выбора цвета Color. В верхней половине диалоговой панели расположены 48 прямоугольников, имеющих различные цвета. Они представляют так называемые основные цвета (Basic colors). Можно выбрать один из этих цветов и нажать кнопку OK. После того, как диалоговая панель закрыта (метод DoModal завершил свою работу), можно воспользоваться методами класса CColorDialog, чтобы узнать цвета, выбранные пользователем.
Для определения цвета, выбранного пользователем, можно обратиться к методу GetColor класса CColorDialog. Данный метод возвращает значение COLORREF, соответствующее выбранному цвету.
Если пользователю недостаточно основных цветов, представленных в диалоговой панели Color, он может выбрать до 16 дополнительных цветов. Для этого он должен нажать кнопку DefineCustom Colors. Диалоговая панель изменит свой внешний вид - появятся дополнительные органы управления, позволяющие выбрать любой из 16 777 216 цветов. Когда цвет выбран, нужно нажать кнопку Add Custom Colors. Выбранный цвет будет добавлен к дополнительным цветам (Custom colors) - один из свободных прямоугольников окрасится соответствующим цветом.
При помощи метода GetSavedCustomColors класса CColorDialog можно определить дополнительные цвета, выбранные пользователем в диалоговой панели Color. Этот метод возвращает указатель на массив из 16 элементов типа COLORREF. Каждый элемент массива описывает один дополнительный цвет.
Когда диалоговая панель Color отображается приложением первый раз, все прямоугольники, отображающие дополнительные цвета, имеют белый цвет. Дополнительные цвета, выбранные пользователем, сохраняются во время работы приложения. После перезапуска приложения дополнительные цвета сбрасываются.
Панель выбора файлов (класс CFileDialog)
Среди стандартных диалоговых панелей, для которых в библиотеке MFC создан специальный класс, есть панели для работы с файловой системой - Open и Save As. Диалоговая панель Open позволяет выбрать один или несколько файлов и открыть их для дальнейшего использования. Диалоговая панель Save As позволяет выбрать имя файла для записи в него документа.Для управления диалоговыми панелями Open и Save As предназначен один класс CFileDialog. Рассмотрим конструктор класса CFileDialog более подробно:
CFileDialog(BOOL bOpenFileDialog,
LPCTSTR lpszDefExt=NULL,LPCTSTR lpszFileName=NULL,
DWORD dwFlags=OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT,
LPCTSTR lpszFilter=NULL,CWnd* pParentWnd=NULL);
Объекты класса CFileDialog представляют диалоговые панели Open или Save As в зависимости от параметра bOpenFileDialog. Если параметр bOpenFileDialog содержит значение TRUE, то создается объект, управляющий диалоговой панелью Open, а если FALSE - диалоговой панелью Save As.
Параметр bOpenFileDialog является единственным обязательным параметром, который необходимо указать. Остальные параметры конструктора класса CFileDialog задают различные режимы работы панели и могут не указываться.
Чтобы создать объект класса CFileDialog , представляющий диалоговую панель для открытия файлов (mFileOpen), и объект, представляющий диалоговую панель для сохранения файлов (mFileSaveAs), можно воспользоваться следующими вызовами конструктора класса:
CFileDialog mFileOpen(TRUE); // для панели открытия файлов
CFileDialog mFileSaveAs(FA LSE); // для панели сохранения файла
Во многих случаях имена файлов, которые нужно открыть или закрыть, имеют определенное расширение. Параметр lpszDefExt позволяет задать расширение файлов, используемое по умолчанию. То есть, если пользователь при определении имени файла не укажет расширение, имени файла автоматически присваивается расширение, принятое по умолчанию. Если при определении свойств диалоговой панели программист присвоит параметру lpszDefExt значение NULL, то расширение файлов должно задаваться пользователем явно.
В некоторых случаях требуется, чтобы диалоговые панели отображались с уже выбранным именем файла. Чтобы указать имя файла, используемое по умолчанию, применяется параметр lpszFileName. Если параметр lpszFileName имеет значение NULL, данная возможность не реализуется.
С помощью флага dwFlags можно изменить внешний вид и некоторые другие характеристики стандартных диалоговых панелей класса CFileDialog. В него можно записать комбинацию флагов, управляющих различными характеристиками этих панелей. Например, флаг OFN_HIDEREADONLY означает, что из диалоговой панели удаляется переключатель "Read Only", а флаг OFN_OVERWRITEPROMPT (используемый для панели Save As) - что необходимо выводить диалоговую панель с предупреждением, если пользователь выбирает для сохранения имя уже существующего файла.
Диалоговые панели выбора файлов обычно имеют список так называемых фильтров, включающих названия типов файлов и расширения имен файлов данного типа. Выбрав фильтр, пользователь указывает, что он желает работать только с файлами определенного типа, имеющими соответствующее расширение. Файлы с другими расширениями в диалоговых панелях не отображаются.
Список фильтров можно указать через параметр lpszFilter. Одновременно можно указать несколько фильтров. Каждый фильтр задается двумя строками - строкой, содержащей имя фильтра, и строкой, в которой перечислены соответствующие ему расширения имен файлов. Если одному типу соответствует несколько расширений, они разделяются символом ;. Строка, содержащая имя фильтра, отделяется от строки с расширениями файлов символом |. Если используется несколько фильтров, то они также отделяются друг от друга символом |. Например, в качестве строки, задающей фильтры, можно использовать строку вида:
char szFilters[] =
" Data (*.dat) |*.dat| Packed Data (*.pac;*.wav) | *.pac; *.wav| All Files (*.*)| *.* ";
Диалоговые панели, представленные объектами класса CFileDialog, могут иметь или не иметь родительского окна. Чтобы указать родительское окно, нужно передать конструктору CFileDialog указатель на него через параметр pParentWnd.
Методы класса CFileDialog
Создание объекта класса CFileDialog еще не вызывает отображения соответствующей диалоговой панели. Для этого необходимо воспользоваться методом DoModal класса CFileDialog.При вызове метода DoModal для ранее созданного объекта класса CFileDialog на экране открывается соответствующая диалоговая панель. После того, как пользователь завершает работу с диалоговой панелью, метод DoModal вернет значение IDOK или IDCANCEL в случае успешного завершения и нуль - в случае возникновения ошибок:
CFileDialog dlgOpen(TRUE);
int iResult=dlgOpen.DoModal();
После того, как пользователь закроет диалоговую панель и метод DoModal вернет управление, можно воспользоваться другими методами класса CFileDialog , чтобы определить имена выбранных файлов:
Наиболее важный метод - GetPathName. Он получает полный путь файла, выбранного из диалоговых панелей Open или Save As. Если диалоговая панель позволяет выбрать сразу несколько файлов, тогда метод GetPathName возвращает массив строк, состоящий из нескольких строк, заканчивающихся двоичным нулем. Первая из данных строк содержит путь к каталогу, в котором расположены выбранные файлы, остальные строки содержат имена выбранных файлов. Выделение строки, содержащей путь к каталогу, проблем не вызывает, а чтобы получить имена выбранных файлов, необходимо воспользоваться методами GetStartPosition и GetNextPathName.
Метод GetStartPosition возвращает значение типа POSITION. Оно предназначено для передачи методу GetNextPathName и получения очередного имени выбранного файла. Если пользователь не выбрал ни одного файла, метод GetStartPosition возвращает значение NULL. Значение, полученное этим методом, следует записать во временную переменную типа POSITION и передать ссылку на нее методу GetNextPathName. Метод GetNextPathName вернет полный путь первого из выбранных в диалоговой панели файлов и изменит значение переменной pos, переданной методу по ссылке. Новое значение pos можно использовать для последующих вызовов метода GetNextPathName и получения путей всех остальных выбранных файлов. Когда метод GetNextPathName вернет имена всех выбранных файлов, в переменную pos записывается значение NULL.
В панелях Open и Save As имеется переключатель "ReadOnly". По умолчанию этот преключатель не отображается. Если есть необходимость воспользоваться этим переключателем, то нужно отказаться от использования флага OFN_HIDEREADONLY.
Метод GetReadOnlyPref позволяет определить положение переключателя "ReadOnly". Если переключатель включен, то метод GetReadOnlyPref возвращает ненулевое значение. В противном случае GetReadOnlyPref возвращает нуль.
Панель выбора шрифта (класс CFontDialog)
Стандартная диалоговая панель Font предназначена для выбора шрифта. Эта панель отображает список шрифтов, установленных в системе, и позволяет выбрать название шрифта, его начертание и другие параметры.Для управления диалоговой панелью Font в библиотеку классов MFC включен класс CFontDialog. Методы этого класса можно использовать для отображения панели Font и определения характеристик шрифта, выбранного пользователем. Конструктор класса CFontDialog:
CFontDialog(LPLOGFONT lplfInitial=NULL,
DWORD dwFlags=CF_EFFECTS | CF_SCREENFONTS,
CDC* pdcPrinter,CWnd* pParentWnd=NULL);
Все параметры конструктора являются необязательными. Настройка стандартной панели выбора шрифта, которая выполняется конструктором класса CFontDialog по умолчанию, удовлетворяет большинству пользователей.
Параметр lplfInitial является указателем на структуру LOGFONT, описывающую логический шрифт. Если этот параметр используется, то в диалоговой панели по умолчанию будет выбран шрифт, наиболее соответствующий шрифту, описанному в структуре LOGFONT.
Параметр dwFlags задает набор флагов, управляющий различными режимами работы панели. Например, флаг CF_EFFECTS позволяет пользователю создавать подчеркнутые и перечеркнутые буквы, определять цвет букв, а флаг CF_SCREENFONTS - разрешает выбирать только экранные шрифты.
Через параметр pdcPrinter можно передать конструктору контекст отображения принтера, шрифты которого будут представлены в диалоговой панели Font. Данный параметр используется только в том случае, если в параметре dwFlags указаны флаги CF_PRINTERFONTS или CF_BOTH.
Через параметр pParentWnd можно указать родительское окно для диалоговой панели Font.
Методы класса CFontDialog
Для отображения диалоговой панели Font предназначен виртуальный метод DoModal. Если пользователь выбрал шрифт и нажал кнопку OK, метод DoModal возвращает идентификатор IDOK, если пользователь отменил выбор шрифта, метод DoModal возвращает идентификатор IDCANCEL:
CFontDialog dlgFont;
int iResult=dlgFont.DoModal();
Остальные методы класса предназначены для определения характеристик выбранного пользователем шрифта.
Метод GetCurrentFont позволяет сразу определить все характеристики выбранного шрифта, записав их в структуру LOGFONT.
Остальные методы класса позволяют определить только отдельные характеристики выбранного шрифта:
Перед тем, как использовать функции
// тип PFN_MyFunction будет объявлять указатель на функцию, // принимающую указатель на символьный буфер и выдающую значение типа int typedef int (WINAPI *PFN_MyFunction)(char *); …… PFN_MyFunction pfnMyFunction;Первая программа на C++, типы данных и их размер
Что бы начать изучать C++ сначала создадим простое консольное приложение. Для этого запустите Visual C++. Выберите 'New' в меню 'File'. Проверте, что бы в диалоговой панеле 'New' была выбрана закладка 'Projects'. В списке типов проектов выберите 'Win32 Console Application'. Выберите каталог для проекта( лучше оставить по умолчанию ) и имя проекта, например, 'First' и нажмите 'OK'. У вас создатся 'First classes'. После этого выберите опять 'New', но с закладкой 'Files' и выберите 'C++ Source File'. Далее нажмите 'OK' и создастся файл 'First.cpp'. Всё, теперь можно писать программу. Но перед тем, как писать программу, давайте разберёмся какие типы данных существуют в C++.В C++ существуют несколько часто используемых типов данных( не все ):
1. Численные знаковые целые( int, short, char )
2. Численные знаковые дробные( float, double, long( в С ), long double( в С ) )
3. Численные без знаковые - все перечисленные выше типы с добавлением Unsigned
4. Char так же может использоваться как символьный тип.
Теперь напишем программыу, которая будет выводить размер типов данных в байтах.
#include
void main( void )
{
cout cout cout cout cout cout cout }
Первое, что необходимо сделать
HINSTANCE hMyDll; …… if((hMyDll=::LoadLibrary(“MyDLL”))==NULL) { /* не удалось загрузить DLL */ } else { /* приложение имеет право пользоваться функциями DLL через hMyDll */ }Первый способ использования таймера
В этом разделе мы рассмотрим первый способ работы с таймером - подключение таймера к окну. В этом случае функция окна, к которому подключен таймер, будет получать сообщения от таймера с кодом WM_TIMER.Этот способ самый простой. Вначале вам надо вызывать функцию SetTimer, указав ей в качестве параметров идентификатор окна, идентификатор таймера и период, с которым от таймера должны приходить сообщения: #define FIRST_TIMER 1 int nTimerID; nTimerID = SetTimer(hwnd, FIRST_TIMER, 1000, NULL);
В данном примере создается таймер с идентификатором FIRST_TIMER, который будет посылать сообщения примерно раз в секунду.
Для уничтожения таймера, созданного этим способом, следует вызвать функцию KillTimer, указав параметры следующим образом: KillTimer(hwnd, FIRST_TIMER);
Для изменения интервала посылки сообщений вам следует вначале уничтожить таймер, а потом создать новый, работающий с другим периодом времени: KillTimer(hwnd, FIRST_TIMER); nTimerID = SetTimer(hwnd, FIRST_TIMER, 100, NULL);
Преимущества использования MFC
Как уже упоминалось, MFC – это базовый набор (библиотека) классов, написанных на языке С++ и предназначенных для упрощения и ускорения процесса программирования для Windows. Библиотека содержит многоуровневую иерархию классов, насчитывающую около 200 членов. Они дают возможность создавать Windows-приложения на базе объектно-ориентированного подхода. С точки зрения программиста, MFC представляет собой каркас, на основе которого можно писать программы для Windows.Библиотека MFC разрабатывалась для упрощения задач, стоящих перед программистом. Как известно, традиционный метод программирования под Windows требует написания достаточно длинных и сложных программ, имеющих ряд специфических особенностей. В частности, для создания только каркаса программы таким методом понадобится около 75 строк кода. По мере же увеличения сложности программы ее код может достигать поистине невероятных размеров. Однако та же самая программа, написанная с использованием MFC, будет примерно в три раза меньше, поскольку большинство частных деталей скрыто от программиста.
Одним из основных преимуществ работы с MFC является возможность многократного использования одного и того же кода. Так как библиотека содержит много элементов, общих для всех Windows-приложений, нет необходимости каждый раз писать их заново. Вместо этого их можно просто наследовать (говоря языком объектно-ориентированного программирования). Кроме того, интерфейс, обеспечиваемый библиотекой, практически независим от конкретных деталей, его реализующих. Поэтому программы, написанные на основе MFC, могут быть легко адаптированы к новым версиям Windows (в отличие от большинства программ, написанных обычными методами).
Еще одним существенным преимуществом MFC является упрощение взаимодействия с прикладным программным интерфейсом (API) Windows. Любое приложение взаимодействует с Windows через API, который содержит несколько сот функций. Внушительный размер API затрудняет попытки понять и изучить его целиком. Зачастую даже сложно проследить, как отдельные части API связанны друг с другом! Но поскольку библиотека MFC объединяет (путем инкапсуляции) функции API в логически организованное множество классов, интерфейсом становится значительно легче управлять.
Поскольку MFC представляет собой набор классов, написанных на языке С++, поэтому программы, написанные с использованием MFC, должна быть в то же время программами на С++. Для этого необходимо владеть соответствующими знаниями. Для начала необходимо уметь создавать собственные классы, понимать принципы наследования и уметь переопределять виртуальные функции. Хотя программы, использующие библиотеку MFC, обычно не содержат слишком специфических элементов из арсенала С++, для их написания тем не менее требуются солидные знания в данной области.
Замечание
. Небольшое число классов, определенных в библиотеке, не связанно непосредственно с программированием под Windows. Это, в частности, классы, предназначенные для создания строк, управления файлами и обработки особых ситуаций. Иногда называемые классами общего назначения, они могут использоваться как Windows-, так и не- Windows-приложениями.
Преимущества мастеров проектов
Рассмотрим преимущества использования мастеров в процессе создания приложений. Прежде всего, нужно отметить, что создание проекта - это не только творчество, но и большой объем технической работы, требующей внимания и аккуратности.Например, все Windows-приложения имеют достаточно общую структуру, и, следовательно, можно построить некоторые шаблонные заготовки, подходящие для того или иного типа проектов. Построению таких заготовок способствует то, что приложения, создаваемые на основе MFC, строятся из элементов фиксированных классов. Логическим развитием этой идеи было введение специальных классов и специальной архитектуры построения приложения, которая подходила бы широкому классу приложений. О такой архитектуре уже упоминалось, когда речь шла о библиотеке MFC, - это архитектура Document-View. Она является основной, но не единственной при построении проектов в среде Visual C++.
Суть этой архитектуры в том, что работу многих приложений можно рассматривать как обработку документов. При этом можно отделить сам документ, отвечающий за представление и хранение данных, от образа этого документа, видимого на экране и допускающего взаимодействие с пользователем, который просматривает и (или) редактирует документ. В соответствии с этой архитектурой библиотека MFC содержит два семейства классов, производных от базовых классов CDocument и CView.
В результате появилась двухэтапная технология создания проектов. Вначале создается некая заготовка проекта с общими свойствами, подходящими для многих проектов этого типа. На втором этапе производится уже настройка, учитывающая специфику задачи. Для каждого этапа фирма Microsoft разработала свое инструментальное средство.
Начальная заготовка - остов приложения - создается в диалоге с пользователем инструментальным средством AppWizard. В процессе диалога пользователь определяет тип и характеристики проекта, который он хочет построить. Определив, какие классы из MFC необходимы для этого проекта, AppWizard строит остовы всех нужных производных классов. Построенный AppWizard остов приложения содержит все необходимые файлы для создания стартового приложения, которое является законченным приложением и обладает разумными функциональными свойствами, общими для целого класса приложений. Естественно, никаких специфических для данного приложения свойств остов не содержит. Они появятся на следующем этапе, когда программист начнет работать с остовом, создавая из заготовки свое собственное приложение. Тем не менее стартовое приложение можно транслировать и запускать на исполнение.
Термин остов (приложения, класса, функции) применяется для заготовок, создаваемых инструментальными средствами AppWizard и ClassWizard. Нужно подчеркнуть - остов приложения и каркас приложения - разные понятия.
Создаваемый остов приложения составлен так, что в дальнейшей работе с проектом можно использовать другое инструментальное средство - ClassWizard (мастер классов).
При использовании вышеприведенного
#define EXPORT extern “C” __declspec (dllexport) EXPORT int CALLBACK MyFunction(char *str); a таким: extern “C” int CALLBACK MyFunction(char *str);При запуске приложение пытается
Приложение типа Windows Application
Что бы создать приложение типа Windows Application с использованиеи MFC нужно сделать следующие шаги( создадим для простоты приложение основанное на диалогах ):1. Запустите Visual C++.
2. Выберите File / New.
3. Выберите закладку "Projects" / "MFC AppWizard( exe )", введите имя проекта( Project name ) и место для проекта( Location ) и нажмите кнопку "OK". В ответ будут выводится диалоговые панели.
4. MFC AppWizard - Step 1. Выберите интересующий тип проекта( простой документ, мулти-документ или документ, основанный на диалогах ) и нажмите кнопку "Next>" ( Вам надо выбрать "Dialog based").
5. MFC AppWizard - Step 2. Нажмите кнопку "Next>".
6. MFC AppWizard - Step 3. Нажмите кнопку "Finish".
7. New Project Information. Нажмите кнопку "OK".
Ну вот и всё, у Вас есть уже готовая программа, потдерживающая MFC.
Применение указателей в C++
Напишем следующую программу, которая использует указатели. Предположим, что значение iNum1 равно 2, а адрес iNum1 — 1000. INum1 будет занимать байты с адресами 1000, 1001, 1002 и 1003. Если значение iNum2 было равно, то переменная iNum2 могла бы занимать ячейки с адресами 1004, 1005, 1006 и 1007. Следовательно, iNumI начинается с адреса 1000, а iNum2 начинается с адреса 1004. Однако, хотя iNumI занимает четыре адреса, в С/С++ адресом iNumI называется адрес 1000, а адресом iNum2 называется адрес 1004. Теперь объявим две переменные как указатели — pNum1 и pNum2. Ваша цель состоит в том, чтобы сохранить число 1000 (адрес iNumI) в pNum1 и число 1004 (адрес iNum2) в pNum2.Внесите следующие изменения в main(void):
void main(void)
{
int iNum1;
int iNum2;
int iResult;
int* pNum1;
int* pNum2;
iNum1 = 2;
iNum2 = 3;
pNum1 = &iNum1;
pNum2 = &iNum2;
iResult = *pNum1 + *pNum2;
cout << "The result is: ";
cout << iResult << endl;
}
Код, который вы ввели, объявляет три целых переменных:
int iNum1;
int iNum2 ;
int iResult;
Затем объявляются еще две переменные:
int* pNum1;
int* pNum2;
Обратите внимание, что в объявлении использована запись int*. К какому же типу относится переменная pNum1? Можете ли вы сохранить целое значение в pNum1? Нет. В pNum1 вы можете сохранить адрес переменной типа int. Вы должны сохранить в переменной pNum1 число 1000, поскольку 1000 является адресом iNum1. Точно так же вы должны сохранять адрес целого значения и в переменной pNum2. После этого вы присваиваете значения переменным iNum1 и iNum2:
iNum1 = 2;
iNum2 = 2;
Затем вы присваиваете значения переменным pNumI и pNum2:
pNum1 = &iNum1;
pNum2 = &iNum2;
Эти два оператора сохраняют адрес переменной iNum1 в pNum1 и адрес iNum2 в pNum2. Далее вам нужно вычислить результат сложения iNum1 с iNum2. Вы могли бы бы просто написать оператор
iResult = iNum1 + iNum2;
Однако попробуем выполнить вычисления, применив указатели, а не переменные. Например, чтобы вычислить результат сложения iNuml и iNum2, вы пишете следующий оператор:
iResult = *pNum1 + *pNum2;
Когда вы используете указатель с предшествующим символом *, вы извлекаете значение, хранящееся по данному адресу. *pNum1 — это то же, что и *1000, так что программа обращается к значению, хранящемуся по адресу 1000. Поскольку переменная pNum1 была объявлена как int* (а компилятор знает, что целое значение занимает четыре байта памяти), программа обращается к адресам 1000, 1001, 1002 и 1003. Она находит по этим адресам значение 2, так как *pNum1 равно 2. Аналогично, *pNum2 равно 3, поскольку pNum2 равно 1004, а ячейки памяти 1004, 1005, 1006 и 1007 содержат целое со значением. И, наконец, выполняется оператор cout, который выводит на экран значение переменной iResult:
cout << "The result is: " << endl;
cout << iResult;
Сохраните свою работу, выполните компиляцию и компоновку программы. Запустите программу и убедитесь, что значение iResult равно 5 (2+3=5).
Пример графической программы с оптимизацией
можно взять рабочую программу в диалоговом режиме, с оптимизированной графикой.Во многих книжках работа с графикой описывается следующим образом:
1. Все графические функции описывабтся в OnPaint().
2. Далее в другом месте программы вызываются функции Invalidate, InvalidateRect или InvalidateRgn.
3. Такой тип построения программы не совсем верен, так как в таком случае обычно всё мигает и это нервирует.
4. Есть немного другой способ работы с графикой и ниже он будет описан.
Этот метод заключается в следующем :
1. Вся графика рисуется в какой-то функции F().
2. По событию таймера или по другим событиям вызывается F().
3. Эдементы графики рисуются сначала в памяти, а потом выводятся на экран.
4. Предворительные расчёты можно вести как в F() так и в других частях программы.
5. Функция OnPaint() содержит копию функции F(), это нужно только для перерисовки окна при изменении его положения или размера.
Пример использования MFC в Visual C++.
В этой главе будет показано как включить потдержку MFC в Visual C++ на примере двух типов приложений:Пример проекта
можно взять рабочую программу под MFC, в которой проигрываются Wave-файлы.Пример Windows-приложения, использующего таймер
можно взять рабочую программу в диалоговом режиме, использующую таймер. После загрузки программы вы можете нажать на кнопку "Start timer" и услышать периодические звуковые сигналы( 1 сек. ). После нажатия кнопки "End timer" или при закрытие приложения таймер будет уничтожен.Пример Windows-приложения, использующего стандартные ресурсы
можно взять рабочую программу в диалоговом режиме, использующего стандартные ресурсы.можно взять рабочую программу в диалоговом режиме, использующего стандартные панели управления.
Примеры записи и чтения из файла
Приведем фрагменты кода, в которых демонстрируется использование стандартных диалоговых панелей выбора файла и процедуры чтения и записи в файл.Открытие файла и чтение из него
CString m_Text; ……
// создание стандартной панели выбора файла Open
CFileDialog DlgOpen(TRUE,(LPCSTR)"txt",NULL, OFN_HIDEREADONLY,(LPCSTR)" Text Files (*.txt) |*.txt");
// отображение стандартной панели выбора файла Open
if(DlgOpen.DoModal()==IDOK) {
// создание объекта и открытие файла для чтения
CStdioFile File(DlgOpen.GetPathName(),CFile::modeRead|CFile::typeBinary);
// чтение из файла строки
CString& ref=m_Text; File.ReadString(ref); // передается ссылка на строку m_Text }
находится рабочий код программы, выполненной для простоты в виде консольного приложения под MFC. Чтобы программа работала не забудте сделать следующее:
Запустите программу - Build / Rebuild all ( будут ошибки ), выберите Build / Set active configuration - Win 32 Realise, выберите пункт меню "Project", далее "Settings...", закладку "C/C++", Category - Code Generation и в пункте "Use run-time library" выберите "Multithreaded". После этого сделайте опять Build / Rebuild all и программа будет работать.
Открытие файла и запись из него
CString m_Text; ……
// создание стандартной панели выбора файла SaveAs
CFileDialog DlgSaveAs(FALSE,(LPCSTR)"txt",NULL, OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT, (LPCSTR)" Text Files (*.txt) |*.txt");
// отображение стандартной панели выбора файла SaveAs
if(DlgSaveAs.DoModal()==IDOK) {
// создание объекта и открытие файла для записи
CStdioFile File(DlgSaveAs.GetPathName(), CFile::modeCreate|CFile::modeWrite|CFile::typeBinary);
// запись в файл строки
File.WriteString((LPCTSTR)m_Text); }
находится рабочий код программы, выполненной для простоты в виде консольного приложения под MFC. Чтобы программа работала не забудте сделать следующее:
Запустите программу - Build / Rebuild all ( будут ошибки ), выберите Build / Set active configuration - Win 32 Realise, выберите пункт меню "Project", далее "Settings...", закладку "C/C++", Category - Code Generation и в пункте "Use run-time library" выберите "Multithreaded". После этого сделайте опять Build / Rebuild all и программа будет работать.
Приведем теперь исходный код простого
#includeПриведем теперь полностью исходный
#includeПроект приложения
О принципах устройства приложения рассказывалось выше. Теперь рассмотрим, как оно создается с помощью Visual C++. Сначала разберем одно важное понятие - проект. До сих пор приложение рассматривалось, как только как совокупность объектов базовых и производных классов. Но для обеспечения работы приложения требуется нечто большее - наряду с описанием классов необходимо описание ресурсов, связанных с приложением, нужна справочная система и т.п. Термин "проект" как раз и используется, когда имеется в виду такой более общий взгляд на приложение.В среде Visual C++ можно строить различные типы проектов. Такие проекты после их создания можно компилировать и запускать на исполнение. Фирма Microsoft разработала специальный инструментарий, облегчающий и ускоряющий создание проектов в среде Visual C++. Например, мастер MFC AppWizard (exe) позволяет создать проект Windows-приложения которое имеет однодокументный, многодокументный или диалоговый интерфейс и использует библиотеку MFC.
Создаваемый остов приложения составлен так, что в дальнейшей работе с проектом можно использовать другое инструментальное средство - ClassWizard (мастер классов), предназначенное для создания остовов новых производных классов. Еще одно основное назначение ClassWizard в том, что он создает остовы для переопределяемых методов. Он позволяет показать все сообщения, приходящие классу, и создать остов обработчика любого из этих сообщений. Это только две основные функции ClassWizard. Он не всесилен, но его возможности довольно велики.
Программная среда Windows
Рассмотрим наиболее важные моменты работы Windows и принципы взаимодействия программ с ней.Интерфейс вызовов функций в Windows
Благодаря данному интерфейсу доступ к системным ресурсам осуществляется через целый рад системных функций. Совокупность таких функций называется прикладным программным интерфейсом, или API (Application Programming Interfase). Для взаимодействия с Windows приложение запрашивает функции API, с помощью которых реализуются все необходимые системные действия, такие как выделение памяти, вывод на экран, создание окон и т.п.
Библиотека MFC инкапсулирует многие функции API. Хотя программам и разрешено обращаться к ним напрямую, все же чаще это будет выполняться через соответствующие функции-члены. Как правило, функции-члены либо аналогичны функциям API, либо непосредственно обращаются к нужной части интерфейса.
Библиотеки динамической загрузки (DLL)
Поскольку API состоит из большого числа функций, может сложиться впечатление, что при компиляции каждой программы, написанной для Windows, к ней подключается код довольно значительного объема. В действительности это не так. Функции API содержатся в библиотеках динамической загрузки (Dynamic Link Libraries, или DLL), которые загружаются в память только в тот момент, когда к ним происходит обращение, т.е. при выполнении программы. Рассмотрим, как осуществляется механизм динамической загрузки.
Динамическая загрузка обеспечивает ряд существенных преимуществ. Во-первых, поскольку практически все программы используют API-функции, то благодаря DLL-библиотекам существенно экономится дисковое пространство, которое в противном случае занималось бы большим количеством повторяющегося кода, содержащегося в каждом из исполняемых файлов. Во-вторых, изменения и улучшения в Windows-приложениях сводятся к обновлению только содержимого DLL-библиотек. Уже существующие тексты программ не требуют перекомпиляции.
Win16 или Win32
В настоящее время широко распространены две версии API. Первая называется Win16 и представляет собой 16-разрядную версию, используемую в Windows 3.1. Вторая, 32-разрядная версия, называется Win32 и используется в Windows 95 и Windows NT. Win32 является надмножеством для Win16 (т.е. фактически включает в себя этот интерфейс), так как большинство функций имеет то же название и применяется аналогичным образом. Однако, будучи в принципе похожими, оба интерфейса все же отличаются друг от друга. Win32 поддерживает 32-разрядную линейную адресацию, тогда как Win16 работает только с 16-разрядной сегментированной моделью памяти. Это привело к тому, что некоторые функции были модифицированы таким образом, чтобы принимать 32-разрядные аргументы и возвращать 32-разрядные значения. Часть из них пришлось изменить с учетом 32-разрядной архитектуры. Была реализована поддержка потоковой многозадачности, новых элементов интерфейса и прочих нововведений Windows.
Так как Win32 поддерживает полностью 32-разрядную адресацию, то логично, что целые типы данных (intergers) также объявлены 32-разрядными. Это означает, что переменные типа int и unsignerd будут иметь длину 32 бита, а не 16, как в Windows 3.1. Если же необходимо использовать переменную или константу длиной 16 бит, они должны быть объявлены как short. (дальше будет показано, что для этих типов определены независимые typedef-имена.) Следовательно, при переносе программного кода из 16-разрядной среды необходимо убедиться в правильности использования целочисленных элементов, которые автоматически будут расширены до 32 битов, что целочисленных элементов, которые автоматически будут расширены до 32 битов, что может привести к появлению побочных эффектов.
Другим следствием 32-разрядной адресации является то, что указатели больше не нужно объявлять как near и far. Любой указатель может получить доступ к любому участку памяти. В Windows 95 и Windows NT константы near и far объявлены (с помощью директивы #define)пустыми.
Интерфейс GDI
Одним из подмножеств API является GDI (Graphics Device Interfase – интерфейс графического устройства). GDI – это та часть Windows, которая обеспечивает поддержку аппаратно-независимой графики. Благодаря функциям GDI Windows-приложение может выполняться на самых различных компьютерах.
Многозадачность в Windows
Как известно, все версии Windows поддерживают многозадачность. В Windows 3.1 имеется только один тип многозадачности – основанный на процессах. В более передовых системах, таких как Windows 95 и Windows NT, поддерживается два типа многозадачности: основанный на процессах и основанный на потоках. Давайте рассмотрим их чуть подробнее.
Процесс
– это программа, которая выполняется. При многозадачности такого типа две или более программы могут выполняться параллельно. Конечно, они по очереди используют ресурсы центрального процессора и с технической точки зрения, выполняются неодновременно, но благодаря высокой скорости работы компьютера это практически незаметно.
Поток
– это отдельная часть исполняемого кода. Название произошло от понятия “направление протекания процесса”. В многозадачности данного типа отдельные потоки внутри одного процесса также могут выполняться одновременно. Все процессы имеют по крайней мере один поток, но в Windows 95 и Windows NT их может быть несколько.
Отсюда можно сделать вывод, что в Windows 95 и Windows NT допускается существование процессов, две или более частей которых выполняются одновременно. Оказывается, такое предположение верно. Следовательно, при работе в этих операционных системах возможно параллельное выполнение, как программ, так и отдельных частей самих программ. Это позволяет писать очень эффективные программы.
Есть и другое существенное различие между многозадачностями Windows 3.1 и Windows 95/NT. В Windows 3.1 используется неприоритетная многозадачность. Это означает, что процесс, выполняющийся в данный момент, получает доступ к ресурсам центрального процессора и удерживает их в течение необходимого ему времени. Таким образом, неправильно выполняющаяся программа может захватить все ресурсы процессора и не давать выполняться другим процессам. В отличие от этого в Windows 95 и Windows NT используется приоритетная многозадачность. В этом случае каждому активному потоку предоставляется определенный промежуток времени работы процессора. По истечению данного промежутка управление автоматически передается следующему потоку. Это не дает возможность программам полностью захватывать ресурсы процессора. Интуитивно должно быть понятно, что такой способ более предпочтителен.
Взаимодействие программ и Windows
Во многих операционных системах взаимодействие между системой и программой инициализирует программа. Например, в DOS программа запрашивает разрешение на ввод и вывод данных. Говоря другими словами, не- Windows-программы сами вызывают операционную систему. Обратного процесса не происходит. В Windows все совершенно наоборот: именно система вызывает программу. Это осуществляется следующим образом: программа ожидает получения сообщения от Windows. Когда это происходит, то выполняется некоторое действие. После его завершения программа ожидает следующего сообщения.
Windows может посылать программе сообщения множества различных типов. Например, каждый раз при щелчке мышью в окне активной программы посылается соответствующее сообщение. Другой тип сообщений посылается, когда необходимо обновить содержимое активного окна. Сообщения посылаются также при нажатии клавиши, если программа ожидает ввода с клавиатуры. Необходимо запомнить одно: по отношению к программе сообщения появляются случайным образом. Вот почему Windows-программы похожи на программы обработки прерываний: невозможно предсказать, какое сообщение появиться в следующий момент.
Проигрывание Wave-файла с диска
Для проигрывания WAVE-файла с диска можно использовать функцию :Проигрывание Wave-файла в виде ресурса
Первым делом надо создать ресурс, для этого в файле mysound.rc2 надо вписать строчку IDSOUND_CORRECT sound res\correct.wav, где IDSOUND_CORRECT - индефикатор ресурса, sound - тип ресурса( название можно менять ), res\correct.wav - файл ресурса. После этого в файле Resource.h надо зарегистрировать ресурс: #define IDSOUND_CORRECT 130. Число 130 не должно совпадать с другими числами.Как только ресурс зарегистрирован можно написать в файле mysoundDlg.cpp функции проигрывания этого ресурса :
Простая программа, использующая MDI интерфейс
В этом разделе рассматривается программа использующая MDI ( интерфейс многих документов )Мы создадим программу, в которой документом является графическое изображение - круг. В ToolBar будет создана иконка, при нажатие на которою будет вызываться диалоговое окно, позволяющее изменять координаты круга. Местоположение круга можно будет согранять в файл с расширением CIR.
Работа с файлами с помощью MFC( классы CFile, CStdioFile, ... ) и стандартный класс MFC CFileDialog.
В библиотеку MFC включено несколько классов для обеспечения работы с файлами. Рассматриваемые ниже классы наследуются от базового класса CFile.
Работа с файлами в C ( работает и в C++ )..
#include#include
void main( void )
{
FILE *file;
char* file_name = "file.txt";
char load_string[50] = "none";
file = fopen( file_name, "w" );
fputs( "string", file );
fclose( file );
file = fopen( file_name, "r" );
if( file != 0 )
{
fgets( load_string, 50 , file );
cout }
else
{
cout }
fclose(file);
}
Сначала надо создать указатель на переменную типа FILE ( FILE* file; ).
Открытие файла производится вызовом функции fopen ( file = fopen( file_name, "w" ); )
Первый параметр этой функции - имя файла, второй - указывает в каком режиме должен быть открыт файл. "w" - открыть для записи, "r" - открыть для чтения, "a" - дополнение файла( это наиболее используемые режимы, хотя есть и другие ). Запись и считывание данных из файла осуществляется следующими функциями : fputc, fputs, fgetc, fgets, fprintf, fscanf( описание этих функций смотрите в stdio.h).
Закрытие файла осуществляется вызовом функции fclose ( fclose( file ); ).
Рассмотрим ряд аспектов создания и использования библиотек DLL:
Рассмотрим теперь, как осуществляется
class AFX_EXT_CLASS CMyClass : public CObject ( // Your class declaration } void AFX_EXT_API MyFunc() ;Синтаксис файлов с расширением
MyDLL.defLIBRARY “MyDLL”
DESCRIPTION ‘MyDLL – пример DLL-библиотеки’ EXPORTS MyFunction @1
Сначала создадим проект tab_control
Для начала сделайте первые три пункта, создайте переменную m_ctrTab класса CTabCtrl. После этого в функцие BOOL CTab_controlDlg::OnInitDialog() добавте следующее:
Сначала в заголовочном файле определяется
MyDLL.h#define EXPORT extern “C” __declspec (dllexport) EXPORT int CALLBACK MyFunction(char *str);
Содержательная часть программ примитивна:
Соглашение об именах
Если Вы не знакомы с программированием под Windows, некоторые имена и описания, употребляемые в каркасной программе, могут показаться несколько необычными. Однако они соответствуют соглашениям, представленным фирмой Microsoft для программирования под Windows. Для функций используются имена, построенные из глаголов и существительных, причем первые буквы этих слов — заглавные.Для имен переменных Microsoft предлагает более сложную систему, предусмат ривающую обозначение именуемых типов данных. Для этого используется неболь шой префикс из строчных букв, а собственно имя начинается с заглавной буквы, Типы префиксов представлены в нижеследующей таблице. Откровенно говоря, использование префиксов, обозначающих тип данных, спорно и не всегда адекватно. Большинство Windows-программистов прибегают к такой системе имено вания, но Вы в своих программах можете поступать по своему усмотрению.
Префикс - Тип данных
-------------------------------------------------------
b - Булевский (байт).
с - Символ (байт).
s - Строка ( char или CString ).
dw - Длинное беззнаковое целое (DWORD).
f - 16-битный флаг (битовая карта).
fn - Функция.
h - Дескриптор (handle).
l - Длинное целое (long).
i - Данные типа Int.
lр - Длинный указатель (long pointer).
n - Целое (16 бит).
р - Указатель (pointer).
pt - Точка (два 32-битных целых).
w - Целое без знака (WORD, 16 бит).
sz - Указатель на строку, заканчивающуюся 0 (string>zero).
Ipsz - Длинный указатель на sz (long pointer string zero).
rgb - Длинное целое, содержащее цветовую комбинацию RGB.
Сообщение WM_TIMER
Параметр wParam сообщения WM_TIMER содержит идентификатор таймера, который был указан или получен от функции SetTimer при создании таймера.С помощью параметра lParam можно определить адрес функции, которая обрабатывает сообщения таймера.
После обработки этого сообщения приложение должно возвратить нулевое значение.
Заметим, что сообщение WM_TIMER является низкоприоритетным. Это означает, что функция DispatchMessage посылает это сообщение приложению только в том случае, если в очереди приложения нет других сообщений. В этом отличие таймера Windows от аналогичных средств MS-DOS, реализованных с помощью перехвата прерывания INT8h.
Выполнение программы MS-DOS прерывается синхронно с приходом аппаратного прерывания таймера и программа MS-DOS, перехватившая это прерывание, немедленно оповещается о нем. Выполнение приложения Windows тоже, разумеется, прерывается по аппаратному прерыванию таймера, но оповещение об этом событии приходит не всегда, и как правило, позже, вместе с сообщением WM_TIMER.
Создание и уничтожение таймера
Для создания виртуального таймера приложение должно использовать функцию SetTimer: UINT WINAPI SetTimer(HWND hwnd, UINT idTimer, UINT uTimeout, TIMERPROC tmprc);Первый параметр функции (hwnd) должен содержать идентификатор окна, функция которого будет получать сообщения от таймера, или NULL. В последнем случае с создаваемым таймером не связывается никакое окно и сообщения от таймера будут приходить в специально созданную для этого функцию.
Второй параметр (idTimer) определяет идентификатор таймера (он не должен быть равен нулю). Идентификатор используется только в том случае, если первый параметр функции SetTimer содержит идентификатор окна. Так как для одного окна можно создать несколько таймеров, для того чтобы различать сообщения, приходящие от разных таймеров, приложение при создании должно снабдить каждый таймер собственным идентификатором.
Если первый параметр указан как NULL, второй параметр функции игнорируется, так как для таймера задана специальная функция, получающая сообщения только от этого таймера.
Третий параметр (uTimeout) определяет период следования сообщений от таймера в миллисекундах. Учтите, что физический таймер тикает приблизительно 18,21 раза в секунду (точное значение составляет 1000/54,925). Поэтому, даже если вы укажете, что таймер должен тикать каждую миллисекунду, сообщения будут приходить с интервалом не менее 55 миллисекунд.
Последний параметр (tmprc) определяет адрес функции, которая будет получать сообщения WM_TIMER (мы будем называть эту функцию функцией таймера). Этот параметр необходимо обязательно указать, если первый параметр функции SetTimer равен NULL.
Тип TIMERPROC описан в файле windows.h следующим образом: typedef void (CALLBACK* TIMERPROC)(HWND hwnd, UINT msg, UINT idTimer, DWORD dwTime);
Сравните это с описанием типа WNDPROC, который используется для знакомой вам функции окна: typedef LRESULT (CALLBACK* WNDPROC)(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
Как видно из описания, функция таймера не возвращает никакого значения, имеет другие (по сравнению с функцией окна) параметры, но описана с тем же ключевым словом CALLBACK: #define CALLBACK _far _pascal
Возвращаемое функцией SetTimer значение является идентификатором созданного таймера (если в качестве первого параметра функции было указано значение NULL). В любом случае функция SetTimer возвращает нулевое значение, если она не смогла создать таймер. В Windows версии 3.0 максимальное количество созданных во всей системе таймеров было 16. Для Windows версии 3.1 это ограничение снято.
Тем не менее, если приложение больше не нуждается в услугах таймера, оно должно уничтожить таймер, вызвав функцию KillTimer: BOOL WINAPI KillTimer (HWND hwnd, UINT idTimer);
Первый параметр функции (hwnd) определяет идентификатор окна, указанный при создании таймера функцией SetTimer.
Второй параметр (idTimer) - идентификатор уничтожаемого таймера. Это должен быть либо тот идентификатор, который вы указали при создании таймера (если таймер создавался для окна), либо значение, полученное при создании таймера от функции SetTimer (для таймера, имеющего собственную функцию обработки сообщений).
Функция KillTimer возвращает значение TRUE при успешном уничтожении таймера или FALSE, если она не смогла найти таймер с указанным идентификатором.
Создание проекта программы
1. Создайте новый проект( у меня MDI ), использующая MDI интерфейс с поддержкой MFC. Все шесть шагов в MFC AppWizard оставте без изменения.2. Если вы сделали всё правильно, то создадутся пять классов : CMDIApp, CMainFrame, CChildFrame, CMDIDoc и CMDIView. В классе документов CMDIDoc вы пишите код для поддержки данных программы, а в классе представления CMDIView - код, отвечающий за то, что вы видите на экране. Вы будете писать код в функциях-элементах только этих двух классов.
3. Объявляем элементы данных класса документа. Их будет два : координаты круга по X и по Y. Для этого открываем файл CMDIDoc.h и изменяем объявление класса CMDIDoc следующим образом:
Создание собственных ActiveX элементов
1. Введение
Элементов управления ActveX — это файл с расширением ОСХ (например, MyButton.OCX), который вы можете использовать в своем приложении Visual C++. Visual C++ и другие визуальные языки программирования дают вам возможность включить элемент управления ActiveX в свою программу и пользоваться им так же, как и стандартным элементом управления Visual C++. Вы помещаете элемент управления ActiveX в диалоговую панель, задаете его свойства и связываете код с его событиями. После того как ы создали собственный элемент управления ActiveX, вы ожете передавать его другим программистам, которые могут вводить его в свои программы.
Поскольку расширением файла элемента управления ActiveX является .ОСХ, то иногда элементы управления ActiveX называют элементами ОСХ.
В этой главе вы разработаете свой собственный элемент управления ActiveX — MyClock.ОСХ, который выполняет задачу вывода текущего времени. Когда программист помещает элемент управления MyClock.ОСХ в форму или в диалоговую панель, MyClock. ОСХ будет непрерывно отображать текущее время.
2. Создание проекта
Чтобы создать проект элемента управления MyClock.OCX : 1) Выберите New в меню File.
В ответ Visual C++ выведет диалоговую панель New.
2) Выберите закладку Projects диалоговой панели New.
3) Выберите MFC ActiveX ControlWizard из списка типов проектов
4) Напечатайте MyClock в окне Project Name.
5) Щелкните на кнопке, которая расположена с правой стороны окна Location, и выберите каталог для проекта.
6) Щелкните на кнопке ОК.
В ответ Visual C++ выведет окно MFC ActiveX ControlWizard Step 1 of 2
В окне ActiveX ControlWizard Step 1 оставьте все установки в состоянии по умолчанию и щелкните на кнопке Next.
В окне ActiveX ControlWizard Step 2 оставьте все установки в состоянии по умолчанию и щелкните на кнопке Finish.
В ответ Visual C++ выведет диалоговую панель New Project Information.
Щелкните на кнопке ОК в диалоговой панели New Project Information и выберите Set Active Configuration в меню Build.
В ответ Visual C++ выведет диалоговую панель Set Active Project Configuration.
Выберите MyClock - Win32 Release в диалоговом окне Set Active Project Configuration и щелкните на кнопке ОК.
Это все! Вы завершили создание файла проекта и каркасов файлов элемента управления ActiveX MyClock.ОСХ.
3. Настройка значка инструмента MyClock
Значок инструмента MyClock отображает буквы ОСХ. Вам нужно настроить элемент управления MyClock таким образом, чтобы значок его инструмента представлял собой рисунок часов. Для настройки значка инструмента MyClock вы должны отредактировать растровое изображение IDB_MYCLOCK. Это изображение было создано Visual C++.
Чтобы вывести растровое изображение IDB_MYCLOCK в режиме проектирования, сделайте следующее:
1) Выберите закладку ResourceView в окне Project Workspace, раскройте пункт MyClock resources, раскройте пункт Bitmap и дважды щелкните на пункте IDB_MYCLOCK.
В ответ Visual C++ выведет растровое изображение IDB_MYCLOCK в режиме проектирования.
2) Используя визуальные инструменты Visual C++, замените растровое изображение IDB_MYCLOCK букв ОСХ на рисунок простейших часов (окружность и две линии в качестве стрелок).
4. Рисование в элементе управления MyClock
Пока элемент управления MyClock выводит эллипс. Вам нужно, чтобы MyClock отображал текущее время, так что вы должны написать соответствующий код:
Откройте файл MyClockCtl.cpp.
Файл MyClockCtl.cpp — это файл реализации элемента управления МуСlock, созданный для вас Visual C++; в этом файле вы будете писать свой код для настройки MyClock.
Найдите функцию OnDraw() в файле MyClockCtl.cpp и напишите следующий код:
Создание собственных диалоговых окон
Для того, что бы создать собственное диалоговое окно надо сделать следующее:1) Создайте программу в диалоговом режиме ( с поддежкой MFC )
2) Назовите её TEST, что бы было лучше сравнивать с моей рабочей программой
3) Главный класс вашей программы будет CTestDlg
4) Что бы создать другую диалоговую панель нужно создать новый класс, для этого выбери закладку ResourceView -> правой кнопкой на Dialog -> Insert Dialog -> создастся новый диалог.
5) Имя диалога можно менять, поставте IDD_MY_DIALOG
6) Дальше надо зарегистрировать новый класс, для этого: при открытом новом диалоге( это обязательно ) надо вызвать ClassWizard( в верхнем меню) -> Create new class -> надо ввести имя класса ( введите CMyDialog( MyDialog.cpp), имя должно начинаться с C, что означает class ) -> два раза ОК
7) Теперь надо, чтобы выша главная программа "узнала" новый класс -> в начале файла TestDlg.cpp напишите строчку
#include "MyDialog.h"
8) Ну вот и всё, теперь можно использовать новое диалоговое окно ->
CMyDialog MyDlg;
MyDlg.DoModal();
можно взять рабочую программу в диалоговом режиме, в которой используется собственное диалоговое окно.
Static void PlayResource(LPCTSTR
В фунции ::FindResource(AfxGetResourceHandle(), lpszSound, _T("sound")) третий параметр - тип ресурса, который был описан выше.Теперь можно проиграть ресурс : PlayResource( IDSOUND_CORRECT );
Структуры в С++
Как вы уже знаете, переменная в C/C++ объявляется следующим образом:int iMyVariable;
В приведенном операторе iMyVariable объявлена как целая переменная. А вот объявление переменной типа char:
char cMyChar;
Такие типы данных, как int, float, char и long, являются неотъемлемой частью C/C++ и вам не нужно писать никакого кода, чтобы сообщить компилятору о том, что означают эти слова. C/C++ позволяет вам также объ-являть свои собственные, специальные типы данных. В следующем разделе вы узнаете, как объявлять структуры, которые можно отнести к специальным типам данных.
Напишите следующий исходный код:
#include
#include
// Объявление структуры.
struct MYSTRUCTURE
{
char sName[100];
int iAge;
};
void main( void )
{
MYSTRUCTURE MyStructure;
strcpy(MyStructure.sName, "Andy" );
MyStructure.iAge = 13;
cout cout cout cout cout )
#include
#include
Файл iostream.h включен в код, поскольку в main(void) используется cout. Файл string.h включается потому, что в main(void) используется функция strcpy() (объявленная в файле string.h). Затем вы объявляете структуру:
Struct MYSTRUCTURE
{
char sName[100];
int iAge;
};
Обратите внимание на синтаксис объявления структуры. Оно начинается с ключевого слова struct, за которым следует имя типа-структуры. В этой программе типу структуры присвоено имя MYSTRUCTURE. Затем следует собственно определение структуры, заключенное в фигурные скобки. Не забудьте поставить точку с запятой после закрывающей фигурной скобки. Теперь посмотрите на код внутри фигурных скобок:
char sName[100];
int iAge;
Это означает, что MYSTRUCTURE состоит из строки с именем sName и целого с именем iAge, sName и iAge называются элементами данных структуры; Вы объявили их "Внутри" cтруктуры MYSTRUCTURE. Код в main(void) объявляет переменную с именем MyStructure типа MYSTRUCTURE:
MYSTRUCTORE MyStructure;
Вспомните, что в объявляли переменную iNum1 следующим образом:
int iNum1;
Когда вы объявляете MyStructure , которая будет структурой типа MYSTRUCTURE, рассматривайте переменную MyStructure аналогично переменной iNum1. MyStructure - это имя переменной, а ее типом является MYSTRUCTURE точно так же, как типом переменной iNum1 является int. (Обратите внимание, что по традиции имя структуры составлено из символов нижнего регистра или в нем смешаны символы нижнего и верхнего регистров, как, например, в имени MyStructure, но в имени типа структуры используются только символы верхнего регистра, как, например, в MYSTRUCTURE.)
Следующий оператор в main(void) копирует строку 'Andy' в элемент данных MyStructure.sName:
strcpy ( MyStructure.sName, "Andy" );
В этом операторе обращение к элементу данных sName записано как MyStructure.sName Следующий оператор присваивает значение 13 элементу данных iAge cтруктуры MyStructure: MyStructure.iAge - 13; Затем выполняется ряд операторов вывода cout:
cout cout cout cout cout
Сложив все вместе, мы видим, что программа MyStruct выводит сообщение My name is Andy and I am 13 years old. (Меня зовут Andy и мне 13 лет)
TC_ITEM TabItem; TabItem.mask
Это код инициализации Tab Control, мы создаём три закладки. Теперь нам надо, чтобы при нажатие на любую закладку, на экране появлялось то, что нам нужно. Самый простой вариант - это использовать на каждую закладку по диалогу - и потом просто в области Tab Control'а - выводить нужный диалог, в зависимости от текущей закладки.
Сделаем это. Добавим три диалога в редакторе ресурсов и создадим каждому из них по классу - наследнику от CDialog. Назовем эти классы CPage1, CPage2 и CPage3( файлы Page1.cpp(h), Page2.cpp(h), Page3.cpp(h) ) .
В свойствах этих трёх диалогов поставте Style как "Child" и Border как "none" - это очень важно, а в самих диалогах создайте какие либо элементы ( например, типа Static Text ), чтобы было видно отличие.
Напишите эти три строчки в начале файла tab_controlDlg.cpp
Типы мастеров проектов
В среде Visual C++ можно строить различные типы проектов. Такие проекты после их создания можно компилировать и запускать на исполнение. Фирма Microsoft разработала специальный инструментарий, облегчающий и ускоряющий создание проектов в среде Visual C++.Рассмотрим некоторые типы проектов, которые можно создавать при помощи различных средств (мастеров проектов) Microsoft Visual C++:
MFC AppWizard (exe)
– при помощи мастера приложений можно создать проект Windows-приложения которое имеет однодокументный, многодокументный или диалоговый интерфейс. Однодокументное приложеие может предоставлять пользователю в любой момент времени работать только с одним файлом. Многодокументное приложение, напротив, может одновременно представлять несколько документов, каждый в собственном окне. Пользовательский интерфейс диалогового приложения представляет собой единственное диалоговое окно.
MFC AppWizard (dll) –
этот мастер приложений позволяет создать структуру DLL, основанную на MFC. При помощи него можно определить характеристики будующей DLL.
AppWizard ATL COM
– это средство позволяет создать элемент управления ActiveX или сервер автоматизации, используя новую библиотеку шаблонов ActiveX (ActiveX Template Library - ATL). Опции этого мастера дают возможность выбрать активный сервер (DLL) или исполняемый внешний сервер (exe-файл).
Custom AppWizard
– при помощи этого средства можно создать пользовательские мастера AppWizard. Пользовательский мастер может базироваться на стандартных мастерах для приложений MFC или DLL, а также на существующих проектах или содержать только определеямые разработчиком шаги.
DevStudio Add-in Wizard
– мастер дополнений позволяет создавать дополнения к Visual Studio. Библиотека DLL расширений может поддерживать панели инструментов и реагировать на события Visual Studio.
MFC ActiveX ControlWizard
- мастер элементов управления реализует процесс создания проекта, содержащего один или несколько элементов управления ActiveX, основанных на элементах управления MFC.
Win32 Application
– этот мастер позволяет создать проект обычного Window-приложения. Проект создается незаполненным, файлы с исходным кодом в него следует добавлять вручную.
Win32 Console Application
– мастер создания проекта консольного приложения. Консольная приложение – это программа, которая выполняется из командной cтроки окна DOS или Windows и не имеет графического интерфейса (окон). Проект консольного приложения создается пустым, предполагая добавление файлов исходного текста в него вручную.
Win32 Dynamic-Link Library
– создание пустого проекта динамически подключаемой библиотеки. Установки компилятора и компоновщика будут настроены на создание DLL. Исходные файлы следует добавлять вручную.
Win32 Static Library
– это средство создает пустой проект, предназначенный для генерации статической (объектной) библиотеки. Файлы с исходным кодом в него следует добавлять вручную.
Void CMDIDoc::Serialize(CArchive&
9. Часто бывает нужно изменить некоторые параметры программы, такие как заголовок главного окна или тип файла по умолчанию, который выводится в диалоговых панелях SAVE и OPEN. Для этого нужно выбрать закладку ResourceView и открыть пункт String Table. Вы увидите список переменных проекта( три колонки : ID, Value и Caption ).IDR_MAINFRAME - заголовок главного окна (изменяется в поле Caption)
IDR_MCIRCLTYPE - тип файла по умолчанию, вы увидите 6 подстрок разделёнными знаком \n. Третья и четвёртая подстроки определяют тип документа по умолчанию. У меня CIR FILES( *.cir ) и .cir соответственно. Вы можете поставить свои значения.
10. Теперь создадим кнопку в панеле инструментов. Для этого нужно выбрать закладку ResourceView и открыть пункт Toolbar. Вы увидите панель инструментов в режиме редактирования. Нажмите на самую правую кнопку( пунктирный квадрат ), ниже нарисуйте кнопку по вашему усмотрению. Теперь дважды нажмете на вашу кнопку и введите ID: ID_MYBUTTON и Prompt: Изменение координат круга\nИзменение координат круга. Ну вот и всё, кнопка готова. Теперь нужно создать функцию, которая будет выполняться при нажатии на вашу кнопку :
Выберите пункт меню View далее ClassWizard, выберите закладку Message Maps, Project: MDI, Class name: CMDIView, Object IDs: ID_MYBUTTON, Message: COMMAND и нажмите на кнопку Add Function. В ответ создастся функция void CMDIView::OnMybutton().
11. Теперь по аналогии с главой 15 создадим собственное диалоговое окно с ID: IDD_MY_DIALOG и классом CMyDialog и разместим в нём четыре Edit Box с переменными типа INT: m_DX - текущая позиция по X, m_DY - текущая позиция по Y, m_DXN - новая позииция по X, m_DYN - новая позииция по Y. Не забудте написать #include "MyDialog.h" в файлах MDIDoc.cpp и MDIView.cpp.
12. Теперь напишем код в функцие OnMybutton().
Void CMDIView::OnDraw(CDC* pDC)
8. Напишем код для сохранения и считывания данных из файла.Откройте файл MDIDoc.cpp, найдите в нём функцию Serialize() и измените её:
Void CMDIView::OnInitialUpdate()
7. Теперь напишем код для вывода круга на экран.Функция OnDraw() класса представления автоматически выполняется всякий раз, когда нужно вывести окно документа.
Напишите следующий код в функции OnDraw() :
Void CMDIView::OnMybutton() {
13. Ну вот и всё, программа готова. можно взять рабочую программу, использующую MDI, в которой используется собственное диалоговое окно.Void CMyClockCtrl::OnDraw(CDC*
5. Вывод текущего времени в непрерывном режимеЧтобы отображать время непрерывно, вам нужно сделать следующее:
1) Написать код, который устанавливает таймер с 1000-миллисекундным периодом для элемента управления MyClock.
2) Связать код с событием WM_TIMER элемента управления MyClock.
После установки таймера каждые 1000 миллисекунд (каждую секунду) Windows будет посылать сообщение WM_TIMER элементу управления MyClock, в ответ на которое будет выполняться код, который вы свяжете с этим событием элемента управления. Этот код будет просто выводить текущее время, так что значение времени будет непрерывно обновляться.
Таймер необходимо установить сразу после создания элемента управления, так что вам нужно связать код, устанавливающий таймер, с событием WM_CREATE элемента управления:
Выведите диалоговую панель ClassWizard, выбрав ClassWizard в меню View. На странице Message Maps выберите следующее событие:
Class Name: CMyClockCtrl
Object ID: CMyClockCtrl
Message: WM_CREATE
Щелкните на кнопке Add Function.
В ответ Visual C++ добавит в класс CMyClockCtrl функцию-элемент ОпСreate().
Щелкните на кнопке Edit Code в ClassWizard.
В ответ Visual C++ откроет файл MyClockCtrl.cpp с функцией OnCreate() в режиме редактирования.
Напишите следующий код в функции OnCreate():
Ну вот и всё, теперь элемент управления MyClock имеет свойства BackColor и ForeColor.
7. Включение специального свойства в ActiveX MyClock
Во многих случаях вам понадобится включить в свой элемент управления такие свойства, которые не входят в список стандартных. Эти свойства называются специальными.
Для примера включем в MyClock специальное свойство UpdateInterval - период обновления:
View -> ClassWizard -> Automation( проверте, чтобы в окне Class name установлен класс CMyClockCtrl )
Нажмите на кнопку Add Property
В окне External name наберите UpdateInterval
В окне Type выберите Long
В окне Variable name должно быть m_updateinterval
В окне Notification function поставьте OnUpdateIntervalChanged
Проверте, что в камке Implementation выбрана кнопка Member variable и нажмите OK
Тем самым мы определили, что со свойством UpdateInterval будет связана переменная m_updateinterval и всякий раз, когда значение свойства UpdateInterval будет именяться, автоматически выполнится функция OnUpdateIntervalChanged.
Теперь надо проинициализировать свойство UpdateInterval:
Откройте файл MyClockCtl.cpp
Найдите функцию DoPropExchange() и напишиет в ней следующее:
// Инициализация свойства UpdateInterval значением 1000
PX_Long( pPX, _T("UpdateInterval"), m_updateinterval, 1000 );
Теперь надо модернизировать функции OnUpdateIntervalChanged:
// проверка на отризательность
if( m_updateinterval < 0 )
{
MessageBox( "This property cannot be negative !!!" );
m_updateinterval = 1000;
}
// Установка таймера
SetTimer( 1, (UINT)m_updateinterval, NULL );
и OnCreate: // Установка таймера
SetTimer( 1, (UINT)m_updateinterval, NULL );
Void CMyClockCtrl::OnTimer(UINT
6. Включение базовых свойств в ActiveX MyClockБазовые свойства( Stock properties ) - преопределены.
Ниже приведён список базовых свойств:
Appearance - Внешний вид( 3-х мерный или плоский )
BackColor - Цвет фона
BorderStyle - Стиль рамки
Caption - Заголовок
Enabled - Состояние доступен/недоступен
Font - Шрифт
ForeColor - Цвет переднего плана
hWnd - Маркер окна
ReadyState - Состояние готовности
Text - Текст
Для практики включим два базовых свойства в ActiveX MyClock: BackColor и ForeColor.
Выполните следующие действия:
View -> ClassWizard -> Automation( проверте, чтобы в окне Class name установлен класс CMyClockCtrl )
Нажмите на кнопку Add Property
Выберите из списка BackColor и нажмите OK
Также добавьте и свойство ForeColor.
Элемент управления MyClock имеет сейчас свойства BackColor и ForeColor, но пока не использует значения, хранящиеся в этих свойствах. Вам надо написать код в функции OnDraw(), который выполняет эту задачу:
Void CTab_controlDlg::OnDestroy()
Ну вот и всё, приложение готово.можно взять рабочую программу под MFC, с использованием CTabCtrl.
Void CTab_controlDlg::OnSelchangingTab(NMHDR*
Здесь используются те самые указатели, которые мы спрятали в OnInitDialogТеперь освободим память и разрушим диалоговые окна при выходе из приложения.
Добавим функцию OnDestroy:
Второй способ использования таймера
Второй способ работы с таймером заключается в использовании для таймера специальной функции, которая будет получать сообщения WM_TIMER. Эта функция является функцией обратного вызова, определяется с ключевым словом _export и, так же как и функция окна, имеет специальный пролог и эпилог: void CALLBACK _export TimerProc(HWND hwnd, UINT msg, UINT idTimer, DWORD dwTime);Как и для функции окна, для функции таймера можно выбрать любое имя. При создании таймера вам надо указать адрес функции таймера, а имя не имеет никакого значения.
Первый параметр функции таймера - идентификатор окна, с которым связан таймер. Если при создании таймера в качестве идентификатора было указано значение NULL, это же значение будет передано функции таймера.
Второй параметр представляет собой идентификатор сообщения WM_TIMER.
Третий параметр является идентификатором таймера, пославшего сообщение WM_TIMER.
И наконец, последний параметр - текущее время по системным часам компьютера. Это время выражается в количестве тиков таймера с момента запуска Windows. Вы можете узнать текущее системное время в любой момент, если воспользуетесь функцией GetCurrentTime или GetTickCount: DWORD WINAPI GetCurrentTime(void); DWORD WINAPI GetTickCount(void);
Эти функции совершенно аналогичны, однако название функции GetTickCount более точно отражает выполняемое ей действие.
Если для создания приложения вы пользуетесь современными средствами разработки, такими, как Borland C++ версии 3.1, Microsoft С++ версии 7.0, Microsoft Visual C++, для определения функции обратного вызова достаточно использовать ключевое слово _export. В этом случае вы можете создать таймер, например, так: nTimerID = SetTimer(hwnd, 0, 1000, (TIMERPROC)TimerProc);
Для удаления таймера в этом случае необходимо использовать идентификатор, возвращенный функцией SetTimer: KillTimer(hwnd, nTimerID );
Если же используемые вами средства разработки не позволяют указать ключевое слово _export, для подключения функции таймера придется использовать более сложный способ.
Когда вы не можете ограничиться использованием ключевого слова _export, для работы с функциями обратного вызова нужно сделать специальный переходник (thunk), вызвав функцию MakeProcInstance: FARPROC WINAPI MakeProcInstance(FARPROC lpProc, HINSTANCE hinst);
В качестве первого параметра функции (lpProc) необходимо передать адрес функции, для которой создается переходник, а в качестве второго (hinst) - идентификатор приложения hInstance, полученный функцией WinMain при запуске приложения.
Функция MakeProcInstance для указанной функции создает функцию-переходник, возвращая ее адрес, а также обеспечивает функции доступ к сегменту данных приложения, загружая соответствующим образом сегментные регистры.
Процедура создания таймера с использованием функции MakeProcInstance может выглядеть следующим образом:
TIMERPROC lpfnTimerProc; lpfnTimerProc = (TIMERPROC)MakeProcInstance((FARPROC)TimerProc, hInstance); nTimerID = SetTimer(hwnd, 0, 1000, (TIMERPROC)lpfnTimerProc);
После уничтожения таймера следует уничтожить созданный функцией MakeProcInstance переходник, для чего следует вызвать функцию FreeProcInstance: void WINAPI FreeProcInstance(FARPROC lpProc);
Этой функции необходимо передать адрес уничтожаемой функции-переходника: FreeProcInstance(lpfnTimerProc);
Функции MakeProcInstance и FreeProcInstance можно использовать совместно с современными средствами разработки, понимающими ключевое слово _export. Это не приведет к неправильной работе приложения.
Старые средства разработки приложений Windows требуют, чтобы все функции обратного вызова, такие, как функции окон и функции таймеров, были описаны в файле определения модуля, имеющем расширение .def, при помощи оператора EXPORTS, например: EXPORTS WndProc TimerProc
Транслятор Borland C++ версии 3.1 распознает ключевое слово _export и автоматически формирует нужный пролог и эпилог для функций обратного вызова. То же самое относится и к трансляторам Microsoft C++ версии 7.0 и Microsoft Visual C++. Поэтому в наших примерах функции MakeProcInstance и FreeProcInstance, а также оператор файла определения модуля EXPORTS не используются.
Запись и считывание данных ( работа с файлами ).
В этом разделе будут рассотрены два способа работы с фыйлами и стандартный класс MFC CFileDialog.Затем следует получить дескриптор
hMyDll=::LoadLibrary(“MyDLL”); pfnMyFunction=(PFN_MyFunction)::GetProcAddress(hMyDll,”MyFunction”); …… int iCode=(*pfnMyFunction)(“Hello”); 
Биржевая торговля: Механические торговые системы - Создание - Программирование
- Механические торговые системы (МТС)
- Технический анализ и МТС
- Разработка механических торговых систем
- Механические торговые системы
- GNU механические торговые системы
- Тестирование механических торговых систем
- MetaStock - механические торговые системы
- Omega Trade Station - механические торговые системы
- МТС - обзор языков программирования
- Си для механических торговых систем
- C# для механических торговых систем
- C++ для механических торговых систем
- Borland C++ для механических торговых систем
- C++ Builder для механических торговых систем
- Visual C++ для механических торговых систем