struct T1 
{
    ... some data ...
    std::vector<T2*> links;
}

struct T2 
{
    ... some data ...
    T1 *link;
}

struct T3
{
    ... some data ...
    std::vector<T1*> items;
}

struct T4
{
    ... some data ...
    std::map<int, T3*> items;
}

class CALC
{
public:
    static void Activate(T1* arg);
    static void Activate(T3* arg);
    static void Activate(T4* arg); <-- точка входа
};

void CALC::Activate(T4* arg)
{
	for(auto cur=arg->items.begin(),end=arg->items.end(); cur!=end; cur++)
		Activate(cur->second);
}

void CALC::Activate(T3* arg)
{
	for(int i=0,cnt=arg->items.size(); i<cnt; i++)
		Activate(arg->items[i]);
}

void CALC::Activate(T1* arg)
{
	for(int i=0,cnt=arg->links.size(); i<cnt; i++)
		... some calculations ... arg->links[i] ...
	... some calculations ... 
}

//------------------------------------------------------------------------------
void CALC::Activate(TNeuron* neuron)
{
    TLink *link;
    double sumval = 0;
    for(int i=0,cnt=neuron->Inputs.size(); i<cnt; i++) {
        link = neuron->Inputs[i];
        sumval += link->_Weight * link->NeurSrc->_Outval;
    }

    double value = 0;
    double threshold = neuron->_Threshold;
    double factor = neuron->_Factor;
    switch(neuron->_Activation)
    {
    case AF_LINEAR:
    break;

    case AF_LOGISTIC:
        value = factor * sumval;
        value = 1.0 / (1.0 + exp(-value));

        if(threshold > 0)
            if(value > 1.0-threshold) value = 1;
            else
            if(value < threshold) value = 0;
    break;

    case AF_TANHYP:
    break;
    }
    neuron->_Outval = value;
}
//------------------------------------------------------------------------------
void CALC::Activate(TLayer* layer)
{
    if(layer->_Type == LR_INPUT) return;
    for(int i=0,cnt=layer->Neurons.size(); i<cnt; i++)
        Activate(layer->Neurons[i]);
}
//------------------------------------------------------------------------------
void CALC::Activate(TNet* net)
{
    for(auto cur=net->Layers.begin(),end=net->Layers.end(); cur!=end; cur++)
        Activate(cur->second);
}
//------------------------------------------------------------------------------

struct TNeuron {
    // Данные
    ...
    // Связи (ссылки)
    std::vector<TLink*> Inputs;
    std::vector<TLink*> Outputs;
    TLayer* Layer;
};
struct TLink {
    // Данные
    ...
    // Связи (ссылки)
    TNeuron* NeurSrc;
    TNeuron* NeurDst;
    TNet* Net;
};
struct TLayer {
    // Данные
    ...
    // Связи (ссылки)
    std::vector<TNeuron*> Neurons;
    TNet* Net;
};
struct TNet {
    // Данные
    ...
    // Связи (реальные объекты)
    std::map<int, TLayer*> Layers;
    std::map<int, TNeuron*> Neurons;
    std::map<int, TLink*> Links;
};

for(long count=0;count<1000000;count++)
    CALC::Activate(net);

class Activate {...};
class Linear : Activate {...};
class Logistic: Activate {...};
class TanHyp : Activate {...};

class Activate {...};
class Linear : Activate {...};
class Logistic: Activate {...};
class TanHyp : Activate {...};

typedef void (*pF)(T* arg);
inline void F1(T* arg);
inline void F2(T* arg);
inline void F3(T* arg);
pF F[] = { F1, F2, F3 };

typedef void (*pF)(T* arg);
inline void F1(T* arg);
inline void F2(T* arg);
inline void F3(T* arg);
pF F[] = { F1, F2, F3 };

typedef void (__fastcall* F)(T* arg);
void __fastcall F1(T* arg);
void __fastcall F1(T* arg);
void __fastcall F1(T* arg);
const static FActNeuron ActNeuron[] = { F1, F2, F3 };