One of the first things that is going to strike many first-time programmers of the Win32 API is that there are tons and tons of old data types to deal with. Sometimes, just keeping all the correct data types in order can be more difficult than writing a nice program. This page will talk a little bit about some of the data types that a programmer will come in contact with.
Hungarian Notation[edit | edit source]
First, let’s make a quick note about the naming convention used for some data types, and some variables. The Win32 API uses the so-called «Hungarian Notation» for naming variables. Hungarian Notation requires that a variable be prefixed with an abbreviation of its data type, so that when you are reading the code, you know exactly what type of variable it is. The reason this practice is done in the Win32 API is because there are many different data types, making it difficult to keep them all straight. Also, there are a number of different data types that are essentially defined the same way, and therefore some compilers will not pick up on errors when they are used incorrectly. As we discuss each data type, we will also note the common prefixes for that data type.
Putting the letter «P» in front of a data type, or «p» in front of a variable usually indicates that the variable is a pointer. The letters «LP» or the prefix «lp» stands for «Long Pointer», which is exactly the same as a regular pointer on 32 bit machines. LP data objects are simply legacy objects that were carried over from Windows 3.1 or earlier, when pointers and long pointers needed to be differentiated. On modern 32-bit systems, these prefixes can be used interchangeably.
LPVOID[edit | edit source]
LPVOID data types are defined as being a «pointer to a void object». This may seem strange to some people, but the ANSI-C standard allows for generic pointers to be defined as «void*» types. This means that LPVOID pointers can be used to point to any type of object, without creating a compiler error. However, the burden is on the programmer to keep track of what type of object is being pointed to.
Also, some Win32 API functions may have arguments labeled as «LPVOID lpReserved». These reserved data members should never be used in your program, because they either depend on functionality that hasn’t yet been implemented by Microsoft, or else they are only used in certain applications. If you see a function with an «LPVOID lpReserved» argument, you must always pass a NULL value for that parameter — some functions will fail if you do not do so.
LPVOID objects frequently do not have prefixes, although it is relatively common to prefix an LPVOID variable with the letter «p», as it is a pointer.
DWORD, WORD, BYTE[edit | edit source]
These data types are defined to be a specific length, regardless of the target platform. There is a certain amount of additional complexity in the header files to achieve this, but the result is code that is very well standardized, and very portable to different hardware platforms and different compilers.
DWORDs (Double WORDs), the most commonly occurring of these data types, are defined always to be unsigned 32-bit quantities. On any machine, be it 16, 32, or 64 bits, a DWORD is always 32 bits long. Because of this strict definition, DWORDS are very common and popular on 32-bit machines, but are less common on 16-bit and 64-bit machines.
WORDs (Single WORDs) are defined strictly as unsigned 16-bit values, regardless of what machine you are programming on. BYTEs are defined strictly as being unsigned 8-bit values. QWORDs (Quad WORDs), although rare, are defined as being unsigned 64-bit quantities. Putting a «P» in front of any of these identifiers indicates that the variable is a pointer. putting two «P»s in front indicates it’s a pointer to a pointer. These variables may be unprefixed, or they may use any of the prefixes common with DWORDs. Because of the differences in compilers, the definition of these data types may be different, but typically these definitions are used:
#include <stdint.h>
typedef uint8_t BYTE; typedef uint16_t WORD; typedef uint32_t DWORD; typedef uint64_t QWORD;
Notice that these definitions are not the same in all compilers. It is a known issue that the GNU GCC compiler uses the long and short specifiers differently from the Microsoft C Compiler. For this reason, the windows header files typically will use conditional declarations for these data types, depending on the compiler being used. In this way, code can be more portable.
As usual, we can define pointers to these types as:
#include <stdint.h>
typedef uint8_t * PBYTE; typedef uint16_t * PWORD; typedef uint32_t * PDWORD; typedef uint64_t * PQWORD;
typedef uint8_t ** PPBYTE; typedef uint16_t ** PPWORD; typedef uint32_t ** PPDWORD; typedef uint64_t ** PPQWORD;
DWORD variables are typically prefixed with «dw». Likewise, we have the following prefixes:
| Data Type | Prefix |
|---|---|
| BYTE | «b» |
| WORD | «w» |
| DWORD | «dw» |
| QWORD | «qw» |
LONG, INT, SHORT, CHAR[edit | edit source]
These types are not defined to a specific length. It is left to the host machine to determine exactly how many bits each of these types has.
- Types
typedef long LONG; typedef unsigned long ULONG; typedef int INT; typedef unsigned int UINT; typedef short SHORT; typedef unsigned short USHORT; typedef char CHAR; typedef unsigned char UCHAR;
- LONG notation
- LONG variables are typically prefixed with an «l» (lower-case L).
- UINT notation
- UINT variables are typically prefixed with an «i» or a «ui» to indicate that it is an integer, and that it is unsigned.
- CHAR, UCHAR notation
- These variables are usually prefixed with a «c» or a «uc» respectively.
If the size of the variable doesn’t matter, you can use some of these integer types. However, if you want to exactly specify the size of a variable, so that it has a certain number of bits, use the BYTE, WORD, DWORD, or QWORD identifiers, because their lengths are platform-independent and never change.
STR, LPSTR[edit | edit source]
STR data types are string data types, with storage already allocated. This data type is less common than the LPSTR. STR data types are used when the string is supposed to be treated as an immediate array, and not as a simple character pointer. The variable name prefix for a STR data type is «sz» because it’s a zero-terminated string (ends with a null character).
Most programmers will not define a variable as a STR, opting instead to define it as a character array, because defining it as an array allows the size of the array to be set explicitly. Also, creating a large string on the stack can cause greatly undesirable stack-overflow problems.
LPSTR stands for «Long Pointer to a STR», and is essentially defined as such:
#define STR * LPSTR;
LPSTR can be used exactly like other string objects, except that LPSTR is explicitly defined as being ASCII, not unicode, and this definition will hold on all platforms. LPSTR variables will usually be prefixed with the letters «lpsz» to denote a «Long Pointer to a String that is Zero-terminated». The «sz» part of the prefix is important, because some strings in the Windows world (especially when talking about the DDK) are not zero-terminated. LPSTR data types, and variables prefixed with the «lpsz» prefix can all be used seamlessly with the standard library <string.h> functions.
TCHAR[edit | edit source]
TCHAR data types, as will be explained in the section on Unicode, are generic character data types. TCHAR can hold either standard 1-byte ASCII characters, or wide 2-byte Unicode characters. Because this data type is defined by a macro and is not set in stone, only character data should be used with this type. TCHAR is defined in a manner similar to the following (although it may be different for different compilers):
#ifdef UNICODE #define TCHAR WORD #else #define TCHAR BYTE #endif
TSTR, LPTSTR[edit | edit source]
Strings of TCHARs are typically referred to as TSTR data types. More commonly, they are defined as LPTSTR types as such:
#define TCHAR * LPTSTR
These strings can be either UNICODE or ASCII, depending on the status of the UNICODE macro. LPTSTR data types are long pointers to generic strings, and may contain either ASCII strings or Unicode strings, depending on the environment being used. LPTSTR data types are also prefixed with the letters «lpsz».
HANDLE[edit | edit source]
HANDLE data types are some of the most important data objects in Win32 programming, and also some of the hardest for new programmers to understand. Inside the kernel, Windows maintains a table of all the different objects that the kernel is responsible for. Windows, buttons, icons, mouse pointers, menus, and so on, all get an entry in the table, and each entry is assigned a unique address known as a HANDLE. If you want to pick a particular entry out of that table, you need to give Windows the HANDLE value, and Windows will return the corresponding table entry.
HANDLEs are defined as void pointers (void*). They are used as unique identifiers to each Windows object in our program such as a button, a window an icon, etc. Specifically their definition follows:
typedef PVOID HANDLE;
and
typedef void *PVOID;
In other words HANDLE = void*.
HANDLEs are generally prefixed with an «h». Handles are unsigned integers that Windows uses internally to keep track of objects in memory. Windows moves objects like memory blocks in memory to make room, if the object is moved in memory, the handles table is updated.
Below are a few special handles that are worth discussing:
HWND[edit | edit source]
HWND data types are «Handles to a Window», and are used to keep track of the various objects that appear on the screen. To communicate with a particular window, you need to have a copy of the window’s handle. HWND variables are usually prefixed with the letters «hwnd», just so the programmer knows they are important.
Canonically, main windows are defined as:
HWND hwnd;
Child windows are defined as:
HWND hwndChild1, hwndChild2...
and Dialog Box handles are defined as:
HWND hDlg;
Although you are free to name these variables whatever you want in your own program, readability and compatibility suffer when an idiosyncratic naming scheme is chosen — or worse, no scheme at all.
HINSTANCE[edit | edit source]
HINSTANCE variables are handles to a program instance. Each program gets a single instance variable, and this is important so that the kernel can communicate with the program. If you want to create a new window, for instance, you need to pass your program’s HINSTANCE variable to the kernel, so that the kernel knows what program instance the new window belongs to. If you want to communicate with another program, it is frequently very useful to have a copy of that program’s instance handle. HINSTANCE variables are usually prefixed with an «h», and furthermore, since there is frequently only one HINSTANCE variable in a program, it is canonical to declare that variable as such:
HINSTANCE hInstance;
It is usually a benefit to make this HINSTANCE variable a global value, so that all your functions can access it when needed.
[edit | edit source]
If your program has a drop-down menu available (as most visual Windows programs do), that menu will have an HMENU handle associated with it. To display the menu, or to alter its contents, you need to have access to this HMENU handle. HMENU handles are frequently prefixed with simply an «h».
WPARAM, LPARAM[edit | edit source]
In the earlier days of Microsoft Windows, parameters were passed to a window in one of two formats: WORD-length (16-bit) parameters, and LONG-length (32-bit) parameters. These parameter types were defined as being WPARAM (16-bit) and LPARAM (32-bit). However, in modern 32-bit systems, WPARAM and LPARAM are both 32 bits long. The names however have not changed, for legacy reasons.
WPARAM and LPARAM variables are generic function parameters, and are frequently type-cast to other data types including pointers and DWORDs.
Next Chapter[edit | edit source]
- Unicode
Word Size and Data Types
A word is the amount of data that a machine can process at one time. This fits into the document analogy that includes characters (usually eight bits) and pages (many words, often 4 or 8KB worth) as other measurements of data. A word is an integer number of bytes for example, one, two, four, or eight. When someone talks about the «n-bits» of a machine, they are generally talking about the machine’s word size. For example, when people say the Pentium is a 32-bit chip, they are referring to its word size, which is 32 bits, or four bytes.
The size of a processor’s general-purpose registers (GPR’s) is equal to its word size. The widths of the components in a given architecture for example, the memory bus are usually at least as wide as the word size. Typically, at least in the architectures that Linux supports, the memory address space is equal to the word size[2]. Consequently, the size of a pointer is equal to the word size. Additionally, the size of the C type long is equal to the word size, whereas the size of the int type is sometimes less than that of the word size. For example, the Alpha has a 64-bit word size. Consequently, registers, pointers, and the long type are 64 bits in length. The int type, however, is 32 bits long. The Alpha can access and manipulate 64 bits, one word at a time.
Further read : http://www.makelinux.com/books/lkd2/ch19lev1sec2
-
07-02-2010
#1
Registered User
what is the WORD datatype?
I had a programming class assignment to make a simple guessing game ( we’re just starting out programming in C) and I read this code that changes the color of the console:
Code:
HANDLE mainwin = GetStdHandle ( STD_OUTPUT_HANDLE ); WORD DefaultColor; CONSOLE_SCREEN_BUFFER_INFO csbiInfo; GetConsoleScreenBufferInfo(mainwin, &csbiInfo); DefaultColor = csbiInfo.wAttributes;I know what each bit does, but I would like to know what the WORD datatype / structure is? ( sorry if I’m not using the correct terminology, I’m just beginning programming, and it’s really fun
) Thanks alot for the help
-
07-02-2010
#2
C++まいる！Cをこわせ！
WORD in a Windows environment is just that — a word. Now the definition of a word is some type of data that is 16 bits (2 bytes) for x86. Typically an alias for short (ONLY guaranteed under Windows!).
Originally Posted by Adak
io.h certainly IS included in some modern compilers. It is no longer part of the standard for C, but it is nevertheless, included in the very latest Pelles C versions.
Originally Posted by Salem
You mean it’s included as a crutch to help ancient programmers limp along without them having to relearn too much.
Outside of your DOS world, your header file is meaningless.
-
07-02-2010
#3
Registered User
Oh ok, thanks
So word is sort of like a string that can only hold to characters? (2 bytes?)
Thanks for the help
-
07-03-2010
#4
Registered User
No, a WORD is just a 2-Byte (unsigned) data type, you can use it for whatever you like.
Windows Data Types (Windows)
-
07-03-2010
#5
C++まいる！Cをこわせ！
When we speak of types such as word, dword, qword, etc, they all refer to a storage unit, or place, where we can store at most n bytes (2, 4, 8 in this case respectively). What exactly you want to store in them is up to you, because to the hardware it’s all bits.
Now, these types are all (usually) represented by integer types (short, int, long long respectively in this case). Originally Posted by Adak
io.h certainly IS included in some modern compilers. It is no longer part of the standard for C, but it is nevertheless, included in the very latest Pelles C versions.
Originally Posted by Salem
You mean it’s included as a crutch to help ancient programmers limp along without them having to relearn too much.
Outside of your DOS world, your header file is meaningless.
-
07-03-2010
#6
Registered User
Oh ok, its starting to make more sense now,
Thanks alot Elysia and DeadPlanet,
+ the link was really helpful as well
-
07-05-2010
#7
Programming Wraith
Short question: Why are data types bigger that BYTE called *WORD? (WORD, DWORD, QWORD … )
Devoted my life to programming…
-
07-05-2010
#8
Just a pushpin.
Short question: Why are data types bigger that BYTE called *WORD? (WORD, DWORD, QWORD … )
A word is the data size that a processor naturally handles. So for a 32-bit processor, it’s theoretically 32 bits (or an int), although x86 processors support 16 and 32 bits equally via the *x and e*x registers.
Since smaller data sizes have to be padded for operations there’s really no speed gain from using e.g. bytes vs. words. So it’s probably more convenient to define data types that are word size rather than byte size — that way you have a much larger int range at no cost of speed.
Therefore Windows has DWORD (double word) and QWORD (quad word), which correspond to 2 words and 4 words respectively (or a 16-bit long int and long long int).Since the modern Windows API really came about in Windows ’95 and that was a 16-bit system, WORD was defined to be a 16-bit data structure (on 16-bit processors, an int, and a short was 8 bits like a char). Hence the 16-bit Windows word. And it stuck on into win32, probably for compatibility reasons.
EDIT: Nevermind the ’95 part, 16-bit started out with DOS, but the point is still valid.
Last edited by bernt; 07-06-2010 at 08:23 AM.
Consider this post signed
-
07-05-2010
#9
Programming Wraith
Devoted my life to programming…
what is the WORD datatype?
) 
Originally Posted by Adak
| title | description | ms.assetid | keywords | ms.topic | ms.date | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
Windows Data Types (BaseTsd.h) |
The data types supported by Windows are used to define function return values, function and message parameters, and structure members. |
4553cafc-450e-4493-a4d4-cb6e2f274d46 |
|
reference |
05/31/2018 |
The data types supported by Windows are used to define function return values, function and message parameters, and structure members. They define the size and meaning of these elements. For more information about the underlying C/C++ data types, see Data Type Ranges.
The following table contains the following types: character, integer, Boolean, pointer, and handle. The character, integer, and Boolean types are common to most C compilers. Most of the pointer-type names begin with a prefix of P or LP. Handles refer to a resource that has been loaded into memory.
For more information about handling 64-bit integers, see Large Integers.
| Data type | Description | ||
|---|---|---|---|
| APIENTRY | The calling convention for system functions. This type is declared in WinDef.h as follows: #define APIENTRY WINAPI |
||
| ATOM | An atom. For more information, see About Atom Tables. This type is declared in WinDef.h as follows: typedef WORD ATOM; |
||
| BOOL | A Boolean variable (should be TRUE or FALSE). This type is declared in WinDef.h as follows: typedef int BOOL; |
||
| BOOLEAN | A Boolean variable (should be TRUE or FALSE). This type is declared in WinNT.h as follows: typedef BYTE BOOLEAN; |
||
| BYTE | A byte (8 bits). This type is declared in WinDef.h as follows: typedef unsigned char BYTE; |
||
| CALLBACK | The calling convention for callback functions. This type is declared in WinDef.h as follows: #define CALLBACK __stdcallCALLBACK, WINAPI, and APIENTRY are all used to define functions with the __stdcall calling convention. Most functions in the Windows API are declared using WINAPI. You may wish to use CALLBACK for the callback functions that you implement to help identify the function as a callback function. |
||
| CCHAR | An 8-bit Windows (ANSI) character. This type is declared in WinNT.h as follows: typedef char CCHAR; |
||
| CHAR | An 8-bit Windows (ANSI) character. For more information, see Character Sets Used By Fonts. This type is declared in WinNT.h as follows: typedef char CHAR; |
||
| COLORREF | The red, green, blue (RGB) color value (32 bits). See COLORREF for information on this type. This type is declared in WinDef.h as follows: typedef DWORD COLORREF; |
||
| CONST | A variable whose value is to remain constant during execution. This type is declared in WinDef.h as follows: #define CONST const |
||
| DWORD | A 32-bit unsigned integer. The range is 0 through 4294967295 decimal. This type is declared in IntSafe.h as follows: typedef unsigned long DWORD; |
||
| DWORDLONG | A 64-bit unsigned integer. The range is 0 through 18446744073709551615 decimal. This type is declared in IntSafe.h as follows: typedef unsigned __int64 DWORDLONG; |
||
| DWORD_PTR | An unsigned long type for pointer precision. Use when casting a pointer to a long type to perform pointer arithmetic. (Also commonly used for general 32-bit parameters that have been extended to 64 bits in 64-bit Windows.) This type is declared in BaseTsd.h as follows: typedef ULONG_PTR DWORD_PTR; |
||
| DWORD32 | A 32-bit unsigned integer. This type is declared in BaseTsd.h as follows: typedef unsigned int DWORD32; |
||
| DWORD64 | A 64-bit unsigned integer. This type is declared in BaseTsd.h as follows: typedef unsigned __int64 DWORD64; |
||
| FLOAT | A floating-point variable. This type is declared in WinDef.h as follows: typedef float FLOAT; |
||
| HACCEL | A handle to an accelerator table. This type is declared in WinDef.h as follows: typedef HANDLE HACCEL; |
||
| HALF_PTR | Half the size of a pointer. Use within a structure that contains a pointer and two small fields. This type is declared in BaseTsd.h as follows:
|
||
| HANDLE |
A handle to an object. This type is declared in WinNT.h as follows:
|
||
| HBITMAP |
A handle to a bitmap. This type is declared in WinDef.h as follows:
|
||
| HBRUSH |
A handle to a brush. This type is declared in WinDef.h as follows:
|
||
| HCOLORSPACE |
A handle to a color space. This type is declared in WinDef.h as follows:
|
||
| HCONV |
A handle to a dynamic data exchange (DDE) conversation. This type is declared in Ddeml.h as follows:
|
||
| HCONVLIST |
A handle to a DDE conversation list. This type is declared in Ddeml.h as follows:
|
||
| HCURSOR |
A handle to a cursor. This type is declared in WinDef.h as follows:
|
||
| HDC |
A handle to a device context (DC). This type is declared in WinDef.h as follows:
|
||
| HDDEDATA |
A handle to DDE data. This type is declared in Ddeml.h as follows:
|
||
| HDESK |
A handle to a desktop. This type is declared in WinDef.h as follows:
|
||
| HDROP |
A handle to an internal drop structure. This type is declared in ShellApi.h as follows:
|
||
| HDWP |
A handle to a deferred window position structure. This type is declared in WinUser.h as follows:
|
||
| HENHMETAFILE |
A handle to an enhanced metafile. This type is declared in WinDef.h as follows:
|
||
| HFILE |
A handle to a file opened by OpenFile, not CreateFile. This type is declared in WinDef.h as follows:
|
||
| HFONT |
A handle to a font. This type is declared in WinDef.h as follows:
|
||
| HGDIOBJ |
A handle to a GDI object. This type is declared in WinDef.h as follows:
|
||
| HGLOBAL |
A handle to a global memory block. This type is declared in WinDef.h as follows:
|
||
| HHOOK |
A handle to a hook. This type is declared in WinDef.h as follows:
|
||
| HICON |
A handle to an icon. This type is declared in WinDef.h as follows:
|
||
| HINSTANCE |
A handle to an instance. This is the base address of the module in memory. HMODULE and HINSTANCE are the same today, but represented different things in 16-bit Windows. This type is declared in WinDef.h as follows:
|
||
| HKEY |
A handle to a registry key. This type is declared in WinDef.h as follows:
|
||
| HKL |
An input locale identifier. This type is declared in WinDef.h as follows:
|
||
| HLOCAL |
A handle to a local memory block. This type is declared in WinDef.h as follows:
|
||
| HMENU |
A handle to a menu. This type is declared in WinDef.h as follows:
|
||
| HMETAFILE |
A handle to a metafile. This type is declared in WinDef.h as follows:
|
||
| HMODULE |
A handle to a module. This is the base address of the module in memory. HMODULE and HINSTANCE are the same in current versions of Windows, but represented different things in 16-bit Windows. This type is declared in WinDef.h as follows:
|
||
| HMONITOR |
A handle to a display monitor. This type is declared in WinDef.h as follows:
|
||
| HPALETTE |
A handle to a palette. This type is declared in WinDef.h as follows:
|
||
| HPEN |
A handle to a pen. This type is declared in WinDef.h as follows:
|
||
| HRESULT |
The return codes used by COM interfaces. For more information, see Structure of the COM Error Codes. To test an HRESULT value, use the FAILED and SUCCEEDED macros. This type is declared in WinNT.h as follows:
|
||
| HRGN |
A handle to a region. This type is declared in WinDef.h as follows:
|
||
| HRSRC |
A handle to a resource. This type is declared in WinDef.h as follows:
|
||
| HSZ |
A handle to a DDE string. This type is declared in Ddeml.h as follows:
|
||
| HWINSTA |
A handle to a window station. This type is declared in WinDef.h as follows:
|
||
| HWND |
A handle to a window. This type is declared in WinDef.h as follows:
|
||
| INT |
A 32-bit signed integer. The range is -2147483648 through 2147483647 decimal. This type is declared in WinDef.h as follows:
|
||
| INT_PTR |
A signed integer type for pointer precision. Use when casting a pointer to an integer to perform pointer arithmetic. This type is declared in BaseTsd.h as follows:
|
||
| INT8 |
An 8-bit signed integer. This type is declared in BaseTsd.h as follows:
|
||
| INT16 |
A 16-bit signed integer. This type is declared in BaseTsd.h as follows:
|
||
| INT32 |
A 32-bit signed integer. The range is -2147483648 through 2147483647 decimal. This type is declared in BaseTsd.h as follows:
|
||
| INT64 |
A 64-bit signed integer. The range is -9223372036854775808 through 9223372036854775807 decimal. This type is declared in BaseTsd.h as follows:
|
||
| LANGID |
A language identifier. For more information, see Language Identifiers. This type is declared in WinNT.h as follows:
|
||
| LCID |
A locale identifier. For more information, see Locale Identifiers. This type is declared in WinNT.h as follows:
|
||
| LCTYPE |
A locale information type. For a list, see Locale Information Constants. This type is declared in WinNls.h as follows:
|
||
| LGRPID |
A language group identifier. For a list, see EnumLanguageGroupLocales. This type is declared in WinNls.h as follows:
|
||
| LONG |
A 32-bit signed integer. The range is -2147483648 through 2147483647 decimal. This type is declared in WinNT.h as follows:
|
||
| LONGLONG |
A 64-bit signed integer. The range is -9223372036854775808 through 9223372036854775807 decimal. This type is declared in WinNT.h as follows:
|
||
| LONG_PTR |
A signed long type for pointer precision. Use when casting a pointer to a long to perform pointer arithmetic. This type is declared in BaseTsd.h as follows:
|
||
| LONG32 |
A 32-bit signed integer. The range is -2147483648 through 2147483647 decimal. This type is declared in BaseTsd.h as follows:
|
||
| LONG64 |
A 64-bit signed integer. The range is -9223372036854775808 through 9223372036854775807 decimal. This type is declared in BaseTsd.h as follows:
|
||
| LPARAM |
A message parameter. This type is declared in WinDef.h as follows:
|
||
| LPBOOL |
A pointer to a BOOL. This type is declared in WinDef.h as follows:
|
||
| LPBYTE |
A pointer to a BYTE. This type is declared in WinDef.h as follows:
|
||
| LPCOLORREF |
A pointer to a COLORREF value. This type is declared in WinDef.h as follows:
|
||
| LPCSTR |
A pointer to a constant null-terminated string of 8-bit Windows (ANSI) characters. For more information, see Character Sets Used By Fonts. This type is declared in WinNT.h as follows:
|
||
| LPCTSTR |
An LPCWSTR if UNICODE is defined, an LPCSTR otherwise. For more information, see Windows Data Types for Strings. This type is declared in WinNT.h as follows:
|
||
| LPCVOID |
A pointer to a constant of any type. This type is declared in WinDef.h as follows:
|
||
| LPCWSTR |
A pointer to a constant null-terminated string of 16-bit Unicode characters. For more information, see Character Sets Used By Fonts. This type is declared in WinNT.h as follows:
|
||
| LPDWORD |
A pointer to a DWORD. This type is declared in WinDef.h as follows:
|
||
| LPHANDLE |
A pointer to a HANDLE. This type is declared in WinDef.h as follows:
|
||
| LPINT |
A pointer to an INT. This type is declared in WinDef.h as follows:
|
||
| LPLONG |
A pointer to a LONG. This type is declared in WinDef.h as follows:
|
||
| LPSTR |
A pointer to a null-terminated string of 8-bit Windows (ANSI) characters. For more information, see Character Sets Used By Fonts. This type is declared in WinNT.h as follows:
|
||
| LPTSTR |
An LPWSTR if UNICODE is defined, an LPSTR otherwise. For more information, see Windows Data Types for Strings. This type is declared in WinNT.h as follows:
|
||
| LPVOID |
A pointer to any type. This type is declared in WinDef.h as follows:
|
||
| LPWORD |
A pointer to a WORD. This type is declared in WinDef.h as follows:
|
||
| LPWSTR |
A pointer to a null-terminated string of 16-bit Unicode characters. For more information, see Character Sets Used By Fonts. This type is declared in WinNT.h as follows:
|
||
| LRESULT |
Signed result of message processing. This type is declared in WinDef.h as follows:
|
||
| PBOOL |
A pointer to a BOOL. This type is declared in WinDef.h as follows:
|
||
| PBOOLEAN |
A pointer to a BOOLEAN. This type is declared in WinNT.h as follows:
|
||
| PBYTE |
A pointer to a BYTE. This type is declared in WinDef.h as follows:
|
||
| PCHAR |
A pointer to a CHAR. This type is declared in WinNT.h as follows:
|
||
| PCSTR |
A pointer to a constant null-terminated string of 8-bit Windows (ANSI) characters. For more information, see Character Sets Used By Fonts. This type is declared in WinNT.h as follows:
|
||
| PCTSTR |
A PCWSTR if UNICODE is defined, a PCSTR otherwise. For more information, see Windows Data Types for Strings. This type is declared in WinNT.h as follows:
|
||
| PCWSTR |
A pointer to a constant null-terminated string of 16-bit Unicode characters. For more information, see Character Sets Used By Fonts. This type is declared in WinNT.h as follows:
|
||
| PDWORD |
A pointer to a DWORD. This type is declared in WinDef.h as follows:
|
||
| PDWORDLONG |
A pointer to a DWORDLONG. This type is declared in WinNT.h as follows:
|
||
| PDWORD_PTR |
A pointer to a DWORD_PTR. This type is declared in BaseTsd.h as follows:
|
||
| PDWORD32 |
A pointer to a DWORD32. This type is declared in BaseTsd.h as follows:
|
||
| PDWORD64 |
A pointer to a DWORD64. This type is declared in BaseTsd.h as follows:
|
||
| PFLOAT |
A pointer to a FLOAT. This type is declared in WinDef.h as follows:
|
||
| PHALF_PTR |
A pointer to a HALF_PTR. This type is declared in BaseTsd.h as follows:
|
||
| PHANDLE |
A pointer to a HANDLE. This type is declared in WinNT.h as follows:
|
||
| PHKEY |
A pointer to an HKEY. This type is declared in WinDef.h as follows:
|
||
| PINT |
A pointer to an INT. This type is declared in WinDef.h as follows:
|
||
| PINT_PTR |
A pointer to an INT_PTR. This type is declared in BaseTsd.h as follows:
|
||
| PINT8 |
A pointer to an INT8. This type is declared in BaseTsd.h as follows:
|
||
| PINT16 |
A pointer to an INT16. This type is declared in BaseTsd.h as follows:
|
||
| PINT32 |
A pointer to an INT32. This type is declared in BaseTsd.h as follows:
|
||
| PINT64 |
A pointer to an INT64. This type is declared in BaseTsd.h as follows:
|
||
| PLCID |
A pointer to an LCID. This type is declared in WinNT.h as follows:
|
||
| PLONG |
A pointer to a LONG. This type is declared in WinNT.h as follows:
|
||
| PLONGLONG |
A pointer to a LONGLONG. This type is declared in WinNT.h as follows:
|
||
| PLONG_PTR |
A pointer to a LONG_PTR. This type is declared in BaseTsd.h as follows:
|
||
| PLONG32 |
A pointer to a LONG32. This type is declared in BaseTsd.h as follows:
|
||
| PLONG64 |
A pointer to a LONG64. This type is declared in BaseTsd.h as follows:
|
||
| POINTER_32 |
A 32-bit pointer. On a 32-bit system, this is a native pointer. On a 64-bit system, this is a truncated 64-bit pointer. This type is declared in BaseTsd.h as follows:
|
||
| POINTER_64 |
A 64-bit pointer. On a 64-bit system, this is a native pointer. On a 32-bit system, this is a sign-extended 32-bit pointer. Note that it is not safe to assume the state of the high pointer bit. This type is declared in BaseTsd.h as follows:
|
||
| POINTER_SIGNED |
A signed pointer. This type is declared in BaseTsd.h as follows:
|
||
| POINTER_UNSIGNED |
An unsigned pointer. This type is declared in BaseTsd.h as follows:
|
||
| PSHORT |
A pointer to a SHORT. This type is declared in WinNT.h as follows:
|
||
| PSIZE_T |
A pointer to a SIZE_T. This type is declared in BaseTsd.h as follows:
|
||
| PSSIZE_T |
A pointer to a SSIZE_T. This type is declared in BaseTsd.h as follows:
|
||
| PSTR |
A pointer to a null-terminated string of 8-bit Windows (ANSI) characters. For more information, see Character Sets Used By Fonts. This type is declared in WinNT.h as follows:
|
||
| PTBYTE |
A pointer to a TBYTE. This type is declared in WinNT.h as follows:
|
||
| PTCHAR |
A pointer to a TCHAR. This type is declared in WinNT.h as follows:
|
||
| PTSTR |
A PWSTR if UNICODE is defined, a PSTR otherwise. For more information, see Windows Data Types for Strings. This type is declared in WinNT.h as follows:
|
||
| PUCHAR |
A pointer to a UCHAR. This type is declared in WinDef.h as follows:
|
||
| PUHALF_PTR |
A pointer to a UHALF_PTR. This type is declared in BaseTsd.h as follows:
|
||
| PUINT |
A pointer to a UINT. This type is declared in WinDef.h as follows:
|
||
| PUINT_PTR |
A pointer to a UINT_PTR. This type is declared in BaseTsd.h as follows:
|
||
| PUINT8 |
A pointer to a UINT8. This type is declared in BaseTsd.h as follows:
|
||
| PUINT16 |
A pointer to a UINT16. This type is declared in BaseTsd.h as follows:
|
||
| PUINT32 |
A pointer to a UINT32. This type is declared in BaseTsd.h as follows:
|
||
| PUINT64 |
A pointer to a UINT64. This type is declared in BaseTsd.h as follows:
|
||
| PULONG |
A pointer to a ULONG. This type is declared in WinDef.h as follows:
|
||
| PULONGLONG |
A pointer to a ULONGLONG. This type is declared in WinDef.h as follows:
|
||
| PULONG_PTR |
A pointer to a ULONG_PTR. This type is declared in BaseTsd.h as follows:
|
||
| PULONG32 |
A pointer to a ULONG32. This type is declared in BaseTsd.h as follows:
|
||
| PULONG64 |
A pointer to a ULONG64. This type is declared in BaseTsd.h as follows:
|
||
| PUSHORT |
A pointer to a USHORT. This type is declared in WinDef.h as follows:
|
||
| PVOID |
A pointer to any type. This type is declared in WinNT.h as follows:
|
||
| PWCHAR |
A pointer to a WCHAR. This type is declared in WinNT.h as follows:
|
||
| PWORD |
A pointer to a WORD. This type is declared in WinDef.h as follows:
|
||
| PWSTR |
A pointer to a null-terminated string of 16-bit Unicode characters. For more information, see Character Sets Used By Fonts. This type is declared in WinNT.h as follows:
|
||
| QWORD |
A 64-bit unsigned integer. This type is declared as follows:
|
||
| SC_HANDLE |
A handle to a service control manager database. For more information, see SCM Handles. This type is declared in WinSvc.h as follows:
|
||
| SC_LOCK |
A lock to a service control manager database. For more information, see SCM Handles. This type is declared in WinSvc.h as follows:
|
||
| SERVICE_STATUS_HANDLE |
A handle to a service status value. For more information, see SCM Handles. This type is declared in WinSvc.h as follows:
|
||
| SHORT |
A 16-bit integer. The range is -32768 through 32767 decimal. This type is declared in WinNT.h as follows:
|
||
| SIZE_T |
The maximum number of bytes to which a pointer can point. Use for a count that must span the full range of a pointer. This type is declared in BaseTsd.h as follows:
|
||
| SSIZE_T |
A signed version of SIZE_T. This type is declared in BaseTsd.h as follows:
|
||
| TBYTE |
A WCHAR if UNICODE is defined, a CHAR otherwise. This type is declared in WinNT.h as follows:
|
||
| TCHAR |
A WCHAR if UNICODE is defined, a CHAR otherwise. This type is declared in WinNT.h as follows:
|
||
| UCHAR |
An unsigned CHAR. This type is declared in WinDef.h as follows:
|
||
| UHALF_PTR |
An unsigned HALF_PTR. Use within a structure that contains a pointer and two small fields. This type is declared in BaseTsd.h as follows:
|
||
| UINT |
An unsigned INT. The range is 0 through 4294967295 decimal. This type is declared in WinDef.h as follows:
|
||
| UINT_PTR |
An unsigned INT_PTR. This type is declared in BaseTsd.h as follows:
|
||
| UINT8 |
An unsigned INT8. This type is declared in BaseTsd.h as follows:
|
||
| UINT16 |
An unsigned INT16. This type is declared in BaseTsd.h as follows:
|
||
| UINT32 |
An unsigned INT32. The range is 0 through 4294967295 decimal. This type is declared in BaseTsd.h as follows:
|
||
| UINT64 |
An unsigned INT64. The range is 0 through 18446744073709551615 decimal. This type is declared in BaseTsd.h as follows:
|
||
| ULONG |
An unsigned LONG. The range is 0 through 4294967295 decimal. This type is declared in WinDef.h as follows:
|
||
| ULONGLONG |
A 64-bit unsigned integer. The range is 0 through 18446744073709551615 decimal. This type is declared in WinNT.h as follows:
|
||
| ULONG_PTR |
An unsigned LONG_PTR. This type is declared in BaseTsd.h as follows:
|
||
| ULONG32 |
An unsigned LONG32. The range is 0 through 4294967295 decimal. This type is declared in BaseTsd.h as follows:
|
||
| ULONG64 |
An unsigned LONG64. The range is 0 through 18446744073709551615 decimal. This type is declared in BaseTsd.h as follows:
|
||
| UNICODE_STRING |
A Unicode string. This type is declared in Winternl.h as follows:
|
||
| USHORT |
An unsigned SHORT. The range is 0 through 65535 decimal. This type is declared in WinDef.h as follows:
|
||
| USN |
An update sequence number (USN). This type is declared in WinNT.h as follows:
|
||
| VOID |
Any type. This type is declared in WinNT.h as follows:
|
||
| WCHAR |
A 16-bit Unicode character. For more information, see Character Sets Used By Fonts. This type is declared in WinNT.h as follows:
|
||
| WINAPI |
The calling convention for system functions. This type is declared in WinDef.h as follows:
CALLBACK, WINAPI, and APIENTRY are all used to define functions with the __stdcall calling convention. Most functions in the Windows API are declared using WINAPI. You may wish to use CALLBACK for the callback functions that you implement to help identify the function as a callback function. |
||
| WORD |
A 16-bit unsigned integer. The range is 0 through 65535 decimal. This type is declared in WinDef.h as follows:
|
||
| WPARAM |
A message parameter. This type is declared in WinDef.h as follows:
|
Requirements
| Requirement | Value |
|---|---|
| Minimum supported client | Windows XP [desktop apps only] |
| Minimum supported server | Windows Server 2003 [desktop apps only] |
| Header |
|
Типы данных, поддерживаемые Microsoft ® Windows
® используются для определения
возвращаемых значений функциями,
параметров функций и сообщений и членов
структур. Они определяют размер и значение
этих элементов.
Нижеследующая таблица содержит такие
перечисляемые типы, как: символ, целое число,
Булево число, указатель и дескриптор. Типы
символ, целое и Булево число являются
стандартными для большинства трансляторов
с языка C. Большинство названий типа
указателя начинаются с префикса
P или
LP.
Дескрипторы ссылаются на ресурс, который
был загружен в память. Для получения
дополнительной информации об обработке 64-разрядных
целых чисел, см. Большие
целые числа.
|
Термин |
Описание |
ATOM |
Атом. Дополнительную информацию typedef WORD ATOM;
|
BOOL |
Булева переменная (должна быть ИСТИНА (TRUE)
typedef int BOOL;
|
BOOLEAN |
Булева переменная (должна быть ИСТИНА (TRUE)
typedef BYTE BOOLEAN;
|
BYTE |
Байт (8 бит). Этот тип объявлен в Windef.h
typedef unsigned char BYTE;
|
CALLBACK |
Соглашение о вызовах для функций
#define CALLBACK __stdcall
|
CHAR |
8-битовый символ Windows (ANSI). typedef char CHAR;
|
COLORREF |
Красный (red), typedef DWORD COLORREF;
|
CONST |
Переменная, значение которой остается постоянным в ходе выполнения
#define CONST const
|
DWORD |
32-разрядное беззнаковое целое число. Этот
typedef unsigned long DWORD;
|
| DWORDLONG | 64-разрядное беззнаковое целое число. Этот тип объявлен в Winnt.h как показано ниже: typedef ULONGLONG DWORDLONG;
|
DWORD_PTR |
Тип беззнаковый дальний для точности
Этот typedef ULONG_PTR DWORD_PTR;
|
DWORD32 |
32-разрядное беззнаковое целое число. Этот
typedef unsigned int DWORD32;
|
DWORD64 |
64-разрядное беззнаковое целое число. Этот
typedef unsigned __int64 DWORD64;
|
FLOAT |
Переменная с плавающей точкой. Этот
typedef float FLOAT;
|
HACCEL |
Дескриптор typedef HANDLE HACCEL;
|
HANDLE |
Дескриптор объекта. Этот
typedef PVOID HANDLE;
|
HBITMAP |
Дескриптор точечного typedef HANDLE HBITMAP;
|
HBRUSH |
Дескриптор кисти. Этот typedef HANDLE HBRUSH;
|
| HCOLORSPACE | Дескриптор цветового пространства (color space).Этот тип объявлен в Windef.h как показано ниже: if(WINVER >= 0x0400)
typedef HANDLE HCOLORSPACE;
|
HCONV |
Дескриптор динамического обмена
typedef HANDLE HCONV;
|
HCONVLIST |
Дескриптор списка DDE typedef HANDLE HCONVLIST;
|
HCURSOR |
Дескриптор курсора. Этот typedef HICON HCURSOR;
|
HDC |
Дескриптор контекста устройства (DC). Этот typedef HANDLE HDC;
|
HDDEDATA |
Дескриптор данных DDE. Этот typedef HANDLE HDDEDATA;
|
HDESK |
Дескриптор рабочего стола. Этот
typedef HANDLE HDESK;
|
HDROP |
Дескриптор структуры вставки внутрь. Этот
typedef HANDLE HDROP;
|
HDWP |
Дескриптор структуры отложенной
typedef HANDLE HDWP;
|
HENHMETAFILE |
Дескриптор усовершенствованного typedef HANDLE HENHMETAFILE;
|
HFILE |
Дескриптор открытого файла при помощи OpenFile, typedef int HFILE;
|
HFONT |
Дескриптор шрифта. Этот typedef HANDLE HFONT;
|
HGDIOBJ |
Дескриптор объекта GDI. Этот typedef HANDLE HGDIOBJ;
|
HGLOBAL |
Дескриптор блока глобальной памяти. Этот
typedef HANDLE HGLOBAL;
|
HHOOK |
Дескриптор hook-точки. Этот typedef HANDLE HHOOK;
|
HICON |
Дескриптор пиктограммы. Этот typedef HANDLE HICON;
|
HINSTANCE |
Дескриптор экземпляра исполняемого
typedef HANDLE HINSTANCE;
|
HKEY |
Дескриптор ключа реестра. Этот
typedef HANDLE HKEY;
|
HKL |
Идентификатор ввода данных
typedef HANDLE HKL;
|
HLOCAL |
Дескриптор блока локальной памяти. Этот
typedef HANDLE HLOCAL;
|
HMENU |
Дескриптор меню. Этот typedef HANDLE HMENU;
|
HMETAFILE |
Дескриптор метафайла. Этот typedef HANDLE HMETAFILE;
|
HMODULE |
Дескриптор модуля. Это значение —
typedef HINSTANCE HMODULE;
|
HMONITOR |
Дескриптор монитора. Этот
if(WINVER >= 0x0500)
typedef HANDLE HMONITOR;
|
HPALETTE |
Дескриптор палитры. Этот typedef HANDLE HPALETTE;
|
HPEN |
Дескриптор пера. Этот typedef HANDLE HPEN;
|
| HRESULT | Возвращает код используемый интерфейсом. Он равняется нулю после успешного завершения, а не нуль обозначает код ошибки или информацию о состоянии. Этот тип объявлен в Winnt.h как показано ниже: typedef LONG HRESULT;
|
HRGN |
Дескриптор региона. Этот typedef HANDLE HRGN;
|
HRSRC |
Дескриптор ресурса. Этот
typedef HANDLE HRSRC;
|
HSZ |
Дескриптор строки DDE. Этот
typedef HANDLE HSZ;
|
HWINSTA |
Дескриптор оконной typedef HANDLE WINSTA;
|
HWND |
Дескриптор окна. Этот typedef HANDLE HWND;
|
INT |
32-разрядное знаковое целое число. Этот
typedef int INT;
|
INT_PTR |
Целый знаковый тип для точности
#if defined(_WIN64)
typedef __int64 INT_PTR;
#else
typedef int INT_PTR;
|
INT32 |
32-разрядное знаковое целое число. Этот
typedef signed int INT32;
|
INT64 |
64-разрядное знаковое целое число. Этот
typedef signed __int64 INT64;
|
LANGID |
Идентификатор языка. За большей typedef WORD LANGID;
|
LCID |
Идентификатор национального языка За typedef DWORD LCID;
|
LCTYPE |
Тип информации о национальном языке. typedef DWORD LCTYPE;
|
| LGRPID | Идентификатор группы языков. Список смотри в описании EnumLanguageGroupLocales. Этот тип объявлен в Winnls.h как показано ниже: typedef DWORD LGRPID;
|
LONG |
32-разрядное знаковое целое число. Этот
typedef long LONG;
|
| LONGLONG | 64-разрядное знаковое целое число. Этот тип объявлен в Winnt.h как показано ниже: typedef __int64 LONGLONG;
#else
typedef double LONGLONG;
|
LONG_PTR |
Дальний знаковый тип для точности
typedef long LONG_PTR;
|
LONG32 |
32-разрядное знаковое целое число. Этот
typedef signed int LONG32;
|
LONG64 |
64-разрядное знаковое целое число. Этот
typedef __int64 LONG64;
|
LPARAM |
Параметр сообщения. Этот
typedef LONG_PTR LPARAM;
|
LPBOOL |
Указатель на BOOL. Этот typedef BOOL *LPBOOL;
|
LPBYTE |
Указатель на BYTE. Этот typedef BYTE *LPBYTE;
|
LPCOLORREF |
Указатель на значение typedef DWORD *LPCOLORREF;
|
LPCSTR |
Указатель на строковую константу с typedef CONST CHAR *LPCSTR;
|
LPCTSTR |
Если определен Unicode, #ifdef UNICODE
typedef LPCWSTR LPCTSTR;
#else
typedef LPCSTR LPCTSTR;
|
LPCVOID |
Указатель на константу любого типа. Этот
typedef CONST void *LPCVOID;
|
LPCWSTR |
Указатель на строковую константу с typedef CONST WCHAR *LPCWSTR;
|
LPDWORD |
Указатель на DWORD. Этот typedef DWORD *LPDWORD;
|
LPHANDLE |
Указатель на HANDLE (ДЕСКРИПТОР). Этот typedef HANDLE *LPHANDLE;
|
LPINT |
Указатель на INT. Этот typedef int *LPINT;
|
LPLONG |
Указатель на LONG. Этот typedef long *LPLONG;
|
LPSTR |
Указатель на строку с нулем в конце из typedef CHAR *LPSTR;
|
LPTSTR |
Если определен как #ifdef UNICODE
typedef LPWSTR LPTSTR;
#else
typedef LPSTR LPTSTR;
|
LPVOID |
Указатель на любой тип. Этот
typedef void *LPVOID;
|
LPWORD |
Указатель на WORD. typedef WORD *LPWORD;
|
LPWSTR |
Указатель на строку с нулем в конце из typedef WCHAR *LPWSTR;
|
LRESULT |
Знаковый результат обработки
typedef LONG_PTR LRESULT;
|
PBOOL |
Указатель на BOOL. Этот typedef BOOL *PBOOL;
|
PBOOLEAN |
Указатель на BOOL. Этот typedef BOOLEAN *PBOOLEAN;
|
PBYTE |
Указатель на BYTE. Этот typedef BYTE *PBYTE;
|
PCHAR |
Указатель на CHAR. Этот typedef CHAR *PCHAR;
|
PCSTR |
Указатель на строковую константу с typedef CONST CHAR *PCSTR;
|
PCTSTR |
Если определен в Unicode, #ifdef UNICODE
typedef LPCWSTR PCTSTR;
#else
typedef LPCSTR PCTSTR;
|
PCWSTR |
Указатель на строковую константу с typedef CONST WCHAR *PCWSTR;
|
PDWORD |
Указатель на DWORD. Этот typedef DWORD *PDWORD;
|
| PDWORDLONG | Указатель на DWORDLONG. Этот тип объявлен в Winnt.h как показано ниже: typedef DWORDLONG *PDWORDLONG;
|
| PDWORD_PTR | Указатель на DWORD_PTR. Этот тип объявлен в Basetsd.h как показано ниже: typedef DWORD_PTR *PDWORD_PTR;
|
| PDWORD32 | Указатель на DWORD32. Этот тип объявлен в Basetsd.h как показано ниже: typedef DWORD32 *PDWORD32;
|
| PDWORD64 | Указатель на DWORD64. Этот тип объявлен в Basetsd.h как показано ниже: typedef DWORD64 *PDWORD64;
|
PFLOAT |
Указатель на FLOAT. Этот typedef FLOAT *PFLOAT;
|
PHANDLE |
Указатель на HANDLE typedef HANDLE *PHANDLE;
|
PHKEY |
Указатель на HKEY. Этот typedef HKEY *PHKEY;
|
PINT |
Указатель на INT. Этот typedef int *PINT;
|
| PINT_PTR | Указатель на INT_PTR. Этот тип объявлен в Basetsd.h как показано ниже: typedef INT_PTR *PINT_PTR;
|
| PINT32 | Указатель на INT32. Этот тип объявлен в Basetsd.h как показано ниже: typedef INT32 *PINT32;
|
| PINT64 | Указатель на INT64. Этот тип объявлен в Basetsd.h как показано ниже: typedef INT64 *PINT64;
|
PLCID |
Указатель на LCID. Этот typedef PDWORD PLCID;
|
PLONG |
Указатель на LONG. Этот typedef LONG *PLONG;
|
| PLONGLONG | Указатель на LONGLONG. Этот тип объявлен в Winnt.h как показано ниже: typedef LONGLONG *PLONGLONG;
|
| PLONG_PTR | Указатель на LONG_PTR. Этот тип объявлен в Basetsd.h как показано ниже: typedef LONG_PTR *PLONG_PTR;
|
| PLONG32 | Указатель на LONG32. Этот тип объявлен в Basetsd.h как показано ниже: typedef LONG32 *PLONG32;
|
| PLONG64 | Указатель на LONG64. Этот тип объявлен в Basetsd.h как показано ниже: typedef LONG64 *PLONG64;
|
POINTER_32 |
32-разрядный указатель. На 32-разрядной
#if defined(_WIN64)
#define POINTER_32 __ptr32
#else
#define POINTER32
|
POINTER_64 |
64-разрядный указатель. На 64-разрядной
#define POINTER_64 __ptr64
|
PSHORT |
Указатель на SHORT. Этот typedef SHORT *PSHORT;
|
| PSIZE_T | Указатель на SIZE_T. Этот тип объявлен в Basetsd.h как показано ниже: typedef SIZE_T *PSIZE_T;
|
| PSSIZE_T | Указатель на SSIZE_T. Этот тип объявлен в Basetsd.h как показано ниже: typedef SSIZE_T *PSSIZE_T;
|
PSTR |
Указатель на строковую константу с typedef CHAR *PSTR;
|
PTBYTE |
Указатель на TBYTE. Этот typedef TBYTE *PTBYTE;
|
PTCHAR |
Указатель на TCHAR. Этот typedef TCHAR *PTCHAR;
|
PTSTR |
Если определен как #ifdef UNICODE
typedef LPWSTR PTSTR;
#else
typedef LPSTR PTSTR;
|
PUCHAR |
Указатель на UCHAR. Этот typedef UCHAR *PUCHAR;
|
PUINT |
Указатель на UINT. Этот typedef UINT *PUINT;
|
| PUINT_PTR | Указатель на UINT_PTR. Этот тип объявлен в Basetsd.h как показано ниже: typedef UINT_PTR *PUINT_PTR;
|
| PUINT32 | Указатель на UINT32. Этот тип объявлен в Basetsd.h как показано ниже: typedef UINT32 *PUINT32;
|
| PUINT64 | Указатель на UINT64. Этот тип объявлен в Basetsd.h как показано ниже: typedef UINT64 *PUINT64;
|
PULONG |
Указатель на ULONG. Этот typedef ULONG *PULONG;
|
| PULONGLONG | Указатель на ULONGLONG. Этот тип объявлен в Windef.h как показано ниже: typedef ULONGLONG *PULONGLONG;
|
| PULONG_PTR | Указатель на ULONG_PTR. Этот тип объявлен в Basetsd.h как показано ниже: typedef ULONG_PTR *PULONG_PTR;
|
| PULONG32 | Указатель на ULONG32. Этот тип объявлен в Basetsd.h как показано ниже: typedef ULONG32 *PULONG32;
|
| PULONG64 | Указатель на ULONG64. Этот тип объявлен в Basetsd.h как показано ниже: typedef ULONG64 *PULONG64;
|
PUSHORT |
Указатель на USHORT. Этот typedef USHORT *PUSHORT;
|
PVOID |
Указатель на любой тип. Этот
typedef void *PVOID;
|
PWCHAR |
Указатель на WCHAR. Этот typedef WCHAR *PWCHAR;
|
PWORD |
Указатель на WORD. Этот typedef WORD *PWORD;
|
PWSTR |
Указатель на строку с нулем в конце из typedef WCHAR *PWSTR;
|
|
SC_HANDLE
|
Дескриптор менеджера сервисного typedef HANDLE SC_HANDLE;
|
SC_LOCK |
Дескриптор менеджера сервисного typedef LPVOID SC_LOCK;
|
SERVICE_STATUS_ HANDLE |
Значение дескриптора состояния модуля typedef HANDLE SERVICE_STATUS_HANDLE;
|
SHORT |
Короткое целое число (16 бит). Этот
typedef short SHORT;
|
SIZE_T |
Максимальное число байтов, на которые
typedef ULONG_PTR SIZE_T;
|
SSIZE_ T |
Знаковый SIZE_T. Этот typedef LONG_PTR SSIZE_T
|
TBYTE |
Если определен как Unicode, #ifdef UNICODE
typedef WCHAR TBYTE;
#else
typedef unsigned char TBYTE;
|
TCHAR |
Если определен как Unicode, #ifdef UNICODE
typedef WCHAR TCHAR;
#else
typedef char TCHAR;
|
UCHAR |
Беззнаковый CHAR. Этот typedef unsigned char UCHAR;
|
UINT |
Беззнаковый INT. Этот typedef unsigned int UINT;
|
UINT_PTR |
Беззнаковый INT_PTR. Этот #if defined(_WIN64)
typedef unsigned __int64 UINT_PTR;
#else
typedef unsigned int UINT_PTR;
|
UINT32 |
Беззнаковый INT32. Этот typedef unsigned int UINT32;
|
UINT64 |
Беззнаковый INT64. Этот typedef usigned __int 64 UINT64;
|
ULONG |
Беззнаковый LONG. Этот typedef unsigned long ULONG;
|
| ULONGLONG | 64-разрядное беззнаковое целое число. Этот тип объявлен в Winnt.h как показано ниже: typedef unsigned __int64 ULONGLONG;
#else
typedef double ULONGLONG
|
ULONG_PTR |
Беззнаковый LONG_PTR. Этот #if defined(_WIN64)
typedef unsigned __int64 ULONG_PTR;
#else
typedef unsigned long ULONG_PTR;
|
ULONG32 |
Беззнаковый LONG32. Этот typedef unsigned int ULONG32;
|
ULONG64 |
Беззнаковый LONG64. Этот typedef unsigned __int64 ULONG64;
|
USHORT |
Беззнаковый SHORT. Этот typedef unsigned short USHORT;
|
| USN | Обновление числа последовательности (USN). Этот тип объявлен в Winnt.h как показано ниже: typedef LONGLONG USN;
|
VOID |
Любой тип. Этот
#define VOID void
|
WCHAR |
16-битовый символ Unicode. Дополнительную typedef wchar_t WCHAR;
|
WINAPI |
Соглашение о вызовах для системных
#define WINAPI __stdcall
|
WORD |
16-битовое беззнаковое целое число. Этот
typedef unsigned short WORD;
|
WPARAM |
Параметр сообщения. Этот typedef UINT_PTR WPARAM;
|
Целые числа
Данные каким-либо образом необходимо представлять в памяти компьютера. Существует множество различных типов данных, простых и довольно сложных, имеющих большое число компонентов и свойств. Однако, для компьютера необходимо использовать некий унифицированный способ представления данных, некоторые элементарные составляющие, с помощью которых можно представить данные абсолютно любых типов. Этими составляющими являются числа, а вернее, цифры, из которых они состоят. С помощью цифр можно закодировать практически любую дискретную информацию. Поэтому такая информация часто называется цифровой (в отличие от аналоговой, непрерывной).
Первым делом необходимо выбрать систему счисления, наиболее подходящую для применения в конкретных устройствах. Для электронных устройств самой простой реализацией является двоичная система: есть ток — нет тока, или малый уровень тока — большой уровень тока. Хотя наиболее эффективной являлась бы троичная система. Наверное, выбор двоичной системы связан еще и с использование перфокарт, в которых она проявляется в виде наличия или отсутствия отверстия. Отсюда в качестве цифр для представления информации используются 0 и 1.
Таким образом данные в компьютере представляются в виде потока нулей и единиц. Один разряд этого потока называется битом. Однако в таком виде неудобно оперировать с данными вручную. Стандартом стало разделение всего потока на равные последовательные группы из 8 битов — байты или октеты. Далее несколько байтов могут составлять слово. Здесь следует разделять машинное слово и слово как тип данных. В первом случае его разрядность обычно равна разрядности процессора, т.к. машинное слово является наиболее эффективным элементом для его работы. В случае, когда слово трактуется как тип данных (word), его разрядность всегда равна 16 битам (два последовательных байта). Также как типы данных существую двойные слова (double word, dword, 32 бита), четверные слова (quad word, qword, 64 бита) и т.п.
Теперь мы вплотную подошли к представлению целых чисел в памяти. Т.к. у нас есть байты и различные слова, то можно создать целочисленные типы данных, которые будут соответствовать этим элементарным элементам: byte (8 бит), word (16 бит), dword (32 бита), qword (64 бита) и т.д. При этом любое число этих типов имеет обычное двоичное представление, дополненное нулями до соответствующей размерности. Можно заметить, что число меньшей размерности можно легко представить в виде числа большей размерности, дополнив его нулями, однако в обратном случае это не верно. Поэтому для представления числа большей размерности необходимо использовать несколько чисел меньшей размерности. Например:
- qword (64 бита) можно представить в виде 2 dword (32 бита) или 4 word (16 бит) или 8 byte (8 бит);
- dword (32 бита) можно представить в виде 2 word (16 бит) или 4 byte (8 бит);
- word (16 бит) можно представить в виде 2 byte (8 бит);
Если A — число, B1..Bk — части числа, N — разрядность числа, M — разрядность части, N = k*M, то:
Например:
- A = F1E2D3C4B5A69788 (qword)
- A = 232 * F1E2D3C4 (dword) + 20 * B5A69788 (dword)
- A = 248 * F1E2 (word) + 232 * D3C4 (word) + 216 * B5A6 (word) + 20 * 9788 (word)
- A = 256 * F1 (byte) + 248 * E2 (byte) + … + 28 * 97 (byte) + 20 * 88 (byte)
Существуют понятия младшая часть (low) и старшая часть (hi) числа. Старшая часть входит в число с коэффициентом 2N-M, а младшая с коэффициентом 20. Например:
Байты числа можно хранить в памяти в различном порядке. В настоящее время используются два способа расположения: в прямом порядке байт и в обратном порядке байт. В первом случае старший байт записывается в начале, затем последовательно записываются остальные байты, вплоть до младшего. Такой способ используется в процессорах Motorola и SPARC. Во втором случае, наоборот, сначала записывает младший байт, а затем последовательно остальные байты, вплоть до старшего. Такой способ используется в процессорах архитектуры x86 и x64. Далее приведен пример:
Используя подобные целочисленные типы можно представить большое количество неотрицательных чисел: от 0 до 2N-1, где N — разрядность типа. Однако, целочисленный тип подразумевает представление также и отрицательных чисел. Можно ввести отдельные типы для отрицательных чисел от -2N до -1, но тогда такие типы потеряют универсальность хранить и неотрицательные, и отрицательные числа. Поэтому для определения знака числа можно выделить один бит из двоичного представления. По соглашению, это старший бит. Остальная часть числа называется мантиссой.
Если старший бит равен нулю, то мантисса есть обычное представление числа от 0 до 2N-1-1. Если же старший бит равен 1, то число является отрицательным и мантисса представляет собой так называемый дополнительный код числа. Поясним на примере:
Как видно из рисунка, дополнительный код равен разнице между числом 2N-1 и модулем исходного отрицательного числа (127 (1111111) = 128 (10000000) — |-1| (0000001)). Из этого вытекает, что сумма основного и дополнительного кода одного и того же числа равна 2N-1.
Из вышеописанного получается, что можно использовать только целочисленные типы со знаком для описания чисел. Однако существует множество сущностей, которые не требуют отрицательных значений, а значит, место под знак можно включить в представление неотрицательного числа, удвоив количество различных неотрицательных значений. Как результат, в современных компьютерах используются как типы со знаком или знаковые типы, так и типы без знака или беззнаковые типы.
В итоге можно составить таблицу наиболее используемых целочисленных типов данных:
| Общее название | Название в Pascal | Название в C++ | Описание | Диапазон значений |
| unsigned byte | byte | unsigned char | беззнаковый 8 бит | 0..255 |
| signed byte | shortint | char | знаковый 8 бит | -128..127 |
| unsigned word | word | unsigned short | беззнаковый 16 бит | 0..65535 |
| signed word | smallint | short | знаковый 16 бит | -32768..32767 |
| unsigned double word | cardinal | unsigned int | беззнаковый 32 бита | 0..232-1 |
| signed double word | integer | int | знаковый 32 бита | -231..231-1 |
| unsigned quad word | uint64 | unsigned long long unsigned __int64_t (VC++) |
беззнаковый 64 бита | 0..264-1 |
| signed quad word | int64 | long long __int64_t (VC++) |
знаковый 64 бита | -263..263-1 |
Содержание
- Тип данных word windows
- Типы данных в файле windows.h
- Имена констант в файле windows.h
- Имена параметров функций
Тип данных word windows
Исходные тексты любого приложения Windows включают файл windows.h:
Этот файл содержит множество определений типов данных, макросов, прототипов функций, констант и т. д.
Наряду с этим файлом вы можете включить в приложения и другие, знакомые вам по MS-DOS, include-файлы, такие, как stdlib.h и string.h.
Если в проекте Borland C++ for Windows версии 3.1 указывается, что создается приложение Windows, компилятор определяет символ _WINDOWS. Этот символ влияет на включаемые файлы стандартной библиотеки Си. В частности, из include-файлов могут быть исключены прототипы функций, не совместимых с Windows.
Перед включением файла windows.h для выполнения более строгой проверки типов рекомендуется определить символ STRICT:
После включения этой строки многие типы данных определяются по-другому. В частности, все многочисленные идентификаторы ресурсов Windows, такие, как идентификатор контекста, идентификатор окна и т. п., определяются как различные типы данных. При этом вы не сможете по ошибке выполнить, например, присваивание идентификатора окна переменной, предназначенной для хранения идентификатора контекста отображения или идентификатора меню.
Есть целый набор символов, при определении которых из файла windows.h будут исключены определения функций или типов данных, связанных с отдельными подсистемами Windows. Вы можете определить эти символы для ускорения обработки файла windows.h при трансляции (разумеется, если соответствующие подсистемы не используются вашим приложением). Приведем список некоторых из таких символов.
| Символ | Что исключает |
| NOATOM | Прототипы функций для работы с атомами |
| NOCLIPBOARD | Прототипы функций, идентификаторы сообщений и константы для работы с универсальным буфером обмена Clipboard |
| NOCOMM | Прототипы функций, структуры и константы для работы с портом последовательной передачи данных |
| NOCTLMGR | Прототипы функций для работы с диалоговыми панелями, структуры и константы для работы с диалоговыми панелями, сообщения WM_CTLCOLOR, WM_GETFONT, WM_SETFONT, стили органов управления |
| NOCOLOR | Прототипы функций GetSysColor, SetSysColor и константы с префиксом COLOR |
| NODRAWTEXT | Прототип функции DrawText и связанные с этой функцией константы |
| NOGDI | Все определения функций и констант для графического интерфейса GDI |
| NOHELP | Функцию WinHelp, структуры и константы для нее |
| NOICONS | Идентификаторы встроенных пиктограмм |
| NOKERNEL | Прототип функции WinMain, определения всех функций ядра Windows, структур данных и константы |
| NOMB | Прототип функций MessageBox, MessageBeep и константы для них |
| NOMENUS | Прототипы функций и константы для работы с меню |
| NOMETAFILE | Прототипы функций и константы для работы с метафайлами |
| NOSYSCOMMANDS | Константы системных команд с префиксом SC |
| NOUSER | Прототипы и определения констант для пользовательских функций (эти функции относятся к программному интерфейсу Windows и вызываются приложениями) |
| NOVIRTUALKEYCODES | Коды виртуальных клавиш |
| NOWINMESSAGES | Определения кодов сообщений Windows |
| NOWINSTYLES | Константы для определения стилей окон |
Для разработки приложений Windows используется большое количество типов данных и констант, определенных в таких файлах, как windows.h, commdlg.h и других. Эти типы данных как бы замещают собой стандартные типы данных языка Си.
Такая замена позволяет отделить программный интерфейс Windows от самой операционной системы Windows, с одной стороны, и от конкретных реализаций компиляторов языка Си, с другой. Например, система разработки программ Borland C++ версии 3.1 трактует тип unsigned int как беззнаковое целое размером 16 бит. В файле windows.h определен тип UNIT, который для указанной выше системы разработки отображается на тип unsigned int :
Однако при разработке 32-разрядных приложений (таких, как Windows NT) для 32-разрядных процессоров тип UINT должен иметь размер 32 бит. Если вы будете думать о типе UINT как о типе, который используется для представления беззнакового целого естественной для данного процессора длины, вы можете избежать ошибок, связанных с неправильным определением размера целого числа без знака.
Другой пример — дальний указатель на строку символов char _far *. Для разработки приложений Windows версии 3.1 в среде разработки Borland C++ вместо этого типа данных используется тип LPSTR, определенный следующим образом:
Ключевое слово FAR определено так:
В 16-разрядной среде тип LPSTR отображается на дальний указатель, состоящий из селектора и смещения. В 32-разрядной среде при использовании сплошной (FLAT) модели памяти содержимое сегментных регистров устанавливается один раз при запуске приложения и в дальнейшем не изменяется (самим приложением). Для адресации в этом случае используется только 32-разрядная компонента смещения.
Если ваша программа использует тип LPSTR, при ее переносе в среду Windows NT вам не придется изменять исходные тексты, достаточно выполнить новую трансляцию. Для этой операционной системы ключевое слово FAR определено как пустое место:
Поэтому все дальние указатели, определенные с использованием этого ключевого слова, автоматически превратятся в ближние (что и требовалось).
Если бы вы определяли дальний указатель на строку символов как char _far *, вам бы пришлось удалять или переопределять ключевое слово _far.
Типы данных в файле windows.h
Файл windows.h должен включаться во все исходные файлы приложений Windows. Он содержит определение типов данных, символических имен констант и прототипы функций программного интерфейса Windows.
Для создания мобильных приложений, которые вы сможете перенести в среду Windows NT или аналогичную среду, поддерживающую программный интерфейс Windows, следует пользоваться не стандартными типами данных, реализованными в конкретной версии системы, а теми типами данных, которые определены в файле windows.h.
Этот файл содержит описание базовых типов и производных, созданных из базовых. Имена типов (как правило, это указатели) могут начинаться с префикса. Префикс LP означает дальний указатель (Long Pointer), префикс NP — ближний указатель (Near Pointer), и префикс P — указатель без определения типа. Для константных типов данных (определенных с ключевым словом const) после префикса добавляется буква «C», например, LPCSTR.
Приведем список базовых типов данных, определенных в файле windows.h.
| Тип данных | Определение типа в файле windows.h | Описание |
| BOOL | int | Булевый (двоичный) |
| BYTE | unsigned char | Байт |
| WORD | unsigned short | Беззнаковое целое размером 16 бит |
| DWORD | unsigned long | Беззнаковое целое размером 32 бит |
| UINT | unsigned int | Беззнаковое целое естественного для данной системы размера |
Заметим, что в Windows версии 3.1 изменилось определение типа данных WORD по сравнению с версией 3.0. В файле windows.h, предназначенном для разработки приложений Windows версии 3.0, тип данных WORD был определен следующим образом:
В обоих случаях (и для версии 3.0, и для версии 3.1) тип данных отображается на беззнаковое целое длиной 16 бит. Но для Windows NT типы данных unsigned int и unsigned short уже не эквивалентны. Использование вместо них типа данных WORD упростит задачу переноса исходных текстов приложений в 32-разрядную среду.
На основе приведенного выше набора базовых типов в файле windows.h определены производные типы, которые являются указателями:
| Тип данных | Определение типа в файле windows.h | Описание |
| PSTR | char NEAR * | Ближний указатель на символ типа char |
| NPSTR | char NEAR * | Ближний указатель на символ типа char |
| LPSTR | char FAR * | Дальний указатель на символ типа char |
| LPCSTR | const char FAR * | Константный дальний указатель на символ типа char |
| PBYTE | BYTE NEAR * | Ближний указатель на байт |
| LPBYTE | BYTE FAR * | Дальний указатель на байт |
| PINT | int NEAR * | Ближний указатель на int |
| LPINT | int FAR * | Дальний указатель на int |
| PWORD | WORD NEAR * | Ближний указатель на беззнаковое целое размером 16 бит |
| LPWORD | WORD FAR * | Дальний указатель на беззнаковое целое размером 16 бит |
| PLONG | long NEAR * | Ближний указатель на знаковое целое размером 32 бит |
| LPLONG | long FAR * | Дальний указатель на знаковое целое размером 32 бит |
| PDWORD | DWORD NEAR * | Ближний указатель на беззнаковое целое размером 32 бит |
| LPDWORD | DWORD FAR * | Дальний указатель на беззнаковое целое размером 32 бит |
| LPVOID | void FAR * | Дальний указатель, для которого не определен тип данных |
Файл windows.h содержит определения для многочисленных структур данных, таких, как POINT, RECT, TEXTMETRICS и т. п. Для всех структур данных определены указатели, например:
Тип данных PPOINT в зависимости от используемой модели памяти может быть как дальним, так и ближним указателем. Поэтому, для того чтобы избежать неоднозначность в тех случаях, когда вам нужен, например, дальний указатель, лучше воспользоваться типом LPPOINT.
Мы не будем перечислять все структуры данных, описанные в файле windows.h, так как их очень много. Вы можете посмотреть определения нужных вам структур непосредственно в файле windows.h, который всегда находится в каталоге с именем include.
Еще один важный тип данных, определенный в файле windows.h, — это различные идентификаторы (handle).
Для использования того или иного ресурса Windows вы должны получить идентификатор нужного вам ресурса. Для получения идентификатора вызывается одна из функций программного интерфейса Windows. Например, для получения идентификатора контекста отображения можно воспользоваться функцией GetDC:
Само по себе полученное значение идентификатора не имеет для вас никакого смысла. Идентификатор должен использоваться только для ссылки на ресурс, например:
Вы не можете изменять значение идентификатора ни самостоятельно, ни с помощью каких-либо функций программного интерфейса Windows.
Некоторые ресурсы являются ограниченными, поэтому после того, как вы их использовали, эти ресурсы следует отдать Windows с помощью специально предназначенных для этого функций. Например, для того чтобы отдать идентификатор контекста отображения, следует вызвать функцию ReleaseDC:
Приведем список некоторых типов идентификаторов ресурсов:
| Тип идентификатора | Описание |
| GLOBALHANDLE | Идентификатор блока глобальной памяти |
| HACCEL | Акселератор |
| HBITMAP | Изображение в виде битового образа (bitmap) |
| HBRUSH | Кисть |
| HCURSOR | Курсор |
| HDC | Контекст устройства |
| HDRVR | Драйвер устройства |
| HFONT | Шрифт |
| HGDIOBJ | Объект графического интерфейса GDI |
| HGLOBAL | Идентификатор блока глобальной памяти |
| HICON | Пиктограмма |
| HLOCAL | Идентификатор блока локальной памяти |
| HMENU | Меню |
| HMETAFILE | Метафайл |
| HPALETTE | Палитра |
| HPEN | Перо |
| HRGN | Область |
| HRSRC | Ресурс |
| HSTR | Строка символов |
| HTASK | Задача |
| HWND | Окно |
| LOCALHANDLE | Идентификатор блока локальной памяти |
С некоторыми перечисленными выше идентификаторами вы уже знакомы, с некоторыми вам еще только предстоит познакомиться в следующих томах «Библиотеки системного программиста».
Имена констант в файле windows.h
Файл windows.h содержит определение большого количества имен символических констант, таких, как коды сообщений, режимы работы и возможные варианты параметров для различных функций программного интерфейса Windows. Простое перечисление всех символических имен, определенных в файле windows.h, заняло бы не один десяток страниц. Так как наша книга не справочник, а скорее учебное пособие, и к тому же размер книги ограничен, мы не будем подробно описывать каждое символическое имя. Все необходимые сведения приведены в тексте вместе с описанием соответствующих функций. Здесь же мы расскажем только о префиксах символических имен.
Символические имена большинства констант, определенные в файле windows.h и других файлах, включаемых в исходные тексты приложений Windows, начинаются с префиксов, таких, как WM или WS. Имена некоторых констант не имеют таких префиксов, например OPAQUE, TRANSPARENT и т. п.
Приведем список некоторых префиксов имен констант, определенных в файле windows.h.
| Префикс символического имени константы | Описание |
| BI | Компрессия изображений bitmap |
| BN | Коды сообщений от кнопок |
| BS | Стили логических кистей |
| CB | Стили органа управления Combo Box |
| CBN | Коды сообщений от органа управления Combo Box |
| CBS | Стили при создании органа управления Combo Box |
| CE | Коды ошибок при передаче данных |
| CF | Форматы универсального буфера обмена данными Clipboard |
| COLOR | Системные цвета отдельных элементов пользовательского интерфейса Windows |
| CS | Стили класса окна |
| DRIVE | Тип диска |
| DS | Стили при создании диалоговых панелей |
| DT | Технология, использованная при создании устройства ввода/вывода |
| DT | Режимы форматирования при выводе текста функцией DrawText |
| HT | Коды, возвращаемые функцией DefWindowProc при обработке сообщения WM_NCHITTEST |
| ID | Идентификаторы команд диалоговой панели |
| IDC | Идентификаторы встроенных курсоров |
| IDI | Идентификаторы встроенных пиктограмм |
| MB | Флаги для функции MessageBox |
| META | Коды для метафайлов |
| MM | Режимы отображения |
| СС | Способность устройства рисовать различные кривые |
| OF | Константы для работы с файлами |
| PS | Стили пера |
| RT | Типы ресурсов |
| SB | Команды и константы для полосы просмотра (Scroll Bar) |
| SBS | Стили полосы просмотра |
| SC | Значения системных команд, передаваемых вместе с сообщением WM_SYSCOMMAND |
| SIZE | Константы для описания способа изменения размера окна |
| SM | Константы для определения системных метрик |
| SW | Константы для функции ShowWindow |
| TA | Константы для выбора способа выравнивания текста при его выводе с помощью функций TextOut и ExtTextOut. |
| VK | Коды виртуальных клавиш |
| WM | Сообщения Windows |
| WS | Стили окна |
| WS_EX | Расширенные стили окна |
Имена параметров функций
Изобилие типов в приложениях Windows создает определенные трудности для программиста. Ему приходится постоянно думать о соответствии имен переменных типам переменных. Для облегчения работы программистов рекомендуется для всех имен параметров функций и других переменных использовать префиксы. Эти префиксы должны быть заданы маленькими буквами. Приведем список некоторых префиксов, рекомендуемых для различных типов данных:
| Префикс | Тип данных |
| atm | ATOM |
| f | BOOL |
| b | BYTE |
| lpb | BYTE FAR* |
| lpch | char FAR* |
| dlgprc | DLGPROC |
| dw | DWORD |
| lpdw | DWORD FAR* |
| haccl | HACCEL |
| hbm | HBITMAP |
| hbr | HBRUSH |
| hcur | HCURSOR |
| hdc | HDC |
| hdrvr | HDRVR |
| hdwp | HDWP |
| hf | HFILE |
| hfont | HFONT |
| hgdiobj | HGDIOBJ |
| hglb | HGLOBAL |
| hhook | HHOOK |
| hicon | HICON |
| hinst | HINSTANCE |
| hloc | HLOCAL |
| hmenu | HMENU |
| hmf | HMETAFILE |
| hmod | HMODULE |
| hkprc | HOOKPROC |
| hpal | HPALETTE |
| hpen | HPEN |
| hrgn | HRGN |
| hrsrc | HRSRC |
| hstr | HSTR |
| htask | HTASK |
| hwnd | HWND |
| n | int |
| l | LONG |
| lParam | LPARAM |
| lpb | LPBYTE |
| lpsz | LPCSTR |
| lpn | LPINT |
| lpl | LPLONG |
| lpsz | LPSTR |
| lpv | LPVOID |
| lpw | LPWORD |
| lResult | LRESULT |
| npsz | NPSTR |
| npb | PBYTE |
| lppt | POINT FAR* |
| lprc | RECT FAR* |
| tmprc | TIMERPROC |
| u | UINT |
| wndenmprc | WNDENUMPROC |
| wndprc | WNDPROC |
| u или w | WORD |
| wParam | WPARAM |
Так же как и при разработке программ для MS-DOS, при создании приложений Windows вам следует правильно выбрать модель памяти. Напомним основные различия между моделями памяти.
Модель памяти Tiny. Для этой модели создается один сегмент кода и один сегмент данных, причем суммарный размер этих сегментов не должен превышать 64 Кбайт. Эта модель памяти используется при создании загрузочных модулей с расширением имени com. Вы не можете использовать эту модель памяти при создании приложений Windows.
Модель памяти Small. Для этой модели создается один сегмент кода и один сегмент данных, причем суммарный размер этих сегментов не должен превышать 128 Кбайт. Размер массивов данных, созданных с использованием этой модели, не должен превышать 64 Кбайт. Все указатели являются ближними. Эта модель памяти пригодна для приложений Windows. Все примеры приложений, приведенные в нашей книге, созданы с использованием модели памяти Small.
Модель памяти Medium. В этой модели памяти создается один сегмент данных и несколько сегментов кода. Размер массива данных не должен превышать 64 Кбайт. Эта модель памяти часто используется при создании относительно сложных приложений Windows, для которых невозможно обойтись одним сегментом кода размером 64 Кбайт. Для вызова функций в данной модели памяти используются 32-разрядные адреса, состоящие из компонент .
Модель памяти Compact. При использовании этой модели памяти можно создать только один сегмент кода, но несколько сегментов данных. Размер массива данных не должен превышать 64 Кбайт. Для вызова функций, определенных внутри приложения, используется только компонента смещения. Для адресации данных применяются 32-разрядные адреса.
Модель памяти Large. В этой модели памяти создается несколько сегментов кода и несколько сегментов данных. Размер массива данных по-прежнему не должен превышать 64 Кбайт. Для вызова функций и адресации данных используются 32-разрядные адреса в формате .
Модель памяти Huge. Эта модель памяти во всем аналогична модели Large, но допускает работу с массивами неограниченного размера.
Операционная система Windows версии 3.0 могла быть запущена в реальном режиме работы процессора. В этом случае сегменты данных моделей памяти Compact, Large и Huge оказывались зафиксированными в области реальных адресов. В защищенном режиме работы эта неприятность не наблюдается.
Большинство приложений Windows использует либо модель памяти Small, либо Medium, либо так называемую смешанная модель памяти.
Смешанная модель памяти. Для использования смешанной модели памяти в программах MS-DOS используются такие ключевые слова, как _near или _far. Приложения Windows должны пользоваться словами NEAR или FAR.
В смешанной модели памяти вы можете комбинировать ближние и дальние адреса данных и функций, добиваясь получения оптимальной производительности.
Следует отметить, что, строго говоря, вне зависимости от того, какую модель памяти вы укажете при создании проекта, все равно вам придется пользоваться смешанной моделью памяти. Даже при использовании модели памяти Small ваше приложение будет вызывать функции программного интерфейса Windows. Все эти функции в Windows версии 3.1 описаны с ключевым словом _far и расположены в сегментах, принадлежащих не вашему приложению, а операционной системе. Программа MS-DOS, созданная с использованием модели памяти Small, не может содержать дальних вызовов, так как все вызываемые ей функции расположены в одном сегменте кода, а вызовы MS-DOS выполняются через прерывания. Приложения Windows, напротив, не используют прерывания для вызова операционной системы. Они всегда (при использовании любой модели памяти) вызывают операционную систему с помощью команды дальнего вызова.
При использовании редактора текста, входящего в состав систем разработки Borland C++ for Windows версии 3.1 или Turbo C++ for Windows версии 3.1, вы можете столкнуться с невозможностью просмотра комментариев или текстовых строк, набранных с использованием символов кириллицы. Это связано с тем, что указанные выше средства используют для работы с текстом собственный шрифт, который не содержит символов кириллицы.
Вы можете выйти из положения, заменив этот в общем-то неплохой шрифт на другой, в котором есть символы кириллицы.
Для замены шрифта из главного меню системы разработки выберите меню «Options». В меню «Options» выберите строку «Environment». Затем на экране появится еще одно (!) меню, в котором надо выбрать строку «Preferences. «. На экране появится диалоговая панель «Preferences» (рис. 8.1).
Рис. 8.1. Выбор нового шрифта
По умолчанию в меню «Font» выбран шрифт BorlandTE, в котором нет символов кириллицы. Мы рекомендуем вам вместо этого шрифта выбрать шрифт Courier Cyrillic, который есть в русской версии Windows и который устанавливается практически всеми программами локализации Windows, такими, как CyrWin. К сожалению, версия 3.1 системы разработки Borland C++ for Windows не может работать со шрифтами TrueType. Этот недостаток устранен в следующей версии.
Посмотрите на исходный текст приложения Windows, приведенный в листинге 8.1. Не торопитесь делать вывод, что эта программа попала сюда случайно из учебника по языку программирования Си Кернигана и Риччи. То, что вы видите, и в самом деле приложение Windows. Вы можете легко в этом убедиться, если запустите exe-файл этого приложения, который есть на дискете (дискета продается вместе с книгой). Главное окно приложения изображено на рис. 8.2.
Листинг 8.1. Файл easywineasywin1.cpp
Рис. 8.2. Окно приложения EASYWIN1
Но есть одна маленькая тонкость. В проекте должно быть указано, что данная программа есть не что иное, как приложение Windows.
Если вы не купили дискету, прилагаемую к книге, и набрали приведенный выше текст программы самостоятельно, выберите из меню «Options» среды Borland C++ for Windows строку «Application. «. На экране появится диалоговая панель «Application Options» (рис. 8.3).
Рис. 8.3. Диалоговая панель «Application Options»
В этой диалоговой панели вам надо нажать кнопку с надписью «Windows App».
Когда вы собираете загрузочный модуль приложения, компилятор находит там вместо функции WinMain функцию main. Так как в проекте указано, что данное приложение является приложением Windows, компилятор автоматически подключает к приложению функции интерфейса EasyWin и оно становится приложением Windows.
А как же, спросите вы, быть без функции WinMain? Очень просто — эта функция есть, она определена в подключаемых к вашему приложению функциях EasyWin.
Фактически интерфейс EasyWin полностью скрывает от программиста интерфейс Windows, предоставляя ему взамен старый добрый интерфейс консольного ввода/вывода. В программах EasyWin вы можете пользоваться всеми стандартными функциями ввода/вывода, такими, как printf, gets, getch и т. д. Дополнительно можно вызывать функции gotoxy, wherex, wherey, clrscr и clreol, которые входят в стандартную библиотеку Borland C++ для MS-DOS.
Аналогичный интерфейс предусмотрен и в системе разработки Microsoft Visual C++. Этот интерфейс называется QuickWin. Он позволяет использовать практически любые функции стандартной библиотеки транслятора для MS-DOS, в том числе графические. Создаваемое с помощью этого интерфейса приложение может работать в среде Windows в полноэкранном режиме, внешне не отличаясь от своего варианта для MS-DOS.
Зачем все это нужно? Мы так долго говорили о преимуществах Windows, а теперь снова возвратились к MS-DOS?
Возвратились, но не совсем.
Мы можем использовать функции консольного ввода/вывода, но этот вывод выполняется не на экран реального видеомонитора, а в обычное окно Windows. Наше приложение работает в защищенном режиме и может использовать все преимущества адресации расширенной памяти, доступные стандартному приложению Windows. Кроме того, в приложении можно вызывать и обычные функции программного интерфейса Windows.
Для чего же обычно используют интерфейс EasyWin?
Во-первых, для переноса старых программ в среду Windows. Если у вас есть исходные тексты программ MS-DOS, составленных на языке программирования Си, которыми вы продолжаете пользоваться и которые для ввода/вывода на экран используют только функции консольного ввода/вывода, вы сможете без особого труда сделать из этих программ приложения Windows. Для этого вам достаточно перетранслировать их в среде Borland C++ for Windows версии 3.1, указав в проекте, что нужно сделать приложение Windows. Скорее всего вам не придется менять ни одной строчки исходного кода.
Во-вторых, интерфейс EasyWin удобно использовать для создания небольших тестовых приложений, когда нужно быстро получить результат.
В качестве примера такого приложения приведем второй вариант приложения TMETRICS, предназначенного для просмотра пространственных характеристик шрифта, выбранного в контекст отображения (листинг 8.2).
Листинг 8.2. Файл easywineasywin2.cpp
В этом приложении мы создаем контекст отображения, вызывая функцию программного интерфейса Windows CreateDC. Затем мы вызываем знакомую вам функцию GetTextMetrics, определяющую метрики шрифта. Названия метрик и соответствующие численные значения выводятся в окно приложения функцией Print. Функция Print определена в нашем приложении и выглядит чрезвычайно просто благодаря применению для вывода функции printf.
Главное окно приложения изображено на рис. 8.4.
Рис. 8.4. Главное окно приложения EASYWIN2
Без малейших усилий с нашей стороны у окна появились вертикальная и горизонтальная полосы просмотра, с помощью которых можно увидеть целиком окно «виртуальной консоли».
Обратите внимание также на то, что мы вызываем в этой программе функцию программного интерфейса MessageBox.
А можно ли поступить наоборот — из обычного приложения Windows инициализировать интерфейс EasyWin и воспользоваться функциями консольного ввода/вывода?
Можно, именно так мы и поступили в нашем следующем приложении, которое выполняет такие нетипичные для приложений задачи, как перезагрузка компьютера или перезапуск операционной системы Windows (листинг 8.3).
Листинг 8.3. Файл easywineasywin3.cpp
Это приложение содержит стандартную для Windows функцию WinMain. Для инициализации интерфейса EasyWin вызывается функция _InitEasyWin, описанная в файлах stdio.h, io.h, iostream.h:
После вызова этой функции появляется окно и вы можете вызывать стандартные функции консольного ввода/вывода.
В качестве примера мы вызываем функцию GetWindowsDirectory, которая возвращает полный путь к каталогу, содержащему файлы операционной системы Windows:
Параметр lpszSysPath является указателем на буфер, в который будет записан путь к каталогу Windows. Длина буфера должна быть не менее 144 символов, она задается параметром cbSysPath.
Функция GetWindowsDirectory возвращает длину строки записанной в буфер, без учета закрывающего строку двоичного нуля. Если вы не предусмотрели буфер достаточного размера, функция возвратит требуемый размер буфера. В случае ошибки возвращается нулевое значение.
Получив строку пути к каталогу Windows, приложение отображает его на экране и предлагает меню (рис. 8.5).
Рис. 8.5. Главное окно приложения EASYWIN3
В этом меню вам предлагается три возможности. Нажав клавишу , вы сможете завершить работу Windows и перезагрузить компьютер. При этом будет выполнена загрузка MS-DOS.
Если вы нажмете клавишу , произойдет перезапуск Windows без перезагрузки компьютера.
Если нажать клавишу , работа Windows будет завершена и запустится Norton Commander (если он есть на диске вашего компьютера). После завершения работы программы Norton Commander произойдет автоматический запуск Windows.
Для перезапуска Windows и перезагрузки компьютера мы использовали функцию программного интерфейса Windows с именем ExitWindows:
Старший байт параметра dwReturnCode должен быть равен нулю, младший байт должен содержать код возврата, передаваемый MS-DOS при завершении работы Windows:
| Параметр | Описание |
| EW_RESTARTWINDOWS | Перезапуск Windows |
| EW_REBOOTSYSTEM | Завершение работы Windows и перезапуск системы. Этот код допустим только для Windows версии 3.1 и более старших версий |
Параметр wReserved зарезервирован и должен быть равен нулю.
Функция ExitWindowsExec определена в программном интерфейсе Windows версии 3.1. Она завершает работу Windows, передавая управление указанной в параметре программе MS-DOS. После завершения работы этой программы Windows запускается вновь. Приведем прототип функции ExitWindowsExec:
Параметр lpszExe является дальним указателем на строку символов, закрытую двоичным нулем, содержащую путь к запускаемой программе MS-DOS. Через параметр lpszParams запускаемой программе можно передать строку параметров. Это значение можно задать как NULL.
При невозможности завершить работу Windows или в случае появления других ошибок функция возвращает значение FALSE.
Как правило, функции ExitWindowsExec и ExitWindows используются в программах установки программного обеспечения для Windows (в инсталляторах). О том, как создавать собственные инсталляторы, мы расскажем в отдельной главе в одной из следующих книг серии «Библиотека системного программиста».
До появления такой среды разработки приложений Windows, как Borland C++ версии 2.0, отладка приложений требовала наличия двух мониторов или даже двух компьютеров. На одном мониторе отображался ход выполнения программы, другой использовался для работы приложения.
Начиная с версии 2.0 в системе разработки Borland C++ появился одноэкранный отладчик Turbo Debugger for Windows, значительно упрощающий процесс отладки приложений. Для работы этого отладчика достаточно одного компьютера и одного экрана (хотя наилучшие результаты могут быть достигнуты только с двумя компьютерами).
Самый простой способ отладки приложений Windows тем не менее вообще не требует применения отладчика. Он заключается в том, что вы вставляете в разные места исходного текста приложения вызовы функции MessageBox, с помощью которых прослеживаете ход выполнения программы. Если же вам требуется узнать содержимое каких-либо переменных, это можно сделать с помощью функции wsprintf. Вначале с помощью функции wsprintf вы преобразуете интересующее вас значение в текстовую строку, а затем выводите эту строку функцией MessageBox. В некоторых случаях достаточно ограничиться выдачей звукового сигнала, для чего можно вызвать функцию MessageBeep. Примеры вызова функций MessageBox, wsprintf и MessageBeep вы можете найти в приложениях, описанных в нашей книге.
Однако для отладки более сложных приложений вы не сможете ограничиться выдачей диагностических сообщений. Тогда, если вы программист, который только начинает создавать приложения для Windows, мы рекомендуем вам воспользоваться одноэкранным отладчиком Turbo Debugger for Windows, который входит в комплект поставки системы разработки Borland C++ for Windows версии 3.1 или Turbo C++ for Windows.
Учтите, что указанный отладчик не работает с видеоадаптером EGA. Поэтому, если у вас установлен такой видеоадаптер, мы рекомендуем заменить его на другой. Лучше всего приобрести видеоадаптер SVGA с ускорителем для Windows, в котором многие графические операции выполняются аппаратно, благодаря чему скорость вывода изображения сильно повышается. Стоимость такого видеоадаптера может составлять порядка 100 долларов. В крайнем случае на первом этапе вы можете использовать видеоадаптер VGA, однако в этом случае вам не будут доступны режимы с высоким разрешением и с большим количеством цветов.
С помощью отладчика вы сможете выполнить приложение в пошаговом режиме, выполнить обратную трассировку, установить точки прерывания, просмотреть состояние переменных, содержимое стека, файлов данных, изменить значение переменных и сделать многое другое.
Для запуска отладчика из среды разработки выберите из меню «Run» строку «Debugger». Перед этим вы можете задать параметры командной строки для отлаживаемого приложения. Для этого из указанного меню надо выбрать строку «Debugger Arguments. «.
После выбора строки «Debugger» на экране появится сообщение о загрузке отладчика, после чего экран переключится в текстовый режим. К сожалению, отладчик Turbo Debugger for Windows, который поставляется в комплекте со средой разработки Borland C++ for Windows версии 3.1, может работать только в текстовом режиме (среда разработки Borland C++ for Windows версии 4.0 содержит, помимо отдельного отладчика Turbo Debugger for Windows, отладчик, который встроен в среду разработки и работает в обычном окне Windows в графическом режиме). Несмотря на это, указанный отладчик не способен работать с видеоконтроллером EGA.
После запуска отладчика вы попадаете в среду, знакомую вам по отладчику Turbo Debugger для MS-DOS. В отладчике Turbo Debugger for Windows используются почти такие же функциональные клавиши и меню, что и в версии для MS-DOS. Из-за недостатка места в книге мы не будем описывать работу с отладчиком Turbo Debugger. Если вы разрабатывали программы для MS-DOS, вы скорее всего уже пользовались этим отладчиком. Поэтому мы ограничимся только несколькими замечаниями, которые относятся к отладке приложений Windows.
Первое замечание касается отладки функций обратного вызова, таких, как функция окна WndProc.
Так как структура стандартного приложения Windows отличается от линейной структуры программы MS-DOS, для отладки функций обратного вызова вам надо установить в них точки останова. В противном случае вы никогда не сможете отладить такие функции — при пошаговом выполнении приложения вы окажетесь в цикле обработки сообщений. Добраться до функций обратного вызова через пошаговое выполнение приложения невозможно, так как эти функции вызываются не из приложения, а из операционной системы Windows.
Если функция окна расположена в отдельном файле, для установки точки останова вам надо перейти в режим просмотра этого файла. Для просмотра модуля, расположенного в отдельном файле, выберите из меню отладчика «View» строку «Module». Вы окажитесь в диалоговой панели, с помощью которой можно выбрать имя модуля. Приложения, приведенные в нашей книге, используют для функции окна файл с именем wndproc.cpp, поэтому в появившейся диалоговой панели выберите строку «WNDPROC».
После этого в окне отладчика вы увидите исходный текст функции окна. Выберите нужное вам место и установите точку останова, нажав клавишу . Далее запустите приложение на выполнение, нажав клавишу . Когда будет достигнута установленная вами точка останова, отладчик переключится в пошаговый режим.
Второе замечание относится к просмотру экрана выполняющегося приложения.
Отладчик Turbo Debugger for Windows имеет дополнительные возможности по сравнению с версией для MS-DOS. В частности, с помощью этого отладчика можно протоколировать сообщения, которые получают и посылают окна вашего приложения, работать с глобальной и локальной памятью, просматривать полный список загруженных модулей, отлаживать библиотеки динамической загрузки DLL и просматривать содержимое любого селектора.
Для просмотра списка сообщений, получаемых функцией окна, выберите в отладчике из меню «View» строку «Windows Message». На экране появится диалоговая панель «Windows Message», разделенная на три части. В левой верхней части следует указать имя функции окна или идентификатор окна, для которого нужно протоколировать сообщения. В правой верхней части окна можно выбирать, какие сообщения следует отображать, а какие — игнорировать. Нижняя часть окна предназначена для отображения получаемых сообщений.
Выберите мышью левую верхнюю часть окна «Windows Message» и нажмите комбинацию клавиш . На экране появится меню из трех строк:
Выберите строку «Add. «. На экране появится диалоговая панель «Add window or handle to watch». В этой диалоговой панели установите переключатель «Identify by» в положение «Window proc» и в поле «Window identifier» введите имя функции окна, например wndproc. Затем нажмите кнопку «OK».
С помощью строк «Remove» и «Delete all» вы можете удалить отдельный или все идентификаторы или имена функций, для которых нужно протоколировать получаемые сообщения.
В правой верхней части диалоговой панели «Windows Message» находится надпись «Log all messages», которая означает, что будут протоколироваться все сообщения, поступающие в указанные вами окна. Если сообщений слишком много, вы можете выбрать для отображения только некоторые классы сообщений. Для этого выберите мышью правую верхнюю часть диалоговой панели «Windows Message» и нажмите комбинацию клавиш . Появится уже знакомое вам меню:
Выберите строку «Add. «. С помощью переключателя «Message class» вы можете выбрать различные классы отображаемых (протоколируемых) сообщений:
| Класс сообщения | Описание |
| All Messages | Все сообщения |
| Mouse | Сообщения от мыши |
| Window | Сообщения от системы управления окнами (такие, как WM_PAINT и WM_CREATE) |
| Input | Сообщения от клавиатуры, системного меню, полос просмотра или кнопок изменения размера |
| System | Системные сообщения |
| Initialization | Сообщения, которые появляются при создании приложением окна или диалоговой панели |
| Clipboard | Сообщения, которые создаются приложением при доступе к универсальному буферу обмена Clipboard или окну другого приложения |
| DDE | Сообщения, которые возникают в результате динамического обмена данными между приложениями с использованием механизма DDE |
| Non-client | Сообщения, которые создаются Windows для работы с внешней (non-client) областью окна (такие, как WM_NCHITTEST или WM_NCCREATE) |
| Other | Остальные сообщения, не попавшие в перечисленные выше классы, такие, как сообщения интерфейса MDI |
| Single Message | Любое выбранное вами сообщение. Символическое имя или десятичный идентификатор сообщения следует указать в поле «Single Message Name» |
С помощью переключателя «Action» вы можете задать действие, выполняемое отладчиком при перехвате сообщения. По умолчанию включен режим «Log», что соответствует протоколированию сообщения и отображению его в нижней части диалоговой панели «Windows Messages». Режим «Break» позволяет вам организовать останов приложения по сообщению.