MensajePublicado: Lun 01 Sep, 2003 7:11 am    Asunto: Comparativa C++ v/s Object Pascal (Algo para leer) Responder citando
Hola a todos, en un foro por ahi encontre esta respuesta a alguien que trataba de decidirse entre Builder y Delphi, me parecio interesante que uds. lo pudieran leer(Pertenece a Mario del Grupo Albor):


Cita:
> Hola a todos

Hola.

> me gustaría también aprender delphi

Si es por gusto, adelante.

> no se si seria como una especie de redundancia

Sería, a mi entender, demasiado trabajo. Aprender varios lenguajes se
parece a lo que el otro día decía alguien aquí: "necesito aprender
rápido el tema de la programación orientada a objetos".

En un libro de hace unos 8 años, unos reconocidos autores (me parece que
Chris H. Pappas y William H Murray) venían a decir (cito de memoria) que
aprender programación orientada a objetos requiere una serie de pasos.

Durante el primero de ellos, que llevaría de 4 a 5 años, se trataría de
comprender ese tipo de programación. El segundo paso, de 2 a 3 años, se
aplicarían los conocimientos del paso anterior mediante la creación de
aplicaciones no triviales orientadas a objeto. El tercer paso (e imagino
que último), es el de consolidación del aprendizaje, ampliación de
conocimientos y descubrimiento y aplicación de sutilezas y opciones
avanzadas del lenguaje. Este paso llevaría no menos de 3 años y no
tendría fin (un suponer).

Así que, si hemos de hacer caso a esos autores, aprender un lenguaje
orientado a objetos y aplicarlo, requiere de unos 8 a 10 años, si no más.
Si te dedicas a dos lenguajes, imagino que habrá que duplicar esos años.

> no se si ambos entornos(lenguajes) están
> orientados para implementar cualquier aplicación

Excepto para cuestiones muy avanzadas, es indiferente que uses Object
Pascal o C++. Y, si se trata de crear aplicaciones avanzadas, la elección
es clara: C++.

Yo programé, durante años, con Object Pascal. Entre la versión 1 y la 5 de
Delphi, para ser precisos. A mi entender, lo bueno que tiene Object Pascal
es, más que el lenguaje, el compilador: no he trabajado nunca con un
compilador más rápido que Delphi. Claro que, luego, "rascando" un poco,
uno se da cuenta de la razón de que sea tan rápido: el enlazador construye
los ejecutables sin optimización alguna. Por decirlo de alguna manera, toma
los ficheros objeto, DCU, y los une en el ejecutable final.

Dicho sea de paso, C++Builder hace algo por el estilo, aunque incluye alguna
optimización que retarda hasta lo insufrible el proceso de enlazado. Se puede
comprobar esto viendo el tamaño de un ejecutable que sólo tenga un formulario,
sin nada.

En cuanto al lenguaje Object Pascal, a mi, de entrada, se me quedaba corto
(venía de programar en C). Eso, cuando no veía que la teoría de la orientación
a objetos y Object Pascal parecían ir por dos caminos distintos.

Existen gran cantidad de cosas que, para poder realizarlas, hay que dar más
vueltas que un tonto:

* No existe la posibilidad de crear operadores. Quizá este punto no sea muy
interesante pero, si estamos hablando de programación orientada a objetos,
debería ser posible tratar un objeto como lo que es: si necesito sumarlo,
haré "objeto0 + objeto1" y, si compararlo, "objeto0 == objeto1".

* Todas las clases descienden de TObject ("interfaz gruesa"): no sé a qué
lumbreras se le ocurrió que "un 'empleado' ES UN TObject*" ni qué tiene
que ver un 'conductor_de_ambulancia' con un 'misil_teledirigido'. Pero
el asunto es que en Object Pascal te encuentras con cosas así.

* No existe herencia múltiple lo que lleva, casi de cabeza, a introducir
"switch" por todos lados: para hacer que, por ejemplo, un 'empleado' sea
un "conductor de taxi", en un momento dado, y, en otro, sea el "encargado
de los taxistas".

