IOC代码实例

下面代码是从实际代码工程中剥离出来的。类似于IOC模式。感觉蛮有用的。设计模式才是王道。

ProcesserFactory.h

#pragma once
#include <map>
#include <string>
#include "ICommand.h"

class Icommand;
#define COMMAND_BEGIN	void ProcesserFactory::addCommand() {
#define COMMAND_END		}
#define COMMAND_ADD( cmdName, cmdClass) { \
	ICommand * pObj = new cmdClass(); \
	std::string str = cmdName; \
	_cmdMap.insert(COMMAND_MAP::value_type(str, pObj)); }

class ProcesserFactory
{
	typedef std::map<std::string,ICommand*> COMMAND_MAP;
public:
	ProcesserFactory(void);
	~ProcesserFactory(void);
public:
	void addCommand();
	ICommand * getCommandProcesser(const char * pCmd);
private:
	
	COMMAND_MAP _cmdMap;
};

ProcesserFactory.cpp

#include "ProcesserFactory.h"

ProcesserFactory::ProcesserFactory(void)
{
}

ProcesserFactory::~ProcesserFactory(void)
{
}

ICommand * ProcesserFactory::getCommandProcesser(const char * pCmd)
{
	ICommand * pProcessor = NULL;
	do {
		COMMAND_MAP::iterator iter;
		iter = _cmdMap.find(pCmd);
		if(iter != _cmdMap.end()) {
			pProcessor = iter->second;
		}
	}while(0);
	return pProcessor;
}

ICommand.h

#pragma once

class ICommand
{
public:
	ICommand(void);
	~ICommand(void);
};

ICommand.cpp

#include "ICommand.h"

ICommand::ICommand(void)
{
}

ICommand::~ICommand(void)
{
}

Command.h

#pragma once
#include "ICommand.h"

#define TRACECOMMAND		"TraceCommand";
#define DEFALUTCOMMAND		"DefaultCommand";
#define CREATENODECOMMAND	"CreateNodeCommand";

class TraceCommand : public ICommand
{
public:
	TraceCommand(void) {}
	~TraceCommand(void){}
};

class DefaultCommand : public ICommand
{
public:
	DefaultCommand(void) {}
	~DefaultCommand(void){}
};

class CreateNodeCommand : public ICommand
{
public:
	CreateNodeCommand(void){}
	~CreateNodeCommand(void){}
};

Commands.cpp

#include "Commands.h"
#include "ProcesserFactory.h"

COMMAND_BEGIN
COMMAND_ADD(TRACECOMMAND,TraceCommand)
COMMAND_ADD(DEFALUTCOMMAND,DefaultCommand)
COMMAND_ADD(CREATENODECOMMAND,CreateNodeCommand)
COMMAND_END

Main.cpp

#include "ICommand.h"
#include "ProcesserFactory.h"
#include <iostream>
int main(int argc, char ** argv)
{
	ProcesserFactory* pf = new ProcesserFactory();
	ICommand * ic = pf->getCommandProcesser("TraceCommand");
}