mjhjmtu

I'm trying to write a class that takes two templated types. This class inherits from an interface. See the below code.

#include <iostream>
#include <string>

template <typename T>
class IObserver 
 public:
 virtual void Next(const T& value) noexcept = 0;
;

template <typename T1, typename T2>
class BinaryObserver : public IObserver<T1>, public IObserver<T2> 
 public:
 void Next(const T1& value) noexcept override;

 void Next(const T2& value) noexcept override;
;

int main() 
 // This is OK
 BinaryObserver<int, float> mc1;
 mc1.Next(0);
 mc1.Next(0.0f);

 // This fails to compile with "multiple overloads"
 BinaryObserver<int, int> mc2;
 mc2.Next(0);
 mc2.Next(0);

I'm having trouble when T1 is the same type as T2. Obviously this means two Next functions will be generated with the same type, which gives an error: multiple overloads of 'Next' instantiate to the same signature.

What's an idiomatic way of fixing this? I'm not sure how to handle the case when T1=T2 since I'd only need one Next function generated

Thanks!

How about a specialization:

template <typename T>
class BinaryObserver<T, T> : public IObserver<T> 
 public:
 void Next(const T & value) noexcept override;
;

You have another issue in your program:

BinaryObserver<int, int> mc2;
mc2.Next(0);
mc2.Next(0);

Which one of the Next you expect the compiler would choose in case you succeed?
In the VIT's answer you will have only a sigle Next implemented in specification and calling it twice will do something different.

So, the best solution is to have different IObserver classes with different function names to overload, i.e

class BinaryObserver : public IObserver<T1>, public IObserver1<T2> 
...
mc2.Next(0);
mc2.Next1(0); 

Another possibility is to put one of Ts in another container. I used Shell struct in this example:

template
struct Shell
T t;
Shell(T t): t(t)
operator T() const return t;
;

template <typename T1, typename T2>
class BinaryObserver : public IObserver<T1>, public IObserver<Shell<T2>> 
 public:
 void Next(const T1& value) noexcept overrideT1 t = value;;
 void Next(const Shell<T2>& value) noexcept overrideT2 t = value;;
;

...

 BinaryObserver<int, float> mc1;
 mc1.Next(0);
 mc1.Next(0.0f);

 BinaryObserver<int, int> mc2;
 mc2.Next(0);
 mc2.Next(Shell<int>(0));