Лабораторный практикум «Основы разработки приложений Windows» (стр. 3 )

Функция BitBlt() позволяет не только выводить в окна приложения нарисованные заранее растровые изображения, но и закрашивать область копирования, а также выполнять над битами изображения и битами области копирования ряд логических операций (НЕ, ИЛИ, И и ряд более сложных). С их помощью можно, в частности, стирать выведенное ранее изображение. Вид операции, выполняемой над изображением (вид растровой операции), определяется значением последнего параметра ROP функции BitBlt(). При выводе в окно статических изображений используется операция простого копирования и параметр ROP имеет значение SRCCOPY (source copy, копирование источника). При выводе движущихся изображений, когда перед выводом изображения на новое место надо сначала стереть старое изображение, используются и другие растровые операции.

Функция BitBlt() требует указания размеров изображения. Для получения характеристик графических объектов Windows предусмотрена функция GetObject(), которая возвращает информацию о запрошенном объекте в соответствующую этому объекту структуру. Для объекта-растра используется структура типа BITMAP. Элемент bmWidth этой структуры принимает значение ширины изображения, а элемент bmHeight – его высоты. Эти значения можно затем использовать при вызове функции BitBlt():

BITMAP bm;//Переменная для характеристик объекта

HBITMAP hBitmap=(HBITMAP)LoadImage(...);//Загрузка растра

GetObject(hBitmap, sizeof(BITMAP),&bm);//Получение

//характеристик объекта

BitBlt(hdc,10,20,bm. bmWidth, bm. bmHeight, hdcMem,0,0,SRCCOPY);

В приведенном примере все изображение копируется в окно со сдвигом от начала окна на 10 пикселов по горизонтали и 20 по вертикали.

Компоновка составных изображений

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

SelectBitmap(hdcMem, hBitmap);//Выбираем в совместимый

//контекст дескриптор совместимой памяти

