Initialize a vector of classes that have member pointers to another class' member variables

Question

For a scientific code I need to construct classes that require (member) pointers to member variables of other classes (i.e. both parents and siblings).

I have researched this for hours and found several topics about pointers to member variables, but nothing about my specific problem. Hence my question: what is the correct syntax to instantiate class C in the example below such that the pointer in class C points to the VectorXd beta in class B?

Edit: To clarify my question, the intended behavior is that a call to the class B member function PrintBetas() prints out the current value of VectorXd beta nr_C times.

#include <iostream>
#include <vector>
#include <Eigen/Dense>

using namespace Eigen;
using namespace std;


class C {
    
  public:    
    C( VectorXd *beta_IN ): beta( beta_IN ) {}
         
    void PrintBeta() {
      cout << "(*beta) = " << (*beta).transpose() << endl;  // ???
    }    

  private:
    const VectorXd *beta;
};


class B {
      
  public:            
    B( VectorXd beta_IN, int nr_C ): beta( beta_IN ) {
      for( auto i=0; i<nr_C; i++)
        vec.push_back( C( &beta ) );
    }
    
    void PrintBetas() {
      for (auto c : vec)
        c.PrintBeta();
    }

    VectorXd beta;
            
  private:    
      
   vector<C> vec;
          
};


class A {
  
  public: 
    A( int nr_B, int nr_C ) {
          
      for (auto i=0; i<nr_B; i++) {
        VectorXd beta = VectorXd::Random(3);
        subclass.push_back( B( beta, nr_C) );
      }
   }
   
   vector<B> subclass;
};
  
  

int main() {
    
  A test(2,3);
  test.subclass[0].PrintBetas();
  test.subclass[1].beta.setZero();
  test.subclass[1].PrintBetas();
  
}

Answer 1

In your code, whenever you copy a B object, the Cs inside the new B still point to the beta member in the old B. This is the problem you'd want to solve.

Option 1: Use only B pointers, wrapped in smart pointers like or shared_ptr. Now when you copy it does not copy the underlying B object, and all Cs remain intact.

Option 2: When you copy a B, overload the copy constructor to adjust all underlying Cs to point to the new object's beta member:

B::B(const B& other)
  : beta(other.beta),
    vec(other.vec)
{
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        it->beta = β
    }
}

This may seem expensive, but you're copying all the Cs anyway, so it doesn't change the time complexity. However, you'd probably also want to overload the move constructor, and that's a different story:

B::B(B&& other)
  : beta(std::move(other.beta)),
    vec(std::move(other.vec))
{
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        it->beta = β
    }
}

This now changes the time complexity from probably constant to probably linear.

Note: "Pointers to member variables" mean something different from pointers to variables which are inside objects, but neither would probably be of much use here. If you have a pointer to member, you might declare/define it like:

VectorXd B::* member_ptr = &B::beta;

and you would use it on a specific instance b of type B like:

VectorXd val = b.*member_ptr;

. If you define member_ptr the way I showed above, then this line just means:

VectorXd val = b.beta;

.