Question

I am having a problem calling a template function with two template arguments.

I have a class and the class accepts objects of two different types. I don’t know the types yet, so I left them as template parameters. I then store the objects in wrapper classes. In the end I want to be able to call a templated function with two template arguments, that takes my two objects. But I am perplexed at how to do this.

Here is a stripped down version of the code to explain my problem.

template<typename A, typename B>
void someTemplateFunction(A a, B b);


class Problem
{
  private:
    class WrapperA
    {
      public:
        virtual void doSomething() = 0;
    };

    template<typename A>
    class ConcreteWrapperA : public wrapperA
    {
      private:
        A a;
      public:
        ConcreteWrapperB(A b_) : a(a_) {}
        virtual void doSomething();
    };

    class WrapperB
    {
      public:
        virtual void doSomething() = 0;
    };

    template<typename B>
    class ConcreteWrapperB : public wrapperB
    {
      private:
        B b;
      public:
        ConcreteWrapperB(B b_) : b(b_) {}
        virtual void doSomething();
    };

    WrapperA *a;
    WrapperB *b;

  public:

    template<typename A>
    void setA(A a)
    {
      a = new ConcreteWrapperA<A>(a);
    }

    template<typename B>
    void setB(B b)
    {
      a = new ConcreteWrapperB<B>(b);
    }

    void call_someTemplateFunction(); // ??????? How do i do this?
};

Answer 1

The problem is that you’ve type-erased both types A and B separately, so there’s nowhere in the translation of your code that both types A and B are known.

If you can write a single function template<typename A, typename B> void set(A, B) then you could capture the pair type <A, B> at that point.

Alternatively, would it be possible for someTemplateFunction to operate without knowing both types A and B at the same time?

---

This is an issue fundamental to the design of C++ as a single-pass, separate compilation language.

Suppose that your program has three compilation units; A.cpp calls setA with a range of types T[A], B.cpp calls setB with another range of types T[B], and C.cpp owns the Problem object and wants to call someTemplateFunction. Then there’s no time during compilation when the compiler knows both the range of types in A.cpp and the range of types in B.cpp, so it can’t instantiate someTemplateFunction with the appropriate cross-product T[A] x T[B].