SetTextColor(hdcMem, RGB(0,0,200);//Изменяем цвет шрифта в

//совместимом контексте

SetTextMode(HdcMem, TRANSPARENT); //Делаем в нем фон прозрачным

char str[]="Образец";//Строка для вывода поверх изображения

TextOut(hdcMem,100,100,str, strlen(str));//Выводим строку

Разумеется, выведенный в совместимую память текст не появится в окне приложение до тех пор, пока мы не скопируем совместимую память в окно функцией BitBlt().

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

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

Однако для выполнения такой процедуры необходимо иметь пустую совместимую память требуемого размера. Для такой памяти предусмотрена функция CreateCompatibleBitmap():

HBITMAP hBitMap=CreateCompatibleBitmap(hdc,800,600);

В этом примере создается совместимая память размером во весь экран (800´600 пикселов). Заметим, что для создания совместимой памяти таким способом так же, как и при создании совместимого контекста, требуется иметь контекст окна hdc. Поскольку пустая совместимая память обычно создается заранее, в функции OnCreate(), контекст hdc получают вызовом функции GetDC().

При создании пустой совместимой памяти с помощью функции CreateCompatibleBitmap()следует иметь в виду, что реально эта память отнюдь не пуста, а может быть заполнена любым “мусором”. Если затем эта память заполняется копируемым в нее изображением целиком, то “мусор”, разумеется, затирается. Если, однако, графические объекты выводятся в отдельные участки большого блока совместимой памяти, ее следует предварительно очистить. Проще всего это сделать с помощью функции FillRect(), которая позволяет залить указанную в ее параметрах прямоугольную область любой кистью (не обязательно белой):

RECT rect;//Структура, описывающая прямоугольник

rect. left=rect. top=0;//Зальем всю совместимую память

rect. right=800;//размером 800´600 пикселов

rect. bottom=600;

HBRUSH hBrush=CreateSolidBrush(RGB(180,250,250));//Кисть

FillRect(hdcMem,&rect, hBrush);//Заливаем

В этом примере вся совместимая память закрашивается бледно-бирюзовой кистью.

6. Обслуживание файлов в 32-разрядных приложениях Windows

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

Для 32-разрядных приложений системой Windows предоставляются как традиционные средства работы с файловой системой (создание и удаление файлов и каталогов, чтение и запись, поиск, изменение характеристик и др.), так и специфические средства, не поддерживаемые в 16-разрядных приложениях Windows или в MS-DOS. К последним прежде всего следует отнести проецирование файлов в память, асинхронные операции с файлами и расширенное толкование понятия физической памяти как суммы оперативной памяти и страничных файлов (файлов подкачки).

Базовые операции с файлами

Открытие и создание файла

Перед тем как начать работать с файлом, программа должна либо его создать заново, либо открыть, если он был создан ранее. И та и другая операция выполняются в 32-разрядных приложениях Windows с помощью одной универсальной функции – CreateFile(). При успешном выполнении эта функция возвращает 32-разрядный дескриптор файла типа HANDLE, через который потом и выполняются все операции с данным файлом. Если файл открыть не удалось, функция CreateFile() возвращает 0xFFFFFFFF. Функция CreateFile() имеет следующий прототип:

HANDLE CreateFile(

LPCTSTR lpFileName,//Адрес спецификации файла

DWORD dwDesiredAccess,//Режим доступа

DWORD dwShareMode,//Режим разделения

LPSECURITY_ATTRIBUTES lpSecurityAttributes,//Адрес

//структуры с атрибутами защиты

DWORD dwCreationDistribution,//Режим открытия

DWORD dwFlagsAndAttributes,//Атрибуты файла

HANDLE hTemplateFile //Дескриптор файла-шаблона

);

Параметр lpFileName описывает спецификацию файла по обычным правилам, например "Myfile.001", если файл находится в текущем каталоге, или "C:\\Dir\\1.1", если файл находится в конкретном каталоге конкретного диска. Обратите внимание на обозначение пути к файлу. Поскольку в языке С++ символ “\” является управляющим, то для того чтобы ввести этот символ в символьную строку, например, в качестве разделителя каталогов в составном пути, следует указывать два таких символа. Допустимо также использование для разделения элементов пути одного знака деления: "C:/Dir/1.1"

Параметр dwDesiredAccess при работе с файлами чаще всего указывается в виде GENERIC_READ | GENERIC_WRITE, что обеспечивает доступ к файлу как для чтения, так и для записи.

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

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

Параметр dwCreationDistribution может принимать следующие значения:

CREATE_NEW – создается новый файл; если файл уже существует, функция CreateFile() возвращает ошибку;

CREATE_ALWAYS – создается новый файл; если файл с указанным именем уже существует, он затирается вновь создаваемым;

OPEN_EXISTING – открывается существующий файл; если такого файла нет, функция CreateFile() возвращает ошибку;

OPEN_ALWAYS – открывается существующий файл; если такого файла нет, функция CreateFile() создает новый файл с указанным именем.

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

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

Таким образом, типичным для прикладной программы будут следующие формы вызова функции CreateFile():

/*При создании нового файла*/

HANDLE hFile=CreateFile("001.dat",

GENERIC_READ|GENERIC_WRITE,

0, NULL, CREATE_ALWAYS, 0, NULL);

/*При открытии существующего файла*/

HANDLE hFile=CreateFile("001.dat",

GENERIC_READ | GENERIC_WRITE,

0, NULL, OPEN_EXISTING, 0, NULL);

После завершения работы с файлом или перед завершением программы все открытые в ней файлы следует закрыть. Для этого используется функция CloseHandle() c указанием в качестве ее единственного параметра дескриптора закрываемого файла:

CloseHandle(hFile);

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

Запись и чтение файла

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

Функции чтения и записи имеют практически одинаковые прототипы:

BOOL ReadFile(HANDLE hFile,

LPVOID lpBuffer,

DWORD nNumberOfBytesToRead,

LPDWORD lpNumberOfBytesRead,

LPOVERLAPPED lpOverlapped);

BOOL WriteFile(HANDLE hFile,

LPCVOID lpBuffer,

DWORD nNumberOfBytesToWrite,

LPDWORD lpNumberOfBytesWritten,

LPOVERLAPPED lpOverlapped);

Параметр hFile обозначает полученный от функции CreateFile() дескриптор созданного или открытого файла.

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

Третий параметр рассматриваемых функций определяет заказываемый объем пересылаемых данных (в байтах).

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

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

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

DWORD SetFilePointer(HANDLE hFile, LONG lDistanceToMove,

PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod);

Параметр hFile обозначает полученный от функции CreateFile() дескриптор созданного или открытого файла.

Параметр lDistanceToMove задает 32-битовое смещение в файле до точки установки указателя.

Параметр lpDistanceToMoveHigh является адресом старшей половины смещения указателя, если смещение характеризуется 64-битовым значением. Обычно здесь указывается NULL.

Последний параметр dwMoveMethod определяет способ установки указателя. Этот параметр может принимать три значения:

FILE_BEGIN – указатель устанавливается от начала файла и, следовательно, рассматривается как число без знака. Максимальное смещение в файле (если не использовать параметр lpDistanceToMoveHigh) достигает = 4 Гбайт - 2;

FILE_CURRENT – указатель устанавливается от текущей позиции указателя и, следовательно, рассматривается как число со знаком, что позволяет смещать указатель как вперед, так и назад от текущего положения в пределах до 2 Гбайт;

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

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

struct GOODS{//Структура, описывающая изделия на складе

int Nmb;//Номер изделия

int Price;//Цена изделия

};

const int N=1000000;//Пусть на складе миллион образцов изделий

GOODS Stock[N];//Создадим в памяти массив для всех изделий

GOODS Unit1;//Структурная переменная для одного изделия

DWORD dwCount;//Для функций чтения/записи

... //Заполним массив структур данными

/*Создадим новый файл*/

HANDLE hFile=CreateFile("stock. dat",

GENERIC_READ|GENERIC_WRITE,

0,NULL, CREATE_ALWAYS,0,NULL);

/*Запишем в файл весь массив структурных переменных*/

WriteFile(hFile, Stock, sizeof(Stock),&dwCount, NULL);

/*Сместим указатель на последнюю запись и прочитаем ее */

SetFilePointer(hFile, sizeof(GOODS)*(-1),NULL, FILE_END);

ReadFile(hFile,&Unit1,sizeof(GOODS),&dwCount, NULL);

CloseHandle(hFile);//Закроем файл (нет необходимости)

С таким же успехом и даже более наглядно было бы в операциях записи, установки указатели и чтения указывать количество записываемых байтов в виде числа. Поскольку каждое число типа int требует для своего хранения четыре байта, то каждая структурная переменная типа GOODS занимает в памяти 8 байт, а весь массив – 8000000 байт. Поэтому запись в файл можно выполнить таким образом:

WriteFile(hFile, Stock,8&dwCount, NULL);

а, например, установку указателя так:

SetFilePointer(hFile, -8,NULL, FILE_END);

или так:

SetFilePointer(hFile, 7NULL, FILE_BEGIN);

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

Файлы, проецируемые в память

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

·  открытие файла на диске;

·  чтение требуемого участка файла в созданную заранее программную переменную;

·  модификация этой программной переменной по заданному алгоритму;

·  запись модифицированной переменной на то же место в файле на диске.

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

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

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

Процедура создания и использования проекции файла (рис. 6.1) распадается на несколько этапов:

·  открытие (или, возможно, создание) файла обычным образом с помощью функции CreateFile();

·  создание в физической памяти объекта “проекция файла” с помощью функции CreateFileMapping();

·  выделение в линейном пространстве области адресов для проекции файла и отображение этой области на проекцию файла в физической памяти с помощью функции MapViewOfFile(), которая возвращает указатель на выделенную область;

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

Рис. 6.1. Процесс проецирования файла в память

Рассмотрим содержательную часть программы, осуществляющей проецирование файла в память и работу с его проекцией. Будем считать, что файл с именем 1.dat состоит из 1000 чисел типа int (и занимает, следовательно, на диске пространство 4000 байт).

/*Операция открытия существующего файла*/

hFile=CreateFile("1.dat",GENERIC_READ,

0,NULL, OPEN_EXISTING,0,NULL);

/*Создание в памяти объекта "проекция файла"*/

HANDLE hMem = CreateFileMapping

(hFile, NULL, PAGE_READONLY,0,0,NULL);

/*Отображение линейных адресов на проекцию файла */

int* ptr = (int*)MapViewOfFile(hMem, FILE_MAP_READ,0,0,0);

/*Чтение участков файла*/

int x=ptr[0];//Чтение первого данного из файла

int y=ptr[999];//Чтение последнего данного из файла

В приведенном примере файл был открыт только для чтения (параметр GENERIC_READ функции CreateFile()). Соответственно, такой же атрибут получила проекция файла в физической памяти (параметр PAGE_READONLY), а также и выделенная область линейных адресов (параметр FILE_MAP_READ). Если в проецируемый файл предполагается выполнять запись новых данных, тогда для соответствующих параметров вызываемых функций
следует указать значения GENERIC_READ|GENERIC_WRITE, PAGE_READWRITE и FILE_MAP_ALL_ACCESS.

Файл с данными может состоять из данных любого типа. Поэтому функция MapViewOfFile(), которая должна выполнять свою работу для любых типов данных, возвращает в соответствии со своим прототипом обобщенный указатель типа LPVOID. При использовании возвращаемого этой функцией значения его необходимо преобразовать в указатель на конкретный тип данных, содержащихся в файле. В нашем случае файл заполнен числами типа int, и возвращаемое значение явным образом преобразуется в тип int*. Если бы файл был заполнен, например, байтовыми переменными типа char или BYTE, то и указатель на проекцию файла следовало получить такого же типа:

BYTE* ptr = (BYTE*)MapViewOfFile(...);

Четвертый и пятый параметры функции CreateFile­Map­ping() позволяют задать размер проекции файла. Указание в качестве параметров нулевых значений заставляет Windows спроеци­ровать весь файл.

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

7. Процессы и потоки

Процессом (process) называют экземпляр выполняемой программы – не ход выполнения программы, а именно саму программу вместе с ее ресурсами – выделенным ей адресным пространством, динамически подключаемыми библиотеками и др. Таким образом, процесс в Win32, в противоречии со смыслом этого слова, не является динамическим объектом – это скорее оболочка, набор ресурсов, которые нужны для выполнения программы.

Сам же ход выполнения программы называют потоком (thread). Поток выполняется в рамках владеющего им процесса или, как говорят, в контексте процесса. Именно потокам операционная система выделяет кванты процессорного времени. Когда операционная система запускает приложение, она создает первичный поток процесса, составляющего это приложение. Таким образом, любой процесс имеет по крайней мере один поток выполнения. Первичный поток может запустить дополнительные потоки, которые в программе оформляются как более или менее самостоятельные функции. Эти потоки будут выполняться параллельно, конкурируя за процессорное время. Кроме того, первичный поток может запустить один или несколько процессов (программ); эти программы, точнее их потоки, также будут выполняться параллельно с породившим их родительским потоком.

Создание дочернего процесса

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

Дочерний процесс создается вызовом функции CreateProcess(). Эта функция требует указания 10 параметров, большинством из которых в простых программах можно пренебречь. Однако для запуска дочернего процесса в программе придется создать и настроить должным образом некоторые служебные поля данных. Рассмотрим простейшую форму запуска дочернего процесса, в качестве которого мы используем, например, Калькулятор CALC. EXE (это не очень интересно по существу, но зато весьма наглядно).

STARTUPINFO si;//Служебная структурная переменная

PROCESS_INFORMATION pi;//Служебная структурная переменная

ZeroMemory(&si, sizeof(si));//Очистим переменную si

si. cb=sizeof(si);//Заносим в член si.cb размер переменной si

CreateProcess("e:\\win98\\calc. exe",NULL, NULL, NULL,

FALSE,0,NULL, NULL,&si,&pi);

Создание дочернего потока

Как уже отмечалось, система, запуская процесс (приложение), организует в нем первичный поток выполнения. Этот поток может с помощью функции CreateThread() создать еще один или несколько потоков, которые будут выполняться параллельно в контексте владеющего ими процесса (запущенной программы). С формальной точки зрения каждый поток представляет собой одну из функций, входящих в состав всего процесса; в отличие от остальных эту функцию можно назвать функцией потока или рабочей функцией. Рабочая функция может иметь любое содержимое, однако ее прототип жестко определен:

DWORD WINAPI Thread(LPVOID);

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

Функция создания (запуска) потока CreateThread() требует указания шести параметров:

HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,

DWORD dwStackSize,

LPTHREAD_START_ROUTINE lpStartAddress,

LPVOID lpParameter,

DWORD dwCreationFlags,

LPDWORD lpThreadId

);

