How to write a function which takes different type of arguments?

Question

I have to classes :

template <class T>
class shared_vector 
{
    T data;
}

template <class  T>
class device_vector
{
    T data;
}

I want to write a function f which accects any kind of object, be it of type shared_vector or device_vector and sets some flags accordingly.

Now the obvious solution is to go for function overloading. But suppose the function f takes 10 arguments which can either be of shared_vector or device_vector, I would have to write 1024 overloaded functions.

Another solution is to use a parent class hybrid_vector from which both the device_vector and shared_vector inherit from.

But unfortunately, device_vector code is not in my control.

How should i solve this problem ?

NOTE : I know typeid (variable).name () can tell the type, but what will be my function declaration and how can I infer type from it ?

It sounds like you might want the builder pattern to solve this combinatorial explosion. — Oliver Charlesworth, Mar 20 '16 at 18:15
Or in fact, just an array of super-type pointers. Given that you don't control the types in question, you could just create your own wrapper types. — Oliver Charlesworth, Mar 20 '16 at 18:16
@OliverCharlesworth how would you do create an array of super type of both classes ? — Rohith R, Mar 20 '16 at 18:18
A function with 10 parameters will never be nice. Find a way to reduce the parameter count. — Christian Hackl, Mar 20 '16 at 18:21
Use type-erasure and implement ["ad-hoc polymorphism"](http://stackoverflow.com/questions/18856824/ad-hoc-polymorphism-and-heterogeneous-containers-with-value-semantics). — Nawaz, Mar 20 '16 at 18:53
What are you going to do with these parameters in the version that takes 10 arguments — M.M, Mar 21 '16 at 00:11

score 2 · Accepted Answer · answered Mar 21 '16 at 00:04

It might be an option to accept boost::variant<shared_vector<T>, device_vector<T>>.

Another option is std::enable_if :

template<typename V>
std:enable_if<
  std::same_type<V, shared_vector<decltype(V::data)>::value |
  std::same_type<V, device_vector<decltype(V::data)>::value ,
  void>::type
foo(V const& vector);

Still going to be verbose if you have V1..V10 but it's just 2*10 checks, not 1024. And of course you can write your own is_device_or_shared<Vector>::value to wrap those 2 tests in something slightly more readable.

How to write a function which takes different type of arguments?

1 Answers1