首先介绍我通过这题所理解的抽象工厂:所谓抽象工厂,就是把一些类看做工厂类,专门用来new产品类,而产品类所要实现的就是构造函数,和一些简单的方法。这种写法的好处在于,有效地提高了代码的封装性,符合面向对象的需求。
下面是题目的代码。
Client.cpp
#include <iostream>
#include <string>
#include "Factory.hpp"
#include "Product.hpp"
int main() {
UIFactory* ui = 0;
int choose;
std::cin >> choose;
switch (choose) {
case 0:
ui = new MFCUIFactory();
break;
case 1:
ui = new GtkUIFactory();
break;
case 2:
default:
ui = new QtUIFactory();
}
/* Use the factory to build interface. */
Window* toolbox = ui->getToolboxWindow();
Window* layers = ui->getLayersWindow();
Window* main = ui->getMainWindow();
/* See what have we recieved. */
std::cout << toolbox->getToolkit() << ":" << toolbox->getType() << std::endl;
std::cout << layers->getToolkit() << ":" << layers->getType() << std::endl;
std::cout << main->getToolkit() << ":" << main->getType() << std::endl;
ui->deleteWindow(toolbox);
ui->deleteWindow(layers);
ui->deleteWindow(main);
delete ui;
}
factory,hpp
#ifndef FACTORY
#define FACTORY
#include "Product.hpp"
class UIFactory {
public:
virtual Window* getToolboxWindow() = 0;
virtual Window* getLayersWindow() = 0;
virtual Window* getMainWindow() = 0;
void deleteWindow(Window* w) {
if (w != NULL) {
delete w;
}
}
};
/* Factory for Gtk toolkit */
class GtkUIFactory : public UIFactory {
public:
Window* getToolboxWindow() { return new GtkToolboxWindow(); }
Window* getLayersWindow() { return new GtkLayersWindow(); }
Window* getMainWindow() { return new GtkMainWindow(); }
};
/* Factory for Qt toolkit */
class QtUIFactory : public UIFactory {
public:
Window* getToolboxWindow() { return new QtToolboxWindow(); }
Window* getLayersWindow() { return new QtLayersWindow(); }
Window* getMainWindow() { return new QtMainWindow(); }
};
/* Factory for MFC toolkit */
class MFCUIFactory : public UIFactory {
public:
Window* getToolboxWindow() { return new MFCToolboxWindow(); }
Window* getLayersWindow() { return new MFCLayersWindow(); }
Window* getMainWindow() { return new MFCMainWindow(); }
};
#endif
Product.hpp
#ifndef PRODUCT
#define PRODUCT
#include <iostream>
#include <string>
class Window {
protected:
int width;
int height;
std::string toolkit;
std::string type;
Window(std::string usedToolkit, std::string windowType)
: toolkit(usedToolkit), type(windowType) {}
public:
virtual ~Window() {}
std::string getToolkit() { return toolkit; }
std::string getType() { return type; }
};
class GtkToolboxWindow : public Window {
public:
GtkToolboxWindow() : Window("Gtk", "ToolboxWindow") {}
};
class GtkLayersWindow : public Window {
public:
GtkLayersWindow() : Window("Gtk", "LayersWindow") {}
};
class GtkMainWindow : public Window {
public:
GtkMainWindow() : Window("Gtk", "MainWindow") {}
};
class QtToolboxWindow : public Window {
public:
QtToolboxWindow() : Window("Qt", "ToolboxWindow") {}
};
class QtLayersWindow : public Window {
public:
QtLayersWindow() : Window("Qt", "LayersWindow") {}
};
class QtMainWindow : public Window {
public:
QtMainWindow() : Window("Qt", "MainWindow") {}
};
class MFCToolboxWindow : public Window {
public:
MFCToolboxWindow() : Window("MFC", "ToolboxWindow") {}
};
class MFCLayersWindow : public Window {
public:
MFCLayersWindow() : Window("MFC", "LayersWindow") {}
};
class MFCMainWindow : public Window {
public:
MFCMainWindow() : Window("MFC", "MainWindow") {}
};
#endif
以上是+7大神的十分透彻的代码, 但是一开始我对这个的理解不透彻,故此只是实现了功能,但是没有体现出抽象工厂,毕竟提前了太多。
一下是我的实现方法
My.hpp
#include <iostream>
using namespace std;
class Window {
public:
string kit;
string type;
Window(string _kit, string _type) {
kit = _kit;
type = _type;
}
string getToolkit() {return kit;}
string getType() {return type;}
};
class UIFactory {
public:
virtual Window* getToolboxWindow() =0;
virtual Window* getLayersWindow() =0;
virtual Window* getMainWindow() =0;
void deleteWindow(Window *type) {
delete type;
}
};
class MFCUIFactory : public UIFactory {
virtual Window* getToolboxWindow() {
Window* a = new Window("MFC", "ToolboxWindow");
return a;
}
virtual Window* getLayersWindow() {
Window* a = new Window("MFC", "LayersWindow");
return a;
}
virtual Window* getMainWindow() {
Window* a = new Window("MFC", "MainWindow");
return a;
}
};
class GtkUIFactory : public UIFactory {
virtual Window* getToolboxWindow() {
Window* a = new Window("Gtk", "ToolboxWindow");
return a;
}
virtual Window* getLayersWindow() {
Window* a = new Window("Gtk", "LayersWindow");
return a;
}
virtual Window* getMainWindow() {
Window* a = new Window("Gtk", "MainWindow");
return a;
}
};
class QtUIFactory : public UIFactory {
virtual Window* getToolboxWindow() {
Window* a = new Window("Qt", "ToolboxWindow");
return a;
}
virtual Window* getLayersWindow() {
Window* a = new Window("Qt", "LayersWindow");
return a;
}
virtual Window* getMainWindow() {
Window* a = new Window("Qt", "MainWindow");
return a;
}
};
我的代码不够优美, 很多地方可以直接一句 return new Window("xxx", "xxx");
可以解决的,但是多写了一些。
总的来说这题不难,主要是在于掌握抽象工厂的概念。