What is a Windows Handle

Question

What is a  Handle  when discussing resources in Windows   How do they work

User · Answer

So at the most basic level a HANDLE of any sort is a pointer to a pointer or

#define HANDLE void **

Now as to why you would want to use it

Lets take a setup:

class Object{
   int Value;
}

class LargeObj{

   char * val;
   LargeObj()
   {
      val = malloc(2048 * 1000);
   }

}

void foo(Object bar){
    LargeObj lo = new LargeObj();
    bar.Value++;
}

void main()
{
   Object obj = new Object();
   obj.val = 1;
   foo(obj);
   printf("%d", obj.val);
}

So because obj was passed by value (make a copy and give that to the function) to foo, the printf will print the original value of 1.

Now if we update foo to:

void foo(Object * bar)
{
    LargeObj lo = new LargeObj();
    bar->val++;
}

There is a chance that the printf will print the updated value of 2. But there is also the possibility that foo will cause some form of memory corruption or exception.

The reason is this while you are now using a pointer to pass obj to the function you are also allocating 2 Megs of memory, this could cause the OS to move the memory around updating the location of obj. Since you have passed the pointer by value, if obj gets moved then the OS updates the pointer but not the copy in the function and potentially causing problems.

A final update to foo of:

void foo(Object **bar){
    LargeObj lo = LargeObj();
    Object * b = &bar;
    b->val++;
}

This will always print the updated value.

See, when the compiler allocates memory for pointers it marks them as immovable, so any re-shuffling of memory caused by the large object being allocated the value passed to the function will point to the correct address to find out the final location in memory to update.

Any particular types of HANDLEs (hWnd, FILE, etc) are domain specific and point to a certain type of structure to protect against memory corruption.

User · Answer

A HANDLE is a context-specific unique identifier  By context-specific  I mean that a handle obtained from one context cannot necessarily be used in any other aribtrary context that also works on HANDLEs   For example  GetModuleHandle returns a unique identifier to a currently loaded module  The returned handle can be used in other functions that accept module handles  It cannot be given to functions that require other types of handles  For example  you couldn t give a handle returned from GetModuleHandle to HeapDestroy and expect it to do something sensible   The HANDLE itself is just an integral type  Usually  but not necessarily  it is a pointer to some underlying type or memory location  For example  the HANDLE returned by GetModuleHandle is actually a pointer to the base virtual memory address of the module  But there is no rule stating that handles must be pointers  A handle could also just be a simple integer  which could possibly be used by some Win32 API as an index into an array    HANDLEs are intentionally opaque representations that provide encapsulation and abstraction from internal Win32 resources  This way  the Win32 APIs could potentially change the underlying type behind a HANDLE  without it impacting user code in any way  at least that s the idea    Consider these three different internal implementations of a Win32 API that I just made up  and assume that Widget is a struct   Widget   GetWidget  std  string name        Widget  w       w   findWidget name        return w      void   GetWidget  std  string name        Widget  w       w   findWidget name        return reinterpret cast lt void   gt  w       typedef void   HANDLE   HANDLE GetWidget  std  string name        Widget  w       w   findWidget name        return reinterpret cast lt HANDLE gt  w       The first example exposes the internal details about the API  it allows the user code to know that GetWidget returns a pointer to a struct Widget  This has a couple of consequences    the user code must have access to the header file that defines the Widget struct the user code could potentially modify internal parts of the returned Widget struct    Both of these consequences may be undesirable   The second example hides this internal detail from the user code  by returning just void    The user code doesn t need access to the header that defines the Widget struct    The third example is exactly the same as the second  but we just call the void   a HANDLE instead  Perhaps this discourages user code from trying to figure out exactly what the void   points to   Why go through this trouble  Consider this fourth example of a newer version of this same API   typedef void   HANDLE   HANDLE GetWidget  std  string name        NewImprovedWidget  w       w   findImprovedWidget name        return reinterpret cast lt HANDLE gt  w       Notice that the function s interface is identical to the third example above  This means that user code can continue to use this new version of the API  without any changes  even though the  behind the scenes  implementation has changed to use the NewImprovedWidget struct instead   The handles in these example are really just a new  presumably friendlier  name for void    which is exactly what a HANDLE is in the Win32 API  look it up at MSDN   It provides an opaque wall between the user code and the Win32 library s internal representations that increases portability  between versions of Windows  of code that uses the Win32 API

User · Answer

A HANDLE in Win32 programming is a token that represents a resource that is managed by the Windows kernel   A handle can be to a window  a file  etc   Handles are simply a way of identifying a particulate resource that you want to work with using the Win32 APIs   So for instance  if you want to create a Window  and show it on the screen you could do the following      Create the window HWND hwnd   CreateWindow        if   hwnd     return     hwnd not created     Show the window  ShowWindow hwnd  SW SHOW     In the above example HWND means  a handle to a window     If you are used to an object oriented language you can think of a HANDLE as an instance of a class with no methods who s state is only modifiable by other functions   In this case the ShowWindow function modifies the state of the Window HANDLE     See Handles and Data Types for more information

User · Answer

A handle is a unique identifier for an object managed by Windows  It s like a pointer  but not a pointer in the sence that it s not an address that could be dereferenced by user code to gain access to some data  Instead a handle is to be passed to a set of functions that can perform actions on the object the handle identifies

User · Answer

It s an abstract reference value to a resource  often memory or an open file  or a pipe   Properly  in Windows   and generally in computing  a handle is an abstraction which hides a real memory address from the API user  allowing the system to reorganize physical memory transparently to the program   Resolving a handle into a pointer locks the memory  and releasing the handle invalidates the pointer   In this case think of it as an index into a table of pointers    you use the index for the system API calls  and the system can change the pointer in the table at will   Alternatively a real pointer may be given as the handle when the API writer intends that the user of the API be insulated from the specifics of what the address returned points to  in this case it must be considered that what the handle points to may change at any time  from API version to version or even from call to call of the API that returns the handle  - the handle should therefore be treated as simply an opaque value meaningful only to the API   I should add that in any modern operating system  even the so-called  real pointers  are still opaque handles into the virtual memory space of the process  which enables the O S to manage and rearrange memory without invalidating the pointers within the process

User · Answer

Think of the window in Windows as being a struct that describes it   This struct is an internal part of Windows and you don t need to know the details of it   Instead  Windows provides a typedef for pointer to struct for that struct   That s the  handle  by which you can get hold on the window

User · Answer

A handle is like a primary key value of a record in a database   edit 1  well  why the downvote  a primary key uniquely identifies a database record  and a handle in the Windows system uniquely identifies a window  an opened file  etc  That s what I m saying

[windows] What is a Windows Handle?

Examples related to windows

Examples related to handle