* No existe la herencia privada o protegida, con lo que es bastante difícil
adaptar una clase a un problema distinto de para el que se ha creado
originalmente. Adaptarla a otro problema se puede pero, en ocasiones,
merece la pena crear una clase nueva que intentar adaptar la antigua:
la "reutilización del código" se pierde en este paso.

* No existen las clases anidadas ni los espacios de nombres ni las funciones
o clases amigas. La forma en que se realiza esto último (nuestras "friend")
es colocar las funciones y procedimientos en el mismo módulo donde se
define la clase: las funciones y procedimientos del módulo pueden acceder
a los campos internos de la clase lo que, como poco, me produce sudores
fríos, ya que no es la primera vez que he modificado un campo interno
de una clase sin darme cuenta.

* No existen las plantillas o, lo que es lo mismo, la "programación genérica"
brilla por su ausencia. En Object Pascal, la programación genérica se
consigue a través de punteros pero, como todo es un TObject*, funciona
de perlas... siempre que se tenga cuidado con el manejo de punteros.
Unido a esto, se encuentra la necesidad (mejor dicho, obligación) de
programar basándose en la información de tipos en tiempo de ejecución
(cosa que se conoce con las siglas RTTI) ya que todo es un puntero.

* También unido a eso se encuentra la comprobación débil de tipos: saber
de qué tipo es un puntero (y si es válido) se deja para el momento de
la ejecución, momento en que al programador sólo le queda cruzar los
dedos para que todo vaya como la seda: que todas las clases se creen
en memoria libre y que exista tanta memoria como se necesite. No es
raro leer mensajes en el foro Delphi que cuentan cómo una aplicación
no es capaz de arrancar por falta de memoria.

* Una clase o función de un módulo puede acceder a campos internos de
una clase definida en el mismo módulo (ya lo he dicho antes pero lo
repito por lo que tiene de barbaridad), lo que dice muy poco de la
"ocultación de la información".

* etc. etc. etc.

> En resumen, con delphi y builder se pueden
> hacer cualquier tipo de aplicación

Se puede. Sin embargo, si ya estás comenzando en C++ te sugiero que
continúes por el mismo camino.

> existen aplicaciones para las cuales es mejor un entorno que otro

Existen aplicaciones (como, por ejemplo, los VXD) que requieren mayor
rendimiento y que se realizan, habitualmente, en C/C++, cuando no en
ensamblador. Sin embargo, eso no quiere decir que no puedan hacerse
en Object Pascal: irá más lento, ocupará más memoria (y espacio en
disco), pero irá.

> ya sea por facilidad en la implementación

A mi juicio, cuando se conoce, es más fácil C++ que Object Pascal. Pero
probablemente sean cosas mías. A otros les puede resultar más sencillo
Object Pascal. Y a otros Visual Basic.

> por la eficiencia del lenguaje,.....?

En estos momentos, no hay un lenguaje más eficiente que C++. Y las mejoras
que se anuncian para el lenguaje y para C++Builder hacen presagiar que, en
un tiempo más bien corto, dará un salto adelante.

> O al final resulta que es solo cuestión de gustos?

A mi entender no es cuestión de gustos en absoluto. Ambos lenguajes
sirven para hacer aplicaciones. Pero puede decirse lo mismo de
cualquier otro (Visual Basic mismamente).

La diferencia entre C++ y Object Pascal es abismal.

Ni siquiera los últimos añadidos a la biblioteca VCL han conseguido
acortar esa distancia. Por ejemplo, los "pseudocontenedores" están
basados en punteros genéricos ('Pointer' en Object Pascal). Pienso
que Object Pascal irá siempre "a remolque" de C++, debido a las
carencias del lenguaje. Carencias que son debidas, en su mayor
parte, a las compatibilidades que mantiene con el Pascal estándar.

Saludos
Mario


Mis respetos a quien escribio esto Exclamation
_________________
"Ser inteligente no es ser mas, solo equivocarse menos y no usar Visual Basic"
Atte.
Victor Yañez
Apoyen el Proyecto OpenSource del Club Builder. Ya tenemos componentes Listos!!!