Failing to change members of structs stored in two-dimensional array - c++

Question

I have a global two dimensional array holding a number of structs. From inside a function I try to change it's members like this:
struct ControlPin {
int pin;
int previousValue;
};
ControlPin controls[CHANNELS][MULTIPLEXERS];
void readControlInput(int channel, int multiplexer) {
ControlPin control = controls[channel][multiplexer];
control.previousValue = analogRead(control.pin);
}
If i print out control.previousValue inside readControlInput() I can verify that it has changed, but after getting out of the function scope, the change is gone. How can I get a reference to the struct instead of copying it? I assume that's what happening, but I cant see why. I know that when you pass a value as a parameter to a function it is actually a copy, but here I'm accessing the global array directly?
I'm used to Java so this is a bit confusing to me.

Answer 1

In Java all objects are (IIRC) references. In C++ the default is that objects are values. When you do
ControlPin control = controls[channel][multiplexer];
you copy the "value" in controls[channel][multiplexer], then when you modify control you only modify the local value, and not the value in the array.
The simplest option is to explicitly say that control is a reference, by using the ampersand (&) when declaring the variable:
ControlPin& control = controls[channel][multiplexer];
// ^
// |
// Note ampersand here
That tells the compiler that control is a reference and then initializes it to reference the object (value) at controls[channel][multiplexer].
On an unrelated not, C++ have no bounds-checking. If you access an array out of bounds the compiler will happily allow it, but it will lead to undefined behavior at run-time. You need to do bounds-checking yourself if you want to avoid weird problems. It doesn't have to be in the function, but it needs to be done somewhere.

Answer 2

You're not accessing the array directly, this works exactly like if you had passed the element to a function:
void readInput(ControlPin control)
{
control.previousValue = analogRead(control.pin);
}
void readControlInput(int channel, int multiplexer) {
readInput(controls[channel][multiplexer]);
}
You can tell from the types - ControlPin means the same thing regardless of whether it is a local variable or a parameter.
In C++, variables that contain class instances always contain class instances and not some kind of "reference" to them, so just like when calling a function,
ControlPin control = controls[channel][multiplexer];
creates a copy of the array element, and
control.previousValue = analogRead(control.pin);
modifies that copy.
The simplest fix is to write it in one line:
controls[channel][multiplexer].previousValue = analogRead(control.pin);
You can also use a reference variable (which is different from Java's "references") to refer to the array element itself:
ControlPin& control = controls[channel][multiplexer];
control.previousValue = analogRead(control.pin);
This is most useful if you need to do more than one thing with the same element - it's both more readable and more resilient to errors than duplicating the indexing.