Patrones de diseño C ++: Modelo abstracto de fábrica

Abstract Factory (modelo abstracto de fábrica) es crear un modelo para otras fábricas en torno a una super planta. El super planta, también conocida como la fábrica de la planta.

introducción

Intención: proporcionar una serie de objetos relacionados o dependientes de crear interfaces sin especificar sus clases concretas.

Principalmente para resolver: el problema principal de opciones de interfaz.

Cuándo usar: productos del sistema tienen más de una familia de productos, y el único sistema en el que una familia de productos de consumo.

¿Cómo resolver: en una familia de productos en el interior, definen varios productos.

El código de la llave: la agregación de múltiples productos similares en una fábrica.

Ejemplos de aplicación: el trabajo, con el fin de participar en algunas reuniones, debe haber dos o más conjuntos de ropa de TI con, por ejemplo, ropa de trabajo (juegos completos, una serie de productos específicos), vestido de la manera (juegos completos, una serie de productos específicos), incluso para una familia puede tener mujeres de negocios, de los hombres de negocios, la moda femenina, moda masculina, estos también son el conjunto de esa serie de productos específicos. Se asume que un caso (en realidad no existe, o de lo contrario, no el comunismo, pero es propicio para explicar el patrón de fábrica abstracta), en su casa, un armario (planta de hormigón) sólo puede almacenar una cierta clase de como esto ropa (juegos completos, una serie de productos específicos), cada vez que reciba este conjunto de ropa del armario de forma natural sacaron. Con el pensamiento programación orientada a objetos de entender, todo el armario (planta de hormigón) son la clase de armario (fábrica de resumen) uno, y cada uno de un conjunto de ropa y una chaqueta incluyendo específica (un producto en particular), pantalones (una específica producto), que de hecho son la capa de la chaqueta específica (productos abstractos), los pantalones son los pantalones específicos (otro producto abstracto).

Pros: Cuando una familia de productos de múltiples objetos están diseñados para el trabajo en conjunto cuando garantiza siempre los clientes utilizan sólo los objetos de la misma familia de productos.

Desventajas: la expansión de la familia de productos es muy difícil, para aumentar un producto de una serie, tanto en los códigos de creador Riga abstractos, sino también añadir el interior de código específico.

escenarios de uso:  1, QQ para la piel, un conjunto de cambio juntos. 2, generan diferentes procedimientos del sistema operativo.

Nota: La familia de productos es difícil de ampliar, fácil de expandir el nivel de producto.

 Código es el siguiente:

shape.h

#pragma once
class Shape
{
public:
	Shape();
	~Shape();
	virtual void draw() = 0;
};

class Circle :public Shape
{
public:
	Circle();
	~Circle() {};
	virtual void draw() override;
};

class Square :public Shape
{
public:
	Square();
	~Square() {};
	virtual void draw() override;
};

class Rectangle :public Shape
{
public:
	Rectangle();
	~Rectangle() {};
	virtual void draw() override;
};

shape.cpp

#include "Shape.h"
#include <iostream>
using namespace std;


Shape::Shape()
{
}


Shape::~Shape()
{
}

Circle::Circle() :Shape()
{
}

void Circle::draw()
{
	cout << "Circle::draw()\n";
}

Square::Square() :Shape()
{
}

void Square::draw()
{
	cout << "Square::draw()\n";
}

Rectangle::Rectangle() :Shape()
{
}

void Rectangle::draw()
{
	cout << "Rectangle::draw()\n";
}

color.h

#pragma once

class Color
{
public:
	Color();
	~Color();
	virtual void fill() = 0;
};

class Red :public Color
{
public:
	Red() :Color() {}
	~Red() {}
	virtual void fill();
};

class Green :public Color
{
public:
	Green() :Color() {}
	~Green() {}
	virtual void fill();
};

class Blue :public Color
{
public:
	Blue() :Color() {}
	~Blue() {}
	virtual void fill();
};

color.cpp

#include "Color.h"
#include <iostream>
using namespace std;


Color::Color()
{
}


Color::~Color()
{
}

void Red::fill()
{
	cout << "Red::fill()\n";
}

void Green::fill()
{
	cout << "Green::fill()\n";
}

void Blue::fill()
{
	cout << "Bule::fill()\n";
}

abstractFactory.h

#pragma once
class Shape;
class Color;

