设计模式系列之抽象工厂模式

//maskA.hpp
#ifndef MASKA_HPP
#define MASKA_HPP

class MaskAFigure{
  public:
    virtual ~MaskAFigure()=0;
  protected:
    MaskAFigure();
};

class MaskARound:public MaskAFigure {
  public:
    MaskARound();
    ~MaskARound();
};

class MaskARec:public MaskAFigure {
  public:
    MaskARec();
    ~MaskARec();
};

class MaskATri:public MaskAFigure {
  public:
    MaskATri();
    ~MaskATri();
};
#endif
//maskA.cpp
#include <iostream>
#include "maskA.hpp"

using std::cout;
using std::endl;

MaskAFigure::MaskAFigure() {

}

MaskAFigure::~MaskAFigure() {

}

MaskARound::MaskARound() {
  cout<<"Draw roundness on MaskA"<<endl;
}

MaskARound::~MaskARound() {

}

MaskARec::MaskARec() {
  cout<<"Draw rectangle on MaskA"<<endl;
}

MaskARec::~MaskARec() {

}

MaskATri::MaskATri() {
  cout<<"Draw triangle on MaskA"<<endl;
}

MaskATri::~MaskATri() {

}
//maskB.hpp
#ifndef MASKB_HPP
#define MASKB_HPP

class MaskBFigure{
  public:
    virtual ~MaskBFigure()=0;
  protected:
    MaskBFigure();
};

class MaskBRound:public MaskBFigure {
  public:
    MaskBRound();
    ~MaskBRound();
};

class MaskBRec:public MaskBFigure {
  public:
    MaskBRec();
    ~MaskBRec();
};

class MaskBTri:public MaskBFigure {
  public:
    MaskBTri();
    ~MaskBTri();
};

#endif
//maskB.cpp
#include <iostream>
#include "maskB.hpp"

using std::cout;
using std::endl;

MaskBFigure::MaskBFigure() {

}

MaskBFigure::~MaskBFigure() {

}

MaskBRound::MaskBRound() {
  cout<<"Draw roundness on MaskB"<<endl;
}

MaskBRound::~MaskBRound() {

}

MaskBRec::MaskBRec() {
  cout<<"Draw rectangle on MaskB"<<endl;
}

MaskBRec::~MaskBRec() {

}

MaskBTri::MaskBTri() {
  cout<<"Draw triangle on MaskB"<<endl;
}

MaskBTri::~MaskBTri() {

}
//abstractfactory.hpp
#ifndef ABSTRACT_MASKFACTORY_HPP
#define ABSTRACT_MASKFACTORY_HPP

#include "maskB.hpp"
#include "maskA.hpp"

class FigureFactory {
 public:
  virtual ~FigureFactory()=0;
  virtual MaskAFigure* CreateFigureA()=0;
  virtual MaskBFigure* CreateFigureB()=0;
 protected:
  FigureFactory();
};

class RoundFactory:public FigureFactory {
 public:
  RoundFactory();
  ~RoundFactory();
  MaskARound* CreateFigureA();
  MaskBRound* CreateFigureB();
};

class RecFactory:public FigureFactory {
 public:
  RecFactory();
  ~RecFactory();
  MaskARec* CreateFigureA();
  MaskBRec* CreateFigureB();
};

class TriFactory:public FigureFactory {
 public:
  TriFactory();
  ~TriFactory();
  MaskATri* CreateFigureA();
  MaskBTri* CreateFigureB();
};

#endif
//abstractfactory.cpp
#include <iostream>
#include "abstractfactory.hpp"

using std::cout;
using std::endl;

FigureFactory::FigureFactory() {

}

FigureFactory::~FigureFactory() {

}

RoundFactory::RoundFactory() {
  cout<<"Init RoundFactory"<<endl;
}

RoundFactory::~RoundFactory() {

}

MaskARound* RoundFactory::CreateFigureA() {
  return new MaskARound();
}

MaskBRound* RoundFactory::CreateFigureB() {
  return new MaskBRound();
}

RecFactory::RecFactory() {
  cout<<"Init RecFactory"<<endl;
}

RecFactory::~RecFactory() {

}

MaskARec* RecFactory::CreateFigureA() {
  return new MaskARec();
}

TriFactory::TriFactory() {
  cout<<"Init TriFactory"<<endl;
}

TriFactory::~TriFactory() {

}

MaskATri* TriFactory::CreateFigureA() {
  return new MaskATri();
}

MaskBTri* TriFactory::CreateFigureB() {
  return new MaskBTri();
}
//main.cpp
#include <iostream>
#include <memory>
#include "abstractfactory.hpp"

using std::cout;
using std::endl;
using std::shared_ptr;


int main() {
  shared_ptr<RoundFactory> rof(new RoundFactory());
  shared_ptr<MaskARound>    maro(rof->CreateFigureA());
  shared_ptr<MaskBRound>    mbro(rof->CreateFigureB());

  shared_ptr<RecFactory>   ref(new RecFactory());
  shared_ptr<MaskARec>    mare(ref->CreateFigureA());
  shared_ptr<MaskBRec>    mbre(ref->CreateFigureB());

  shared_ptr<TriFactory>  tif(new TriFactory());
  shared_ptr<MaskATri>    matr(tif->CreateFigureA());
  shared_ptr<MaskBTri>    mbtr(tif->CreateFigureB());
}