C / C++ / MFC

Cedric Moonen wrote:

CString provides a cast operator that returns the same type as the GetBuffer function.

TRUE if the menu can be displayed; otherwise, FALSE. 

BOOL CFieldPane::OnShowControlBarMenu(CPoint point)
{
  return TRUE;
}

BOOL CFieldPane::OnShowControlBarMenu(CPoint point)
{
  return FALSE;
}

typedef struct{ // size, offset 32 bits, offset 64 bits
  int   nCount;    //  4,  0,  0
  short nMode;     //  2,  4,  4 <- ???
  sHue  sColor;    //  8,  8,  8
  char* pTest;     //  4, 16, 16
  __declspec( align(8))
  char  aData[10]; // 10, 24, 24
}sStack,*psStack;  // 28 (real) -> 40 (sizeof 32 bits), 40 (sizeof 64 bits)

typedef  struct
{
	int nCount;
	short nMode;
	sHue sColor;
	__int64 pTest;
	char aData[10];
} sStack,*psStack;

Specifies the value, in bytes, to be used for packing. The default value for n is 8. Valid values are 1, 2, 4, 8, and 16. The alignment of a member will be on a boundary that is either a multiple of n or a multiple of the size of the member, whichever is smaller.

Kochise wrote:

I imagine it would be kind to pack the whole struct in a #pragma pack(1) fashion for message-passing, yet rendering it useless for run-time usage due to alignment fault that could arise

int main()
{
   char x[] = {1,2,3,4,5,6,7,8};
   int* pp = (int*)(x+1);
   std::cout << std::hex << (*pp) << std::endl;
}

typedef struct{ // size, offset 32 bits, offset 64 bits
    int  nCount  : 32;    //  4,  0,  0
    int  nMode   : 16;     //  2,  4,  4 <- ???
    int  sColor  : 8;    //  8,  8,  8
    int  pTest   : 32;     //  4, 16, 16
    int  aData0_3  : 32; // 10, 20, 24
    int  aData4_7  : 32; // 10, 20, 24
    int  aData8_9  : 16; // 10, 20, 24
    
  }sStack,*psStack;

sStack Deserialize(BYTE* pBuffer, size_t nBytes)
{
   _ASSERTE(nBytes >= 4 + 2 + 1 + 8 + 4 + 10);
   sStack s;
   s.nCount = *(int*)pBuffer;
// etc etc
   return s;
}

#pragma pack(push, 8)
typedef  struct{
	int   nCount;	
	short nMode;	
	sHue  sColor;
	union {
		char*    pTest;  // used by sender
		__int64  hTest;  // used by receiver
	};
	char aData[10];
} sStack,*psStack;
#pragma pack(pop)

#include <<foreign_lib.h>>

/* ======== foreign_lib.h ========
typedef struct foreign_struct
{ char  nMode;
  float fValue;
  int*  pArray;
};

foreign_struct* get_struct(void);
=== I HAVE NO CONTROL OVER THIS === */

// int send_frame(void* pBuffer, size_t nSize);

int test_struct(foreign_struct* frame)
{
#pragma pack(2)
  struct foreign_struct sFrame;
#pragma pack()

// foreign_struct : native struct format
// sFrame : my packed struct frame

  if(send_frame(frame, sizeof(foreign_struct))
  == send_frame(&sFrame, sizeof(sFrame)))
    return (int) TRUE;
  else
    return (int) FALSE;
}

int main(int argc, char *argv[])
{
  return test_struct(get_struct());
}

svt gdwl wrote:

protected mode