Reference member variables causing unexpected results - c++

Question

I am working on an implementation of a Moog VCF filter that creates a fourth order filter by placing four first order filters in series. These first order filters all share the same values for their coefficients. One way of approaching this was to use aggregation and create a filter class whose member variables were reference types:
class FirstOrderFilter {
public:
FirstOrderFilter(float& a1, float& b0, float& b1, float& g) : a1(a1), b0(b0), b1(b1), g(g) {}
float process(float in);
private:
// Coefficients
float& a1;
float& b0;
float& b1;
float& g;
// x[n-1]
float previousInput;
// y[n-1]
float previousOutput;
};
The idea was that I could create an array or vector of filters at the start of the program and any change to the coefficients would cause the member variables for each class to be updated without the need to call a setter function.
This does work but I ran into a few issues. The only two options for initialising the containers that work are:
std::vector<FirstOrderFilter> filters (4, FirstOrderFilter{gA1, gB0, gB1, gCutoff});
std::array<FirstOrderFilter, 4> = {
FirstOrderFilter{gA1, gB0, gB1, gCutoff},
FirstOrderFilter{gA1, gB0, gB1, gCutoff},
FirstOrderFilter{gA1, gB0, gB1, gCutoff},
FirstOrderFilter{gA1, gB0, gB1, gCutoff}
};
If I do the following:
std::vector<FirstOrderFilter> filters;
for (int i = 0; i < 4; i++)
filters.push_back({gA1, gB0, gB1, gCutoff});
The program crashes because the output becomes incredibly large (although there is no runtime error produced). If I use emplace_back the program still runs but the filter does not display the correct behaviour.
I looked into using std::reference_wrapper but I am not sure of the correct way to use it. For example, the following does not improve matters:
// Coefficients
std::reference_wrapper<float> a1;
std::reference_wrapper<float> b0;
std::reference_wrapper<float> b1;
std::reference_wrapper<float> g;
I understand this is caused by the fact that references cannot be copied or assigned, however, I thought emplace_back might help get round this. If I was to use an array instead of a vector, is there another way of initialising the array instead of the cumbersome method above?
Can anyone explain what is happening here?
Here is a minimal reproducible example:
#include <iostream>
#include <vector>
float gA1 = 0.0f, gB0 = 0.0f, gB1 = 0.0f;
float gCutoff = 0.0f;
void calculate_coefficients()
{
gA1 = 1.0f; gB0 = 1.0f / 1.3f; gB1 = 0.3f / 1.3f;
gCutoff = 1.0f;
}
class Filter {
public:
Filter(float& a1, float& b0, float& b1, float& g) : a1(a1), b0(b0), b1(b1), g(g) {}
float process(float in);
private:
// Coefficients
float& a1;
float& b0;
float& b1;
float& g;
// x[n-1]
float previousInput = 0.0f;
// y[n-1]
float previousOutput = 0.0f;
};
float Filter::process(float in)
{
float out = ((b0*in + b1*previousInput - a1*previousOutput) * g) + a1*previousOutput;
previousInput = in;
previousOutput = out;
return out;
}
std::vector<Filter> filters;
// This produces the expected result
// std::vector<Filter> filters (4, Filter(gA1, gB0, gB1, gCutoff));
int main() {
// Comment out this loop if using fill constructor
for (unsigned int i = 0; i < 4; i++)
filters.push_back(Filter(gA1, gB0, gB1, gCutoff));
calculate_coefficients();
float out = 1.0f;
for (unsigned int i = 0; i < filters.size(); i++)
out = filters[i].process(out);
std::cout << std::to_string(out) << std::endl;
}
The output produced by running the above code is a negative long double. Something like -66466164548257686390571008.000000, for example.
Update: This error was caused by declaring the reference types on the same line and not initialising previousInput and previousOutput correctly.