compile - C++ 11: ¿Cómo alias una función?

g++

Question

Si tengo una clase Foo en la barra del espacio de nombres:

namespace bar
{
    class Foo { ... }
};

Puedo entonces:

using Baz = bar::Foo;

y ahora es justo como definí la clase en mi espacio de nombres con el nombre Baz.

¿Es posible hacer lo mismo para las funciones?

namespace bar
{
    void f();
}

Y entonces:

using g = bar::f; // error: ‘f’ in namespace ‘bar’ does not name a type

¿Cuál es la forma más limpia de hacer esto?

La solución también debería ser válida para las funciones de plantilla.

Definición: Si alguna entidad B es un alias de A, que si cualquiera o todos los usos (no declaraciones o definiciones de curso) de A se reemplazan por B en el código fuente, el código generado (eliminado) sigue siendo el mismo. Por ejemplo typedef AB es un alias. #define BA es un alias (al menos). T& B = A no es un alias, B puede implementarse efectivamente como un puntero indirecto, donde un "A no alias" puede usar "semántica inmediata".

Answer 1

Absolutamente:

#include <iostream>

namespace Bar
{
   void test()
   {
      std::cout << "Test/n";
   }


   template<typename T>
   void test2(T const& a)
   {
      std::cout << "Test: " << a << std::endl;
   }
}

void (&alias)()        = Bar::test;
void (&a2)(int const&) = Bar::test2<int>;

int main()
{
    Bar::test();
    alias();
    a2(3);
}

Tratar:

> g++ a.cpp
> ./a.out
Test
Test
Test: 3
>

Una referencia es un alias de un objeto existente.
Acabo de crear una referencia a una función. La referencia se puede usar exactamente de la misma manera que el objeto original.

Answer 2

El puntero de función constexpr se puede usar como un alias de función.

namespace bar
{
    int f();
}

constexpr auto g = bar::f;

En el lugar donde se usa el alias, el compilador llamará a la función con alias aun cuando compile sin ninguna optimización.

Con GCC7 el siguiente uso

int main()
{
    return g();
}

se convierte

main:
  push rbp
  mov rbp, rsp
  call bar::f()  # bar::f() called directly.
  pop rbp
  ret

El ensamblado se generó en Compiler Explorer .

Answer 3

Es posible introducir la función en un alcance diferente sin cambiar su nombre. Para que pueda alias una función con un nombre calificado diferente:

namespace bar {
  void f();
}

namespace baz {
  using bar::f;
}

void foo() {
  baz::f();
}

Answer 4

Las clases son tipos , por lo que se pueden alias con typedef y using (en C ++ 11).

Las funciones se parecen mucho más a objetos , por lo que no existe un mecanismo para aliarlas. En el mejor de los casos, podría usar punteros de funciones o referencias de funciones:

void (*g)() = &bar::f;
void (&h)() = bar::f;

g();
h();

En el mismo sentido, no hay un mecanismo para aliasing variables (corto a través de punteros o referencias).

Answer 5

No es C ++ estándar, pero la mayoría de los compiladores proporcionan una forma de hacerlo. Con GCC puedes hacer esto:

void f () __attribute__ ((weak, alias ("__f")));

Esto crea el símbolo f como un alias para __f . Con VC ++ haces lo mismo de esta manera:

#pragma comment(linker, "/export:f=__f")

Answer 6

Puede definir un alias de función (con algo de trabajo) utilizando un reenvío perfecto:

template <typename... Args>
auto g(Args&&... args) -> decltype(f(std::forward<Args>(args)...)) {
  return f(std::forward<Args>(args)...);
}

Esta solución se aplica incluso si f está sobrecargado y / o una plantilla de función.

Answer 7

Puedes usar buenas macros antiguas

namespace bar
{
    void f();
}

#define f bar::f

int main()
{
    f();
}