Question

class Foo1: public IFoo
{
public:
    template <class T>
    std::vector<T> foo()
    {
        return std::vector<T>();
    }
};

class Foo2: public IFoo
{
public:
    template <class T>
    std::vector<T> foo()
    {
        return std::vector<T>();
    }
};

How can I define a common interface class for the two implementations above, such that std::vector<T> foo() is defined for this interface? Ignore that the implementations of the functions are identical.

UPDATE:

I’m writing a Container class which represents data which is sent to me via a C api.

An instance of my Container will store data of a given type, such as Container<int>, Container<std::string> and Container<Foo>.

The C api returns the data in a very awkward manner and it is possible that this will change in the future. It is possible that I can copy the data into for example std::list or std::vector, but since so much data is passed from the C api it is not known yet if this will be OK or not.

For this reason, the Container class should be independent of how the data is actually stored. I achieve this using Getter and Setter classes which I pass into the contructor, as follows:

Container<int>(Getter1<int>(uglyCApiContainer),Setter1<int>(uglyCApiContainer));

Therefore if I abandon Getter1 and Getter2 which deals with how the C api stores data, I will only need to change the creation of Containers.

However, I have a problem with this design. The type Foo.

Foo is a complex type which contains itself a set of Containers. At the moment it looks something like this:

class Foo
{
public:
        ...
    template <class V>
    Container<V> getMember(std::string& memberName)
};

So a given Foo can have a set of containers of different types. The types of these members are know to me in advance since they are stored in a model. Foo is currently a wrapper around the ugly C api memory implementation, but I would like to separate also for Foo the memory representation as I’ve done for the Container.

I’m not sure how to make Foo free of its memory implementation. One idea I had was to make getMember virtual so as to introduce perhaps different implementations but this isnt possible for templated functions.

Answer 1

Here’s a solution using tag dispatching and virtual inheritance:

#include <vector>

template<typename T> struct tag {};

template<typename T> class IFooImpl {
public:
    virtual std::vector<T> getImpl(tag<T>) = 0;
};

class IFoo: public virtual IFooImpl<char>, virtual IFooImpl<int>
{
public:
    template<typename T> std::vector<T> get() {
        return static_cast<IFooImpl<T> *>(this)->getImpl(tag<T>{});
    }
};

template<typename T>
class FooImpl: public virtual IFooImpl<T> {
public:
    std::vector<T> getImpl(tag<T>) { return {}; }
};

class Foo: public IFoo, FooImpl<char>, FooImpl<int> {
};

int main() {
    Foo().get<char>();
}

There’s a little bit of repetition where the supported types are covered (here char and int), but that can be avoided with variadic template inheritance:

#include <vector>

template<typename T> struct tag {};

template<template<typename> class C, typename... Types> class Inherit {};
template<template<typename> class C, typename T, typename... Rest>
class Inherit<C, T, Rest...>: public C<T>, Inherit<C, Rest...> {};

template<typename T> class IFooImplV {
public:
    virtual std::vector<T> getImpl(tag<T>) = 0;
};
template<typename T> class IFooImpl: public virtual IFooImplV<T> {};

template<typename... Types> class IFoo: public Inherit<IFooImpl, Types...> {
public:
    template<typename T> std::vector<T> get() {
        return static_cast<IFooImpl<T> *>(this)->getImpl(tag<T>{});
    }
};

template<typename T> class FooImpl: public IFooImpl<T> {
public:
    std::vector<T> getImpl(tag<T>) { return {}; }
};

template<typename... Types> class FooMulti:
    public IFoo<Types...>, Inherit<FooImpl, Types...> {};
class Foo: public FooMulti<char, int> {};

int main() {
    Foo().get<char>();
}