Un puntero a función miembro no es una dirección de ejecución autónoma como lo es un puntero a una función libre; es, en esencia, una descripción de un protocolo de acceso que requiere obligatoriamente una instancia de una clase para ser válido. A diferencia de un puntero a función estándar, su tipo incluye el alcance de la clase (como MiClase::*) y, a nivel de ABI, su implementación puede ser más compleja de lo que parece, ya que debe gestionar el paso implícito del puntero this y, en el caso de métodos virtuales, la resolución a través de la vtable.
Para entender su funcionamiento, debemos separar la definición del tipo de la sintaxis de invocación. El tipo de un puntero a una función miembro que no es constante y que recibe un int es void (Clase::*)(int). La sintaxis de invocación es deliberadamente verbosa para evitar ambigüedades de precedencia: si tienes un objeto obj y un puntero ptr, debes escribir (obj.*ptr)(args) para que el operador de puntero a miembro .* tenga prioridad sobre el operador de llamada (). Si trabajas con un puntero a objeto p_obj, la sintaxis es (p_obj->*ptr)(args).
Este mecanismo es fundamental cuando implementas tablas de despacho manuales (dispatch tables) para sistemas de comandos o máquinas de estado donde la lógica no se define mediante polimorfismo virtual, sino mediante una selección de métodos en tiempo de ejecución. Sin embargo, los punteros a función miembro tienen una limitación crítica: su firma debe ser exacta. No puedes asignar un método de una clase derivada a un puntero de una clase base de forma directa si los tipos de retorno o los parámetros varían mínimamente, a diferencia de lo que permite la herencia de métodos virtuales.
En el C++ moderno, la complejidad de esta sintaxis ha sido mitigada por dos herramientas clave. std::mem_fn [C++11] actúa como un wrapper que encapsula el puntero a miembro y permite tratarlo como un objeto callable, facilitando su uso en algoritmos de la STL. Por su parte, std::invoke [C++17] proporciona una interfaz de invocación uniforme, permitiendo que una misma plantilla pueda llamar a una función libre, a un puntero a función miembro o a un objeto functor sin necesidad de sobrecargar el código para cada caso.
Si intentas tratar un puntero a función miembro como si fuera un puntero a función normal —por ejemplo, intentando pasarlo directamente a un std::for_each sin envolverlo en std::mem_fn— el compilador lanzará un error de tipo masivo e incomprensible. Lo mismo ocurre si intentas invocarlo sin proporcionar una instancia válida, lo que resultará en un acceso a memoria inválida (un this nulo o corrupto) y, por tanto, en un comportamiento indefinido.
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <functional> // Para std::mem_fn y std::invoke
class ProcesadorDeDatos {
public:
void procesar(int valor) const {
std::cout << "Procesando valor: " << valor << std::endl;
}
void transformar(int& valor) const {
valor *= 2;
}
int obtener_estado() const { return 42; }
};
class Logueador {
public:
void registrar(const std::string& msg) const {
std::cout << "[LOG]: " << msg << std::endl;
}
};
// Un template que abstrae la invocación usando std::invoke [C++17]
// Esto permite que la misma lógica funcione para funciones libres o miembros.
template <typename F, typename T, typename... Args>
void ejecutar_comando(T& objeto, F&& func, Args&&... args) {
std::invoke(std::forward<F>(func), objeto, std::forward<Args>(args)...);
}
int main() {
ProcesadorDeDatos procesador;
Logueador logueador;
// 1. Definición de punteros a función miembro
// La sintaxis requiere especificar el alcance de la clase
void (ProcesadorDeDatos::*ptr_procesar)(int) = &ProcesadorDeDatos::procesar;
void (Logueador::*ptr_log)(const std::string&) = &Logueador::registrar;
// 2. Invocación manual con la sintaxis de puntero a miembro
// Los paréntesis son obligatorios debido a la precedencia de operadores
(procesador.*ptr_procesar)(100);
(logueador.*ptr_log)("Operación iniciada");
// 3. Uso de std::mem_fn [C++11] con algoritmos STL
// std::mem_fn convierte el puntero en un objeto que acepta el objeto como primer arg.
std::vector<int> datos = {1, 2, 3, 4, 5};
std::for_each(datos.begin(), datos.end(), std::mem_fn(&ProcesadorDeDatos::procesar));
// Nota: El ejemplo anterior fallaría si procesar requiriera argumentos adicionales,
// pero funciona aquí porque for_each pasa el elemento como argumento único.
// 4. Aplicación de std::invoke [C++17] para uniformidad
// Podemos pasar la función directamente, el puntero o el wrapper de mem_fn
std::cout << "--- Invocación Uniforme ---" << std::endl;
ejecutar_comando(procesador, &ProcesadorDeDatos::procesar, 200);
ejecutar_comando(logueador, &Logueador::registrar, "Ejecución de comando mediante invoke");
// 5. Tabla de despacho (Dispatch Table) manual
// Útil para evitar vtables cuando los métodos no son virtuales pero se quieren seleccionar
using FuncPtr = void (ProcesadorDeDatos::*)(int);
FuncPtr tabla[] = { &ProcesadorDeDatos::procesar, &ProcesadorDeDatos::procesar };
for (auto f : tabla) {
(procesador.*f)(50);
}
return 0;
}
Análisis del código
En el ejemplo, observamos cómo la sintaxis de ptr_procesar requiere la estructura void (ProcesadorDeDatos::*)(int). El uso de (procesador.*ptr_procesar)(100) es la única forma correcta de invocar el método; sin los paréntesis externos, el compilador intentaría evaluar la llamada ptr_procesar(100) antes de aplicar el puntero al objeto, lo cual es un error sintáctico.
La función ejecutar_comando es el ejemplo de potencia de std::invoke. Internamente, std::invoke detecta si el primer argumento es un puntero a miembro de función; si lo es, aplica automáticamente la llamada con la sintaxis (obj.*func)(args...). Esto permite que nuestro template sea agnóstico a si estamos operando sobre una función normal o un método de clase, eliminando la necesidad de usar std::enable_if o especializaciones complejas para diferenciar la forma de llamada.
Cuando usamos std::mem_fn(&ProcesadorDeDatos::procesar) dentro de std::for_each, lo que ocurre es que se crea un objeto temporal que actúa como un functor. Cuando el algoritmo std::for_each llega a cada elemento del std::vector<int>, llama al operador () de ese functor pasándole el elemento actual. El mem_fn toma ese elemento y lo usa internamente como el objeto sobre el cual llamar al método procesar.
El error frecuente
Un error clásico ocurre al intentar pasar un puntero a función miembro directamente a un algoritmo de la STL que espera un Callable convencional, como std::transform.
// ERROR: Esto no compilará
std::vector<int> v = {1, 2, 3};
std::vector<int> r;
std::transform(v.begin(), v.end(), std::back_inserter(r), &ProcesadorDeDatos::procesar);
El error es que std::transform intentará llamar a procesar(elemento), pero &ProcesadorDeDatos::procesar no es una función, sino un puntero que requiere una instancia para operar. El compilador te dirá que no puede convertir un puntero a función miembro en un objeto ejecutable. Para solucionarlo, debes usar std::mem_fn (que crea un objeto que acepta el objeto como primer parámetro) o un lambda: [](ProcesadorDeDatos& p, int v){ p.procesar(v); } (aunque esto último requeriría ajustar la firma del lambda para std::transform o usar std::for_each). En el caso específico de std::transform, la forma correcta sería:
std::transform(v.begin(), v.end(), std::back_inserter(r), std::mem_fn(&ProcesadorDeDatos::procesar)); (siempre que la firma coincida).
N° 138