agnel kurian
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 por printf. #define es obvio… ¿de alguna otra manera?
Soluciones:
#define holler printfvoid (*p)() = fn; //function pointervoid (&r)() = fn; //function referenceinline void g(){ f(); }
sasha.sochka
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 función std::stoi
int stoi (const string&, size_t*, int);
int stoi (const wstring&, size_t*, int);
Si desea hacer un alias a 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é función exacta desea sobrecargar.
Con C++14 puedes ir aún más lejos con constexpr variables de plantilla. Eso le permite crear alias de 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 tienes una función llamada std::mem_fn que permite crear alias de 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);
Excelente, ¿qué hay de C++ 98? Tengo una clase con 2 sobrecargas de “reinicio” que se usan para configurar y restablecer. Internamente, no hay problema. Para los usuarios externos, quería crear un alias como “establecer”, por lo que es intuitivo para el contexto (establecer un objeto de trabajo construido por defecto, claro (), etc.; restablecer). Métodos de clase: (1) “void (&set)(const string&,const bool,const bool);” (2) void (&set)(const string&,const int,const bool); 2 “restablecer” con las firmas correspondientes hacen el trabajo. Dado que tengo la firma en la declaración de clase, ¿puedo simplemente inicializar la clase: establecer (reiniciar), establecer (reiniciar)? Si no, ¿funcionará su ejemplo explícito de static_cast?
– Luv2code
3 de julio de 2015 a las 21:44
Parece que hay un problema con el constexpr enfoque de variables de plantilla: el alias no puede hacer deducción de tipo. El compilador requiere que proporcione una lista de parámetros de plantilla (estoy escribiendo una función de plantilla variable): no se puede hacer referencia a la plantilla variable `alias_to_old’ sin una lista de argumentos de plantilla
– usuario69818
11 de febrero de 2016 a las 19:21
constexpr auto new_fn_name = old_fn_name funciona en C++ 11 (al menos en gcc 4.9.2) y es mejor que colocar &. No requiere que la llamada se realice siempre a través del puntero y, por lo tanto, permite que la función se incorpore en lugar de la llamada.
– solo
10/03/2016 a las 14:31
Con las lambdas genéricas de 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 )... ); };
– Antonio Hall
7 dic 2016 a las 0:33
Utilizando std::mem_fn es no un alias ya que realiza mucha más magia detrás del sentido.
– cgsdfc
21 de febrero de 2019 a las 12:53
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
Esto se lleva la palma. No sabía acerca de las referencias a funciones.
– Agnel Kurian
16 de junio de 2010 a las 13:25
@Vulcan: son casi iguales en el sentido de que puede llamarlos a ambos con la misma sintaxis, pero sus direcciones son un poco diferentes. r no ocupa su propio espacio de memoria para contener una dirección.
– Brian R. Bondy
16 de junio de 2010 a las 13:27
como llamarias fn, utilizando el alias? ¿Puede explicar el puntero de función y la referencia de función? ¿En qué se diferencian? ¿Son iguales aquí?
– ma11hew28
10 de agosto de 2011 a las 17:54
@Matt, lo llamas exactamente como llamarías a fn. r();
– Agnel Kurian
28 de junio de 2012 a las 3:02
¿Cómo harías esto para un método de instancia? EDITAR: esto parece compilar: void (&r)() = this->fn;
– sam
18/09/2013 a las 14:15
typedef int (*printf_alias)(const char*, ...);
printf_alias holler = std::printf;
Debería hacerte bien.
¿No está printf en el espacio de nombres global?
– Agnel Kurian
19 de marzo de 2013 a las 16:34
es global si incluyó
– Injektilo
11 de abril de 2013 a las 8:47
@einpoklum: No hay nada de malo en tipodeclpero la respuesta es de 2010. Entonces no había decltype como se introdujo en c ++ 11. Además, esto también debería funcionar con el viejo C simple.
– Phidelux
5 de enero de 2019 a las 19:16
int (*holler)(const char*, ...) = std::printf;
Utilice una envoltura en línea. Obtiene ambas API, pero mantiene la implementación única.
pez vela009
Desde 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)...); \
}
salón antonio
Con las lambdas genéricas de 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 )... );
};
¡Ja! Eso me entristece, incluso @user5534993, quien originalmente lo presionó para que enviara esta respuesta, luego no pudo emitir un voto positivo en su dirección. Bueno, toma, ten uno conmigo.
– FeRD
21 de agosto de 2020 a las 7:30
Gracias a todos ustedes. A mis colegas les encantará ver
void (&NewName)(some_vector&, float, float, float, float) = OldName;en mi próximo check in.– Agnel Kurian
16 de junio de 2010 a las 13:30
no tanto como les encantará verte usar nombres aleatorios para funciones de biblioteca estándar.
– jalf
16 de junio de 2010 a las 13:58
no me estoy metiendo con
printfaquí. Eso fue solo un ejemplo. El problema aquí tiene más que ver con las limitaciones del inglés que con cualquier otra cosa. Tengo una sola función que sirve para el propósito A y el propósito B, pero simplemente no puedo encontrar un solo nombre que sirva para ambos propósitos aquí.– Agnel Kurian
16 de junio de 2010 a las 16:59
@Neil, precisamente.
T &a = b;crea un nuevo nombre parab.typedefpara tipos ynamespace A=B;para espacios de nombres.– Agnel Kurian
17 de junio de 2010 a las 3:41
Hay
using BaseClass::BaseClassMethody ahí estáusing AliasType = Type;e incluso haynamespace AliasNamespace = Namespace;. Lo que nos falta esusing AliasFunction = Function;– anton_rh
1 de marzo de 2018 a las 9:12