Неправильное выделение памяти в массиве

float** W
...
void generate_weights()
    {
        for (int l = 0; l < neurons; l++) {
            for (int i = 0; i < inputs; i++)
            {
                int randNum = rand() % 2;
                if (randNum == 1)
                    W[l][i] = -1 * (double(rand()) / (double(RAND_MAX) + 1.0));
                else
                    W[l][i] = double(rand()) / (double(RAND_MAX) + 1.0);
 
            }
        }
    }

float W[neurons][inputs];

#include <iostream>
#include <cmath>
#include "layer.h"
using namespace std;
 
float training_set_inputs[4][4] = { {1.0,0.0,0.0,1.0}, {0.0, 0.0, 1.0,0.0}, {1.0, 1.0, 1.0,0.0}, {0.0, 1.0, 0.0,1.0}};
float training_set_outputs[4][1] = { {0.0}, {0.0}, {1.0}, {1.0} };
int epoches = 1000;
 
int law_1_neurons = 4;
int law_2_neurons = 1;
 
Law law_1(4, law_1_neurons, false, 1, 1);
Law law_2(law_1_neurons, law_2_neurons, true, 0, 2);
 
void train(){
    for (int i = 1; i <= epoches;i++) {
        cout << endl << "Epoch: " << i << endl;
        for (int l = 0; l <= 4;l++) {
            float* input = {law_1.think(training_set_inputs[l])};
            float* output = law_2.think(input);
 
            float* error;
            error = new float[law_2.get_neurons()];
            for (int k = 0; k < law_2.get_neurons(); k++) {
                error[k] = training_set_outputs[l][k] - output[k] ;
            }
            
            law_2.calc_derivatives(error);
            float* delta = law_2.get_delta();
 
            law_1.forward(delta, law_2.get_W(), law_2.get_neurons());
            
            law_2.train(input, error);
            law_1.train(training_set_inputs[l],error);
            l+=1;
        }
        for (int l = 1; l <= law_1.get_neurons(); l++) {
            law_1.cout_W(l);
        }
        for (int l = 2; l <= law_1.get_neurons(); l++) {
            law_2.cout_W(l);
        }
    }
}
 
int main() {
    int a,b,c,d;
    train();
    cout <<"Ready" << endl;
    while (true){
        cout << endl << "Enter 1st: ";
        cin >> a;
        cout << "Enter 2nd: ";
        cin >> b;
        cout << "Enter 3rd: ";
        cin >> c;
        cout << "Enter 4th: ";
        cin >> d;
        float input[4] = {a,b,c,d};
        float* inputs = { law_1.think(input) };
        cout << law_2.think(inputs)<< endl;
    }
    return 0;
}

#include <cmath>
#include <iostream>
using namespace std;
 
class Law
{
private:
    int inputs;
    float* sum;
    float* output;
    float** W = {};
    float* delta;
    int neurons;
    bool output_law;
    float** related_forward;
    float* derivatives_forward;
    int neurons_forward;
    int law_name;
 
    void generate_weights()
    {
        float W[neurons][inputs];
        for (int l = 0; l < neurons; l++) {
            for (int i = 0; i < inputs; i++)
            {
                int randNum = rand() % 2;
                if (randNum == 1)
                    W[l][i] = -1 * (double(rand()) / (double(RAND_MAX) + 1.0)); // generate number between -1.0 and 0.0
                else
                    W[l][i] = double(rand()) / (double(RAND_MAX) + 1.0); // generate number between 1.0 and 0.0
 
            }
        }
    }
public:
    Law(int input, int neurons_local, bool is_out, int neurons_forward_local, int name) { inputs = input; generate_weights(); neurons = neurons_local; output_law = is_out; neurons_forward = neurons_forward_local; law_name = name; }
    void cout_W(int neuron) {
        for (int i = 0; i < inputs; i++) {
            cout << "Neuron " << neuron <<" of lawer " << law_name << ": " << W[neuron - 1][i] << " ";
        }
        cout << endl << endl;
    }
    float** get_W() {
        return W;
    }
    int get_neurons() {
        return neurons;
    }
    int get_inputs() {
        return inputs;
    }
    void calc_derivatives(float* error) {
        float* derivatives;
        derivatives = new float[neurons];
        if (output_law == true) {
            for (int i = 0; i < neurons; i++) {
                derivatives[i] = -error[i] * (exp(sum[i]) / pow((1 + exp(sum[i])), 2));
            }
        }
        else {
            for (int i = 0; i < neurons; i++) {
                derivatives[i] = (exp(sum[i]) / pow((1 + exp(sum[i])), 2)) * calc_forward_derivatives(i);
            }
        }
        delta = derivatives;
        //return derivatives;
    }
    float* get_delta(){
        return delta;
    }
    void forward(float* derivatives,float** w_local,int neuron){
        neurons_forward = neuron;
        related_forward=w_local;
        derivatives_forward=derivatives;
    }
    float* think(float* input) {
        for (int l = 0; l < neurons; l++) {
            float res = 0;
            for (int i = 0; i < inputs; i++)
            {
                res += input[i] * W[l][i];
            }
            sum[l]=res;
            output[l] = 1 / (1 + exp(-res));
        }
        //cout << -res << endl;
        return output;
    }
    float get_output(int neuron) {
        return output[neuron - 1];
    }
    float calc_forward_derivatives(int neuron) {
        float sum_derivatives=0;
        for (int i = 0; i < int(neurons_forward);i++) {
            sum_derivatives += related_forward[neuron][i] * derivatives_forward[i];
        }
        return sum_derivatives;
    }
    void train(float* input, float* error) {
        for (int l = 0; l < neurons; l++) {
            if (output_law == true) {
                float delta_local = -error[l] * (exp(sum[l]) / pow((1 + exp(sum[l])), 2));
                for (int i = 0; i < inputs; i++)
                {
                    W[l][i] += input[i] * delta_local;
                }
            }
            else {
                float delta_local = (exp(sum[l]) / pow((1 + exp(sum[l])), 2)) * calc_forward_derivatives(l);
                for (int i = 0; i < inputs; i++)
                {
                    W[l][i] += input[i] * delta_local;
                }
            }
        }
    }
};

    void generate_weights()
    {
        float W[neurons][inputs];
...
...

    void generate_weights()
    {
        W=new float*[neurons];
        for (int n = 0; n < neurons; n++)
        {
            W[n]=new float[inputs];
        }
...
...