En el caso concreto de las coordenadas no hay mucha diferencia... Sin embargo me gustaría matizar un detalle:

* Si cambias la implementación de la función, sin cambiar la firma, únicamente necesitas recompilar la clase para que todo siga funcionando.

* Si expones la variable directamente y después necesitas cambiarlo a función porque te das cuenta de que necesitas realizar algún chequeo u operación adicional, te ves obligado a recompilar todo el código ( en mi caso unas 6 horas ).

* Los getters y los setters pueden ser convertidos a inline por el compilador, por lo que tendrían exactamente el mismo rendimiento que exponer la variable directamente.

Por ese motivo a mí me gusta más la tercera opción... pero creo que es también cuestión de costumbre.


también puedes declarar la clase tal que:

class Coord
{
  public:
    int X( ) const;
    void X( int x );
 
    int Y( ) const;
    void Y( int y );
 
    void SetValues( int x, int y );
};

Tampoco hay demasiada diferencia entre poner coord.X( valor ) y coord.X = valor.

Por otro lado, si es cierto que estaría genial que en alguna revisión incorporasen el concepto de propiedades a C++... reconozco que el uso del operador = es más intuitivo.

También recordar que gracias a la sobrecarga de operadores, es posible "linealizar" este tipo de estructuras para poder acceder a sus elementos de forma secuencial:

class Coord
{
  public:
    int X( ) const;
    void X( int x );
 
    int Y( ) const;
    void Y( int y );
 
    int& operator[]( int index ) const
    {
      int to_return = 0;
 
      if ( index == 0 )
        to_return = x;
      else if ( index == 1 )
        to_return = y;
 
      return to_return;
    }
};

Otra ventaja importante de usar getters y setters es que se pueden poner breakpoints en los mismos... mientras que para los accesos directos a variables esto es imposible.

Es que eso no es un chequeo u operación adicional... eso es un cambio de variable directamente.

Yo me refería a, por ejemplo, tener que añadir una comprobación para evitar coordenadas con valores negativos, o limitar el número de decimales, en el caso del tipo float, para evitar "oscilaciones" debido a la falta de precisión.

Si compilas en Debug, desde luego no van a ser inline porque no se aplicarán optimizaciones... por otro lado, breakpoints en memoria, estoy seguro que muchísima gente no sabe utilizarlos o, directamente, no sabe que existen.