重载函数内部的函数重载

Question

I am using C++14 (and pretty new to it). I have 3 overloaded functions func within which another overloaded function do_something gets called depending on its parent function ( func ).

int func(int a) {
   bar(a);
   foo();
 }

int func(int a, float b) {
   bar(a);
   do_something(b);
   foo();
}

int func(int a, float b, char c) {
   bar(a);
   do_something(b, c);
   foo();
 }

I see that the functionality within func is almost the same except which version of do_something gets called. Is there any way I can make this generic and combine all func 's together?

Answer 1

To begin with, make func a template that accepts a parameter pack. The int a argument, the call to bar and the call to foo are always there, so that's simple. Let's add a placeholder for do_something for now.

template <class ...Args>
int func(int a, Args&&... other)
{
   bar(a);
   // somehow call do_something and do the right thing
   foo();

   return 0;
}

You want to instantiate and invoke the above template as before:

func(42);
func(42, 1.f);
func(42, 1.f, 'A');

Now let's tackle the call to do_something . If you simply add it in the middle of the new func template;

do_something(std::forward<Args>(other)...);

this refuses to compile for func(42) , ie, the case with only one argument. Hence, we need a special case for this. One way to achieve this in another level of indirection for do_something :

// No additional argument case, does nothing:
void do_something_wrapper() {}

// The other two cases    
template <class ...Args>
void do_something_wrapper(Args&&... args)
{
   do_something(std::forward<Args>(args)...);
}

And now, the placeholder from the func function template should be:

do_something_wrapper(std::forward<Args>(other)...);

Answer 2

The first step would be to use variadic-templates to take the part you want to forward to do_something :

template<class ... Args>
int func(int a, Args... args)
{
   bar(a);
   do_something(std::forward<Args>(args)...)
   foo();
}

But now you have lost the argument types of func. So if this is a problem you will have to find a way to test them again.

Answer 3

Although I would probably go with the answer from generic_opto_guy myself, he's right to point out that you would lose the types in your interface. Depending on your situation, you might want to preserve this.

In that case, you can easily rework it to something akin to the following:

namespace details {

template<class ... Args>
int func_impl(int a, Args &&... args)
{
   bar(a);
   do_something(std::forward<Args>(args)...)
   foo();
}

}

int func(int a) { return details::func_impl(a); }

int func(int a, float b) { return details::func_impl(a, b); }

int func(int a, float b, char c) { return details::func_impl(a, b, c); }

Note that the implementation has been adjusted to use perfect forwarding . While not required in this particular case, it is often useful in forwarding situations you might encounter in the future.

Again, unless you absolutely need to present a clear interface to client code, I would just go with the first implementation.

Answer 4

The other answers are good general purpose answers to the question as asked, but if you have a few "spare" values of c available, you could write something like:

int func(int a) {
   func(a, 0.0,'\001');
}

int func(int a, float b, char c = '\002') {
   bar(a);
   switch (c) {
   case '\001':
      break;              // func(a)
   case '\002':
      do_something(b):    // func(a, b)
      break;
   default:
      do_something(b, c); // func(a, b, c)
      break;
   }
   foo();
}

Depending on the application, this may be simpler.

Answer 5

Is too late to play?

You tagged C++14 but, if you could use C++17, you could use if constexpr so

template <typename ... Ts>
int func (int a, Ts && ... ts)
 {
   bar(a);

   if constexpr ( sizeof...(Ts) > 0u )
      do_something(std::forward<Ts>(ts)...);

   foo();

   // and remember to return something of int
 }

In C++14 you have to duplicate something somewhere.

Or you write two func() s

int func (int a)
 {
   bar(a);    
   foo();

   // and remember to return something of int
 }


template <typename ... Ts>
int func (int a, Ts && ... ts)
 {
   bar(a);

   do_something(std::forward<Ts>(ts)...);

   foo();

   // and remember to return something of int
 }

or you add a no-argument do_something()

void do_something ()
 { }

or, as suggested by lubgr, you call do_something() through a wrapper (creating a special no-argument wrapper).