一类的多个接口

Question

I am trying to come up with an elegant solution for the problem of offering multiple interfaces to a class in C++. Suppose we have the classes B,C and D. B and C need customized/controlled access to the class A whereas D can have direct access. The solution for offering such interfaces needs to be extendable. Future interfaces might be specialized for only one particular class.

Currently I am creating interface classes (IA_1, IA_2) which have a reference to the class A. B and C will be provided whith instances of those interfaces and can access A through IA_1 respectively IA_2 in a customized/controlled manner. The situation is depicted in the image below.

This has the advantage that I don't need to touch class A when implementing a new interface. New interfaces can utilize old interfaces through inheritance. Classes which need access to A will only be able to do through their particular interface.

The implementation in C++ would look like this:

class A{
public:
  void foo();
};

class IA_1{
public:
  void foo(const B& b);
private:
  std::weak_ptr<A> m_A;
};

class IA_2{
public:
  void foo();
private:
  std::weak_ptr<A> m_A;
};

class B{
  std::unique_ptr<IA_1> m_A;
};

class C{
  std::unique_ptr<IA_1> m_A;
};

class D{
  std::weak_ptr<A> m_A;
};

The interfaces get a weak_ptr to A because I don't want classes which are only accessing A to participate in its lifetime management.

Currently I am creating an interface object for every instance of B or C, although they are all doing the same. I already thought about creating only one interface object and give every instance of B and C a reference (shared_ptr) of the corresponding interface. In that way I will only have one object for every interface. Maybe this is already a case of premature optimization to reduce the memory footprint of the application.

Is there a way to further improve this design or take a totally different approach?

Answer 1

Probably not a complete answer, just my thoughts.

Cons:

• Extra interface classes introduced
• Extra indirection, with extra maintenance per supported call
• construction: extra factory needed for interface pointing to object
• weak pointers: solve the case where the pointer becomes dangling

Pros:

• clear control over interface to the class
• extra safety over lifetime (can be checked, but should also be handled)
• limited change needed on object (friends?)

About the 1 instance per interface: The footprint will be a bit lower, but you need extra management over accessing that 1 instance.