Нареши! Нареши! Днес можем да вършим много работа всяка година Windows. Сбогом бедната конзола!

Досега ваша отговорност е да знаете добре синтаксиса на C++, да практикувате с отстраняване на грешки и цикли и да разбирате добре работата на функциите. Ако влезете в морска битка, можете да вземете това, което сте поели.

Формуляр за участие в Ugorskaya

Целият код, който е познат на изписването на WinAPI в угорска форма. Това е в името на начина, по който е написан кодът.

За кого, преди името на промяната, поставете буквата от типа на буквата. Всички думи в имената на променливите и функциите започват с голяма буква.

Ос на килка prefіksіv:

b - промяна на тип bool.
l – променено на дълго цяло число.
w - тип дума (word) - 16 бита. Променено на неподписан кратък тип.
dw - двойна дума (поддума) - 32 бита. Променен на неподписан дълъг тип.
sz - ред, който завършва с нула (низ завършва с нула). Просто прекрасен ред, който ние постоянно побеждаваме.
p или lp - индикатор (като показалец). lp (като дълъг указател) – тези индикатори са преминали от миналото. В същото време lp и p означават едно и също.
h - описателен (като дръжка).

Например, индикаторът се нарича оста така:

void*pData;

Формулярът за участие е одобрен от Microsoft. Много хора критикуват този начин на промяна на именуването. Ale, подобни речи (моля, за кодирането) големите компании имат нужда от живот.

Предполагам, че идентификаторите на звука на константите са съставени от по-малко от главни букви: WM_DESTROY. WM_DESTOY - не 2, константа се присвоява чрез define.

Освен това winAPI има много отменени типове. Axis от третата страна - http://msdn.microsoft.com/en-us/library/aa383751(VS.85).aspx, можете да намерите описания на всички видове Windows (на английски).

И още един богат, те не разбраха яку. Индикаторите често очакват стойности NULL. Моля, имайте предвид, че това е просто 0 и че му е присвоена стойност NULL (нула), не влизайте в слота за памет.

Windows API (WinAPI)

Всички програми под Windows използват специален интерфейс за програмиране на WinAPI. След въвеждане на функции и структури в mov C, вашата програма става толкова богата от Windows.

Windows API има голям потенциал за работа с операционна система. Може да се каже – без граници.

Не можем да разгледаме стоте възможности на WinAPI. Исках да получа повече материал скоро, но ще отнеме много време и изтеглянето на WinAPI в блатата, в DirectX "и щяхме да се измъкнем след няколко години. Описанието на WinAPI ще отнеме два урока (включително tsey). Windows.

Програмата под Windows е точно като програмата под DOS, има основна функция. Тук функцията се нарича WinMain.

WinMain функция

Програмата под Windows се състои от следните части (всичко е включено в средата на WinMain):

Създаването на този регистрационен клас vikna. Не се обърквайте от C++ класове. WinAPI е написан на C, така че няма клас за нас.
Създаване на програмата.
Основният цикъл, в който е завършен акомпаниментът.
Obroblyaє програма povіdomlennya на vіkonnіy protsessі. Vіkonna процедура е zvichaynoyu funktієyu.
Оста chi е основата на програмата на Windows. Разтягайки някои от обидните уроки на света, всичко се съобщава. Ако се изгубите в описанието на програмите, обърнете се към тези точки.

Сега нека да разгледаме всичко докладвано:

WinAPI: WNDCLASS структура

Ще трябва да създадем структурна промяна WNDCLASS и след това редовно да регистрираме класа икона.

Ос като структурата изглежда така:

