Как назначить псевдоним имени функции в C++?

Существуют разные подходы:

• С С++ 11 с неперегруженными функциями без шаблонов вы можете просто использовать:

  const auto& new_fn_name = old_fn_name;
  

• Если эта функция имеет несколько перегрузок, вы должны использовать static_cast:

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

  Пример: есть две перегрузки функции std::stoi

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

  Если вы хотите создать псевдоним для первой версии, вы должны использовать следующее:

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

  Примечание. невозможно создать псевдоним для перегруженной функции, чтобы работали все ее перегруженные версии, поэтому всегда следует указывать, какую именно перегрузку функции вы хотите.

• С C++14 вы можете пойти еще дальше с constexpr переменными шаблона. Это позволяет вам создавать псевдонимы шаблонных функций:

  template<typename T>
  constexpr void old_function(/* args */);
  
  template<typename T>
  constexpr auto alias_to_old = old_function<T>;
  

• Кроме того, начиная с C++11, у вас есть функция с именем std::mem_fn, которая позволяет создавать псевдонимы для функций-членов. См. следующий пример:

  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`
  greet_a = std::bind(greet, a, std::placeholders::_1);
  greet_a(3); // equivalent to greet(a, 3) => a.f(3);
  

Вы можете создать указатель на функцию или ссылку на функцию:

void fn()
{
}

//...

void (*p)() = fn;//function pointer
void (&r)() = fn;//function reference

typedef int (*printf_alias)(const char*, ...);
printf_alias holler = std::printf;

Должно быть хорошо.

Используйте встроенную оболочку. Вы получаете оба API, но сохраняете единую реализацию.

Из fluentcpp: ALIAS_TEMPLATE_FUNCTION(f, g)

#define ALIAS_TEMPLATE_FUNCTION(highLevelF, lowLevelF) \
template<typename... Args> \
inline auto highLevelF(Args&&... args) -> decltype(lowLevelF(std::forward<Args>(args)...)) \
{ \
    return lowLevelF(std::forward<Args>(args)...); \
}

С помощью общих лямбда-выражений С++ 14 я смог сделать следующее, что также должно работать, когда целевая функция имеет несколько перегрузок:

constexpr auto holler = [] ( auto &&...args ) {
        return printf( std::forward<decltype(args)>( args )... );
    };

Здесь стоит упомянуть ИМО, что, хотя исходный вопрос (и отличные ответы), безусловно, полезен, если вы хотите переименовать функцию (для этого есть веские причины!), Если все, что вы хотите сделать, это удалить глубокое пространство имен, но сохраните имя, для этого есть ключевое слово using:

namespace deep {
  namespace naming {
    namespace convention {
      void myFunction(int a, char b) {}
    }
  }
}
int main(void){
  // A pain to write it all out every time
  deep::naming::convention::myFunction(5, 'c');

  // Using keyword can be done this way
  using deep::naming::convention::myFunction;
  myFunction(5, 'c');  // Same as above
}

Это также имеет то преимущество, что оно ограничено областью действия, хотя вы всегда можете использовать его на верхнем уровне файла. Я часто использую это для cout и endl, поэтому мне не нужно вводить ВСЕ std с классическим using namespace std; в начале файла, но это также полезно, если вы часто используете что-то вроде std::this_thread::sleep_for() в одном файле или функции, но не везде и не любые другие функции из пространства имен. Как всегда, не рекомендуется использовать его в файлах .h, иначе вы загрязните глобальное пространство имен.

Это не то же самое, что «переименование» выше, но часто это то, что действительно нужно.