There are different approaches:

  • With C++11 with non-template non-overloaded functions you can simply use:

    const auto& new_fn_name = old_fn_name;
  • If this function has multiple overloads you should use static_cast:

    const auto& new_fn_name = static_cast<OVERLOADED_FN_TYPE>(old_fn_name);

Example: there are two overloads of function std::stoi

int stoi (const string&, size_t*, int);
int stoi (const wstring&, size_t*, int);

If you want to make an alias to the first version you should use the following:

const auto& new_fn_name = static_cast<int(*)(const string&, size_t*, int)>(std::stoi);

Note: there is no way to make an alias to overloaded function such that all its overloaded versions work, so you should always specify which exact function overload you want.

  • With C++14 you can go even further with constexpr template variables. That allows you to alias templated functions:

    template<typename T>

    constexpr void old_function(/* args */);

    template constexpr auto aliastoold = old_function;

  • Moreover, starting with C++11 you have a function called std::mem_fn that allows to alias member functions. See the following example:

    struct A {

    void f(int i) { std::cout << "Argument: " << i << '\n'; } };

    A a;

    auto greet = std::mem_fn(&A::f); // alias to member function // prints "Argument: 5" greet(a, 5); // you should provide an object each time you use this alias

    // if you want to bind an object permanently use std::bind greeta = std::bind(greet, a, std::placeholders::1); greet_a(3); // equivalent to greet(a, 3) => a.f(3);