Can C++ free functions be aliased?

Question

I have a namespace with one highly templated free function, such as:

namespace a
{
    template<typename T, typename K, typename H>
    void f(T t, K k, std::vector<H> h_vec = {})
    { /* body */ }
}

Inside another namespace, for convenience I would like to have some aliases of it for a bunch of specific usages, such has:

namespace b
{
    using my_specific_f = a::f<int,string,char>;
}

Which would allow me to provide a better naming for the function, since f is very generic in the code base I am working on (please keep in mind I am providing only simplified examples here to make the point). But unfortunately, this is apparently forbidden by the language.

So in my second attempt I tried to use a function pointer:

namespace b
{
    auto my_specific_f = &a::f<int,string,char>
}

This would normally work, but in my case it does not since f has one defaulted parameter, which I guess leads to the function having more than one function pointer (in this case two), and only the three parameter version can be used.

At this point I just gave up and simply made my_specific_f redirect the call in its body to f:

namespace b
{
    void my_specific_f(int i, string s, vector<char> v = {} )
    {
        a::f(i,s,v);
    }
}

But this solution I do not really like, as it leads to less maintainability in case f will change its signature since all the redirecting functions need to be adapted concordantly, and my original plan was to create more than just one alias.

Is there anything left I could try? Is it even possible or will it be possible in some future release of the standard?

@KamilCuk yes, it is clear that it will never work with `using`. Any other idea? — nyarlathotep108, Mar 28 '19 at 20:32
Are you okay with having a custom name, but not specifying what the function types should be? — NathanOliver, Mar 28 '19 at 20:33
Can you provide MCVE? Your second example compiles as is. https://gcc.godbolt.org/z/IsoJQR The solution would depend MCVE. — SergeyA, Mar 28 '19 at 20:33
@SergeyA it compiles, but only the version with all the three parameters can be used, not the defaulted one with two. — nyarlathotep108, Mar 28 '19 at 20:34
@NathanOliver yes, because in my real world case the custom name I would provide would be much more readable than the parametrized generic function. — nyarlathotep108, Mar 28 '19 at 20:41
If your only problem is with signatures, you can make your `my_specific_f` a variadic template with perfect forwarding. — SergeyA, Mar 28 '19 at 20:48

NathanOliver · Accepted Answer · 2019-03-28T21:46:07.920

10

What you can do is wrap the fucntion in a generic lambda so you can give it a custom name. You can do that like

auto my_really_informative_name = [](auto&&... args) -> decltype(auto) { 
                                      return f(std::forward<decltype(args)>(args)...);
                                  };

This perfectly forwards the parameters to f and if it's signature ever changes it will still work since the lambda can take any number of arguments.

If you want to to be perfectly forwarding (noexcecpt qualification and return type in a SFINAE way)

auto my_really_informative_name = [](auto&&... args) noexcept(noexcept(f(std::forward<decltype(args)>(args)...))) -> decltype(f(std::forward<decltype(args)>(args)...)) { 
                                      return f(std::forward<decltype(args)>(args)...);
                                  };

If you want to make sure the types passed to the function are of a certain type then you can specify them explicitly in the function call like

auto my_really_informative_name = [](auto&&... args) -> decltype(auto) { 
                                      return f<int, std::string, char>(std::forward<decltype(args)>(args)...);
                                  };

edited Mar 28 '19 at 21:46

answered Mar 28 '19 at 20:45

NathanOliver

171,901
28
288
402

With this solution there would be not way to check that `my_really_informative_name` is actually called with the right parameters that match the expectation for that name. Sorry for the misunderstanding. In my not correct first attempt, the one which tries to use the `using` keyword, `my_specific_f` exists only for the parameters `int`, `string` and the optional (defaulted to empty) `vector`. – nyarlathotep108 Mar 28 '19 at 21:27
1

@nyarlathotep108 A solution has been added to the answer. – NathanOliver Mar 28 '19 at 21:48
can this be achieved also with restriction to C++11 somehow? – nyarlathotep108 Mar 29 '19 at 09:57
1

@nyarlathotep108 Not as a lambda. You would have to write a custom functor like: http://coliru.stacked-crooked.com/a/1fa128ddb85f0c57 – NathanOliver Mar 29 '19 at 12:25

Can C++ free functions be aliased?

1 Answers1