¿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 hollerpara printf. #definir 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<OVERLOADED_FN_TYPE>(old_fn_name);

  Ejemplo: hay dos sobrecargas de funciones 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<int(*)(const string&, size_t*, int)>(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é sobrecarga de función exacta desea.

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

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

• Además, comenzando con C ++ 11 tiene una función llamada std::mem_fnque permite alias 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) => a.f(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ía estar bien.

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

Utilice una envoltura en línea. Obtiene ambas API, pero conserva la implementación única.

De 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)...); \
}

Vale la pena mencionar aquí, en mi opinión, que si bien la pregunta original (y las excelentes respuestas) son definitivamente útiles si desea cambiar el nombre de una función (¡hay buenas razones para hacerlo!), Si todo lo que desea hacer es eliminar un espacio de nombres profundo, pero mantener el nombre, existe la usingpalabra clave para esto:

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
}

Esto también tiene la ventaja de que se limita a un ámbito, aunque siempre se puede utilizar en el nivel superior de un archivo. A menudo utilizo esto para couty endlasí que no necesito llevar en todas stdcon el clásico using namespace std;en la parte superior de un archivo, pero también es útil si usted está usando algo comostd::this_thread::sleep_for() una gran cantidad en un solo archivo o función, pero no en todas partes, y ninguna otra función del espacio de nombres. Como siempre, se desaconseja usarlo en archivos .h, o contaminará el espacio de nombres global.

Esto no es lo mismo que el "cambio de nombre" anterior, pero a menudo es lo que realmente se desea.

Con lambdas genéricas C ++ 14, pude hacer lo siguiente, que también debería funcionar cuando la función de destino tiene múltiples sobrecargas:

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