Параметр lpThreadAttributes задает адрес структуры с атрибутами защиты потока. В простой прикладной программе эта структура не нужна, и на месте этого атрибута указан NULL.

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

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

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

Параметр dwCreationFlags определяет режим создания потока. Если для него указать значение CREATE_SUSPENDED, поток будет создан в спящем состоянии и фактически начнет выполняться лишь после вызова функции ResumeThread(). При нулевом значении этого параметра создаваемый поток начнет выполняться сразу после создания.

Наконец, в качестве последнего параметра указывается адрес переменной типа DWORD, в которую функция создания потока вернет его идентификатор.

Создав поток, функция CreateThread() возвращает его дескриптор типа HANDLE, который затем можно использовать при выполнении различных операций над потоком, например, приостановке выполнения потока с помощью функции Suspend­Thread().

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

DWORD WINAPI MyThread(LPVOID);//Прототип рабочей функции

DWORD dwId;//Переменная для идентификатора потока

HANDLE hThread;//Переменная для дескриптора потока

hThread=CreateThread(NULL,0,MyThread, NULL,0,&dwId);

...//Продолжение программы порождающего потока

/*Рабочая функция потока*/

DWORD WINAPI MyThread(LPVOID){

//Любые действия, предназначенные для выполнения

//параллельно с порождающим потоком

return 0;

}

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

