C / C++ / MFC

• Create a variable and initialise it (assigning NULL or using new)
  
• When the dialog should be created the first time check if the variable is NULL and call new if so
  
• Create the dialog
  
• When finished with the dialog, call DestroyWindow()
  
• If the allocated memory is not needed anymore, delete it and assign NULL to the variable
  
• When the variable goes out of scope, delete the memory (e.g. in the destructor of the class holding the variable)
  

Quote:

it is after do the create of the dialog and populate the control including allocating via new a Richedit and streaming data to it that something goes wrong all storage is allocated via new

#include <assert.h> // I am going to check packing at compile time (generates no code)
#include <stdbool.h> // This defines bool we will need it if not included already
#include <stdint.h> // C standard for fixed width types we want uint8_t .. we need to included if not already
#pragma pack(push, 1)
struct psw_s {								// Named the struct for compile time checks
	union {

		/* Variant 1 structure of first 128 bits */
		struct variant1 {
			uint8_t     sysmask;			/* System mask      (0 -  7) */
			uint8_t		pkey;				/* PSW Key          (8 - 11) */
			uint8_t    states;				/* EC,M,W,P bits   (12 - 15) */

			/*  guessing you want an Anonymous struct to match bit count on byte 3 */
			struct byte3_fields {
				uint8_t asc : 2;			/* Address space control  (16 - 17) */
				uint8_t cc : 2;				/* Condition code  (18 - 19) */
				uint8_t progmask : 4;		/* Program mask    (20 - 23) */
			};

			/* best guess at variant unions needed to match bit count on byte 4 */
			union {
				uint8_t     zerobyte;		/* Zeroes          (24 - 31) ... variant 1 */
				struct byte4_fields {		/* variant 2 anonymous struct */
					uint8_t zerobyte4 : 7;	/* Zeroes          (24 - 30) */
					bool amode64 : 1;		/* 64-bit addressing    (31) */
				};
			};

			struct byte5_fields {			/* Addressing mode (32 - 33) */
				bool amode : 1;				/* 31-bit addressing    (32) */
				bool zeroilc : 1;			/* 1=Zero ILC           (33) */
				uint8_t zerobyte5 : 6;		/* Zeroes          (34 - 39) */
			} AddrMode;
			uint8_t variant1_unused[11];	/* (40-127) .. 11 byte * 8bits = 88bits */
		};

		/* Variant 2 ... 16 byte array (first 128 bits) */
		char     ia[16];					/* Instruction address array */

		/* Just me messing around maybe 32bit is faster so lets define it */
		/* Variant 3 ... 4 uint32_t array (first 128 bits) */
		uint32_t ia32[4];                   /* Instruction address array as 32 bits */

	};
	char      amask[4];						/* Address wraparound mask   */
	char      intcode[2];					/* Interruption code         */
	BYTE     ilc;							/* Instruction length count  */
	BYTE     unused;
} PSW;
/* Run compile time check on struct that it packed correctly */
static_assert(offsetof(struct psw_s, amask) == 17, "Structure pack failed amask should be byte 17 in struct");
#pragma pack(pop)

leon de boer wrote:

you must have your warnings turn way down because really it should give a warning.

#pragma section("SharedSection",read,write,shared)
__declspec(allocate("SharedSection")) int counter = 0;

// Assuming
CHost::GetA() { return &m_A; }
CA::DoSomething { /* body */ }
// then
pHost->GetA()->DoSomething();
// is effectively
pHost->&m_A->DoSomething();
// or 
pHost->m_A.DoSomething();

// Can be also implemented as
CHost::DoSomethingWithA() { m_A.DoSomething(); }
// which is effectively called as
pHost->m_A.DoSomething();