Entiendo más la sobrecarga de operadores, con la excepción de los operadores de acceso miembro ->, .*, ->*etc.

En particular, ¿qué se pasa a estas funciones de operador y qué se debe devolver?

¿Cómo sabe la función del operador (por ejemplo operator->(...)) a qué miembro se hace referencia? Puede saber? ¿Es necesario saberlo?

Finalmente, ¿hay alguna consideración constante que deba tenerse en cuenta? Por ejemplo, cuando se sobrecarga algo así operator[], generalmente necesitará tanto una versión const como una no const. ¿Los operadores de acceso de miembros requieren versiones const y no const?

->

Este es el único realmente complicado. Debe ser una función miembro no estática y no requiere argumentos. El valor de retorno se utiliza para realizar la búsqueda de miembros.

Si el valor de retorno es otro objeto de tipo de clase, no un puntero, la búsqueda de miembros subsiguiente también es manejada por una operator->función. Esto se denomina "comportamiento de desglose". El idioma encadena las operator->llamadas hasta que la última devuelve un puntero.

struct client
    { int a; };

struct proxy {
    client *target;
    client *operator->() const
        { return target; }
};

struct proxy2 {
    proxy *target;
    proxy &operator->() const
        { return * target; }
};

void f() {
    client x = { 3 };
    proxy y = { & x };
    proxy2 z = { & y };

    std::cout << x.a << y->a << z->a; // print "333"
}

->*

Este solo es complicado porque no tiene nada de especial. La versión no sobrecargada requiere un objeto de puntero al tipo de clase en el lado izquierdo y un objeto de puntero al tipo de miembro a la derecha. Pero cuando lo sobrecarga, puede tomar los argumentos que desee y devolver lo que quiera. Ni siquiera tiene que ser un miembro no estático.

En otras palabras, éste es sólo un operador binario normal como +, -, y /. Ver también: ¿El operador libre -> * sobrecarga el mal?

.* y .

No se pueden sobrecargar. Ya hay un significado incorporado cuando el lado izquierdo es de tipo de clase. Quizás tenga un poco de sentido poder definirlos para un puntero en el lado izquierdo, pero el comité de diseño del lenguaje decidió que sería más confuso que útil.

La sobrecarga ->, ->*, ., y .*sólo se puede llenar en caso de que iba a ser indefinido una expresión, nunca puede cambiar el significado de una expresión que sería válido sin sobrecarga.

Operador -> es especial.

"Tiene restricciones atípicas adicionales: debe devolver un objeto (o referencia a un objeto) que también tiene un operador de desreferencia de puntero, o debe devolver un puntero que se puede usar para seleccionar a qué apunta la flecha del operador de desferencia de puntero. " Bruce Eckel: Pensando CPP Vol-uno: operador->

La funcionalidad adicional se proporciona para su comodidad, por lo que no tiene que llamar

a->->func();

Simplemente puedes hacer:

a->func();

Eso hace que el operador -> sea diferente de las otras sobrecargas del operador.

No puede sobrecargar el acceso de miembros .(es decir, la segunda parte de lo que ->hace). Sin embargo, puede sobrecargar el unario desreferenciar operador *(es decir, la primera parte de lo que ->lo hace).

El ->operador C ++ es básicamente la unión de dos pasos y esto está claro si cree que x->yes equivalente a (*x).y. C ++ le permite personalizar qué hacer con la (*x)parte cuando xes una instancia de su clase.

La semántica para la ->sobrecarga es algo extraña porque C ++ le permite devolver un puntero regular (que se usará para encontrar el objeto puntiagudo) o devolver una instancia de otra clase si esta clase también proporciona un ->operador. Cuando en este segundo caso, la búsqueda del objeto desreferenciado continúa desde esta nueva instancia.

El ->operador no sabe a qué miembro se está señalando, solo proporciona un objeto para realizar el acceso real del miembro.

Además, no veo ninguna razón por la que no pueda proporcionar versiones const y no const.

Cuando sobrecarga el operador -> () (no se pasan argumentos aquí), lo que el compilador realmente hace es llamar -> recursivamente hasta que devuelva un puntero real a un tipo. Luego usa el miembro / método correcto.

Esto es útil, por ejemplo, para crear una clase de puntero inteligente que encapsule el puntero real. Se llama al operador sobrecargado->, hace lo que sea que haga (por ejemplo, bloqueo por seguridad de subprocesos), devuelve el puntero interno y luego el compilador llama -> para este puntero interno.

En cuanto a la constidad, se ha respondido en los comentarios y otras respuestas (puede y debe proporcionar ambas).