enum ShapeType
{
	CIRCLE_TYPE,
	SQUARE_TYPE,
	RECTANGLE_TYPE
};

enum ColorType
{
	RED_TYPE,
	GREEN_TYPE,
	BLUE_TYPE
};
class AbstractFactory
{
public:
	AbstractFactory();
	~AbstractFactory();
	virtual Shape *getShape(ShapeType shapeType) = 0;
	virtual Color *getColor(ColorType colorType) = 0;
};

class ShapeFactory :public AbstractFactory
{
public:
	ShapeFactory() :AbstractFactory() {}
	~ShapeFactory() {}
	 Shape *getShape(ShapeType shapeType);
	 Color *getColor(ColorType colorType) { return nullptr; }
};

class ColorFactory :public AbstractFactory
{
public:
	ColorFactory() :AbstractFactory() {}
	~ColorFactory() {}
	Shape *getShape(ShapeType shapeType) { return nullptr; };
	Color *getColor(ColorType colorType);
};

abstractFactory.cpp

#include "AbstractFactory.h"
#include "Shape.h"
#include "Color.h"


AbstractFactory::AbstractFactory()
{
}


AbstractFactory::~AbstractFactory()
{
}

Shape * ShapeFactory::getShape(ShapeType shapeType)
{
	if (shapeType == CIRCLE_TYPE)
	{
		return new Circle();
	}
	else if (shapeType == SQUARE_TYPE)
	{
		return new Square();
	}
	else if (shapeType == RECTANGLE_TYPE)
	{
		return new Rectangle();
	}
	else
	{
		return nullptr;
	}
}

Color * ColorFactory::getColor(ColorType colorType)
{
	if (colorType == RED_TYPE)
	{
		return new Red();
	}
	else if (colorType == GREEN_TYPE)
	{
		return new Green();
	}
	else if (colorType == BLUE_TYPE)
	{
		return new Blue();
	}
	else
	{
		return nullptr;
	}
}

FactoryProducer.h

#pragma once
class AbstractFactory;

enum FactoryType
{
	SHAPE_TYPE,
	COLOR_TYPE
};

class FactoryProducer
{
public:
	FactoryProducer();
	~FactoryProducer();
	AbstractFactory * getFactory(FactoryType factoryType);
};

FactoryProducer.cpp

#include "FactoryProducer.h"
#include "AbstractFactory.h"


FactoryProducer::FactoryProducer()
{
}


FactoryProducer::~FactoryProducer()
{
}

AbstractFactory * FactoryProducer::getFactory(FactoryType factoryType)
{
	if (factoryType == SHAPE_TYPE)
	{
		return new ShapeFactory();
	}
	else if (factoryType == COLOR_TYPE)
	{
		return new ColorFactory();
	}
	else
		return nullptr;
}

main.cpp

#include "Shape.h"
#include "Color.h"
#include "AbstractFactory.h"
#include "FactoryProducer.h"
#include <iostream>
using namespace std;

int main()
{
	FactoryProducer *pFactoryProducer = new FactoryProducer;
	AbstractFactory *pAbstractFactory1 = pFactoryProducer->getFactory(SHAPE_TYPE);
	Shape *pShape1 = pAbstractFactory1->getShape(CIRCLE_TYPE);
	pShape1->draw();
	Shape *pShape2 = pAbstractFactory1->getShape(SQUARE_TYPE);
	pShape2->draw();
	Shape *pShape3 = pAbstractFactory1->getShape(RECTANGLE_TYPE);
	pShape3->draw();

	AbstractFactory *pAbstractFactory2 = pFactoryProducer->getFactory(COLOR_TYPE);
	Color *pColor1 = pAbstractFactory2->getColor(RED_TYPE);
	pColor1->fill();
	Color *pColor2 = pAbstractFactory2->getColor(GREEN_TYPE);
	pColor2->fill();
	Color *pColor3 = pAbstractFactory2->getColor(BLUE_TYPE);
	pColor3->fill();

	delete pColor3;
	delete pColor2;
	delete pColor1;
	delete pAbstractFactory2;
	delete pShape3;
	delete pShape2;
	delete pShape1;
	delete pAbstractFactory1;
	delete pFactoryProducer;
	int d;
	cin >> d;
	return 0;
}

salida:

Circle::draw()
Square::draw()
Rectangle::draw()
Red::fill()
Green::fill()
Bule::fill()