¿En qué se diferencian las operaciones de acceso de miembros “->” y “.” En C

He mirado algunos recursos para decirme cómo -> y . Son diferentes, pero parecen hacer lo mismo. ¿Actúa -> como un operador de puntos en una estructura?

. se usa cuando tienes una estructura, y -> se usa cuando tienes un puntero a una estructura. La flecha es una forma corta para eliminar la referencia al puntero y luego usarlo . : p->field es lo mismo que (*p).field .

Son casi lo mismo. La única diferencia es que “->” lleva un puntero a una estructura en el lado izquierdo mientras “.” toma una estructura “->” hace referencia (es decir, sigue) al puntero antes de acceder al miembro de la estructura. Asi que,

 struct foo bar; bar.x = 0; 

es lo mismo que:

 struct foo bar; struct foo *diddly = &bar; diddly->x = 0; 

estás usando un punto al acceder a los miembros del objeto y la flecha -> al acceder a los miembros a través del puntero a un objeto

-> es un puntero a la estructura de qué . es a una estructura.

 struct Data data; data.content = 1; struct Data* pData = &data; pData->content = 2; 

Ah, acabo de encontrarme con la misma pregunta cuando miro la configuración regional. Una es para acceder a los atributos a través del puntero y la otra es para la estructura sin referencia:

 #include  int main (void) { struct lconv *locale_ptr; locale_ptr = localeconv(); printf("Currency symbol: %s\n", (*locale_ptr).currency_symbol); } 

es equivalente a:

 int main (void) { struct lconv *locale_ptr; locale_ptr = localeconv(); printf("Currency symbol: %s\n", locale_ptr->currency_symbol); } 

La mayoría simplemente usas. cuando se opera en un Struct y -> cuando se opera en un puntero a una estructura.

Para mostrar en el código:

  struct s myStruct; myStruct.num = 5; 

Es válido, pero:

  struct s myStruct; myStruct->num = 5; 

No es válido ya que myStruct no es un puntero.

  struct s *myStruct; myStruct->num = 5; 

Sería válido.

El operador -> es en realidad una abreviatura de (* myStruct) .num;

El lenguaje C, a diferencia de muchos otros lenguajes, permite que las variables tengan objetos (aquí estructuras) como valores y también punteros a objetos como valores. Dependiendo de qué tipo de variable se utiliza, “.” o “->” tiene que ser usado respectivamente.

[.] opera sobre un objeto de una estructura. Una vez que se declara un objeto de una estructura particular, el operador [.] Se puede utilizar para operar directamente con los miembros.

[->] opera en un puntero al objeto de una estructura. Este es un operador de desreferencia que se usa exclusivamente con punteros a objetos con miembros. De este modo, nos permite acceder a los miembros al objeto al que tenemos una referencia.

Basado en la statement puede utilizar estos operadores.

El operador a-> b, canónicamente, significa (* a) .b. Por lo tanto, a diferencia de “.”, Se eliminará el primer argumento.

Podría estar equivocado en este punto, pero entiendo que no es parte “oficialmente” de C (mencionas específicamente a C en la pregunta). Es un constructo de C ++ que la mayoría de los proveedores de comstackdores de C han agregado a C. Sin embargo, debo admitir que no he mantenido los cambios en C, por lo que podría estar completamente equivocado.

En C ++ hay más diferencias. El operador “->” es recargable, mientras que como el “”. no es.