What is the most efficient way of regulating memory when passing arrays as arguments?

Question

I learned to program in Python and am just now learning C++ so I apologize if the terms I use aren't conventional (also don't have a comp. sci. education or background).

I'm trying to build a neuron in C++. Weights are usually passed as arrays. When instantiating neurons, I need to pass an array of weights. I've been trying to get the neuron object to just reference the pointer so I don't have to make a copy, but I keep doing something wrong. Could somebody change this code so I'm not making a copy of the array and then explain what you did, and why you did it?

class Neuron {
    private:
        double bias;
        int num_weights;
        double weights[];
    public:
        Neuron(double*, int, double);
        double forward_prop(double[]);
};

Neuron::Neuron(double weights[], int num_weights, double bias) {
    this->num_weights = num_weights;
    this->bias = bias;
    // rotate through weights pointer and reassign to object attribute 'weights'
    for (int i=0;i<this->num_weights;i++) {
        this->weights[i] = weights[i];
    }
    // TODO: delete pointer

}

double Neuron::forward_prop(double values[]) {
    double output = this->bias;

    for (int i=0; i < this->num_weights; i++) {
        output += this->weights[i] * values[i];
    }
    return output;

}

Answer 1

Here is a rewrite of your class, without object copying, and using the C++ standard library. The example below uses std::vector along with move-semantics to avoid copying the data. Comments come after the code sample:

#include <vector>
#include <numeric>
#include <iostream>

class Neuron 
{
    private:
        std::vector<double> weights;  // We use a vector of doubles, not an array
        double bias; 

    public:
    
        Neuron(std::vector<double>&, double);
        double forward_prop(const std::vector<double>&);
};

Neuron::Neuron(std::vector<double>& weights_, double bias_) : weights(std::move(weights_)), bias(bias_) // The std::move avoids the copy
{}

double Neuron::forward_prop(const std::vector<double>& values) 
{
    // the std::inner_product function does what your code is doing now
    return std::inner_product(weights.begin(), weights.end(), values.begin(), bias);
}

int main()
{
    std::vector<double> myWeights {1,2,3,4};
    Neuron n(myWeights, 10);
    std::cout << n.forward_prop({5,6,7,8});
}

Output:

80

Here are the key points:

1. The std::vector is used instead of arrays and pointers. Note that we no longer need a num_weights member variable, since a vector knows its own size already by calling the size() member function of std::vector.

2. In the Neuron constructor, we issue a call to std::move when we're assigning the passed-in vector to the objects' member. This invokes the move-semantics that are built into std::vector. Basically the pointer(s) that the source vector uses are "stolen" or moved into the destination vector, thus avoiding the copy.

Note that the source vector will be changed when this is done. The passed-in vector will essentially become empty (remember that the contents of it were moved out).

3. To top things off, I implemented your forward_prop using std::inner_product.

4. Additional items -- note the usage of the member-initialization list when writing the constructors. Also, the call to forward_prop utilizes the brace-initialization syntax of std::vector, that's why when we called forward_prop, there was no need to explicitly declare a std::vector<double>.

---

Note that the real point to take away from this is that starting with C++11, move-semantics were formally introduced into the language. This allows moving (instead of copying) to be done in a formal way.

With move-semantics now possible, additional functions were added (such as std::move, move constructors and move-assignment operators, emplace_back member functions in some STL container classes, std::unique_ptr works instead of the somewhat broken std::auto_ptr, etc.).

Before C++11, you had to do pointer "tricks" or hope that the compiler's optimizer implicitly did moving (even though there was no formal name for this type of operation).