ATL / WTL / STL

Jim Fell wrote:

http://code.msdn.microsoft.com/windowshardware/USBView-sample-application-e3241039

typedef std::multimap<int,int> MyMap;
MyMap global_map;

void my_func()
{
    // We create a new map instance and we swap its contents with the other "big" container instance.
    // This swap operation replaces the pointers inside the two containers so after the swap() the
    // global_map contains the small newly allocated blocks, and empty_map contains the big mem blocks
    // previously owned by global_map. Note: when empty_map runs out of scope it releases the big block.
    // This trick works with other stl container types too.
    MyMap empty_map;
    empty_map.swap(global_map);
}

bkelly13 wrote:

How should the arguments to Send() be written?

int chars_sent = m_C_Server_Send_Time_Socket->Send((const void*)&m_current_time, t1,   0 );

SYSTEMTIME m_current_time;
GetSystemTime( &m_current_time );
int t1 = sizeof( m_current_time );
// This is the case where you try to convert your instance into a pointer incorrectly:
int chars_sent = m_C_Server_Send_Time_Socket->Send( (LPCTSTR) m_current_time, t1,   0 );
// Here is the correct way to do that:
int chars_sent = m_C_Server_Send_Time_Socket->Send( (LPCTSTR) &m_current_time, t1,   0 );
// Note that every pointer can be converted into (const void*)
//  so the cast is totally unnecessary and you can write simply:
int chars_sent = m_C_Server_Send_Time_Socket->Send( &m_current_time, t1, 0 );

SYSTEMTIME m_current_time;

// The following steps the pointer with sizeof(SYSTEMTIME) bytes in memory!!!!!
// The resulting pointer points to the first byte that follows the last byte of your struct.
SYSTEMTIME* p = &m_current_time + 1;

//Since pointers and arrays in C/C++ work very similarly the above code is identical to this:
SYSTEMTIME* p = &(&m_current_time)[1];
//Pointer arithmetic and array indexing behave very similarly.

// The following expressions step the pointer just by 1 byte (sizeof(char)) in memory!!!!!
// We basically index into our struct as if it was a byte array...
// This is what MS guys wanted to do but in some cases (with unicode character setting)
// their code steps the pointer with 2 byte granularity (sizeof(whcar_t)) that is a bug.
char* p = (char*)&m_current_time + 1;

// The statements below are also valid because <code>char*</code> (like any other non-const
// pointer) is automatically casted to both <code>void*</code> and <code>const void*</code>.
void* p = (char*)&m_current_time + 1;
const void* p = (char*)&m_current_time + 1;