¿Cómo asigno un alias a un nombre de función en C ++?

Es fácil crear un nuevo nombre para un tipo, una variable o un espacio de nombres. ¿Pero cómo asigno un nuevo nombre a una función? Por ejemplo, quiero usar el nombre holler para printf . #define es obvio … ¿de otra manera?

Soluciones:

  1. #define holler printf
  2. void (*p)() = fn; //function pointer
  3. void (&r)() = fn; //function reference
  4. inline void g(){ f(); }

Hay diferentes enfoques:

  • Con C ++ 11 con funciones no sobrecargadas sin plantilla, simplemente puede usar:

     const auto& new_fn_name = old_fn_name; 
  • Si esta función tiene múltiples sobrecargas, debe usar static_cast :

     const auto& new_fn_name = static_cast(old_fn_name); 

    Ejemplo: hay dos sobrecargas de la función std::stoi

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

    Si desea crear un alias para la primera versión, debe usar lo siguiente:

     const auto& new_fn_name = static_cast(std::stoi); 

    Nota: no hay forma de crear un alias para la función sobrecargada de modo que todas sus versiones sobrecargadas funcionen, por lo que siempre debe especificar qué función de sobrecarga exacta desea.

  • Con C ++ 14 puede ir aún más allá con las variables de plantilla constexpr . Eso le permite alias las funciones de plantilla:

     template constexpr void old_function(/* args */); template constexpr auto alias_to_old = old_function; 
  • Además, a partir de C ++ 11 tiene una función llamada std::mem_fn que permite std::mem_fn funciones miembro. Vea el siguiente ejemplo:

     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) => af(3); 

Puede crear un puntero de función o una referencia de función:

 void fn() { } //... void (*p)() = fn;//function pointer void (&r)() = fn;//function reference 
 typedef int (*printf_alias)(const char*, ...); printf_alias holler = std::printf; 

Deberías hacerlo bien

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

Use un contenedor en línea. Obtendrá ambas API, pero mantenga la implementación única.

Desde fluentcpp : ALIAS_TEMPLATE_FUNCTION (f, g)

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