new array of objects with constructor that needs parameters in C++

The line

_layers[i] = new Layer(nb_neurons[i]);

suffers from two problems.

1. There is a type mismatch. _layers[i] is an object while the RHS is a pointer.
2. _layers[i] is a const object. Hence, you can't assign anything to it after it is initialized.

You can resolve the above problem as well as the default constructor problem using

std::vector<Layer*> _layers;

For better and easier memory management, use a vector of smart pointers.

std::vector<std::unique_ptr<Layer>> _layers;

or

std::vector<std::shared_ptr<Layer>> _layers;

You can do this, but you'll have to use placement new. Let's look at how this could be done.

First, we're going to create a class that represents a block of memory. This will be used in conjunction with placement new to create layers. It doesn't need any functions, because it's just used for the purposes of allocating memory of the right size and alignment.

template<size_t count, size_t alignment>
struct alignas(alignment) memory {
    std::array<unsigned char, count> bytes;
};

The two parameters given here allow us to specify the size and alignment of the block of memory. In our case, we want blocks of memory with the same size and alignment of a Layer:

using layer_memory = memory<sizeof(Layer), alignof(Layer)>; 

We can use this to create a class representing an array of layers. I split it up into four parts: - The data members (a pointer to the memory, and a variable storing the number of layers - The member functions (used to access individual layers) - The constructors (used to make the LayerArray from a list of sizes - The destructor (used to delete the block of memory we allocated)

class LayerArray {

    //* PART ONE: DATA MEMBERS *//
   private:
    layer_memory* mem;
    size_t count;

    //* PART TWO: MEMBER FUNCTIONS *//
   public:
    // Get a pointer to the memory as an array of Layers
    Layer* data() {
        return reinterpret_cast<Layer*>(mem); 
    }
    Layer const* data() const {
        return reinterpret_cast<Layer const*>(mem); 
    }
    // Dereference the i-th block of memory as a Layer
    Layer& operator[](size_t i) {
        return data()[i]; 
    }
    Layer const& operator[](size_t i) const {
        return data()[i]; 
    }

    //* PART THREE: CONSTRUCTORS *//

    // Convenience constructor from initializer list
    LayerArray(std::initializer_list<unsigned> counts)
      : LayerArray(counts.begin(), counts.size()) {}

    // Move constructor
    LayerArray(LayerArray&& other)
      : mem(other.mem)
      , count(other.count)
    {
       other.mem = nullptr;
       other.count = 0;
    }

    // Constructor that uses an array of layer sizes
    LayerArray(const unsigned int* layer_size_counts, size_t count)
      : mem(new layer_memory[count])
      , count(count) 
    {
        for(size_t i = 0; i < count; i++) {
            auto layer_size = layer_size_counts[i]; 

            // Create the new layer in the i-th block of memory
            new (mem + i) Layer(layer_size); 
        }
    }

    //* PART FOUR: DESTRUCTOR *//
    ~LayerArray() {
        for(size_t i = 0; i < count; i++) {
            Layer& layer = data()[i]; // Get the layer
            layer.~Layer(); // Manually call the destructor for the Layer
        }
        delete[] mem; 
    }
};

This allows us to create a contiguous array of layers, and instantiate them with different sizes:

int main() {
    // Create an array of layers with the specified sizes
    LayerArray layers { 50, 50, 50, 10, 3 };

    // Do other stuff...
}