Operador de flecha frente a operador de punto [closed]

4 minutos de lectura

Me parece que el operador de flecha de C (->) es innecesario. El operador de punto (.) debería ser suficiente. Tome el siguiente código:

typedef struct {
    int member;
} my_type;

my_type   foo;
my_type * bar;
int       val;

val = foo.member;
val = bar->member;

Vemos que el operador de flecha debe usarse para desreferenciar la barra. Sin embargo, preferiría escribir

val = bar.member;

No hay ambigüedad en cuanto a si estoy tratando de extraer un ‘miembro’ de una estructura o de un puntero a la estructura. Pero es fácil usar el operador incorrecto, especialmente al refactorizar código. (Por ejemplo, tal vez estoy haciendo algunas operaciones complejas en foo, así que muevo el código a una nueva función y le paso un puntero a foo). No creo que deba importarme si foo es un puntero o no; el compilador puede preocuparse por los detalles.

Entonces la pregunta: ¿no sería más sencillo eliminar -> del lenguaje C?

  • Hay miles de millones de líneas de código C en uso hoy en día. No sería sencillo eliminar nada del lenguaje C. Dicho esto, la claridad sobre la indirección es algo bueno.

    –James McNellis

    5 de abril de 2012 a las 21:39


  • Tienes razón, es innecesario. Es azúcar sintáctico para (*bar).member. Por definición, no necesitar cualquier azúcar sintáctico. Por otra parte, no lo hacemos necesitar funciones, tampoco. nosotros pudo solo haz todo con goto.

    – jpm

    5 de abril de 2012 a las 21:43

  • Sí, pero parece azúcar sintáctico que hace las cosas más difíciles que fáciles. Las funciones, por otro lado, son útiles. 🙂

    – remline

    5 de abril de 2012 a las 21:48

  • Duplicado de ¿Por qué existe el operador flecha (->) en C?.

    – Emlai

    13 de diciembre de 2015 a las 23:22

  • En el lenguaje de programación Rust, el . El operador anula la referencia a tantas capas de punteros como sea necesario antes de acceder al campo de estructura. Hace exactamente lo que estás pidiendo en este hilo.

    – Nayuki

    15 de diciembre de 2020 a las 16:27

El operador ‘flecha’ es azúcar sintáctico. bar->member es lo mismo que (*bar).member. Una de las razones de la diferencia es la mantenibilidad. Con el operador de flecha distinto del operador de punto, se vuelve mucho más fácil realizar un seguimiento de qué variables son punteros y cuáles no. Podría ser posible usar siempre . y hacer que el compilador intente hacer lo correcto, pero dudo que eso simplifique el lenguaje. Confiar en el compilador para interpretar lo que quiso decir en lugar de lo que tu literalmente escribió suele salir mal.

  • Sin mencionar las clases que actúan como punteros (proporcionando * y -> operadores), pero en el que . también es una operación válida.

    – jpm

    5 abr 2012 a las 21:47

  • @jpm: C no tiene clases. Sin embargo, tiene un punto en la medida en que esto introduciría una incompatibilidad innecesaria con C ++ (que, por la razón que afirma, probablemente no adoptaría esa convención).

    – celtschk

    5 de abril de 2012 a las 21:49

  • Si member es en sí misma una estructura, ¿esta equivalencia entre (*). y ¿siguen aplicando? p.ej bar→member→value es lo mismo que (*bar).member→valuepero bar→(*member).value es diferente (de hecho, da un error de compilación).

    –Max Coplan

    25 de febrero de 2019 a las 19:30


  • @MaxCoplan Si member es una estructura, no se puede aplicar el * o -> operadores a ella. Ambas cosas bar->member->value y (*bar).member->value son equivalentemente incorrectos. Las únicas formas correctas de hacerlo serían bar->member.value o (*bar).member.value.

    – bta

    25 de febrero de 2019 a las 23:53

  • @MaxCoplan Sí, las dos formas siguen siendo equivalentes, pero la precedencia del operador rápidamente hace que las cosas sean bastante feas y propensas a errores (. y -> enlazar más alto que *). a->b->c se convertiría (*(*a).b).c. Realmente no quieres escribir esto a lo largo en un escenario de varios niveles.

    – bta

    26 de febrero de 2019 a las 18:17

no, seria no ser más fácil de eliminar -> del lenguaje, por la sencilla razón de que tendrían que reescribirse megatones de código si así fuera. Sin embargo, uno pudo define eso p.x es equivalente a p->x si p es un puntero. Eso sería un cambio compatible con versiones anteriores porque ese código actualmente es ilegal.

  • Sí, pero como menciona @bta, sería un cambio imprudente. -> ayuda significativamente a determinar qué variables son valores y cuáles son punteros, lo que a su vez puede ayudar a mantener la gestión de la memoria.

    – jpm

    5 abr 2012 a las 21:45

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad