指针和指向类数据成员的指针的抽象

Question

I think many of you are familiar with the usages of pointer to class data member. The most common usage is when you have a list of objects and process them with a function that only knows the relative offset of the data member.

I have a nested structure where at registration, I only know the relative offsets of the inner struct (b) with respect to the parent struct (A). The global struct instance (a) has not yet been instantiated.

At some point in the program, a will be instantiated and all the data members (including the sub struct (b)) will bind with the absolute locations of the global struct.

Please see an example below

struct A {
   int a1;
   int a2;
   struct B {
      int b1;
      int b2;
   }b; 
}

descA.register(&A::a1,"a1");
descA.register(&A::a2,"a2");
descA.register(&A::b,descB);
...
descB.register(&B::b1,"b1");
descB.register(&B::b2,"b2");

A a; // create instance of nested struct

descA.bind(a);

// a1,a2,b requires the base pointer of a
// b1,b2 requires the base pointer of b   

Now, I would like to abstract the notion of a pointer since I have a simple absolute reference which is A* and I have a pointer to an inner struct B which I would like to generate B* by hiding the deference of (aptr->*b_rel_ptr) inside a pointer class.

UPDATE:

In general, after some more thoughts, I need to have three separate interfaces to this pointer class.

1. I need to be able to assign a val string to the location pointed to by the pointer
2. I need to set the base pointer of a pointer object if the base pointer is not already set
3. I need to define the notion of a struct pointer so I can propagate the base pointer to all its members

These will be the concrete pointer classes I need:

1. absolute struct pointer - a global struct pointer
2. relative struct pointer - a struct pointer inside a struct
3. relative value pointer - a value pointer inside a struct
4. absolute value pointer - a value pointer where the location of the value is already known

Answer 1

Once I am able to define the interfaces to this pointer abstraction. I was able to implement what I needed without too much trouble.

////////////////////////////////////////////////////////////////////////////////
// Pointer abstraction
////////////////////////////////////////////////////////////////////////////////

// interfaces
class Reference {
    public:    
        virtual ~Reference() {}
        virtual void assign(std::string val) = 0;
};

template<typename BT>
class BasePtr {
    public:
        virtual void setBase(BT* ptr) = 0;
        virtual bool isBaseSet() { return false; }
};

template<typename ST>
class StructPtr {
    public:
        virtual void addPtr(BasePtr<ST>* ptr) = 0;
        virtual void notify() = 0;
};

// implementation
template<typename T>
class AbsStructPtr : public Reference, 
                     public BasePtr<T>,
                     public StructPtr<T> {
    public:
        AbsStructPtr() {}
        ~AbsStructPtr() {}
        void assign(std::string val) {
            throw std::runtime_error("struct pointer: cannot assign to struct");
        }
        void setBase(T* p) {
            ptr = p;
        }
        void addPtr(BasePtr<T>* ptr) {
            pointers.push_back(ptr);
        }
        void notify () {
            for(size_t i=0; i<pointers.size(); i++) {
                pointers[i]->setBase(ptr);
            }
        }
    protected:
        T* ptr;
        typedef std::vector<BasePtr<T>*> PointerVec;
        PointerVec  pointers;

};

template<typename T, typename PT>
class RelStructPtr : public Reference, 
                     public BasePtr<PT>,
                     public StructPtr<T> {
    public:
        RelStructPtr(T PT::*ptr) : memptr(ptr), baseptr(NULL) {}
        ~RelStructPtr() {}
        void assign(std::string val) {
            throw std::runtime_error("struct pointer: cannot assign to struct");
        }
        void setBase(PT* p) {
            baseptr = p;
        }
        void addPtr(BasePtr<T>* ptr) {
            pointers.push_back(ptr);
        }
        void notify () {
            T* ptr = &(baseptr->*memptr);
            for(size_t i=0; i<pointers.size(); i++) {
                pointers[i]->setBase(ptr);
            }
        }
    protected:
        T PT::*memptr;
        PT* baseptr;
        typedef std::vector<BasePtr<T>*> PointerVec;
        PointerVec  pointers;
};

template<typename T, typename PT>
class RelValPtr : public Reference, 
                  public BasePtr<PT> {
    public:
        RelValPtr(T PT::*ptr) : memptr(ptr), baseptr(NULL) {}
        ~RelValPtr() {}
        void assign(std::string val) {
            assigner.assign(val);
        }
        void setBase(PT* p) {
            baseptr = p;
        }
    protected:
        T PT::*memptr;
        PT* baseptr;
        Assigner<T> assigner;
};

template<typename T>
class AbsValPtr : public Reference,
                  public BasePtr<T> {
    public:
        AbsValPtr(T* ptr) : valptr(ptr) {}
        ~AbsValPtr() {}
        void assign(std::string val) {
            assigner.assign(val);
        }
        void setBase(T* p) {
            throw std::runtime_error("Base pointer is set");
        }
        bool isBaseSet() { return true; }
    protected:
        T* valptr;
        Assigner<T> assigner;
};