Sobrecarga del operador selector indirecto de miembro (Programación)

Sobrecarga del operador selector indirecto de miembro (Programación) Concepto: Se llama sobrecarga de operadores cuando reutilizando el mismo operador con un número de usos diferentes, y el compilador decide como usar ese operador dependiendo sobre qué opera.

Sobrecarga del operador selector indirecto de miembro (Programación).El selector indirecto de miembro -> es un operador binario que permite acceder a miembros de objetos cuando se dispone de punteros a la clase correspondiente. Una expresión del tipo Cpt->membr representa el miembro de identificador membr de la clase Cl siempre que Cpt sea un puntero a dicha clase. Ejemplo:

Sinopsis

La gramática C++ permite definir una función miembro operator-> que puede ser invocada con la sintaxis del operador selector indirecto de miembro ->. Por ejemplo, siendo obj una instancia de la clase Cl para la que se define la función operator->, y membr un miembro de la misma, la expresión: obj->membr; Es transformada por el compilador en una invocación del tipo: ( obj.operator->() )->membr; La parte entre paréntesis obj.operator->(), representa la invocación del método operator-> sobre el objeto obj. Puesto que el valor devuelto por la función será considerado a su vez el primer operando de -> aplicado a membr, la función operator-> debe devolver un puntero a un objeto de la clase sobre el que se pueda aplicar el operador ->. Es decir, su diseño debe tener el siguiente aspecto:

class Vector {
 ...
 Vector* operator-> () {
   ...
   return this;
 }
};

El puntero que se obtiene como resultado de la invocación obj.operator->() no depende de la naturaleza del operando membr. Por esta razón se considera a veces que operator-> es un operador unario posfijo. Lo que significa que una expresión como

v.operator->();

Tiene sentido y devuelve un puntero al objeto:

Vector v1;
Vector* vptr;
vptr = v1.operator->();  // Ok! vptr señala ahora a v1

Condiciones

Para conseguir este comportamiento el compilador impone ciertas limitaciones, de forma que la función operator-> solo puede ser sobrecargada cumpliendo simultáneamente las siguientes condiciones: a. Ser una función-miembro no estática (que incluya el puntero this como argumento implícito). b. Ser una función-miembro que no acepte argumentos. Ejemplo:

class Cl  {
 ...
 friend Cl* operator->();          // Error debe ser una función-miembro
 Cl* operator->(int i) {/*...*/}   // Error no acepta argumentos
 Cl* operator->() {/*...*/}        // Ok.
};

El operador -> no puede ser sobrecargado

El compilador se limita a sustituir el primer operando de la expresión obj->membr por la invocación a una función-miembro, y una posterior utilización del resultado como primer operando de la versión global del operador, mientras el segundo operando se mantiene invariable. Además, en dicha expresión (invocación de la función-miembro), el primer operando debe ser necesariamente un objeto (instancia) de la clase y no un puntero Cl* como exige el uso regular del selector ->.

Puede Consultar

• Operadores
• Sobrecarga de operadores
• Sobrecarga de operadores binarios (Programación)
• Sobrecarga de operadores unarios (Programación)
• Sobrecarga de operadores lógicos (Programación)
• Sobrecarga del operador subíndice (Programación)

Fuente

• Sobrecarga del operador ->
• Sobrecarga de operadores en c
• Sobrecarga de operadores en C++