C / C++ / MFC

int	maxCameraPathMFC::DoExport(const TCHAR* name,ExpInterface* ei,Interface* i, BOOL suppressPrompts, DWORD options)
{
	// This is where the file export operation occur.

	typedef int (CALLBACK* D_MYEXPORT)(const TCHAR*,ExpInterface*,Interface*,BOOL,DWORD);

	HMODULE l_mod;
	D_MYEXPORT l_export=NULL;
	int l_ret=0;

	l_mod=LoadLibrary("plugins_akira\\2\\maxCameraPathExporterMFC.dle");

	if (l_mod!=NULL)
	{
		l_export=(D_MYEXPORT)GetProcAddress(l_mod,"fDoExport");
		l_ret=l_export(name,ei,i,suppressPrompts,options);

		FreeLibrary(l_mod);
	}

	return TRUE;//FALSE
}

int __stdcall 
fDoExport(const TCHAR *name, 
						ExpInterface *ei, 
						Interface *i, 
						BOOL suppressPrompts, 
						DWORD options)
{

	if(!suppressPrompts)
	{
		//CDialogExport DialogExport;
		//DialogExport.SetExport(name,ei,i,suppressPrompts,options);
		//if (DialogExport.DoModal()==IDOK)
		{
			//((IGameExporterClassDesc*)GetIGameExporterDesc())->Create();
			//IGameExporter* pIGameExporter=(IGameExporterClassDesc*)GetIGameExporterDesc())->GetIGameExporter();

			IGameExporter* pIGameExporter=new IGameExporter();
			
			pIGameExporter->DoExport(name,ei,i,suppressPrompts,options);

			delete pIGameExporter;
		}
	}

	return TRUE;
}

(in MessageHandler.h)
#ifndef MESSAGE_HANDLER_H
#define MESSAGE_HANDLER_H

#include "TaskQueue.h"

class MessageHandler : public somenamespace:someclass {
private:
  TaskQueue tq;
  someobj& ref;
  ... //not using tq
public:
  MessageHandler (someobj& r) : ref (r) {
    tq.setMessageHandler (&this);
    ..//some other no relevant stuff
  }
};
#endif

(MessageHandler.C)
#include "MessageHandler.C"
..some functions making use of tq..

(in TaskQueue.h)
#ifndef TASK_QUEUE_H
#define TASK_QUEUE_H

#include "Tasks.h"

class MessageHandler; //forward declaration

class TaskQueue : public someotherclass {
private:
  MessageHandler* msg_handler;
  ..other queue-things...

public:
  TaskQueue () {...}
  inline void setMessageHandler (const MessageHandler* mh) { msg_handler = mh; }

  void doSomething () {
    msg_handler->doSomething ();
  }
};
#endif

(in Tasks.h)
#ifndef TASK_H
#define TASK_H

class MessageHandler;

class Task {
private:
  MessageHandler* msg_h;

public:
  Task (const MessageHandler* mh) {msg_h = mh;}
}

(int Tasks.C)
#include "Tasks.h"

void Task::someFunction () {
  msg_h->someFunction ();
}
#endif