Understanding Function Aliasing in C 11

In the realm of object-oriented programming in C , the ability to alias classes using the using directive is a common practice to simplify code readability and maintainability. However, when it comes to aliasing functions, the syntax for classes cannot be directly applied.

Let's consider a scenario where you have a function named f defined in namespace bar. Traditionally, you would expect a similar syntax to classes to work:

using g = bar::f; // Error: 'f' in namespace 'bar' does not name a type

Unfortunately, this approach results in an error because functions are not inherently types in C . So, how can you elegantly achieve function aliasing?

Solution: Perfect Forwarding Function Alias

C 11 introduces a technique known as perfect forwarding to create function aliases. Using perfect forwarding, you can define an alias function that accepts an arbitrary number of arguments and forwards them to the original function:

template 
auto g(Args&&... args) -> decltype(f(std::forward(args)...)) {
  return f(std::forward(args)...);
}

This solution works even if the original function (f) is overloaded or a function template. Perfect forwarding ensures that the forwarded arguments match the exact signature of the original function, preserving the intended semantics.

By using perfect forwarding, you effectively create an alias function (g) whose behavior is identical to the original function (f). This technique provides a clean and versatile way to achieve function aliasing in C , enhancing code readability and modularity.