Question

Let’s say I’m writing an interface for a class A that keeps a list of objects of type B, and I want to be able to manipulate that list through class A’s interface. I could put add_B, remove_B, etc. methods to A’s interface, but that’s a lot of code duplication (this situation occurs in many classes in my programme), so I’d rather return a reference to the list itself. That, however, would break encapsulation.
Is there a standard way to handle this situation?

Answer 1

The code below is based on the proxy design pattern. It preserves encapsulation and avoids a bulky interface in ‘A’ by delegating the interface to the ‘proxy’ object.

Also note how the typedef allows freedom of changing ‘list’ to ‘vector’ or anything else.

struct B{};

struct A{
    struct containerproxy{
        void Add(B *pb);
        void Remove(B *pb);
    };
    friend struct containerproxy;
    containerproxy &GetProxy(){return mlprx;}
    typedef containerproxy intf;
    ~A(){
        // Code to delete list elements and cleanup the list
    }
private:
    containerproxy mlprx;
    list<B*> mlp;
};

void A::containerproxy::Add(B *pb){ /*code to add pb to mlp*/}
void A::containerproxy::Remove(B *pb){/*code to remove pb from mlp*/}

int main(){
    A a;
    A::intf &r = a.GetProxy();

    B *p = new B;
    r.Add(p);
}