factory_lab.cpp

设计模式

// Purpose.  Abstract Factory design pattern lab.
// 
// Problem.  #ifdef case statements are spread throughout the code to
// accomodate 3 different porting targets.  This makes maintenance
// difficult, and porting to a 4th platform onerous.
// 
// Assignment.
// o Create an abstract base class Factory.
// o Define pure virtual member functions createSocket(), createPipe(),
//   and createThread().
// o Subclass UnixFactory, VmsFactory, and NtFactory off of Factory.
// o Refactor the "create" free functions to be member functions of one of
//   the Factory derived classes.
// o Declare a Factory* pointer local to main().
// o Use a single #ifdef case statement in main() to instantiate the desired
//   Factory derived class.
// o Do not optimize-out the doOneLaneIPC(), doTwoLaneIPC(), and
//   doParallelProcessing() free functions.
// o Pass the Factory pointer to each of these free functions so that they
//   can create sockets, pipes, and threads without regard to race, creed,
//   or platform.
// o Supply the desired "compiler directive" at compile time.
// o Extra credit: implement the Factory class as a Singleton.
#include <iostream.h>
#define NULL 0
class Factory {
public:
	virtual void createSocket() = 0 {}
	virtual void createPipe() = 0 {}
	virtual void createThread() = 0 {}
};
class UnixFactory : public Factory {
public:
	void createSocket()  { cout << "createUnixSocket:" << endl; }
	void createPipe()    { cout << "createUnixPipe:" << endl; }
    void createThread()  { cout << "createUnixThread:" << endl; }
};
class VmsFactory : public Factory {
public:
    void createSocket()   { cout << "createVmsSocket:" << endl; }
	void createPipe()     { cout << "createVmsPipe:" << endl; }
	void createThread()   { cout << "createVmsThread:" << endl; }
};
class NtFactory : public Factory {
public:
    void createSocket()    { cout << "createNtSocket:" << endl; }
	void createPipe()      { cout << "createNtPipe:" << endl; }
    void createThread()    { cout << "createNtThread:" << endl; }
};

void doOneLaneIPC(Factory *factory) 
{
	if( factory  )
	   factory->createSocket();
}
void doTwoLaneIPC(Factory *factory)
{
	if( factory )
	factory->createPipe();
}
void doParallelProcessing(Factory *factory)
{
	if( factory )
	factory->createThread();
}
void main()
{
	Factory* factory = NULL;
	#ifdef UNIX
    factory = new UnixFactory();
    #elif VMS
    factory = new VmsFactory();
    #elif NT
    factory = new NtFactory();
    #endif
	if( factory )
	{
		doOneLaneIPC(factory);
		doTwoLaneIPC(factory);
		doParallelProcessing(factory);
		cout << "over" << endl;
	}
	else
    	cout << "factory is NULL" << endl;
}
/*
void createUnixSocket()  { cout << "createUnixSocket:" << endl; }
void createVmsSocket()   { cout << "createVmsSocket:" << endl; }
void createNtSocket()    { cout << "createNtSocket:" << endl; }
void createUnixPipe()    { cout << "createUnixPipe:" << endl; }
void createVmsPipe()     { cout << "createVmsPipe:" << endl; }
void createNtPipe()      { cout << "createNtPipe:" << endl; }
void createUnixThread()  { cout << "createUnixThread:" << endl; }
void createVmsThread()   { cout << "createVmsThread:" << endl; }
void createNtThread()    { cout << "createNtThread:" << endl; }

void doOneLaneIPC() {
#ifdef UNIX
   createUnixSocket();
#elif VMS
   createVmsSocket();
#elif NT
   createNtSocket();
#endif
}

void doTwoLaneIPC() {
#ifdef UNIX
   createUnixPipe();
#elif VMS
   createVmsPipe();
#elif NT
   createNtPipe();
#endif
}

void doParallelProcessing() {
#ifdef UNIX
   createUnixThread();
#elif VMS
   createVmsThread();
#elif NT
   createNtThread();
#endif
}


void main( void ) {
   doOneLaneIPC();
   doTwoLaneIPC();
   doParallelProcessing();
   cout << "main: complete" << endl;
}
*/
// -- current output --
// createVmsSocket:
// createVmsPipe:
// createVmsThread:
// main: complete

// -- target output --
// VmsFactory: createSocket
// VmsFactory: createPipe
// VmsFactory: createThread
// main: complete