Factory Pattern in C++0x: un piccolo esempio…

Qualche giorno fa l’amico Martino (che fra l’altro ha appena aperto un suo blog: in bocca al lupo!) mi ha sottoposto un bel problema, ossia creare un oggetto per creare altri oggetti (factory) usando i variadic template del C++0x per gestire il diverso numero di parametri di ciascun tipo di oggetto da creare.

Il problema

In altre parole, seguire il Factory Pattern ma consentire all’utente di impostare il corretto numero di parametri per ciascuna classe creata.

Ad esempio, se stiamo creando delle figure, un cerchio può richiedere (x, y, raggio => 3 parametri) mentre un rettangolo potrebbe richiedere le coordinate di due punti (x1, y1, x2, y2 => 4 parametri).

Quello che vogliamo realizzareè qualcosa che crei gli oggetti ma gestica anche ed opportunamente il diverso numero di parametri.

Al posto dei variadic_template, ho suggerito a Martino le più pratiche initializer_list (già trattate in precedenza).

Codice d’esempio

Eccovi quindi un piccolo codice-esempio riassuntivo, certamente limitato (il numero dei tipi è variabile, il tipo stesso no), ma che spero vi piaccia.

In aggiunta a tutto quanto detto poc’anzi, il codice mostra anche l’uso dei nuovi strongly-typed enums: si tratta di un nuovo modo per definire tipi enumerativi ma senza conversioni implicite da/verso interi (come avviene in linguaggi come il C#).

Inoltre è possibile definire esplicitamente il tipo interno per le varie costanti. Internamente si possono usare, ad esempio, unsigned int, ma dall’esterno l’enumerativo non ammette conversioni implicite al tipo interno: non a caso è detto “fortemente tipizzato”.

/**
 *	FILE      : FactoryPatternTest.cpp
 *	AUTHOR    : Gian Paolo "JP" Ghilardi (http://rejex.wordpress.com)
 *	LICENSE   : released under the terms of GPL v2.0 ("only")
 *	COMPILE   : g++ -Wall -Winline -pedantic -std=c++0x
 *	            FactoryPatternTest.cpp -o FactoryPatternTest
 *	PURPOSE   : simple C++0x example showing the new initializer list
 *	            and uniform initialization facilities applied to
 *	            Factory Pattern Design [5]
 *
 *	TESTED ON :
 *	- Windows 7, x86 32-bit, G++ 4.4.1
 *
 *	REFERENCES:
 *	[1]: http://en.wikipedia.org/wiki/C%2B%2B0x#Initializer_lists
 *	[2]: http://en.wikipedia.org/wiki/C%2B%2B0x#Type_inference
 *	[3]: http://en.wikipedia.org/wiki/C%2B%2B0x#Uniform_initialization
 *	[4]: http://en.wikipedia.org/wiki/C%2B%2B0x#Strongly_typed_enumerations
 *	[5]: http://en.wikipedia.org/wiki/Factory_pattern
 */

#include <cstdlib>
#include <iostream>

using namespace std;

// base class
struct Shape
{
	Shape(){}
	virtual void whoAmI() { cout << "I am a generic shape" << endl; }
};

// simple circle class (3 params required)
class Circle: public Shape
{
	private:
		double x;
		double y;
		double r;

	public:
		Circle(std::initializer_list<double> params)
		{
			if(params.size() != 3)
				throw string("Circle needs 3 params (x, y, radius)!");

			auto i = params.begin();
			x =  *i++;
			y =  *i++;
			r =  *i;
		}

		void whoAmI()
		{
			cout << "I am a circle (" << x << "," << y
					<< "," << r << ")" << endl;
		}
};

// simple square class (4 params required)
class Rectangle: public Shape
{
	private:
		double x1;
		double x2;
		double y1;
		double y2;

	public:
		Rectangle(std::initializer_list<double> params)
		{
			if(params.size() != 4)
				throw string("Rectangle needs 4 params (x1, y1, x2, y2)!");

			auto i = params.begin();
			x1 = *i++;
			y1 = *i++;
			x2 = *i++;
			y2 = *i;
		}
		virtual void whoAmI()
		{
			cout << "I am a rectangle (" << x1 << "," << y1 << ","
					<< x2 << "," << y2 << ")" << endl;
		}
};

// strongly-typed enum [4]
enum class ShapeType
{
	SHAPE, CIRCLE, RECTANGLE
};

Shape* make_shape(ShapeType type, std::initializer_list<double> params)
{
	return	(type == ShapeType::CIRCLE)    ? new Circle(params)    :
			(type == ShapeType::RECTANGLE) ? new Rectangle(params) :
					                         new Shape();
}

int main(int argc, char **argv)
{
	// create a circle...
	Shape* circle = make_shape(ShapeType::CIRCLE, { 1.0, 2.0, 3.0 });
	circle->whoAmI();

	// create a rectangle...
	Shape* rectangle = make_shape(ShapeType::RECTANGLE, { 0, 0, 10, 10 });
	rectangle->whoAmI();

	try
	{
		// this will raise an exception
		Shape* rectangleErr = make_shape(ShapeType::RECTANGLE, { 0, 0, 10, 10, 5 });
		rectangleErr->whoAmI();
	}
	catch(string ex)
	{
		cerr << ex << endl;
	}
	return EXIT_SUCCESS;
}

Il codice in esecuzione

Questo è l’output del programma in esecuzione (si noti che Eclipse CDT non supporta ancora le nuove feature del C++0x)…

P.S.: lanciare eccezioni dai/nei costruttori è perfettamente normale ed accettabile (cfr. FAQ).