抽象工厂的初次尝试 （(15c++ Homework) polymorphic and OOP design pattern Abstract Factory）

  首先介绍我通过这题所理解的抽象工厂：所谓抽象工厂，就是把一些类看做工厂类，专门用来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;
}

从中可以分辨出， Window这个类，明显是通过其他类的方法所生成的，那么Window这个类就是产品类（Product），而生成它的类，就是工厂类（factory）

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"); 

可以解决的，但是多写了一些。

总的来说这题不难，主要是在于掌握抽象工厂的概念。