Рассмотрим приложение, в которой выбором одного пункта меню дочерний поток создается, а выбором другого – уничтожается. Будучи запущен, вторичный поток начинает периодически инициировать вывод в главное окно приложения текущего времени (минуты и секунды). Приводимый пример позволит нам проиллюстрировать программное решение некоторых смежных вопросов: запуск и уничтожение потока по командам меню, циклическое безостановочное выполнение рабочей функции потока, взаимодействие функции потока с главным окном приложения и др. На рис. 7.1 приведен вид главного окна приложения с открытым меню и выведенным текущим временем.

Рис. 7.1. Окно приложения с порожденным потоком

/*Заголовочный файл Thread.h */

#define ID_1 101

#define ID_2 102

/*Файл ресурсов*/

#include "Thread. h"

Main MENU{

POPUP "Потоки"{

MENUITEM "ON", ID_1

MENUITEM "OFF", ID_2

}

}

/*Исходный текст программы (выборочно)*/

#include <windows. h>

#include <windowsx. h>

#include "Thread. h"

HWND hWnd;//Дескриптор главного окна

HANDLE hThread1;//Дескриптор создаваемого потока

BOOL bFin=true;//Булева переменная для закрытия потока

/*Главная функция приложения*/

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR, int){

... //Регистрация класса окна

hWnd=CreateWindow(szClassName, //Создадим главное окно

"Threads",WS_OVERLAPPEDWINDOW,10,10,120,80,

HWND_DESKTOP, NULL, hInst, NULL);

ShowWindow(hWnd, SW_SHOWNORMAL);//Покажем главное окно

while(GetMessage(&msg, NULL,0,0))//Цикл обработки

DispatchMessage(&msg); //сообщений

return 0;

}

