Initialize const ref member variable with Eigen::Ref to matrix

Consider the following class where I would like to initialize two member variables (normal const ref) from two Eigen::Ref, passed to the constructor.

Inside the constructor the prints

std::cout << "Matrix Param: " << current_predicted_sigma_points << std::endl;
std::cout << "Matrix Member: " << current_predicted_sigma_points_ << std::endl;

work as expected, they print the same matrix meaning that current_predicted_sigma_points_ is initialized correctly.

Nevertheless, when I call the Update function, the variable current_predicted_sigma_points_ contains garbage but weights_ is still correct.

template <typename ProcessModel, typename MeasurementModel>
class UnscentedUpdateStrategy
{
  public:
    UnscentedUpdateStrategy(
        const Eigen::Ref<const ukf_utils::PredictedSigmaMatrix<ProcessModel, ProcessModel::n_sigma_points>>
            current_predicted_sigma_points,
        const Eigen::Ref<const Eigen::Vector<double, ProcessModel::n_sigma_points>> weights)
        : current_predicted_sigma_points_{current_predicted_sigma_points}, weights_{weights}
    {
        std::cout << "Matrix Param: " << current_predicted_sigma_points << std::endl;
        std::cout << "Matrix Member: " << current_predicted_sigma_points_ << std::endl;
    }

    void Update(const Eigen::Ref<const typename MeasurementModel::PredictedVector>& measure,
                const simpleukf::ukf_utils::MeanAndCovariance<ProcessModel>& current_hypotesis,
                simpleukf::ukf_utils::MeanAndCovariance<ProcessModel>& mean_and_cov_out) const
    {
        simpleukf::ukf_utils::PredictedSigmaMatrix<MeasurementModel, ProcessModel::n_sigma_points>
            measurement_predicted_sigma_matrix_out;

        std::cout << "Matrix Member Update: " << current_predicted_sigma_points_ << std::endl;
        std::cout << "Weights Update: " << weights_ << std::endl;

        auto measurement_prediction = ukf_utils::PredictMeanAndCovarianceFromSigmaPoints<MeasurementModel>(
            measurement_predicted_sigma_matrix_out, current_predicted_sigma_points_, weights_);
        // std::forward<const MeasurementPredictionArgs>(args)...);

        // add measurement noise covariance matrix
        measurement_prediction.covariance += MeasurementModel::noise_matrix_squared;
        
        // create matrix for cross correlation: predicted measurement `measurement_prediction.mean` and pred covariance
        // `measurement_prediction.covariance`
        const auto cross_correlation_matrix =
            ukf_utils::ComputeCrossCorrelation<ProcessModel, MeasurementModel, ProcessModel::n_sigma_points>(
                current_predicted_sigma_points_,
                current_hypotesis.mean,
                measurement_predicted_sigma_matrix_out,
                measurement_prediction.mean,
                weights_);

        // Kalman gain K;
        Eigen::Matrix<double, ProcessModel::n, MeasurementModel::n> K =
            cross_correlation_matrix * measurement_prediction.covariance.inverse();

        // residual
        typename MeasurementModel::PredictedVector measure_diff = measure - measurement_prediction.mean;

        // angle normalization
        models_utils::AdjustIfNeeded<MeasurementModel>(measure_diff);

        // update state mean and covariance matrix
        mean_and_cov_out.mean = current_hypotesis.mean + K * measure_diff;
        mean_and_cov_out.covariance =
            current_hypotesis.covariance - K * measurement_prediction.covariance * K.transpose();
    }

  private:
    // TODO: should we keep a copy or not?
    const ukf_utils::PredictedSigmaMatrix<ProcessModel, ProcessModel::n_sigma_points>& current_predicted_sigma_points_;
    const Eigen::Vector<double, ProcessModel::n_sigma_points>& weights_;
};

Issues disappear when switching the members to Eigen::Ref types but I would like to understand what is happening in the original case, since I may have the same issues with nested functions taking normal refs.

Your argument passing is wrong with multiple issues:

1. You try to initialize a member of type const Eigen::Vector<...>& from an object of type const Eigen::Ref<const Eigen::Vector<...>>. Those are clearly not the same type. Same for the other argument

2. You pass an Eigen::Ref but want to keep it beyond the scope of the function (the constructor in this case). This is unsafe for two reasons.

The Ref usually simply maps the vector or matrix that you pass but in some cases Ref will take a temporary copy (specifically if the inner stride is above 1, e.g. when passing a row from a matrix as a vector; or when you pass an expression that needs to be evaluated). This copy will be destroyed when the ref goes out of scope, usually when the function returns.

Additionally, the Ref is usually just constructed via conversion operator when passing something else as the function argument. Since the Ref is destroyed when the function (here the constructor) returns, keeping a reference or pointer to this object creates a dangling pointer.

The second issue can be fixed by keeping a Ref object by copy. The first issue cannot be fixed like that. So never do this.

3. A minor issue is the way you pass the Refs. The canonical way is const Eigen::Ref<const ...>& for input arguments and Eigen::Ref<...> for in-out arguments. Note that you missed the & for your const Refs.

How to fix this all? Two options:

1. Change the attribute type to plain Vector<double, ...> and PredictedSigmaMatrix, construct by making a copy of the Refs
2. Change the constructor arguments to plain object references, pointers, shared_ptr or whatever and keep those pointers/references. Don't use Eigen::Ref. That's only for temporary references