I'm developing a pseudo-library for neural network. To simplify
librarary using i wont to implement a sistem to instantiate different
implementation of interface(Layer.h Neuron.h) passing a string to a
function of a ùregistry vlass that hold all sub-classes...

/* ------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();
};

}

This code only for instantiate an object via some line

Registry reg;
Layer* l= reg.getLayer ("offline", "linear", n);

But at this time i have proble with linking...and some other
inconveninet like ciclic include...
Anyone have a good idea to solve this question??

On Nov 16, 6:16 pm, neoairus <francesco.ame...@gmail.com> wrote:

> But at this time i have proble with linking...and some other
> inconveninet like ciclic include...
> Anyone have a good idea to solve this question??

If you have cyclic include problems, a couple of
thoughts come to mind.

- Use include cards on all header files.
- If you don't require to include in the header file, don't i.e.
use forward declarations. A quick look at your code indicates
a couple of examples where this would have sufficed.
- Where possible (if not constrained by execution speed, which
I seriously doubt) move your implementation to .c* files (source
files).
- If you still have linker errors, make sure all static members
have definitions and make sure inline functions defined outside
of the body of classes are indicated as inline if they exist
in the header file.
- Make sure that pure virtual destructors have definitions.
- Make sure that all functions that are called have definitions.
Functions that arent't called don't require definitions. An
example of this is private copy constructor/assigment operator
without definition for the purpose of copying prevention (as
with boost::noncopyable).

Hope this ed.

Werner