Home Library Learn Downloads Support Community
Sign in | United States - English | |
4 out of 5 rated this helpful - Rate this topic

CoTaskMemAlloc function

Applies to: desktop apps | Metro style apps

Allocates a block of task memory in the same way that IMalloc::Alloc does.

Syntax

Copy 
LPVOID CoTaskMemAlloc(
  __in  SIZE_T cb
);

Parameters

cb [in]

The size of the memory block to be allocated, in bytes.

Return value

If the function succeeds, it returns the allocated memory block. Otherwise, it returns NULL.

Remarks

CoTaskMemAlloc uses the default allocator to allocate a memory block in the same way that IMalloc::Alloc does. It is not necessary to call the CoGetMalloc function before calling CoTaskMemAlloc.

The initial contents of the returned memory block are undefined – there is no guarantee that the block has been initialized. The allocated block may be larger than cb bytes because of the space required for alignment and for maintenance information.

If cb is 0, CoTaskMemAlloc allocates a zero-length item and returns a valid pointer to that item. If there is insufficient memory available, CoTaskMemAlloc returns NULL. Applications should always check the return value from this function, even when requesting small amounts of memory, because there is no guarantee that the memory will be allocated.

Requirements

Minimum supported client

Windows 2000 Professional

Minimum supported server

Windows 2000 Server

Header
Objbase.h

Library
Ole32.lib

DLL
Ole32.dll

See also

CoTaskMemFree
CoTaskMemRealloc
IMalloc::Alloc

 

 

Send comments about this topic to Microsoft

Build date: 3/7/2012

Did you find this helpful?
(1500 characters remaining)
Community Content Add
Annotations FAQ
64-bit size argument
You might use this via P/Invoke to allocate a block that is larger than 2 GB at a time; the native function takes a native int (IntPtr), which is 64-bits wide on x64. The Marshal.AllocCoTaskMem method, in contrast, takes a 32-bit integer (int), and can't allocate more than 2 GB per block.

I note that the garbage collected heap .Net uses (as of 4.0) doesn't support individual allocations larger than 2 GB either; but you can access a block that large using pointers or the SafeBuffer class.
History
vb.net syntax 
<DllImport("ole32.dll")> Public Shared Function CoTaskMemAlloc(ByVal cb As IntPtr) As IntPtr
End Function
History
C# syntax 
[DllImport("ole32.dll")]
public static extern IntPtr CoTaskMemAlloc(IntPtr cb);
History
Why P/Invoke?
Why bother with those P/Invoke methods when you can just call Marshal.AllocCoTaskMem?

dmex: for example, you would use these P/Invoke methods if you wanted to change the return of Marshal.AllocCoTaskMem to a SafeBuffer to ensure all allocations are freed.
History