/*Оконная функция*/

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg,

WPARAM wParam, LPARAM lParam){

switch(msg){

HANDLE_MSG(hwnd, WM_COMMAND, OnCommand);

HANDLE_MSG(hwnd, WM_PAINT, OnPaint);

HANDLE_MSG(hwnd, WM_DESTROY, OnDestroy);

default:

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

}

}

/*Оконная функция*/

void OnCommand(HWND, int id, HWND, UINT){

DWORD dwIDThread;//Идентификатор потока

switch(id){

case ID_1://Выбрали ON

bFin=true;//Разрешим потоку выполняться

hThread1=CreateThread(NULL,0,Thread1,//Создание потока

NULL,0,&dwIDThread);

break;

case ID_2://Выбрали OFF

bFin=false;//Завершим поток

CloseHandle(hThread1);//Освободим дескриптор потока

RECT rect;//Для координат главного окна

HDC hdc=GetDC(hWnd);//Получим контекст устройства

GetClientRect(hWnd,&rect);//Получим координаты окна

FillRect(hdc,&rect, GetStockBrush//Закрасим окно белым

(WHITE_BRUSH));

ReleaseDC(hWnd, hdc);//Освободим контекст устройства

break;

}

}

/*Функция обработки сообщения WM_PAINT*/

void OnPaint(HWND hwnd){

char szT[10];

PAINTSTRUCT ps;

SYSTEMTIME st;

HDC hdc=BeginPaint(hwnd,&ps);

if(hThread1){//Только если есть поток

GetLocalTime(&st);//Получим текущее время

wsprintf(szT,"%d:%d",st. wMinute, st. wSecond);

TextOut(hdc,80,5,szT, strlen(szT));//Выведем в окно

}

EndPaint(hwnd,&ps);

}