моят C++ код typedef struct ( UINT style; // WNDPROC прозорец стил lpfnWndProc; // индикатор за процедура на прозорец int cbClsExtra; // допълнителни байтове след класа. Винаги задавайте 0 int cbWndExtra; // допълнителни байтове за всеки екземпляр на прозореца. Винаги задавайте 0 / екземпляр на програмата : Предаден като видим параметър на WinMain HICON hIcon; // икона на програмата HCURSOR hCursor; // програмен курсор HBRUSH hbrBackground; // цвят на фона LPCTSTR lpszMenuName; // име на менюто LPCTSTR lpszClassName; ;

Структурата WNDCLASS в склада на WinAPI определя основната мощност на прозореца, който се създава: икони, вида на курсора на мишката, какво е менюто на прозореца, кое допълнение ще лежи в прозореца ...

След като попълните структурата на база її, можете да регистрирате крайния клас. Това не е същият клас като C++. Можете да разберете по-добре какъв шаблон е този шаблон, регистрирали сте го в системата и сега, въз основа на този шаблон, можете да създадете копие на иконата. И всички tsі vіkna ще бъдат майки на властта, както сте посочили в структурната промяна на WNDCLASS.

WinAPI: Функция CreateWindow

След регистрацията на големия клас на тази база се създава чисто нова програма (веднага пристъпихме към друга точка). Бързайте за допълнителната функция CreateWindow. Може да има обиден прототип:

моят C++ код HWND CreateWindow(LPCTSTR lpClassName, // име на клас LPCTSTR lpWindowName, // име на прозореца (показано в заглавието) DWORD dwStyle, // стил на прозореца int x, // хоризонтална координата на левия край на екрана int y, // вертикална координата на горния край на екрана int nWidth, // ширина на прозореца int nHeight, // височина на прозореца HWND hWndParent, // родителски прозорец HMENU hMenu, // описание на менюто HINSTANCE hInstance, // LPVOID програмен екземпляр lpParam // параметър; зададено на NULL );

Що се отнася до скин класа (структура WNDCLASS), основната мощност на класа е зададена, тук тя е специфична за скин класа: обхват на класа, координати...

Тази функция завърта описанието на прозореца. За помощ при описването на описанието можете да отидете до прозореца, той е приблизително като идентификатор.

Отдайте уважение, тук има много нови видове. Наистина, цялата смрад е стара, просто пренаписана. Например: HWND - не е преназначен на типа HANDLE, който е преназначен на PVOID, който е преназначен на void*. Истината е заровена дълбоко! Ale всички от същия тип HWND - tse pokazhchik на празнотата.

Vіkno е сгънат от няколко части. На практика в кожата на програмата можете да щракнете върху: заглавието на прозореца, системното меню (като щракване върху иконата на програмата в горната лява част на прозореца), три системни бутона за работа с прозореца: включване, включване на целия екран и затворете. Така че на практика добавете меню към допълнението. Оста на останалото определено няма да е в нас. Аз, очевидно, повечето време е заето от т.св. клиентска зона, де повикване и практика ползвач.

Tse shdo vikonnogo режим. За да завърша дългогодишната си практика със самия DiectX на vіknі - ние няма да се използва поноекранен режим.

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

Основната отговорност на всички наши предишни програмиизглед на програмата под Windows

Например, ако потребител натисне клавиш на клавиатурата, се генерира напомняне, че клавишът е натиснат. Нека ви напомним да отидете на програмата, сякаш е активна, ако сте натиснали клавиша.

Тук имаме подиум (събитие) - натиска се клавиш.

Podíya може да бъде: преместване на курсора на мишката, промяна на фокуса на програмата, натискане на клавишите на клавиатурата, затваряне на прозореца. Хайде вече богат. Дудже! За секунда в операционната система могат да се появят десетки модули.

Така оста, ако изглежда като шушулка, операционната система създава предупреждение: такъв клавиш е натиснат, координатите на курсора на мишката са се променили, появи се нов прозорец.

Уведомленията могат да се създават като операционна система, както и различни програми.

Забележете структурата и изглеждайте като офанзивен ранг:

моят C++ код typedef struct tagMSG ( HWND hwnd; // прозорец, ако известието е отменено UINT съобщение; // код за известяване WPARAM wParam; // параметър LPARAM lParam; // параметър DWORD време; // час, ако е възникнала алармата POINT pt; / / координати на курсора на мишката) MSG;

С уважение, що се отнася до помощта на typedef, структурите са предефинирани.

За да създадете тази структура, можете да ускорите следния код:

моят C++ код msg.messgae == 2; // tsі два реда, еквивалентни на това, което msg.message == WM_DESTROY; // Константата WM_DESTROY е две

Тук е полето, в което трябва да бъде публикуван алармен код (Im'ya alert, съпоставен с константата WM_DESTROY. WM - тип съобщение на Windows (Windows alert). WM_DESTROY - код за предупреждение, тъй като се генерира при затваряне на прозореца (унищожи - унищожи).

Код за подпомагане на присвояването на допълнителни константи и използване на префикса WM_: WM_CLOSE, WM_CREATE и други.

Структурата на MSG има тип HWND - като Window Handle (дескриптор на прозорец или описание на прозорец). Tse такова нещо, като "описване" на прозорец. Цената е за szrazok на идентификатора (име на билета).

Запомнете цялата дума - дръжка (опишете, дескриптор). В Windows е ясно, че е по-често срещано. Може да има всички видове Windows, които са базирани на H - описание: описание на иконата, описание на шрифта, описание на екземпляра на програмата. Те са тридесет, помня колко.

Всички взаимодействия между програмите в Windows се използват за допълнителни описания на прозорци (HWND).

Има още едно важно описание - описанието на програмата (HINSTANCE - първият параметър на WinMain) - това е уникалният идентификатор на програмата, така че операционната система не може да смесва две различни програми. Tse е като баркод. Нека да разгледаме йога пизнише.

Така че, ако користувачът работи като акт, той се създава и ще бъде запомнен: описанието на прозореца е зададено, за да може да обърне внимание, идентификаторът на уведомяване е зададен, параметрите са зададени, часът (текущ) е посочено и координатите на курсора са посочени.

След кого, tse спомен операционна система. Ако се стигне до нашия съвет, той ще бъде коригиран до необходимото viknu (windows знае, че винаги е възможно да се коригира грижата за кожата за описанията). Ако ви бъде напомнено да дойдете в програмата, тя ще бъде в черно, за да напомните програмата. Оказва се, че е лесно да се стигне до новото черно.

Да се ​​чудя на този час, ако користувачът беше направил бе-як-то-дия (имаше подия и беше генерирана) и в този момент дали програмата реагира на цу-дия (имаше актуализация на програма), имаше богата подия. Adzhe yak u cherzy Събуждане на Windowsтака че в бъдеще програмата може да бъде подробно обяснена. За първия човек може да е около стотици, за друг човек поне около една цаца.

Процедура Vіkonna (Процедура на прозорец - WndProc)

Prodovzhuєmo от този момент, напомняме, програмата е реабилитирана до краен предел. Добре е за новата чернота, преобръща се. За обработка скин програмата може да има специална функция - процедура vicon. Нарича се WndProc (като Window Procedure). Viklik vykonnoy процедура rastashovaniya в основния цикъл на програмата и vykonuetsya по време на цикъла на повторение на кожата.

Сигналите (за очевидно структурни промени в MSG) са взети от тази функцияПараметри за преглед: описание на прозореца, идентификатор на актуализацията и два параметъра. Моля, имайте предвид, че полетата за време и pt не се предават на процедурата. Tobto, povіdomlennya vzhe "razіbrane".

Използвайте средната процедура за извеждане от експлоатация на превключвателя, като в този случай проверете повторно идентификатора на предупреждението. Оста на дупето на проста процедура vikonnoy (ще е повече работа):

моят C++ код// все още не изпращайте никакво уважение към HRESULT и __stdcall. Нека да ги разгледаме. ) // решаване на контролния списък )

І почивка - основен цикъл. Вин е прост. Итерацията на кожата на цикъла се проверява повторно от програмата. Веднага щом дяволът има напомняне и напомняне, той е извлечен от черните. След това, по време на цикъла, ще има проследяване до края на процедурата, за да завърши известието от chergi.

Ос пламнал и всичко за днес. Вече е ясно, че програмата WinAPI е доста по-сложна от програмата DOS. Както вече писах повече, на следващия етап ще анализираме кода на програмата, която работи.

Как да създадете нов проект. В прозореца Нов проект изберете шаблона (шаблон) - Win32Project (избрахме Win32 Console Application). В една от тези викони не поставяйте флага на Empty Project и IDE ще генерира програмата.

Ако с уважение се чудите на кода на файла project_name.cpp, тогава ще разкриете всички изказвания, които обсъдихме: структурната промяна на MSG, завършването на структурата WNDCLASS, създаването на прозореца чрез функцията CreateWindow, основната програмен цикъл. Освен това на файла е назначена функцията WndProc. Трябва да променим колко пъти трябва да се промени превключвателят: WM_COMMAND, WM_PAINT, WM_DESTROY. Намерете всичко във файла.

Освен това, което видяхме, програмата има много допълнителен код. При следващото издание ще разгледаме програмния код, de bude ще види всичко. Ще бъде по-просто и разбираемо от това, което IDE генерира.

API (Application Programming Interface) е интерфейс за програмиране на програми, термин, който често се използва от доставчиците на софтуер. Точно като програма, която се разширява, има функция, която ви позволява да добавяте към нови и други добавки, това е API на вашата програма. Параметрите, които приемат вашата функция, одобряват API, а фрагментите, освен това, за всякакви други допълнения, взаимодействат с тази функция.

Операционната система Windows предоставя широк набор от функции, които позволяват на различни програми, включително програми Visual FoxPro, да обменят информация с Windows на ниско ниво. Тези функции се наричат ​​Windows API. Използването на Windows API в програмите на Visual FoxPro ви позволява да внедрявате функции, които са извън обсега на стандартните методи за филми.

Оттеглени функции на Windows API във Visual FoxPro

Функциите на Windows API са свързани в библиотеки, които са динамично свързани (Dynamic Link Library, DLL). Като правило файловете на такива библиотеки могат да се разширяват dll. Преди това, как да спечелите функцията Windows API от вашето допълнение, вие сте виновни голи. За деклариране на функцията се изпълнява командата DECLARE..DLL:

ДЕКЛАРИРАНЕ[ cFunctionType] Име на функция IN Име на библиотека ; [cParamType1 [@] ParamName1, cParamType2 [@] ParamName2, ...]

Параметри на командата:

cFunctionType
Необвързващ параметър, който определя типа данни, които трябва да бъдат превърнати от функцията:

cFunctionType	Розмир, байт	Описание
къс		16-битово цяло число
Цело число, дълго	4	32-битово цяло число
Неженен	4	32-цифрен номер на речта
Двойна	8	64-битов номер на речта
низ	-	Ред от знаци

Име на функция
im'ya функционира в DLL-библиотеката. Тази функция е чувствителна към малките букви, така че GetDC и GETDC са имената на напълно различни функции.

Име на библиотека
името на DLL-библиотеката, при която функцията се променя. За библиотеки Kernel32.dll, Gdi32.dll, User32.dll, Mpr.dll и Advapi32.dll е възможно да изберете синоним на WIN32API.

AliasName
Необвързващ параметър, който ви позволява да промените името на функцията, за да спечелите вашите псевдоними. Изписването на псевдонима в името на функцията не е чувствително към регистъра на знаците. Като общо правило, псевдонимът се презаписва, ако функциите на API се извикват от имената на (или вашите) функции на Visual FoxPro.

cParamType
Посочете типа на данните за функцията, които се предават:

Параметърът може да се предава както за стойности, така и за съобщения. За да се посочи, че параметърът се предава при заявка, се използва символът "@".

Visual FoxPro изглежда не прави разлика между дълги и целочислени типове данни. Извикайте типа Integer за подписване на цели числа със знак и типа Long за беззнакови цели числа.

ParamName
neobov'yazykovy параметър, scho има чисто описателен характер и, като правило, се игнорира.

Всички функции на Windows API, като, vtim и Windows, написани от моята C програма. Следователно, за да разберем как правилно да хакнем API функциите във Visual FoxPro (което, най-малкото, така че пише на C, вземе това ядро), ние знаем как да въвеждаме данни в C и Windows и, не по-малко важно, Нека да разгледаме такива видове почит, като pererahuvannya, структури и шоумени. Освен това знаете, че такива прототипи на функциите са в C и така, разчитайки на описанието на прототипа на функцията в MSDN, правилно го декларирайте в командата DECLARE..DLL.

Основни типове данни Сi

Ако познавате моето програмиране на C, тогава знаете колко лесно е да създавате различни типове данни в новия. Достатъчно е да напишете следния код:

Typedef int INT32;

и оста, която имате, е нов тип INT32, който е по-подобен на типа int. Ale, ще погледна Cі, tse zovsim различни видове, и се опитайте да присвоите на типа промяна INT32 стойността на типа промяна int на ада!

Изобилието от типове данни затруднява търговците на дребно да мислят, че програмирането с помощта на API е важно. Но не е така! В C е важно да спечелите следните типове данни:

Тип char - Символ за ANSI формат. Може да продължи 8 разреждания (един байт).

Тип wchar - Unicode символ. Може да има 16 разряда (два байта).

Тип международен - броят на числата. Вонята е разделена в C на три вида: международен, кратко вті дълго междун. Спрете да звъните малко преди това късі дълго. Тип къс- tse 16-bit, но tipi международені дълго- 32-цифрени числа.

Тип плува- Номера на речта, за да направите изстрелна частица. Mayut dozhina 32 разряда (4 байта).

Тип двойно- Речови номера с подвариантна точност. Mayut dozhina 64 разреждания (8 байта).

Тип enum - вида на данъка, който се изплаща.

Тип нищожен vikoristovuєtsya за опознаване на стойности, scho за намиране на нулева точка, която не разбира стойността.

Тип показалец - шоумен; vіn отмъщава за информация от прословутия sensi - подобно на други видове Cі; natomist, индикаторът на кожата има адреси в средата на паметта, където се вземат реални данни. Май дожина 32 разрежда (4 байта).

Не е изненадващо, типът на реда е Cі vіdsutnіy. Всъщност всички редове са представени с един и същ масив от символи.

Deyakі tipi може да бъде безгласен като неподписан. Модификатор неподписан (без знак) vykoristovuetsya с обидни видове почит: char, къс, международені дълго.

Например, началото на изразяване на промяната в Сi:

Подписан вт im'ya_zminnoy;

означава, че е променено - 32-битово цяло число без знак.

Модификатор const показват, че стойността, присвоена на типа, се променя от константа, така че стойността може да бъде променена.

Тип за възстановяване enum po'yazuє zі zmіnnoyu nabrіr іmenovannykh константи, zvіnіh листинг константи. Тип Goloshennya, scho perekahovuetsya, изглежда така:

Enum tag_field { const1, const2, ... } промяна;

Yakscho tag_fieldпонижава, тогава след затваряне на къдравия лък е необходимо да се посочи промяна. Yakscho tag_fieldпосочено, след което не е посочено промяна.

Исторически, типът enum е равен на типа int - той е заменен от тип, който заема 4 байта в паметта. Константата на кожата, която се възкресява, може да бъде стойността, която се присвоява от поредния номер в списъка; номерирането започва от нула. Нека да разгледаме CombineMode:

Enum CombineMode( CombineModeReplace, CombineModeIntersect, CombineModeUnion, CombineModeXor, CombineModeExclude, CombineModeComplement );

За този преход константата CombineModeReplace може да има стойност 0, константата CombineModeIntersect може да има стойност 1 и т.н.; Константата CombineModeComplement може да има стойност 5.

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

Enum DashCap(DashCapFlat=0, DashCapRound=2, DashCapTriangle=3);

Изброените типове данни покриват 99% от всички типове данни, както при програмирането на Windows API. Не звучи толкова просто, нали? Защо описанията на функциите на API трябва да се използват от други типове - HWND, HINSTANCE, POINT и подобни на тях?

Причината за това са тези стриктно писане. Веднъж промяната на един тип може да приеме само тези стойности, сякаш съвпадат с този тип. Не можете да запазите кочана си в ред и след това да дадете номера. Във Visual FoxPro звучим така, сякаш се опитваме да симулираме подобен начин, за да угодим относно именуването. Например, cName е алтернативен тип символ, докато nCount е числов тип. Строго писаневи позволява да създадете нов тип данни, като дадете ново име на съществуващия тип данни. Нов вид кожа изглежда е същият тип други видове, независимо от тези, които вътрешно миришат, освен самите тях.

Windows усложнява концепцията. Например, типът LONG всъщност е дълго int, а типът UINT е int без знак. Типовете Obidva са 32-битови цели числа. Други типове данни се присвояват на различни включващи файлове (файлове с разширения.h). Ако сте използвали Visual Studio.NET, можете да намерите файловете в папката ..\VC7\PlatformSDK\Include\.

Tipi Data Windows

В интерес на истината, кой от базовите типове C ефективно представлява типа данни, които са включени във функцията на API, това е една от най-важните задачи в API за програмиране. Съобразете това правило: не можете да знаете думата float, double, charили улбъде в име на функция или параметър или използвайте 32-битова стойност. Преразглеждането на този навик ще отнеме един лош час и след това лесно ще преработите видове данни. Следващата таблица съдържа основните типове данни на Windows и другите типове, които се избират, когато функцията Visual FoxPro е деактивирана:

тип данни Windows	Въведете без глас функции	Описание
BOOL	Дълго	32-битово цяло число. 0 означава невярно, reshta означава вярно.
БУЛЕВО	Дълго	същите, които аз BOOL.
БАЙТ	низ	8-цифрено число
CHAR	низ	8-цифрено число
CLSID	низ
COLORREF	Дълго	32-битово цяло число
DWORD	Дълго	32-битово цяло число
ДВОЙНО	Двойна	64-битов номер на речта
ПЛАВАНЕ	Неженен	32-цифрен номер на речта
GUID	низ	128-битово число (16 байта)
ДРЪЖКА	Дълго
HBITMAP	Дълго	32-битово цяло число без знак
HDC	Дълго	32-битово цяло число без знак
HICON	Дълго	32-битово цяло число без знак
HGLOBAL	Дълго	32-битово цяло число без знак
HKL	Дълго	32-битово цяло число без знак
HLOCAL	Дълго	32-битово цяло число без знак
НАМЕК	Дълго	32-битово цяло число без знак
HRESULT	Дълго	32-битово цяло число без знак
HWND	Дълго	32-битово цяло число без знак
ДЪЛГО	Дълго	32-битово цяло число
LPARAM	Дълго	32-битово цяло число без знак
КЪС	цяло число	16-битово цяло число
SIZE_T	Дълго	32-битово цяло число без знак
TCHAR	низ	Съвпада с CHAR за низове ANSI и WCHAR за низове в Unicode
UCHAR	низ	Символ в ANSI кодиране
UINT	Дълго	32-битово цяло число без знак
ULONG	Дълго	32-битово цяло число без знак
USHORT	цяло число
UUID	низ	128-битово число (16 байта)
НИЩАВА	не	Няма значение
WCHAR	низ	UNICODE символ
WNDPROC	Дълго	32-битово цяло число без знак
ДУМА	цяло число	16-битово цяло число без знак
WPARAM	Дълго	32-битово цяло число без знак

Vkazivniki

Друга концепция, която се използва широко в C, са указателите. Индикаторът се променя, как да се отмъсти за адреса на областта на паметта, за която се събират данни. Видът на индикатора винаги се определя от типа на данните, където сте посочили; yogo rozmir zavzhdi dorivnyu chotiry bytes. Например индикатор за промяна на типа SHORT е цяло число от 32 бита, като индикатор за всеки друг тип данни. Описанието на индикатора, прието в програмирането на Windows API, започва със знаците "LP", което означава дълъг показалец или "дълъг указател", който работи с 32-битовия модел памет. Нека използваме символа "C" (const), за да посочим, че данните не са виновни. Дадоха описание на вида на променяните данни, чиито адреси се приемат за индикатор. Например LPDWORD - индикатор за промяна на типа DWORD.

Спецификаторите на числови данни, когато функциите на Windows API са озвучени, се прехвърлят при поискване. Като пример, нека разгледаме функцията GetFileSize. Axis її прототип (повече за прототипите на функциите ще бъдат обсъдени по-долу):

DWORD GetFileSize(HANDLE hFile, // манипулатор на файла LPDWORD lpFileSizeHigh // индикатор);

Друг параметър, предаван на функцията, е параметър за промяна на типа DWORD, за която функция да постави стойността на размера на файла в байтове.

Обявени функции за Visual FoxPro:

ДЕКЛАРИРАНЕ GetFileSize В WIN32API Long hFile, Long @ FileSizeHight

Всъщност параметърът FileSizeHight се предава на функцията за помощкъм това, прехвърлянето е в полза - це и є прехвърляне на индикатора.

Складнише вдясно с редове. Както се случваше преди, редовете със символи в масива Cі - tse, при програмирането на API функции, типът е фиксиран ул, начален масив от знаци от тип CHAR (по избор, тип wstrприсвоява масив от знаци на типа WCHAR. Следващата таблица показва типа индикатори на редовете със знаци:

Тип вмъкване подред	Описание
LPSTR	Нулевият терминатор е в съответствие с ANSI формата, който може да бъде модифициран. Предава се по заявка
LPCSTR	Нулевият терминатор е в съответствие с ANSI формата, който не може да бъде променен. Предадено за стойност
LPTSTR	Съвпада с LPSTR за низове ANSI и LPWSTR за низове на UNICODE. Предаден за помощ.
LPCTSTR	Съвпада с LPSTR за низове ANSI и LPWSTR за низове на UNICODE. Мина за смисъл.
LPWSTR	Vkazіvnik за завършване с нула на реда UNICODE, който може да бъде променен. Предава се по заявка
LPCWSTR	Ръководство за завършване с нула на низ UNICODE, който не може да бъде променен. Предадено за стойност

Спецификатори на символни данни могат да се предават както като заявка, така и като стойност - тип String в безгласна функция на Visual FoxPro zavzhd проход kazіvnikпроменете какво да отмъстите за символични данни. Победно предаване на символни данни по искане на само ако функцията на API е виновна за промяна на стойността на параметъра.

структури

Структурата е възможна като набор от различни видове, които могат да се използват в едно цяло. В C структурата се създава зад помощта на ключовата дума структура, след което следва neobov'yazkove поле за етикет(tag) този списък елементиструктури:

Структура tag_field { тип_елемент елемент1; тип_елемент елемент2; ..... тип_елемент елементN; };

Възможно и такава озвучена структура:

структура( тип_елемент елемент1; тип_елемент елемент2; ..... тип_елемент елементN; } промяна;

Който има зашеметен ден поле за етикетсъздава се по такъв начин като анонимен структурен тип; такъв синтаксис ви позволява да добавите една или повече промени към този структурен тип, като например в обидно дупе:

Структура (WORD wГодина; ДУМА с месец; ДУМА wDayOfWeek; ДУМА wДен; ДУМА wHour; ДУМА wМинута; ДУМА wSecond; ДУМА w милисекунди; ) SYSTEMTIME, * PSYSTEMTIME;

Структурите са подобни на записите в таблицата на Visual FoxPro. И така, като запис в таблицата личниотмъсти за нивите фио,адрес,tlf номер и имейл, след това за връщане към полето tlfnumber се използва следният синтаксис:

Personal.tlfnumber

Така че погледнете и вижте полето за структура:

SYSTEMTIME.wМинута

За формирането на структурите на Visual FoxPro се правят промени за замяна на редове от знаци. Например, за структурата SYSTEMTIME, която разгледахте по-горе, трябва да промените максимум 16 байта. Първият има два байта промяна за въвеждане на стойността на полето wГодина, атаката има два байта - стойност на полето с месец, атаката има два байта - стойност на полето wDayOfWeek, и така нататък, докато структурата е напълно оформена. И когато API функцията на Visual FoxPro е изложена, типът на параметъра, към който се предава промяната за замяна на структурата, се дължи на типа String. Как да записвате в ред, променяйки числови данни, знаете малко на година.

При програмиране на Windows API в C, описанието на индикатора за структурата се основава на символите LP (Long Pointer), последвани от името на структурата. И така, индикаторът за структурата SYSTEMTIME е тип LPSYSTEMTIME, индикаторът за структурата POINT е тип LPPOINT, точно така. Като bachite, нищо сгъваемо, но zavdyaki tsіy концепция іsnuє превъзходно голям брой видове индикатори върху структурата.

Ако данните в структурата, която се предава, не са виновни за промяна, тогава индикаторът за такава структура се изразява така:

CONST im'ya_stucture *

Тук модификаторът CONST означава, че данните в структурата не се променят, а символът (*) след името на структурата означава, че целият ред е описание на индикатора за структурата. За това приложение на доказателства, прототипът на функцията CopyRect, като копие на една структура в друга:

BOOL CopyRect(LPRECT lprcDst, CONST RECT * lprcSrc);

Описание на функционални прототипи в MSDN

Сега, ако всичко е станало повече или по-малко ясно с типовете данни, ще разберем по-добре такива понятия C, като прототипи на функции.

Видповідно до стандарта ANSI, всички функции се дължат на прототипи на майката. Прототипът на функцията е прост:

тип_завойиме на функция( тип_параметър(iv) име_на_параметър(іv));

Когато типът на прототипа е посочен като VOID тип_завой, което означава, че функцията не върти едни и същи стойности. Как се присвоява типът VOID? тип_параметър, Ze означава, че функцията не може да бъде параметризирана.

Можете да намерите информация за прототипите на функциите на Windows API, които са включени преди библиотеките Kernel32.dll, Gdi32.dll, User32.dll, Mpr.dll и Advapi32.dll, от MSDN за Visual Studio.NET. :

Библиотека MSDN

Windows Development Win32 API SDK Справочник за документация

В секцията Справка можете да прегледате описанията на функциите, показвайки едно от предстоящите разширения:

Оста е един адрес в MSDN, за който също има информация за функцията API:

Библиотека MSDN

Документация на SDK за проектиране и разработка на потребителски интерфейс Windows Shell

На стъпалото бебе се показва фрагмент от прозореца на системата за разработка на MSDN:

Оста е описана например в MSDN чрез функцията CopyRect:

CopyRect

В CopyRectкопиране на координати на функцията на един правоъгълник в друг.

BOOL CopyRect(
LPRECT lprcDst, // правоъгълник на дестинацията
CONST RECT* lprcSrc// правоъгълник на източника
);

Параметри

lprcDst
Показалец към RECTСтруктурата на това, което се приема, е логически координати на изходния правоъгълник.
lprcSrc
Указател към RECT структури, като координати за копиране в логически пакети.

Върнати стойности

Като функция на виконата, ротацията на стойността е различна от нула.
Както функцията се проваля, връщаната стойност е нула.
Windows NT/2000/XP:За да извлечете допълнителна информация за грешка, извикайте GetLastError.

Забележки

Частите на персонализирането могат да маркират правоъгълници за различни цели, функциите за правоъгълник не маркират изрична мерна единица. Вместо това всички правоъгълни координати и размери са дадени в логически стойности със знак. Режим на картографиране и функция в някои правоъгълни стойности, мерни единици.

Примерен код

За пример вж Използване на правоъгълници.

Изисквания

Windows NT/2000/XP: Включено в Windows NT 3.1 и по-нови версии.
Windows 95/98/Me: Включено в Windows 95 и по-нови.
Заглавие: Обявено в Winuser.h; включва Windows.h.
Библиотека: Използвайте User32.lib.

Як бачите, информацията трябва да бъде завършена до края. Функцията преобразува стойностите в тип BOOL, на който се предават два параметъра: към тип LPRECT и CONST RECT* - индикатори на структура от тип RECT. Когато е посочена функцията Visual FoxPro, ваша отговорност е да посочите, че първият параметър се предава като заявка, а другият като стойност:

ДЕКЛАРИРАНЕ на Long CopyRect В User32.dll низ @ Dst, String src

Как да определя коя функция е в библиотеката User32.dll? Някак просто. Имайте разпространение на препоръки ( Изисквания) параграф Библиотека кажете: Използвайте User32.lib. Изпратете удължаване на заместник libразширяване dll- и всичко! Преди речта, там, в точката Header, се предлага в кой включващ файл се намира описанието на прототипа на функцията.

И все пак не всички! Ако функцията работи със структури, тогава описанието е свързано с хипервръзка към структурата RECT. Щракнете с мишката за тези съобщения и на екрана ще се появи описанието на структурата на отчета.

Формиране на структури във Visual FoxPro

9-та версия на Visual FoxPro вече разшири възможността за използване на функциите BINTOC и CTOBIN. Сега функциите могат да бъдат настроени да преобразуват числови данни във формат, който е подходящ за персонализиране в структури. Предполагам, че функцията BINTOC преобразува числата в ред, а функцията CTOBIN преобразува редовете в число.

Синтаксис на функцията BINTOC:

BINTOC( nExpression, eFlag)

Три използваеми стойности, така че можете да приемете параметъра eFlag, ние тракаме напред:

Синтаксис на функцията CTOBIN:

CTOBIN (ок изразяване, eFlag)

Възможни стойности на параметрите eFlag:

По-долу е обобщение на тези функции:

CTOBIN(BINTOC(1000.55,"4RS"), "4RS") && Резултат: 1000 ? CTOBIN(BINTOC(-1000.55,"4RS"), "4RS") && Резултат: -1000 ? CTOBIN(BINTOC(1000.55,"F"), "4N") && Резултат: 1000.549987929 ? CTOBIN(BINTOC(-1000.55,"F"), "4N") && Резултат: -1000.549987929 ? CTOBIN(BINTOC(1000.55,"B"), "8N") && Резултат: 1000.55 ? CTOBIN(BINTOC(-1000.55,"B"), "8N") && Резултат: -1000.55

Като пример, нека запишем структурата RECT в промяната на Visual FoxPro. Тази структура е обърната от прегледаната по-рано функция CopyRect за описание на координатите на правоъгълна област. Оста като структура е описана в MSDN:

Typedef struct _RECT ( ДЪЛГО вляво; ДЪЛГО отгоре; ДЪЛГО вдясно; ДЪЛГО отдолу; ) RECT, *PRECT;

Подобно на Bachite, структурата RECT покрива полетата, а стойността на типа LONG се взема от етикета на кожата. За да формира Visual FoxPro, имате нужда от ред до 16 байта.

По-долу е кодът, в който функцията CopyRect е озвучена, структурите Dst и Src се формират, за да ги прехвърлят като параметри към функцията и след това да копират една структура в друга. Приложението има функция BINTOC за преобразуване на числа в ред:

ДЕКЛАРИРАНЕ на Long CopyRect В WIN32API String @ Dst, String Src * Структура на формата Src cSrc = BINTOC(nLeft,"4RS") + BINTOC(nTop,"4RS") +; BINTOC(nВдясно,"4RS") + BINTOC(nBottom,"4RS") * Подгответе пространство за Dst структура cDst = REPLICATE(CHR(0),16) nResult = CopyRect(@cDst, cSrc) &&

Заведеното дупе показва как, използвайки функцията CTOBIN, можете да "разбирате" структурата, изваждайки числовите стойности на нейните полета:

NЛяво = CTOBIN(SUBSTR(cDst,1,4), "4RS") && RECT.ляво nTtop = CTOBIN(SUBSTR(cDst,5,4), "4RS") && RECT.горе nДясно = CTOBIN(SUBSTR(cDst, 9,4), "4RS") && RECT.вдясно nBottom = CTOBIN(SUBSTR(cDst,13,4), "4RS") && RECT.отдолу

Структури, които отмъщават на работниците

Ситуацията често се влошава, когато функцията на Windows API се предаде на функционалната структура за отмъщение. Като пример, нека разгледаме функцията StartDoc, която създава един за друг документ на принтера. Axis її прототип:

Int StartDoc(HDC hdc, // манипулиране на DC CONST DOCINFO* lpdi// съдържа имена на файлове);

Въпреки това, другият параметър, който се предава, е указател към структура DOCINFO. Структура на ос:

Typedef структура ( int cbSize; LPCTSTR lpszDocName; LPCTSTR lpszOutput; LPCTSTR lpszDatatype; DWORD fwType; ) DOCINFO, * LPDOCINFO;

Първо структурно поле, cbSizeИзвличане на стойността на текущата структура в байтове. И три полета атакуваха оста - тези индикатори за промяната, за да отмъстят за символичните данни. Зокрема, поле lpszDocNameотмъсти индикаторв ред с имената на документа, които са приятели (същото име на документа, както виждате, гледайки реда с документи, че са приятели).

Visual FoxPro има спретнато структурирана структура, за да отмъсти на шоумените. Първо, трябва да видите блока на паметта и да вземете индикатора за новия. По различен начин е необходимо да се пренапише стойността на промяната на Visual FoxPro в паметта - по този начин ще имаме повече реализации на механизма за показване. Remain, scho zarobiti - поставете стойността на индикатора в структурата. С кого е необходимо да висконираме сто пъти, можем: споменът се вижда, че не е виновен, че е преместен - в противен случай може да се покаже, че нашият индикатор ще посочи региона за момент, докато нашата почит не е за губене годишно!

Използвайте блока памет. Можете да вземете "малко нещо" както от дълбоката памет на Windows, така и от паметта на видяния процес (за вашето допълнение). Друг начин може да бъде по-високоскоростен код, тук можем да видим начина за работа с Windows памет като най-прост.

Функцията GlobalAlloc премахва блока памет с посочения размер от Windows и обръща индикатора към новия. Функция за прототип на ос:

HGLOBAL GlobalAlloc(UINT uFlags, // атрибути на разпределението на паметта SIZE_T dwBytes// Разгъване в байтове);

Параметър uFlags vyznaє, как да си спомня. MSDN казва, че можете да вземете една от следните стойности:

От таблицата по-долу, какъв е параметърът uFlags GPTR следа от усукване. Але, как да знам, якКакво означава? Вижте MSDN за описание на функцията GlobalAlloc и за разпространение Изискваниячудя се дали включен файл има свой прототип. Това е файлът Winbase.h. Същото в следващата стъпка описва значението на константите. Оста е фрагмент от файла, в който са присвоени константите на таблицата:

/ * Global памет Знамена * / #define GMEM_FIXED 0x0000 #define GMEM_MOVEABLE 0x0002 #define GMEM_NOCOMPACT 0x0010 #define GMEM_NODISCARD 0x0020 #define GMEM_ZEROINIT 0x0040 #define GMEM_MODIFY 0x0080 #define GMEM_DISCARDABLE 0x0100 #define GMEM_NOT_BANKED 0x1000 #define GMEM_SHARE 0x2000 #define GMEM_DDESHARE 0x2000 #define GMEM_NOTIFY 0x4000 #define GMEM_LOWER GMEM_NOT_BANKED #define GMEM_VALID_FLAGS 0x7F72 #define GMEM_INVALID_HANDLE 0x8000 #define GHND (GMEM_MOVEABLE | GMEM_ZEROINIT | GMEM_ZEROINIT |

Също така, GPTR = GMEM_FIXED + GMEM_ZEROINIT = 0x0000 + 0x0040 = 0x0040.

Какъв вид розмир е виновен за блока на паметта на майката на виденията? Очевидно е равен ред от редове, в който е взето името на документа. При стъпаловиден приклад той показва следното, като се започне с озвучените функции на API и завършва с блока на паметта:

uFlags, дълго dwBytes cDocumentName = "Име на документа, което ще се използва" && Име на документ nLenDocumentName = LEN(cDocumentName) && Дължина на ред hGlobal = GlobalAlloc(GPTR, nLenDocumentName)

Следващата задача е да се пренапише промененото cDocumentName в следващия блок памет. За кой от тях се ускорява, използвайте функцията Visual FoxPro SYS(2600). Синтаксис на ос:

SYS(2600, dwAddress, дължина [, cNewString])

Функцията се изпълнява различно в угара, в зависимост от параметъра на индикация cNewStringчи ни.

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

Как да параметрирам cNewString неопределено, след това функцията се завърта дължинабайтове в паметта за адреса, посочен в dwAddress.

Як бахете, параметър dwAddress- ce индикатор.

Нека напишем на мястото на реда cDocumentName в паметта на видяната функция GlobalAlloc:

SYS(2600, hGlobal, nLenDocumentName, cDocumentName)

Оста е крайният код за формиране на структурата DOCINFO:

#DEFINE GPTR 0x0040 ДЕКЛАРИРАНЕ на Long GlobalAlloc В WIN32API Long uFlags, дълго dwBytes cDocumentName = "Име на документа, което ще се използва" nLenDocumentName = LEN(cDocumentName) hGlobal = GlobalAlloc(GPTR, nLenDocumentName) SYS(2600, dwAddress, дължина [, cNewString]) * Започва да формира структурата DOCINFO * cDocInfo - променена, в която се формира структурата cDocInfo = BINTOC(20,"4RS") && DOCINFO. cbSize cDocInfo = cDocInfo + BINTOC(hGlobal,"4RS") && DOCINFO. lpszDocName cDocInfo = cDocInfo + REPLICATE(CHR(0),12) && Други полета на структурата * Край на формирането на структурата

Структурата се формира при промяната cDocInfo. Числото 20 е записано в първия байт chotiri - cerezmir на структурата (поле cbSize). Следващите няколко бита, които се добавят към промяната, са индикатор за областта на паметта, по същия начин промяната се пренаписва cDocumentName - името на документа. След това към замяната се добавят още дванадесет нула байта - всички полета на структурата lpszOutput, lpszDatatypeі fwType, yakі, zgidno s документация, може да се игнорира; tse означава, че полетата се дължат на нулеви стойности. В този ред, един ред dozhinoy 20 baytiv - какво означаваше.

Характеристики на победната памет

Ако вашите програми имат функции на Windows API, заседнали в тях, вие сте отговорни да запомните, че Visual FoxPro не може да си спомни какво резервират тези функции. За това, ако промените паметта, например, за допълнителната функция GlobalAlloc, тогава сте длъжни да включите паметта на Windows, като извикате функцията GlobalFree. За скин функцията на API, която резервира памет, функцията е обратната, която прави резервирана памет.

Функция за прототип на ос GlobalFree:

HGLOBAL GlobalFree(HGLOBAL hMem // индикатор за блок памет);

Функцията приема само един параметър - индикатора за блока памет. Axis її озвучена от Visual FoxPro:

ДЕКЛАРИРАЙТЕ Long GlobalFree В WIN32API Long hGlobal GlobalFree(hGlobal)

Тук hGlobal е индикатор за блок памет, завъртян от функцията GlobalAlloc.

Ако забравите да обърнете паметта си, тогава рискувате да се забиете с проблем, наречен намотка на паметта. Последиците от такъв обрат могат да бъдат още по-сумативни - в случай на рязко увеличаване на работата на вашата програма, причинено от фрагментация на паметта, до срив на операционната система.

Предаване на масиви към функция

Масивът от един поглед Cі - tse zmіnna, scho да отмъсти за цаца от елементи от същия тип. Достъпът до масива от елементи, затворен в кожата, е запазен за допълнителен индекс. Елементите на масива могат да имат една и съща rozmіr, невъзможно е да се опише масивът с различни типове данни. Всички елементи на масива се съхраняват в паметта последователно, един по един, като минималната стойност на индекса се дава на първия елемент, а максималната - на оставащия.

Масивът Visual FoxPro може да бъде организиран по различен начин, тъй като ви позволява да записвате в различни елементи от различни типове данни. Следователно е невъзможно да се предаде масив от Visual FoxPro към функция на Windows API, като просто се предаде името му като параметър. Освен това командата DECLARE..DLL няма този тип данни, като масив.

Излезте от лагера. Подобно на структурите, прехвърлянето на масиви, символичните промени са победоносни. Числовите данни от масив от съответните се преобразуват в ред, който предавате като параметър на функцията на Windows API. По някаква причина кодът на функцията ArrayToString, която образува ред в масив. функция taArray(за помощ) този прапорщик tlTypeOfValue; tlTypeOfValue=.F.) или реч ( tlTypeOfValue=.T.) числа:

Функция arreytoString параметри тарпре, tltypeofvalue външен масив тарис локален lnlenarray, lnindex, lcstruct, lctype lctype = iif (tltypeofvalue = .t., "F", "4Rs") lnlenarray = al & for lnindex = 1 до lnlenarray lcstruct = lcstruct + bintoc ( taArray, lcType) ENDFOR RETURN lcStruct ENDFUNC

Функцията работи както с едномерни, така и с двумерни масиви.

Кодиране на символни данни: формати ANSI и UNICODE

При ANSI кодиране (кодирано с Visual FoxPro) символът на кожата се дефинира като един байт, така че максималният брой знаци е 256, което очевидно е твърде малко. Например по време на русификацията част от стандартните ANSI знаци се заменят с кирилица. И в някои азбуки, например японски кана, има стилове на символи, един байт за това кодиране просто не е достатъчен. За да се поддържа такъв mov и, което е по-важно, за да се улесни "превеждането" на програми с други mov, кодирането на Unicode беше разделено. Един символ на кожата на Unicode се състои от два байта, което направи възможно разширяването на набора от валидни знаци до 65536.

За да добавите много функции на Windows API за конвертиране за един час работа със символни низове във формат Unicode. За да работите с такива функции, е необходимо да конвертирате символни данни от един формат в друг.

Функцията Visual FoxPro STRCONV е въведена за преобразуване на редове от ANSI формат в UNICODE и обратно. Синтаксис на ос:

STRCONV( cИзразяване, nConversionSetting [, nRegionalIdentifier [, nRegionalIDType]])

Параметър cИзразяване- последователност, която трябва да бъде преобразувана. Параметър nConversionSettingпоказва естеството на преобразуването. С помощта на йога има само две възможни значения за нас:

• 5 - конвертиране от ANSI в UNICODE
• 6 - конвертиране от UNICODE в ANSI

Необходими езикови параметри nRegionalIdentifierі nRegionalIDTypeозначават допълнителни регионални корекции и могат да бъдат безболезнено игнорирани.

По-долу е даден пример за различна функция STRCONV:

CUnicodeString = STRCONV(cANSIString, 5) && Преобразуване в Unicode cANSIString = STRCONV(cUnicodeString, 6) && Преобразуване в ANSI

Вероятно, когато четете този раздел, сте създали впечатление, че е лесен достъп до API на Windows с помощта на функциите на Visual FoxPro. І така і ні. Например, някои функции на API включват типове данни, които не се поддържат в командата DECLARE..DLL, например 64-битови цели числа. Съществуват и редица функции, които се наричат ​​функции на вратаря. Прототипът на такава функция има модификатор CALLBACK, присъстващ преди описанието на типа, който трябва да се завърти. Жалко, че не можете да спечелите такива функции без посредник. Вярно е също, че структурата може да се използва за проверка за функция - такива API във Visual FoxPro не могат да бъдат победени от само себе си.

Опровержение

Би било по-добре WinAPI да излезе в миналото. От дълго време има голям брой междуплатформени рамки, Windows не е само на настолни компютри, но самият Microsoft няма добавки в своя магазин, като победоносно чудовище. Има много статии за това как да създавате видеоклипове на WinAPI, не само тук, но и в целия интернет, те се броят в хиляди за еднакво количество деца в предучилищна възраст и др. Целият процес на подреждане вече не е за атоми, а за субатомни частици. Какво може да бъде по-просто и по-мъдро? И ето ме...

Але, не всичко е толкова просто, колкото изглежда.

Защо сега за WinAPI?

Веднъж, играейки останките на нечий игор в неприличен човек, си помислих: Това е такава емулсия, но в nalagodzhuvach няма толкова проста реч, като навигиране през бутоните на клавиатурата, като при нормален собственик.

за какво говоря? И кодът на оста shmatochku:

Случай WM_KEYDOWN: MessageBox(hwndDlg,"Умри!","Мъртъв съм!",MB_YESNO|MB_ICONINFORMATION);
По този начин авторите искаха да добавят докосване на клавиатурата и освен това реалността на архитектурата на диалоговите прозорци в Windows zhorstko закрепи такава самоналагане. Ти, кой беше емулаторът и собственикът на новия, поне след като получиш информацията?
Какъв е проблема?

Доказателството е следното: не можете да работите така!

И като се обърнем към основното хранене на WinAPI: дори много популярни и не много, проекти продължават да печелят и в този час, т.к. Накратко, не можете да произнасяте много речи на чистия API (тук неизменно можете да правите аналогии с kshtalt на езици от високо ниво и асемблер, но не наведнъж). Но защо не? Само намигни и това е.

Относно проблема

Диалоговите прозорци улесняват работата на робота с графичния интерфейс, като в същото време ни позволяват да работим независимо. Например, напомняне на WM_KEYDOWN / WM_KEYUP, което е необходимо за процедурата на прозореца, „започвайки“ от наслагванията на DefDlgProc, вземайки имената на такива думи, като: Навигация в раздел, Esc, Enter и т.н. Освен това диалозите не е необходимо да се създават ръчно: просто, дори хвърляйте бутони, списъци, в редактора на ресурси, щракнете върху WinMain CreateDialog/DialogBox и сте готови.

Заобикалянето на такива тривиални проблеми е лесно. И поне два напълно законни начина:

1. Създайте свой собствен клас чрез RegisterClassEx и запазете WM_KEYDOWN в процедурата за обработка на класа, пренасочете процедурата за обработка към самия диалог. Добре добре! Можете да създавате диалози със свой собствен клас и когато VS редакторът ви позволява да зададете свой собствен клас за диалога. Axis знае само за това и tsim koristuetsya?
   Минусът е очевиден: Трябва да регистрирате един клас, майката за 1 процедура ОБРАЩАНЕ е по-голяма, чиято същност ще бъде по-малко в излъчването на Париж. Освен това не знаем kudiим транслюват, случайно съм ограден от полиция.
2. Vikoristovuvat vbudovaniya mekhanіzm acceleratorіv. И няма да можем да променим кода на диалоговата процедура! Е, хей, добавете един ред към превключвателя/калъфа, но за цената по-долу.

уроци?

Не се страхувам да кажа това мустакУроците за създаване на прозорци чрез WinAPI започват от такъв прост код, което означава, че като „цикъл на обработка на ремонт“ (ще пропусна подробностите за подготовката на класа на прозореца и други обвързвания):

Докато (GetMessage(&msg, nullptr, 0, 0)) ( TranslateMessage(&msg); DispatchMessage(&msg); )
Тук всичко е наистина просто:

1. GetMessage() ключов момент: блокиране на потика, като празна торба.
2. TranslateMessage() с WM_KEYDOWN/WM_KEYUP формира предупреждението WM_CHAR/WM_SYSCHAR (ще ви трябва, ако искате да получите свой собствен текстов редактор).
3. DispatchMessage() управлява известията за процедурата на прозореца (както е).

Нека да разгледаме факта, че не е безопасно да се хакне този код и ето защо. Отдайте уважение на виното:

Тъй като връщаната стойност може да бъде различна от нула, нула или -1, избягвайте код като този:
докато (GetMessage(lpMsg, hWnd, 0, 0)) ...

І свалете дупето на правилния цикъл.

Warto казва, че VS шаблоните за Win32 имат допълнителни изписвания като този погрешноцикъл. Твърде неясно е. Адже, малко хора разбират тези, които самите автори са създали, дори и да е априори правилно. И грешен код се умножава наведнъж от грешки, което е още по-лесно за разбиране.

Следващият фрагмент от кода, като правило, следва описанието на ускорителите и се добавят няколко нови реда (с оглед на уважението в MSDN, което ви насърчава да напишете правилния цикъл):

HACCEL hAccel = Ускорители на натоварване (hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR)); BOOL bRet = 0; while (bRet = GetMessage(&msg, nullptr, 0, 0)) ( if (-1 == bRet) прекъсване; if (!TranslateAccelerator(msg.hwnd, hAccel, &msg)) ( TranslateMessage(&msg); DispatchMes ; ) )
Аз съм най-успешният вариант. аз вин ( та-дам) Знам погрешно!

Малка бележка за тези, които са се променили (нека поговорим за проблемите на този код):

На първия ред ресурси се добавя таблица с ключове, при натискане на яка се повдига WM_COMMAND с идентификатора на командата.

Е, TranslateAccelerator е зает: ако искате да проверите WM_KEYDOWN за този ключов код, ако е в този списък, тогава (ще повторя ключовия момент) ще формирате аргументите за актуализиране на WM_COMMAND (MAKEWPARAM (id, 1)), процедури за обработка.

От останалата част от фразата, предполагам, стана ясно защо проблема е с предния код.
Позволете ми да обясня: GetMessage ще се повтаря за ВСИЧКИ обекти от типа „прозорец“ (до който включват и дъщерни: бутони, списъци и т.н.), а TranslateAccelerator ще коригира генерирания WM_COMMAND къде? Точно така: бутонът / списъкът за връщане е твърде тънък. Ale, ние обработваме WM_COMMAND в нашата собствена процедура, което означава, че трябва да го вземем предвид.

Ясно е, че TranslateAccelerator се нуждае от извикване за създадения от нас прозорец:

HWND hMainWnd = Създаване на прозорец(...); HACCEL hAccel = Ускорители на натоварване (hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR)); BOOL bRet = 0; while (bRet = GetMessage(&msg, nullptr, 0, 0)) ( if (-1 == bRet) прекъсване; if (!TranslateAccelerator(hMainWnd, hAccel, &msg)) ( TranslateMessage(&msg); DispatchMess;) )
И сега всичко е добре и чудо: ние анализирахме всичко в детайли и всичко може да бъде перфектно.

знам не. :-) Tse bude pratsyuvati правилно, стига да имаме точно едно vikno - нашето. Веднага след като се появи немодален нов прозорец (диалог), всички клавиши, както ще бъдат натиснати в новия прозорец, ще бъдат преведени в WM_COMMAND и коригирани къде? Знам, че все още е правилно: нашият смут се забавлява много.

На този етап не пропагандирам милицията в края на задънена ситуация, а пропагандирам речи, сякаш е по-рано (иначе те не се включват) в уроците.

IsDialogMessage

Зад името на тази функция можете да помислите какво означава за мен: да дам обяснение на диалога. Але, първо, какво знаеш? И по различен начин какво направихте с тази информация?

Наистина, това е повече, за да ви отнеме трофея, намалете името. И за себе си:

• Създайте навигация за детски контроли, като използвате Tab/Shift+Tab/нагоре/надолу/надясно/ляво. Освен това имаме достатъчно
• След натискане на ESC формуляра WM_COMMAND(IDCANCEL)
• След като щракнете върху формуляра Enter WM_COMMAND(IDOK) или щракнете върху бутона за поток след заключването
• Превключване на бутони след заключване
• Е, има и други неща, които улесняват един користувачев робот с диалог

какво ни даваш? Първо, не е нужно да мислим за навигация в средата на деня. Ние и така мустаци zroblyat. По-точно, навигацията в разделите може да се ускори чрез добавяне на стил WS_EX_CONTROLPARENT към нашия главен прозорец, но е чист и не толкова функционален.

По различен начин това ще ни улесни по всички останали точки, изброени в списъка (и ще добави още три).

Vzagali, тук има победители в горната част на Windows за сигурността на работата модални диалогови прозорци, И е дадено на програмистите да извикват немодални диалози. Въпреки това, ние можем да бъдем победители de zavgodno:

Нещо повече, ако функцията Message Dialog е поставена в модела на диаграмата на кутията, можете да настроите прозореца, как да маркирате знаците, да поправите прозорците, да изградите самата клавиатура, как да завъртите в диалоговия прозорец.

Тобто. сега, така че можем да форматираме цикъла по следния начин:

HWND hMainWnd = Създаване на прозорец(...); HACCEL hAccel = Ускорители на натоварване (hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR)); BOOL bRet = 0; while (bRet = GetMessage(&msg, nullptr, 0, 0)) ( if (-1 == bRet) прекъсване; if (!TranslateAccelerator(hMainWnd, hAccel, &msg)) ( if (!IsDialogMessage(hMainW) TranslateMessage(&msg) ;DispatchMessage(&msg); ) ) )
Това е нашият начин за навигация, като роден диалогов прозорец на Windows. И сега отнехме два недолики:

1. Този код също ще бъде любезно практикуване с един (немодален) прозорец;
2. След като премахнахме всички опции за навигация в диалоговия прозорец, можем също да добавим разширението WM_KEYDOWN/WM_KEYUP към изгледа (само за самия прозорец, не и за контролите за деца);

І ос, на кой етап всички уроци завършват и започват: Как да обработваме събития на клавиатурата в стандартен диалогов прозорец на winapi?
Tse първи изпратени в kuti, ale turn: хиляди их. Относно предлагането на решения (по-кратко от тези - да създадете свой собствен клас диалози, за които писах повече, за подкласове и RegisterHotKey. Тук ще намеря "по-кратък" начин: да спечелите Windows Hooks).

Дойде времето да поговорим за тези, които не са в уроците и рецензиите.

Като правило (като правило! Ако някой иска повече, тогава можете да регистрирате класа си за диалози и да практикувате по този начин. И ако е така, ако имате нужда, мога да добавя тази статия) WM_KEYDOWN независимо под контрола на vikni - tobto. като жизненоважна функция за всеки конкретен диалог. И ако е така, тогава защо не бързаме с богатите възможности, тъй като самият WinAPI ни разпространява: Ускорител за превод.

Skrіz vikoristovuyut точно единтаблица на ускорителите и по-малко от прозореца на главата. Е, честно казано: има само един цикъл на GetMessage и има само една таблица. Къде другаде трябва да отидат?

Всъщност GetMessage-loop може да бъде инвестиции. Нека отново да разгледаме описанието на PostQuitMessage:

PostQuitMessage публикува съобщение WM_QUIT в опашката за съобщения на нишката и се връща незабавно;

Получавам съобщение:

Като функция за опресняване на съобщението WM_QUIT, връщаната стойност е нула.

По този начин ще се появи излизане от цикъла GetMessage, както ние наричаме PostQuitMessage от процедурата за изход. Какво означава?

Можем за кожа безмоден Vіkna в нашата програма, за да създадете свой собствен подобен цикъл. Понякога DialogBoxParam трябва да отидем, т.к не можем да обърнем цикъла си и не можем да влезем. Въпреки това, ако създадем диалог чрез CreateDialogBoxParam или иначе чрез CreateWindow, можем да завъртим един цикъл. При циму в кожадо такова заключение, че диалогът се дължи на съобщението след приключването:

HWND hMainWnd = Създаване на прозорец(...); HACCEL hAccel = Ускорители на натоварване (hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR)); BOOL bRet = 0; while (bRet = GetMessage(&msg, nullptr, 0, 0)) ( if (-1 == bRet) прекъсване; if (!TranslateAccelerator(hMainWnd, hAccel, &msg)) ( if (!IsDialogMessage(hMainWnd) TranslateMessage(&msg) ; hInstance, MAKEINTRESOURCE(IDD_MYDIALOG), hwnd, MyDialogBoxProc), HACCEL hAccel = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR_FOR_MY_DIALOG)); като диалоговия прозорец (диалогов прозорец е модален, gb nupt 0, gb nupt 0 ms, null 1 == bRet) прекъсване; if (!TranslateAccelerator(hDlg, hAccel, &msg)) (if (!isDia , &msg)) ( TranslateMessage(&msg); DispatchMessage(&msg; ) ) ) EnableWindow(hwnd, fStavedEnable); /d / активиране на родителския прозорец. Диалогът беше затворен прекъсване; ) ) INT_PTR ИЗВЪНВАНЕ MyDlgProc(HWND hwnd, UINT umsg, WPARAM wparam, LPARAM lparam) ( switch(umsg) ( case WM_CLOSE: ( // EndDialog(hwnd, 0)); - НЕ НАПРАВЕТЕ ТОВА! // EndDialog е валиден САМО за модални диалози, създадени от DialogBox(Param) DestroyWindow(hwnd); break; ) case WM_DESTROY: ( PostQuitMessage(0); break; ) // .... ) return 0; )
Получете уважение: сега за нов кожен фурнир в нашата програма можем да го добавим към обработка власнуускорителна маса. WM_QUIT ще позволи на GetMessage да излезе от диалоговия цикъл, но текущият цикъл няма да може. Защо така vіdbuvaetsya?

Вдясно, във факта, че текущият цикъл се „издига“ при повикването на DispatchMessage, което извиква нашата процедура, как да включим неговата мощност вътрешницикъл GetMessage със същия DispatchMessage. Класически прикачени повиквания (в този тип DispatchMessage). Следователно текущият цикъл не отменя WM_QUIT и не завършва този етап. Всички pratsyuvateme stringko.

Ale, а ето и вашите собствени недостатъци:
Кожа такъв цикъл е възпроизводим само за "собствен" прозорец. За други тук не знаем. А това означава, че ако тук се появи друг цикъл, тогава reshta всички викони не вземат предвид необходимата обработка на техните известия с двойката TranslateAccelerator/IsDialogMessage.

Е, дойде време да отдадем цялото уважение и да напишем правилния начин, за да завършим цялата информация за успеха на нашата програма. Искам да уважа, че наградата за един поток се вижда по-долу. Защото кожният поток може да поднови своята линия, тогава кожният поток ще трябва да създаде свои собствени структури. Да се ​​борим дори с тривиални промени в кода.

Робимо е красив

Защото Ако формулировката на проблема е правилна и половината от задачата е зададена, тогава първо ще трябва да задам задачата правилно.

Първо, би било логично, но само по-активенВинаги приемам съвети. Тобто. за неактивен прозорец ние не транслираме ускорители и не изпращаме известия до IsDialogMessage.

По друг начин, ако таблицата на ускорителите не е зададена за прозореца, тогава нищо няма да се предава, само обявяване в IsDialogMessage.

Нека създадем прост std::map, който ще преобразува дескриптора на прозореца в дескриптора на таблицата на ускорителя. ос като тази:

std::map l_mAccelTable;
И в света на създаването на прозорци, ние ще добавим нов прозорец с дескриптор към любимата ви таблица (или нула, тъй като такава обработка не е необходима).

BOOL AddAccelerators(HWND hWnd, HACCEL hAccel) ( if (IsWindow(hWnd)) ( l_mAccelTable[ hWnd ] = hAccel; върне TRUE; ) върне FALSE; ) hInstance, accel)); ) BOOL AddAccelerators(HWND hWnd, int accel) (връщане на AddAccelerators(hWnd, MAKEINTRESOURCE(accel));
Това и след затварянето на прозореца можете да видите. ос като тази:

Void DelAccel(HWND hWnd) ( std::map ::iterator me = l_mAccelTable.find(hWnd); if (me != l_mAccelTable.end()) ( if (me->second) ( DestroyAcceleratorTable(me->second); ) l_mAccelTable.erase(me); ) )
Сега, за да създадете нов диалогов прозорец/прозорец, щракнете върху AddAccelerators(hNewDialog, IDR_MY_ACCEL_TABLE). Как да извиете: DelAccel(hNewDialog).

Имаме списък с викони с необходими дескриптори. Някои модификации на нашия основен цикъл за обработка:

// ... HWND hMainWnd = CreateWindow(...); AddAccelerators(hMainWnd, IDR_ACCELERATOR); BOOL bRet = 0; while (bRet = GetMessage(&msg, nullptr, 0, 0)) ( if (-1 == bRet) break; if (!HandleAccelArray(GetActiveWindow(), msg)) ( TranslateMessage(&msg); DispatchMessage ) ) ) // ...
Много по-кратко! Какво става с HandleAccelArray и какво става с GetActiveWindow()?

Трохи на теория:

Има две функции, които завъртат манипулатора на активния прозорец GetForegroundWindow и GetActiveWindow. Vіdminnіst іn първата іn іt іt torі ії, описана доста разумно в описанието на друго:

Връщаната стойност е манипулаторът на активния прозорец, прикрепен към опашката от съобщения на извикващата нишка. В противен случай връщаната стойност е NULL.

Ако първият въртящ се дескриптор е от всякакъв вид в системата, тогава останалото е само това, като vikoristovu cherga за напомняне на нашия поток. Защото за да ни чуруликате до края на нашия поток (а това означава, че вие, сякаш да се грижите за нашите чернокожи), тогава ще спра.

Така оста на HandleAccelArray, ако го предадем като манипулатор на активния прозорец, търси същия прозорец в нашата карта и той все още е там, напомняме на TranslateAccelerator да излъчва и след това (първият не е необходимо да ) в IsDialogMessage. Ако останалите не са завършили известието, завъртете FALSE, за да следвате стандартната процедура TranslateMessage/DispatchMessage.

Изглежда така:

BOOL HandleAccelWindow(std::map ::const_iterator mh, MSG & msg) ( const HWND & hWnd = mh->first; const HACCEL & hAccel = mh->second; if (!TranslateAccelerator(hWnd, hAccel, &msg)) ( // съобщението не е за превод Опитайте с IsDialogMessage if (!IsDialogMessage(hWnd, &msg)) ( // така че, направете нещата по подразбиране, върнете FALSE; ) ) // добре, съобщението е преведено.(HWND hActive, MSG & msg) ( if (!hActive) return FALSE; // няма активен прозорец. Нищо за правене std::map ::const_iterator mh = l_mAccelTable.find(hActive); if (mh != l_mAccelTable.end()) ( // Разбрах! Опитайте се да преведете това съобщение за активния прозорец return HandleAccelWindow(mh, msg); ) return FALSE; )
Сега кожата на дъщеря ми винаги може да добави любимата ми таблица с ускорители и спокойно да хване и обработи WM_COMMAND с необходимия код.

И какво още има за един ред в кода WM_COMMAND?

Описанието в TranslateAccelerator казва:

За да проверите съобщението, че функцията изпраща съобщения, изпратени от менюта или контроли, думата от висок ред на параметъра wParam WM_COMMAND или съобщението WM_SYSCOMMAND съдържа стойността 1.

Извикайте кода за обработка на WM_COMMAND и изглеждайте така:

Switch(HIWORD(wParam)) ( случай BN_CLICKED // Команда от бутони/менюта ( switch(LOWORD(wParam))) ( случай IDC_BUTTON1: DoButton1Stuff(); прекъсване; случай IDC_BUTTON2: DoButton2Stuff ) прекъсване; ) )
Сега можете да пишете така:

Switch(HIWORD(wParam)) ( случай 1: // случай на ускорител BN_CLICKED: // Команда от бутони/менюта ( switch(LOWORD(wParam)) ( случай IDC_BUTTON1: DoButton1Stuff(); прекъсване; случай IDC_BUT) ; // .. .) прекъсване;))
И сега, обръщайки се към същия fceux, добавяйки само един редв кода за обработка на команди от типа бутони, за които трябва да се погрижим: дебъгер от клавиатурата. Достатъчно е да добавите малка обвивка около контура на главата, за да актуализирате новата таблица на ускорителите с необходимите функции VK_KEY => IDC_DEBUGGER_BUTTON.

PS: Малко хора знаят, но можете да създадете своя собствена таблица с ускорители и сега можете да я спрете веднага.

P.P.S.: Защото DialogBox/DialogBoxParam за завъртане на главния цикъл, след което, когато диалогът бъде извикан през тях, ускорителите няма да работят и нашият цикъл (или циклите) ще бъдат „на празен ход“.

P.P.P.S.: След щракване върху HandleAccelWindow на картите l_mAccelTable, може да се промени, TranslateAccelerator или IsDialogMessage извикват DispatchMessage и там можете да използвате AddAccelerators или DelAccel в нашите уроци! Следователно е по-добре от yogo, след като функцията не е да бъде чипирана.

Можете да маркирате кода. За основа е взет кодът, който се генерира от стандартния шаблон MS VS 2017.

Етикети: Добавяне на етикети

Съкращението API, Application Programming Interface (API) е просто един вид готов набор от функции, които търговците на софтуер могат да спечелят. Разбирането на Zagalom tse е еквивалентно на това, което преди често се наричаше библиотека от подпрограми. Въпреки това, повечето от API са засегнати от определена категория такива библиотеки.

Под часа на разработка е практично да получите сгъваема добавка (MyApplication) за края на corystuvach, формира се набор от специфични вътрешни функции, които се избират за изпълнение на конкретна програма, тъй като MyApplication API е Наречен. Често се случва тези функции да бъдат ефективно настроени за създаване на други програми от други програмисти. По какъв начин авторите, които минават през стратегията за популяризиране на своя продукт, са виновни за хранителна корупция - защо дават достъп до този комплект на правилните користувачи? Ако има положителен отговор на нов в описанието на софтуерния пакет, всъщност има фраза за тези, че пакетът включва набор от функции на API.

По този начин по-голямата част от API може да се използва за въвеждане на функции, които са част от една програма, но в същото време са достъпни за избор в други програми. Например, Excel, кремообразен интерфейс за ползване от край до край, може да въвежда Excel API функции, които могат да се използват, zokrema, при създаване на програми с помощта на VB.

Очевидно Windows API е набор от функции, които са част от самата операционна система и в същото време – достъпни за всяка друга програма. В този план аналогията с набор от BIOS/DOS системни прекъсвания е напълно вярна, което всъщност е DOS API.

Разликата се състои във факта, че складът на функциите на Windows API, от една страна, е значително по-широк, подобен на DOS, от друга страна, не включва много предимства на директното управление на компютърните ресурси, които са били налични за програмисти от предната ОС. В допълнение, извикването на Windows API се извиква за допълнителни процедурни извиквания, а извикването на DOS функционира чрез специална машинна команда на процесора, която се нарича прекъсване („рестартиране“).

Win16 API и Win32 API

Очевидно смяната от Windows 3.x към Windows 95 бележи преход от 16-битова архитектура на операционната система към 32-битова. 16-битовият Windows API (Win16 API) беше променен за една нощ на нова 32-битова версия (Win32 API). В този случай просто се нуждаете от майка на улицата, за малка вина, Win32 API е единственият за семействата Windows 9x и Windows NT.

С познаването на Win API става очевидно, че има много функции, които се използват - нищо друго, като преход към най-модерните системни процедури, а само изпълнение на синтаксиса на филма. Поглеждайки назад, необходимостта от различен API се определя от следните опции:

API-функции, като нови имплементации като бъдещи функции. Тим не е по-малко, понякога и по този начин ще преминем към API zastosuvannya, защото позволява понякога да се подобри производителността (zorema, за дневните часове на ненужни промени на параметрите, които се предават).

Въведените функции изпълняват само ограничен брой различни функции на API. Tse dosit прост вариант.

Големият брой API-функции във vzagali нямат аналози в текущата версия на компилаторите. Например, не можете да изтриете директория с помощта на VB - за което трябва да използвате функцията DeleteDirectory.

Важно е също така, че някои API-функции (частта им в Win API е незначителна) не могат да бъдат извикани поради ниската граница на обема, например е възможно да се работи с адреси на паметта. Ale в редица vipadkіv може да помогне нетривиално priyomy програмиране (zocrema, в vipadku z същите тези адреси).

Win APIіБиблиотека с динамични връзки (DLL)

Колекция от Win API реализации като динамични DLL библиотеки.

По този начин можем да използваме традиционната версия на две динамични библиотеки, които осигуряват директен достъп до необходимите процедури – подпрограми или функции (приблизително същото като при извикване на процедури в средата на проекта). Такива библиотеки могат да се създават с допълнителни инструменти - VC++, Delphi, Fortran, Assembler.

Извикването на файловете на динамичните библиотеки може да имат разширение .DLL, но не е обвързващо. За Win16 разширението често се забива. EXE, драйверите за външни устройства са назначени с помощта на .DRV.

Изчислете точния брой функции и файлове на Windows API, които могат да бъдат премахнати, направете го гладко (въпреки че зловонието се купува отново от системния каталог). В този план е по-вероятно да видите склад от библиотеки, които ще формират ядрото на операционната система, тази на основните библиотеки с ключови допълнителни функции.

Библиотеки Win32 Operating Kernel API Windows системи 95/98:

KERNEL32.DLL: функции за грижа за паметта на ниско ниво, които контролират други системни ресурси;

USER32.DLL: тук са основно функциите на основния интерфейс;

GDI32.DLL: библиотека с интерфейс на графичното устройство - различни функции, показвани на външни устройства;

COMDLG32.DLL: функции, свързани с различни диалогови прозорци с общо разпознаване.

Основни библиотеки с функции за разширение:

COMCTL32.DLL: набор от допълнителни елементи на ядрото на Windows, включително Tree List и Rich Text;

MAPI32.DLL: функции за работа с електронна поща;

NETAPI32.DLL: Елементи на поддръжка и функции на работа с мярка;

ODBC32.DLL: библиотечни функции, необходими за работа с различни бази данни чрез ODBC протокола;

WINMM.DLL: операции за достъп до функциите на мултимедийната система.

Тази статия е адресирана до същите, като начинаещи в програмирането на C ++, като доброволно или заради грешки, те написаха WinAPI.
Искам да изпреваря себе си:
Не твърдя, че съм C++ гуру, но WinAPI.
Просто се чудя и искам да доведа тук няколко примера от този вид, за да ми е по-лесно да разработя функциите и механизмите на WinAPI.

В тази статия признавам, че вече трябва да знаете за C ++, за да научите как да създавате класове и да променяте различни оператори за тях и че вече „светите“ харесвате собствените си механизми в класа.

Създаването на тази конзола vikoristannya

За персонализиране на Win32 програми, или просто за да се чудя как е там, всичко в средата изглежда сякаш постоянно съм мачкащ в конзолата.
Ако създадете GUI добавка, но ако не е конзола, тогава конзолата не е свързана. За да щракнете в интернет, за да разберете кода на оста

If(AllocConsole())
{



std::ios::sync_with_stdio();
}
За по-голяма прозрачност увийте yogo върху функция. Например:
void CreateConsole()
{
if (AllocConsole())
{
int hCrt = _open_osfhandle((long)GetStdHandle(STD_OUTPUT_HANDLE), 4);
*stdout = *(::_fdopen(hCrt, "w"));
::setvbuf(stdout, NULL, _IONBF, 0);
*stderr = *(::_fdopen(hCrt, "w"));
::setvbuf(stderr, NULL, _IONBF, 0);
std::ios::sync_with_stdio();
}

Конзолата Viklikana работи само в режим на дисплей и работи както в конзолни добавки. Въведете информацията като и звук - cout / wcout.
За внедряването на този код е необходимо да включите следните файлове преди проекта:
#включи
#включи #включи
и активирайте std пространство от имена за глобалното пространство от имена:
използване на пространство от имена std;
Очевидно, ако не искате да правите това, просто добавете std:: към всички обекти, за които знаете.

Падащи обекти за виждане на тези аритми. операции

Когато създавате, че vivechenni себе си "най-накрая" ми zavzhd е необходимо да въведете в конзолата някаква стойност.
Например:
Отнемате размера на клиентската област на прозореца за допълнителната функция GetClientRect, където параметърът се предава на адреса на обекта от структурата RECT, за да запазите данните за обекта. Ако трябва да знаете размера на вашата клиентска област, можете просто да я въведете във вече свързаната конзола.

Cout<

Елът работи толкова бързо (особено след като често трябва да работите така), че не е удобно.
Тук идваме на помощ на упадъка.
Създайте клас, който попада в структурата RECT и променете изходния оператор<< так, как вам угодно.
Например:

Клас newrect:public RECT
{
обществено:
приятелски поток и оператор<<(ostream &strm,newrect &rect)
{
strm<<"Prtint RECT object:\n";
strm<връщане strm;
}
};

Сега просто въведете обекта за помощта на cout/wcout:

Cout<

И за теб при вида на ръката ти виждаш всичко както ти трябва.
Освен това можете да работите с каквито и оператори, от които се нуждаете.
Например, ако трябва да промените или привлечете структури (например същият RECT или POINT) - променете оператора==() и оператора=() по подходящ начин.
Ако искате да приложите по-малко оператор< что бы быстро сравнивать размеры окна и т.д. перегрузите operator<().
Така че можете да работите, признавам, може би с някои структури и по-напрегнато, че всички функции, които работят с най-големия обект на структурата RECT, така че ще бъде добре да работите с него.
Също така препоръчвам да поставите цялата красота в okremium файл, който е свързан, и да коригирате, ако е необходимо.

Твоят клас

Не знам как другите, но знам зелените, писах за функцията на кожата или за главата на кожата / под главата на книгата, за да създам нов проект, че всичко беше направено на открито и можех да се обърна и освежи паметта ми в един момент яти необходими моменти.
Така че, за да създадете най-простия прозорец в WinAPI, трябва да заредите структурата на класа, да я регистрирате и да напишете тривиална процедура за прозорец, предположих след третия или четвъртия проект, че все още пиша на C ++.
В резултат бутнах всичко в прост клас. Манипулаторът на прозореца, името, името на класа, адресите на процедурата на прозореца, класът на прозореца (WNDCLASS) са заключени в частната секция на класа.
За тяхното otrimannya, опишете прост метод - Get "eri, например:
HWND GetHWND()
LPCTSTR GetClsName() и др.
Регистрацията на класа на прозореца, създаването на самия прозорец и шоуто се извършват при дизайнера.
За по-голяма яснота можете да промените конструктора и да запишете тази регистрация на класа икона като частна функция на класа и възможност за извикване на конструктора на кожата. Универсалността на промяната се основава на факта, че понякога трябва да създам прост дизайн и извиквам конструктора с два параметъра - името на прозореца и програмата за hinstance.
В същото време е по-малко необходимо да се създаде прозорец със специални размери, а не с процедурата на прозореца по подразбиране и с различен стил на песен - извиквам конструктора с допълнителни параметри.
Този клас ми е присвоен във файла, който е свързан отделно, който се намира в папката за включване на IDE.
Шаблон на този клас:
клас BaseWindow
{
WNDCLASSEX_wcex;
TCHAR_className;
TCHAR_windowName;
HWND_hwnd;
bool_WindowCreation();
обществено:
BaseWindow(LPCTSTR име на прозореца,HINSTANCE hInstance,DWORD стил,UINT x,UINT y,UINT височина,UINT ширина);
BaseWindow(LPCTSTR име на прозорец, HINSTANCE hInstance);
const HWND GetHWND() const(връщане HWND;)
LPCTSTR GetWndName()const(връщане _windowName;)
};

След като сте помислили добре и напишете такъв клас, ще улесните живота си и ще отделите повече време, за да научите и усъвършенствате основите на писането на едно и също нещо. Тим е по-голям, аз го уважавам още по-зле – сам да науча такъв час и да добавя йога според нуждите.

P.S.

Всичко описано е вярно за:
Платформа - Windows 7 32 bit
IDE - Visual Studio 2010
Може би за някой друг, за да викаме от смях и ирония, но все пак всички ние, ако изобщо бяхме новодошли/стажанти/юноши.
Моля ви да се поставите в rozumіnyam преди публикацията. Конструктивната критика, разбира се, vitaetsya. Твърди дискове