In C++, how to return different generic types depending on argument in a class?

Question

I have this code:

template<class T1, class T2>
class Pair
{
private:
    T1 first;
    T2 second;

public:
    void SetFirst(T1 first)
    {
        this.first = first;
    }
    void SetSecond(T2 second)
    {
        this.second = second;
    }
    T1 GetFirst()
    {
        return first;
    }
    T2 GetSecond()
    {
        return second;
    }
};

How could I implement two single methods SetValue() and GetValue() , instead of the four I have, that decides depending on parameters which generic type that should be used? For instance I'm thinking the GetValue() method could take an int parameter of either 1 or 2 and depending on the number, return either a variable of type T1 or T2 . But I don't know the return type beforehand so is there anyway to solve this?

Answer 1

Not sure to understand what do you want and not exactly what you asked but...

I propose the use of a wrapper base class defined as follows

template <typename T>
class wrap
 {
   private:
      T  elem;

   public:
      void set (T const & t)
       { elem = t; }

      T get () const
       { return elem; }
 };

Now your class can be defined as

template <typename T1, typename T2>
struct Pair : wrap<T1>, wrap<T2>
 {
   template <typename T>
   void set (T const & t)
    { wrap<T>::set(t); }

   template <typename T>
   T get () const
    { return wrap<T>::get(); }
 };

or, if you can use C++11 and variadic templates and if you define a type traits getType to get the Nth type of a list,

template <std::size_t I, typename, typename ... Ts>
struct getType
 { using type = typename getType<I-1U, Ts...>::type; };

template <typename T, typename ... Ts>
struct getType<0U, T, Ts...>
 { using type = T; };

you can define Pair in a more flexible way as follows

template <typename ... Ts>
struct Pair : wrap<Ts>...
 {
   template <typename T>
   void set (T const & t)
    { wrap<T>::set(t); }

   template <std::size_t N, typename T>
   void set (T const & t)
    { wrap<typename getType<N, Ts...>::type>::set(t); }

   template <typename T>
   T get () const
    { return wrap<T>::get(); }

   template <std::size_t N>
   typename getType<N, Ts...>::type get ()
    { return wrap<typename getType<N, Ts...>::type>::get(); }
 };

Now the argument of set() can select the correct base class and the correct base element

   Pair<int, long>  p;

   p.set(0);  // set the int elem
   p.set(1L); // set the long elem

otherwise, via index, you can write

   p.set<0U>(3); // set the 1st (int) elem
   p.set<1U>(4); // set the 2nd (long) elem

Unfortunately, the get() doesn't receive an argument, so the type have to be explicited (via type or via index)

   p.get<int>();  // get the int elem value
   p.get<long>(); // get the long elem value

   p.get<0U>(); // get the 1st (int) elem value
   p.get<1U>(); // get the 2nd (long) elem value 

Obviously, this didn't work when T1 is equal to T2

The following is a (C++11) full working example

#include <iostream>

template <std::size_t I, typename, typename ... Ts>
struct getType
 { using type = typename getType<I-1U, Ts...>::type; };

template <typename T, typename ... Ts>
struct getType<0U, T, Ts...>
 { using type = T; };

template <typename T>
class wrap
 {
   private:
      T  elem;

   public:
      void set (T const & t)
       { elem = t; }

      T get () const
       { return elem; }
 };

template <typename ... Ts>
struct Pair : wrap<Ts>...
 {
   template <typename T>
   void set (T const & t)
    { wrap<T>::set(t); }

   template <std::size_t N, typename T>
   void set (T const & t)
    { wrap<typename getType<N, Ts...>::type>::set(t); }

   template <typename T>
   T get () const
    { return wrap<T>::get(); }

   template <std::size_t N>
   typename getType<N, Ts...>::type get ()
    { return wrap<typename getType<N, Ts...>::type>::get(); }
 };

int main()
 {
   //Pair<int, int>  p;  compilation error
   Pair<int, long, long long>  p;

   p.set(0);
   p.set(1L);
   p.set(2LL);

   std::cout << p.get<int>() << std::endl;       // print 0
   std::cout << p.get<long>() << std::endl;      // print 1
   std::cout << p.get<long long>() << std::endl; // print 2

   p.set<0U>(3);
   p.set<1U>(4);
   p.set<2U>(5);

   std::cout << p.get<0U>() << std::endl; // print 3
   std::cout << p.get<1U>() << std::endl; // print 4
   std::cout << p.get<2U>() << std::endl; // print 5
 }

Answer 2

C++ is statically typed, so the argument given must be a template-argument instead a function-argument.

And while it will look like just one function each to the user, it's really two.

template <int i = 1> auto GetValue() -> std::enable_if_t<i == 1, T1> { return first; }
template <int i = 2> auto GetValue() -> std::enable_if_t<i == 2, T2> { return second; }
template <int i = 1> auto SetValue(T1 x) -> std::enable_if_t<i == 1> { first = x; }
template <int i = 2> auto SetValue(T2 x) -> std::enable_if_t<i == 2> { second = x; }

I use SFINAE on the return-type to remove the function from consideration unless the template-argument is right.

Answer 3

For this particular situation, you should definitely prefer std::pair or std::tuple .

You can simply overload SetValue() (provided T1 and T2 can be distinguished, if not you have a compile error):

void SetValue(T1 x)
{ first=x; }

void SetValue(T2 x)
{ second=x; }

Then, the compiler with find the best match for any call, ie

Pair<int,double> p;
p.SetValue(0);    // sets p.first
p.SetValue(0.0);  // sets p.second

With GetValue() , the information of which element you want to retrieve cannot be inferred from something like p.GetValue() , so you must provide it somehow. There are several options, such as

template<typename T>
std::enable_if_t<std::is_same<T,T1>,T>
GetValue() const
{ return first; }

template<typename T>
std::enable_if_t<std::is_same<T,T2>,T>
GetValue() const
{ return second; }

to be used like

auto a = p.GetValue<int>();
auto b = p.GetValue<double>();

but your initial version is good enough.