The perfect function alias

Question

For many years, I have waited for function aliases in C++. They still aren't here. I've been using macros to generate wrapper functions. This is my best attempt at the perfect function alias:

#define FUN_ALIAS(NEW_NAME, ...)                                                \
  template <typename... Args>                                                   \
  inline decltype(auto) NEW_NAME(Args &&... args)                               \
    noexcept(noexcept(__VA_ARGS__(std::forward<Args>(args)...))) {              \
    return __VA_ARGS__(std::forward<Args>(args)...);                            \
  }

I'm using std::forward to forward the arguments and I'm using decltype(auto) to get the right return type. In the future, we might have noexcept(auto) which will be perfect for this situation but I'm not getting my hopes up.

Here's an example from my OpenGL wrapper:

template <GLenum TYPE>
Shader<TYPE> makeShader();
template <GLenum TYPE>
Shader<TYPE> makeShader(const GLchar *, size_t);
template <GLenum TYPE, size_t... SIZES>
Shader<TYPE> makeShader(const GLchar (&... sources)[SIZES]);

FUN_ALIAS(makeVertShader, makeShader<GL_VERTEX_SHADER>)
FUN_ALIAS(makeFragShader, makeShader<GL_FRAGMENT_SHADER>)

What I want to know:

• Is there a situation where the compiler will not optimize away the wrapper because the wrapper and the original function have different semantics?
• Does this fail to compile for some functions?

Answer 1

Is there a situation where the compiler will not optimize away the wrapper because the wrapper and the original function have different semantics?

Yes to the first part and no to the second. Any optimizing compiler will inline your wrapper, as it consists of only one return statement.

But on the other hand, the original function might have different semantics: It might be constexpr for example, and your alias will not be.

Does this fail to compile for some functions?

No (except for the constexpr part).

So here are some improvements you can use:

1. Templates are implicitly inline, so you don't need to write it explicitly.

2. Use a lambda to combat the missing constexprness of the alias, because since C++17 lambdas are implicitly constexpr if they can be.

This will get you:

#define FUN_ALIAS(NEW_NAME, ...)                                                \
  inline auto NEW_NAME = [](auto &&... args)                                   \
    noexcept(noexcept(__VA_ARGS__(std::forward<decltype(args)>(args)...)))     \
    -> decltype(auto) {                                                        \
    return __VA_ARGS__(std::forward<decltype(args)>(args)...);                \
  };

Answer 2

This function alias is deficient. decltype(auto) will get you the right return type, but it is not SFINAE friendly. For example, the following fails to compile:

struct A{};
struct B{};

bool old_name(A i)
{
    return false;
}

FUN_ALIAS(new_name, old_name);

// This does compile if I use old_name instead
template <typename T>
auto something_else(T t)
    -> decltype(new_name(t))
{
    return new_name(t);
}

// If the prior overload SFINAEs away, this overload is chosen
bool something_else(...)
{
    return true;
}

bool foo()
{
    // Tries the first overload (varargs are lowest priority), but
    // it's a hard error instead of SFINAE, because new_name isn't
    // SFINAE friendly
    return something_else(B{});
}

Instead of decltype(auto), you need to use a trailing return type:

#define FUN_ALIAS(NEW_NAME, ...)                                                \
  template <typename... Args>                                                   \
  inline auto NEW_NAME(Args &&... args)                                         \
    noexcept(noexcept(__VA_ARGS__(std::forward<Args>(args)...)))                \
    -> decltype(__VA_ARGS__(std::forward<Args>(args)...))                       \
  {                                                                             \
    return __VA_ARGS__(std::forward<Args>(args)...);                            \
  }

This allows the prior snippet to compile.

Answer 3

After taking suggestions from the answers, I have written this new and improved function alias macro:

#define FUN_ALIAS_SPEC(SPECS, NEW_NAME, ...)                                    \
  template <typename... Args>                                                   \
  SPECS auto NEW_NAME(Args &&... args)                                          \
    noexcept(noexcept(__VA_ARGS__(std::forward<Args>(args)...)))                \
    -> decltype(__VA_ARGS__(std::forward<Args>(args)...)) {                     \
    return __VA_ARGS__(std::forward<Args>(args)...);                            \
  }

#define FUN_ALIAS(NEW_NAME, ...)                                                \
  FUN_ALIAS_SPEC(inline, NEW_NAME, __VA_ARGS__)

Thanks to @Justin, this is now SFINAE friendly by putting the function call expression in decltype() rather than using decltype(auto).

Thanks to @Rakete1111, this is now constexpr friendly by allowing the user to put specifiers before the definition. This means that the alias can also be made into static class member.

Thank you both for participating!