Newsgroup: it.comp.lang.c++
Titolo: Class Object Factories, Template e mal di testa

Salve a tutti, questo
Sto portando avanti un pseudo-libreria per reti neurali. Per renderne
più semplice l'utilizzo volevo fare in modo di instanziare la classe
che utilizza lo specifico algoritmo specificandolo attraverso una
stringa...
/* ------Neuron.h--------*/
#include <math.h>
namespace Mnetlib
{
class Neuron
{
	public:
		virtual ~Neuron(){};
		virtual double Run(double arg)=0;
		virtual double RunBack(double o,double e)=0;
	protected:
		double outvalue;
		int mode;
		double input;
};
/* ------Layer.h--------*/
#include <vector>
#include "Neuron.h"
#include "Exception.h"
namespace Mnetlib
{
	class Layer
	{
	public:
		/**
		 * Costruttore di base.
		 * @param n Numero di neuroni presenti nel layer.
		 */
		Layer(int n);
		virtual ~Layer()=0;
                virtual void backprop(){throw new
InstantiationException();};
	protected:
		std::vector<Neuron*> vect;
		int num;
	};
}
/* ------Registry.h--------*/
#include "NeuronLib.h"
#include "LayerLib.h"
#include "Factory.h"
#include <map>
namespace Mnetlib
{
	class Registry
	{
	public:
		Registry();
		~Registry();
		Neuron * getNewNeuron(const std::string& name);
		void registerNeuronFactory( NeuronClassFactory* factory)
		{
			_neuronRegistry[factory->name()]=factory;
		}
		void registerLayerFactory( LayerClassFactory* factory)
		{
			_layerRegistry[factory->name()]=factory;
		}
		Layer* getLayer (const std::string& lName, const std::string& nName,
int n);
	protected:
			std::map<std::string,NeuronClassFactory*> _neuronRegistry;
			std::map<std::string, LayerClassFactory*> _layerRegistry;
			NeuronFactoryWrapper<SigmoidNeuron> sigmoidFactory;
			NeuronFactoryWrapper<LinearNeuron> linearFactory;
			LayerFactoryWrapper<OffLineLayer> offFactory;
			LayerFactoryWrapper<OnLineLayer> onFactory;
	};
}
/* ------Factory.h--------*/
#include "Neuron.h"
#include "Layer.h"
namespace Mnetlib
{
	class NeuronClassFactory
	{
	public:
		virtual ~NeuronClassFactory(){};
		virtual Neuron* create()=0;
		virtual std::string name()=0;
	};
	template < class T >
	class NeuronFactoryWrapper : public NeuronClassFactory
	{
	public:
	virtual ~NeuronFactoryWrapper(){};
	virtual Neuron* create(){ return T::create();}
	virtual std::string name(){ return T::name();}
	};
	class LayerClassFactory
	{
	public:
		virtual ~LayerClassFactory(){};
		virtual Layer* create()=0;
		virtual std::string name()=0;
	};
	template < class T >
	class LayerFactoryWrapper : public LayerClassFactory
	{
	public:
	virtual ~LayerFactoryWrapper(){};
	virtual Layer* create(){ return T::create();}
	virtual std::string name(){ return T::name();}
	void build();
	};
}
/* ------NeuronLib.h--------*/
#include "Neuron.h"
#include <string>
namespace Mnetlib
{
class LinearNeuron: public Neuron
{
public:
	~LinearNeuron(){};
	double Run(double arg);
	double RunBack(double o,double e);
	static LinearNeuron* create(){ return new LinearNeuron();};
	static std::string name(){ return "linear";} ;
};
class SigmoidNeuron: public Neuron
{
public:
	~SigmoidNeuron(){};
	double Run(double arg);
	double RunBack(double o,double e);
	static SigmoidNeuron* create(){ return new SigmoidNeuron();};
	static std::string name(){ return "sigmoid";} ;
};
}
/* ------LayerLib.h--------*/
#include <string>
#include "Layer.h"
namespace Mnetlib
{
	class OnLineLayer : public Layer
	{
	public:
		OnLineLayer(int n);
		~OnLineLayer(){};
		static OnLineLayer* create(int n){ return new OnLineLayer(n);};
		static std::string name(){ return "online";} ;
		void backprop();
	};
	class OffLineLayer : public Layer
	{
	public:
		OffLineLayer();
		~OffLineLayer(){};
		static OffLineLayer* create(){ return new OffLineLayer();};
		static std::string name(){ return "offline";} ;
		void backprop();
	};
}
Tutto ciò ha il semplice scopo di poter instanziare un layer
semplicemente con:
Registry* reg;
Layer* l= reg->getLayer ("offline", "linear", n);
Il codice qui sopra ovviamente ha problemi (bhè, voi direte, se non
avevi problemi mica postavi no?? ;-) ) durante il linking, non trova
il riferimento ai costruttori dei layer definiti in LayerLib.
Mi chiedevo se qualcuno di voi ha qualche soluzione da proporre,
qualsiasi essa sia, anche un drastico cambiamento del codice è ben
accetta, così magari riesco a salvaguardare quella piccola quota di
capelli rimasti dell'essere strappato :)
Grazie a chiunche voglia rispondere.

 Il codice qui sopra ovviamente ha problemi
Non so se c'è qualcuno qua che ha voglia di leggersi tutto quel codice! 
Penso che dovresti lavorare ancora un po' per ridurre il codice al 
minimo possibile in modo da riprodurre l'errore. Prova a mettere tutto 
in un unico file e a eliminare a poco a poco le funzioni e le classi 
inutili. Quando hai un codice di poche righe che ti produce l'errore, 
puoi postare il codice insieme all'errore riportato dal compilatore (o 
dal linker, in questo caso).
E.

 il riferimento ai costruttori dei layer definiti in LayerLib.
Se ti riferisci a OnLineLayer e OffLineLayer, non li trovo neanche io.
Se ti sei dimenticato di riportarli e' un conto; se hai riportato tutto, 
non li trova perche' non ci sono.
Per "definiti in Layerlib" cosa intendi? Manca un file?
  bye
	av.