/*Функция обработки сообщения WM_DESTROY*/

void OnDestroy(HWND){

bFin=FALSE;//Завершим поток при завершении приложения

PostQuitMessage(0);

}

/*Рабочая функция потока */

DWORD WINAPI Thread1(LPVOID){

while(bFin){//Пока выполнение потока разрешено

InvalidateRect(hWnd, NULL, TRUE);//Инициируем WM_PAINT

Sleep(1000);//Усыпим поток на 1 с

}

return 0;Завершим функцию потока (поток уничтожается)

}

Программа построена обычным образом и состоит из главной функции WinMain() и оконной функции, в которой обрабатыва­ются сообщения WM_COMMAND, WM_PAINT и WM_DESTROY. При выборе пункта меню "ON" выполняются два действия: устанавливается в состояние true вспомогательная булева переменная bFin, которая управляет циклическим выполнением рабочей функции потока, и вызовом функции CreateThread() создается вторичный поток. Дескриптор потока сохраняется в переменной hThread1. Начиная с этого момента в контексте приложения параллельно выполняются два потока: первичный, который “крутится” в цикле обработки сообщений, и вторичный, который инициирует периодический вывод в окно текущего времени.

Выбор пункта меню “OFF” приводит к выполнению более сложного алгоритма. Переменная bFin сбрасывается в состояние false, что приводит к разрыву цикла выполнения рабочей функции потока и к ее завершению. Далее вызовом функции CloseHandle() освобождается ненужный более дескриптор потока. Если этого не сделать, то при повторных запусках потока выбором пункта меню “ON”, будут создаваться все новые и новые дескрипторы, что вряд ли разумно.

Последнее действие, выполняемое на этом участке программы, состоит в очистке главного окна приложения. Если окно не очистить, то последнее выведенное значение времени так и останется в окне, путая пользователя. Окно очищается вызовом функции Fillrect(), которая требует в качестве параметров дескриптор контекста устройства, адрес структуры типа RECT с координатами очищаемой области и дескриптор кисти, которой закрашивается окно. Для получения контекста устройства используется функция GetDC(), координаты рабочей области окна определяются с помощью функции GetClientRect(), а белая кисть для закрашивания берется со “склада” Windows.