C / C++ / MFC

LRESULT CALLBACK WndProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
    return DefWindowProc(hwnd, uMsg, wParam, lParam); 
}
  
WNDCLASSEX wndClass;
wndClass.cbClsExtra    = NULL;
wndClass.cbSize        = sizeof(WNDCLASSEX);
wndClass.cbWndExtra    = NULL;
wndClass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
wndClass.hCursor       = ::LoadCursor(NULL, IDC_ARROW);
wndClass.hIcon         = ::LoadIcon(NULL, IDI_APPLICATION);
wndClass.hIconSm       = ::LoadIcon(NULL, IDI_APPLICATION);
wndClass.hInstance     = AfxGetInstanceHandle();
wndClass.lpfnWndProc   = WndProc;
wndClass.lpszClassName = "MyWndClass";
wndClass.lpszMenuName  = NULL;
wndClass.style         = CS_CLASSDC;
  
RegisterClassEx(&wndClass);
  
HWND mHWnd = CreateWindowEx(0, "MyWndClass", "MyTitle", 
                            WS_CAPTION | WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_SYSMENU | WS_VISIBLE,
                            CW_USEDEFAULT, CW_USEDEFAULT, 800, 600, 
                            NULL, NULL, AfxGetInstanceHandle(), this);

LRESULT CALLBACK Window::msgRouter(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	//NOTE: The following messages may need to be handled here explicitly as they are sent
	//before CreateWindow() returns - WM_NCCREATE, WM_GETMINMAXINFO, WM_CREATE.
	
	if(msg == WM_NCCREATE)
	{
		//A window was created. Set the user data of the handle to the pointer passed in the call to createWindow()
		Window *window = reinterpret_cast<Window*>(reinterpret_cast<LPCREATESTRUCT>(lParam)->lpCreateParams);
		SetWindowLongPtr(hWnd, GWLP_USERDATA, reinterpret_cast<long>(window));
		return TRUE;
	}
	else
	{
		Window *window = (Window*)GetWindowLongPtr(hWnd, GWLP_USERDATA);

		if(window)
		{
			return window->wndProc(msg, wParam, lParam);
		}

		return DefWindowProc(hWnd, msg, wParam, lParam);
	}

	return DefWindowProc(hWnd, msg, wParam, lParam);
}

LRESULT CALLBACK Window::wndProc(UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch(msg)
	{
	case WM_CLOSE:
	case WM_DESTROY:
		PostQuitMessage(0);
		return 0;
	case WM_KEYDOWN:
		switch(wParam)
		{
		case VK_ESCAPE:
			PostQuitMessage(0);
			return 0;
		default:
			break;
		}
		break;
	default:
		break;
	}

	return DefWindowProc(mHWnd, msg, wParam, lParam);
}

LRESULT CALLBACK Window::msgRouter(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	//NOTE: The following messages may need to be handled here explicitly as they are sent
	//before CreateWindow() returns - WM_NCCREATE, WM_GETMINMAXINFO, WM_CREATE.
	
	if(msg == WM_CREATE)
	{
		//A window was created. Set the user data of the handle to the pointer passed in the call to createWindow()
		Window *window = reinterpret_cast<Window*>(reinterpret_cast<LPCREATESTRUCT>(lParam)->lpCreateParams);
		SetWindowLongPtr(hWnd, GWLP_USERDATA, reinterpret_cast<long>(window));
		return TRUE;
	}
	else
	{
		Window *window = (Window*)GetWindowLongPtr(hWnd, GWLP_USERDATA);

		if(window)
		{
			return window->wndProc(msg, wParam, lParam);
		}
	}

	return DefWindowProc(hWnd, msg, wParam, lParam);
}

#include <stdio.h>


enum SerialType
{
  eTYPE_UNRECOGNIZED,
  eTYPE_A,
  eTYPE_B,
  eTYPE_C,
  eTYPES
};

struct A
{
  int id;
  int data;
};

struct B
{
  int id;
  float data;
};

struct C
{
  int id;
  double data;
  int data2;
}; 


size_t getSize(SerialType st)
{
  switch( st)
  {
  case eTYPE_A: 
    return sizeof(A);
  case eTYPE_B: 
    return sizeof(B);
  case eTYPE_C: 
    return sizeof(C);
  default:
    return 0;
  }
}

bool store( SerialType st, void * pData, FILE * fp)
{
  int type = st;
  size_t size = getSize(st);

  if (!fp || !pData || !size) return false;
  fwrite(&type, sizeof(type), 1, fp);
  fwrite(pData, size,1,fp);
  return true;
}

SerialType readType( FILE * fp)
{
  SerialType type;
  if (!fp ) return eTYPE_UNRECOGNIZED;

  if ( fread(&type, sizeof(type), 1, fp) == 0 ) return eTYPE_UNRECOGNIZED;
  return type;
}

bool readData( SerialType st, void * pData, FILE * fp)
{
  size_t size = getSize(st);
  if ( !fp || !pData || !size ) return false;
  fread(pData, size, 1, fp);
  return true;
}

void main()
{
  SerialType type;

  A a[2];
  B b;
  C c1,c2;

  A * pa=NULL;
  B * pb=NULL;
  C * pc=NULL;

  // define some variables
  a[0].data = 5;
  a[0].id = 12;

  a[1].data = 6;
  a[1].id = 13;
  
  b.data=25.75f;
  b.id=100;


  c1.data = 27;
  c1.data2=35;
  c1.id = 7;

  c2.data=1000.372;
  c2.data2=1000;
  c2.id=1;

 
  FILE * fp = fopen("data.raw", "wb");

  // store some of the defined variables
  store(eTYPE_C, &c2, fp);
  store(eTYPE_A, &a[1], fp);
  store(eTYPE_B, &b, fp);
  store(eTYPE_A, &a[0], fp);

  fclose(fp);



  // read the variables from the storage, printing their values.
  fp = fopen("data.raw", "rb");

  while ((type=readType(fp)) != eTYPE_UNRECOGNIZED)
  {
    switch (type)
    {
    case eTYPE_A:
      pa = new A();
      readData(type, pa, fp);
      printf("type A,  id=%d, data=%d.\n", pa->id, pa->data);
      delete pa;
      break;
    case eTYPE_B:
      pb = new B();
      readData(type, pb, fp);
      printf("type B,  id=%d, data=%g.\n", pb->id, pb->data);
      delete pb;
    break;
    case eTYPE_C:
      pc = new C();
      readData(type, pc, fp);
      printf("type C,  id=%d, data=%g, data2=%d.\n", pc->id, pc->data, pc->data2);
      delete pb;
    break;
    }
  }
  fclose(fp);
}