¿Cuál es el motivo de la diferencia entre -> y. en c/C++?

Question

duplicados posibles:
C++: ptr->hello(); /* VERSUS */ (*ptr).hello();
Why does C have a distinction between -> and . ?

que conocen la diferencia entre el operador y el país miembro por el operador puntero (->) (.).

¿Por qué los diseñadores de C crearon un operador diferente para este acceso? ¿Por qué el compilador no puede resolverlo por sí mismo?

Si siempre usó a. ¿Existe algún caso donde sea ambiguo si se refiere a un miembro o miembro por puntero?

editar: No estoy buscando la sintaxis "(* a) .b". Pregunto por qué los diseñadores no te permitieron usar "a.b" en lugar de "a-> b".

Answer 1

Cuando tiene un lenguaje que, en esencia, pretende ser un "ensamblador portátil", no intenta ocultar los detalles de implementación del usuario. Por supuesto, el compilador puede darse cuenta de que en la expresión a.b, el a en cuestión es un puntero. ¿Puedes? ¿Seguramente? ¿Todo el tiempo? ¿En código peludo y complicado?¿Y no puedes imaginar una circunstancia en la que no ser capaz de notar rápidamente que a es un puntero podría ser un problema?

Deje de pensar en términos de "difícil de escribir" y comience a pensar en términos de "fácil de leer". (Sí, lo sé. ¡Esto va en contra de todo el mito del programador C!) Leerás el código un par de órdenes de magnitud con más frecuencia de lo que lo estarás escribiendo.

Answer 2

¿Realmente quieres que el compilador "lo resuelva solo?" Si así fuera, entonces el siguiente evaluaría a lo mismo (suponiendo p es un puntero a una estructura con un miembro de x):

(*p).x; 
p.x 

Si el desreferenciar del puntero está implícito allí, debería ser implícita en todas partes? Considere:

int* p; 
int i = p; // should dereferencing be implicit here as well? 

Creo que sería mucho más confuso que tener dos operadores separados.

También puede ser útil tener dos operadores para ayudar a realizar un seguimiento de la cantidad de capas de indirección que tiene. Por supuesto, el operador -> no es estrictamente necesario para esto, ya que p->x es equivalente a (*p).x, pero hace que el código sea un poco más claro y fácil de leer.

Answer 3

(*a).b es lo mismo que a->b

Answer 4

Si la ambigüedad proviene de la capacidad de anular los dos operadores. El mejor ejemplo es shared pointers. Un puntero compartido se puede usar con. y -> operadores y ambos tienen diferentes significados.

Con -> se accede al objeto al que se apunta y con. accede a los miembros del puntero compartido en sí.

Por ejemplo:

class MyObject { 
public: 
    void myFunction() {} 
}; 
boost::shared_ptr<MyObject> ptr; 
ptr.use_count(); // calls use_count, which is a member of boost::shared_ptr. 
ptr->myFunction(); // calls MyObject::myFunction, as the operator-> is overriden 

Answer 5

Tanto fo->bar y (*fo).bar hacer lo mismo!

El lenguaje simplemente proporciona un operador para el acceso indirecto, es decir, la flecha (->) y lo trata como un símbolo único.

Answer 6

El operador -> es simplemente una manera más fácil de referenciar el método o miembro de un objeto por su puntero, en lugar de usar algo como (* p) .member o (* p) .method.

Ejemplo:

MyClass * MyObj;

MyObj-> method(); es mejor leer y comprender que (* MyObj) .method();

Answer 7

C++ le permite superar al operador ->. Cuando tiene una clase de puntero inteligente como std::auto_ptr, la misma variable puede admitir . y ->, en la que utiliza . para acceder a los miembros de auto_ptr y -> para acceder a los miembros del puntero que contiene.