Question

I have several datacontainertype like this but they differ in their content:

struct containerRequest
{
   uint8_t data1
   uint8_t data2
};

struct containerResponse
{
    uint8_t data1;
    uint8_t data2;
};

union myType
{
   containerRequest Request;
   containerResponse Response;
};

Now I would like to create an abstract interface to ensure all of this interfaces have an MyDatatype like this

class IMyInterface
{
   public: 
      union myType
      {
          X Request;
          Y Response;
      };


      bool IsMyType(myType& data) = 0;
      void DoThings(myType& data) = 0;
};

I thought of using template but this brakes the rest of my code:

template <typename X, typename Y>
class IMyInterface
{
    ...
}

but this breaks the rest of my code.

Because I have a collection of the different containers:

void addContainer(IMyInterface& data)
{
     collection.push_back(&data);
}

when I use Templates in the interface g++ forces me to specify the types of my templates.

How can I define X and Y in my derived class without the need to specific the type in my collection?

Answer 1

Sounds like you need (runtime) polymorphism, i.e. want code which deals with an IMyInterface without knowing it’s precise type. Templates alone won’t get you there, since they only provide compile-time polymorphism. The parts of C++ which provide what you want are RTTI (run-time type information) and virtual functions. One of the extremely powerfull features of C++ is that you can combine the two approaches. In your case, that means turning IMyInterface into a template, but letting that template inherit from a non-templated base class which defines the virtual functions you need. Here’s an example.

// Base class for interface types. Make sure it's a polymorphic type by adding a least one
// virtual member. Since polymorphich types should have virtual destructory anyway, adding
// a virtual no-op destructor is the natural choice.
struct IMyInterfaceDataType {
  virtual ~IMyInterfaceDataType() {};
};

// Base class for interface implementations.
struct IMyInterface {
  virtual bool IsMyType(const IMyInterfaceDataType& data);
  virtual void DoThings(IMyInterfaceDataType& data);
}

template<typename RequestType, typename ResponseType>
struct IMyInterfaceImplementation : MyInterface {
  struct MyType : IMyInterfaceDataType {
    union { RequestType Request; ResponseType Response } data;

    // You'll probably want to add some constructors here
  };

  virtual bool IsMyType(const IMyInterfaceDataType& data) {
    // Cast as pointer, not reference, to get NULL instead of an exception if cast fails
    return dynamic_cast<const MyType*>(&data) != NULL;
  }
};

struct SomeRequestType { ... };
struct SomeResponseType { ... };
struct SomeInterface : IMyInterfaceImplementation<SomeRequestType, SomeResponseType> {
  virtual void DoThings(IMyInterfaceDataType& data_raw) {
    // Throws std::bad_cast if data_raw isn't actually a DataType instance
    DataType& data = dynamic_cast<DataType&>(data_row);
    ... Do whatever you want to do with data ...
  } 
};

// This should now work, but you need to store pointers (or references, but
// putting references into a std::vector doesn't work), since polymorphism only
// works as expected with references or pointers.
std::vector<IMyInterface*> interfaces;
void addCollection(IMyInterface* iface) {
  interfaces.push_back(iface);
}

// This would then process an arbitrary data type with the first matching interface
void process(IMyInterfaceDataType& data) {
  for(std::vector<IMyInterface>::iterator i = interfaces.begin(); i != interfaces.end(); ++i) {
    IMyInterface& iface = **i;
    if (iface.IsMyType(data) {
      iface.DoThings(data);
      break;
    }
  }
}

In real code, you should of course not store raw points in the interfaces vector, but instead use some kind of smart pointer. boost::shared_ptr (or std::shared_ptr if you’re using C++11) would be a good choice. You might also want to take a look at boost::any, which wraps objects of arbitrary type and a safe manner (i.e., in a way, it’s void* done right).

Your use of union is a bit dubious, btw. How would a DoThings method know whether the data contains a request or a response? You might want to consider using boost::variant instead of a C-style union.