En general en casi todos los lenguajes vas a poder hacer lo mismo, de mayor
o menor medida, y en algunos te facilita mucho las cosas la sintaxis del
lenguaje porque fue pensado y escrito teniendo en cuenta soportar esas
cosas, y en otros no porque no fue pensado para eso... Sacando casos
extremos en todos los lenguajes podes hacer casi todo.
Esto pasa con el ejemplo anterior, en C++ podes hace properties como muestra
el ejemplo... ahora, es natural o es engorroso hacerlo? Como se puede ver es
medio engorroso porque el lenguaje no fue pensado para eso...
Saludos
Pablo
El día 24/04/08, Leandro Lucarella <[EMAIL PROTECTED]> escribió:
>
> Emilio Astarita, el 24 de abril a las 11:24 me escribiste:
> > > Creo que el único lenguaje OO más o menos popular que no soporta esto
> es
> > > Java (sé que, al menos, Pyton, PHP, Ruby, C++, C# y D lo soportan de
> una
> > > forma u otra).
> > >
> >
> > Pregunta ¿En C++ se haría con sobrecarga de operadores? Si es así, como
> > se haría con los tipos básicos?
>
> Haciendo una clase "proxy", va un ejemplo simplón pero funcional:
>
> --------------------------------------------------------------------------
> #include <iostream>
>
> template <typename Type, typename Host, Type (Host::*Get)() const,
> void (Host::*Set)(const Type&)>
> struct property
> {
> Host& host;
> property(Host& host): host(host) {}
> // set
> property& operator=(const Type& x) { (host.*Set)(x); }
> // get
> operator Type() const { return (host.*Get)(); }
> };
>
> struct clase
> {
> clase(): c(*this) {}
> int real_c;
> int get_c() const
> {
> std::cout << "obteniendo c\n";
> return real_c;
> }
> void set_c(const int& c)
> {
> std::cout << "seteando c\n";
> real_c = c;
> }
> property< int , clase, &clase::get_c, &clase::set_c > c;
> };
>
> int main()
> {
> clase x;
> x.c = 1;
> std::cout << "valor = " << x.c << "\n";
> return 0;
> }
> --------------------------------------------------------------------------
>
> Como bug evidente tiene que el tipo de retorno no puede ser por
> referencia, por lo que no se pueden usar operadores que muten el tipo
> "proxiado". Por ejemplo:
> x.c++;
> No va a tener en efecto en x, porque se va a modificar un temporal. Igual
> esto no debería ser un impedimento, porque en general, si un getter
> obtiene una referencia, ya rompiste todo posibilidad de cambiar la
> implementación interna en un futuro si el atributo "real_c" deja de
> existir (o si cambia a un tipo incopatible o algo así).
>
> PD: Sí, advertí que era engorroso y rebuscado en C++ =)
>
> PD: Va todo publico a propósito así sigue el flame ;)
>
>
> --
> Leandro Lucarella (luca) | Blog colectivo:
> http://www.mazziblog.com.ar/blog/
>
> ----------------------------------------------------------------------------
> GPG Key: 5F5A8D05 (F8CD F9A7 BF00 5431 4145 104C 949E BFB6 5F5A 8D05)
>
> ----------------------------------------------------------------------------
> <original> [Penis Uptime: 2days 13hrs 59mins 35secs]
> <Yapa> viagra? :)
> <original> yea, 20 pills
>
> _______________________________________________
> Lista de correo Programacion.
> [email protected]
> http://listas.fi.uba.ar/mailman/listinfo/programacion
>
>
--
Si yo tengo una manzana y tú tienes una manzana, luego de intercambiarlas
ambos tenemos una manzana. Si yo tengo una idea y tú tienes una idea, luego
de intercambiarlas ambos tenemos dos ideas.
Apoyando a la comunidad Open Source.
Facebook prifile:
http://www.facebook.com/profile.php?id=1244601012
Orkut prifile:
http://www.orkut.com/Profile.aspx?uid=12594853021246287134
_______________________________________________
Lista de correo Programacion.
[email protected]
http://listas.fi.uba.ar/mailman/listinfo/programacion
