[C con Clase] estilo: Sobrecarga en funciones lectura escritura

[Steven Davidson]

Hola Vicente,

vicente lozano wrote:
> Hola!
> 
> Me gustaria saber que pensais vosotros sobre esto:
> 
> class punto {
>     public:
>         punto(int vx=0, int vy=0) : xv(vx), yv(vy) {}
>         const int x() { return xv; }
>         const int y() { return yv; }

Escribir 'const' aquí no es necesario. Lo que sí deberías hacer es 
escribir estas definiciones así:

int x() const  { return xv; }
int y() const  { return yv; }

Con esto, indicamos que las funciones son constantes que significa que 
éstas no tienen intención alguna de modificar el estado de este objeto.

>         void x(int valor) {xv=valor;}
>         void y(int valor) {yv=valor;}
>     private:
>         int xv;
>         int yv;
> };
> 
> Es mas que nada que conceptualmente yo creo que es normal llamar
> punto.x para saber una cordenada y punto.x(5) para cambiarla, pero no
> se si eso de sobrecargar una funcion para que una modifique el objeto
> y la otra solo lo lea es de buen estilo, puede crear algun problema
> de comprension mas adelante o esta desaconsejado o algo asi o esta
> bien.
> 
> Compilar y funcionar ya se que lo hace bien es una cuestion de estilo 
> mas que nada.
> 

A mí me parece bien hacerlo así. También podrías asignar valores de esta 
manera:

punto p(5,-1);

cout << p.x() << ',' << p.y() << endl;

p.x() = 5;
p.y() = 10;

Esto se puede hacer si aplicas los cambios que mencioné anteriormente. 
Al final, la clase quedaría así:

// Obtener - "getter"
int x() const  { return xv; }
int y() const  { return yv; }

// Asignar - "setter"
int &x() { return xv; }
int &y() { return yv; }

Con esto, también podríamos hacer lo siguiente:

cout << ++p.x() << endl;


Algunas bibliotecas y armazones (frameworks, en inglés) implementan el 
concepto de propiedades. El resultado es poder hacer lo siguiente:

punto p;

p.x = 5;
p.y = 10;

Sin embargo, estas asignaciones son seguras. Esto es porque declaran 
'xv' e 'yv' como objetos de una clase especial la cual sobrecarga el 
operador de asignación. Esto aparenta poder asignar directamente a los 
miembros privados.


Espero haber contribuido al tema.

Steven