Programación
La programación es el proceso de diseñar,
codificar, depurar y mantener el codigo fuente de programas computacionales. El
código fuente es escrito en un lenguaje de programación. El propósito de la
programación es crear programas que exhiban un comportamiento deseado. El
proceso de escribir código requiere frecuentemente conocimientos en varias
áreas distintas, además del dominio del lenguaje a utilizar, algoritmos
especializados y lógica formal. Programar no involucra necesariamente otras
tareas tales como el análisis y diseño de la aplicación (pero sí el diseño del
código), aunque sí suelen estar fusionadas en el desarrollo de pequeñas
aplicaciones.
HISTORIA
Para crear un programa, y que la computadora
lo intérprete y ejecute las instrucciones escritas en él, debe usarse un
lenguaje de programación. En sus inicios las computadoras interpretaban sólo
instrucciones en un lenguaje específico, del más bajo nivel, conocido como
código máquina, siendo éste excesivamente complicado para programar. De hecho
sólo consiste en cadenas de números 1 y 0 (sistema binario). Para facilitar el
trabajo de programación, los primeros científicos que trabajaban en el área
decidieron reemplazar las instrucciones, secuencias de unos y ceros, por
palabras o letras provenientes del ingles; las codificaron y crearon así un
lenguaje de mayor nivel, que se conoce como Assembly o lenguaje ensamblador.
Por ejemplo, para sumar se usa la letra A de la palabra inglesa add
(sumar). En realidad escribir en lenguaje ensamblador es básicamente lo mismo
que hacerlo en lenguaje máquina, pero las letras y palabras son bastante más
fáciles de recordar y entender que secuencias de números binarios. A medida que
la complejidad de las tareas que realizaban las computadoras aumentaba, se hizo
necesario disponer de un método sencillo para programar. Entonces, se crearon
los lenguajes de alto nivel. Mientras que una tarea tan trivial como
multiplicar dos números puede necesitar un conjunto de instrucciones en
lenguaje ensamblador, en un lenguaje de alto nivel bastará con solo una. Una
vez que se termina de escribir un programa, sea en ensamblador o en un lenguaje
de alto nivel, es necesario compilarlo, es decir, traducirlo a lenguaje
máquina.
Léxico y programación
La programación se rige por reglas y un conjunto
más o menos reducido de órdenes, expresiones, instrucciones y comandos que
tienden a asemejarse a una lengua natural acotada (en inglés); y que además
tienen la particularidad de una reducida ambigüedad. Cuanto menos ambiguo es un
lenguaje de programación, se dice, es más potente. Bajo esta premisa, y en el
extremo, el lenguaje más potente existente es el binario, con ambigüedad nula
(lo cual lleva a pensar así del lenguaje ensamblador).
En los lenguajes de programación de alto nivel se
distinguen diversos elementos entre los que se incluyen el léxico propio del
lenguaje y las reglas semánticas y sintácticas.
Programas y algoritmos
Un algoritmo es una secuencia no ambigua, finita y
ordenada de instrucciones que han de seguirse para resolver un problema. Un programa
normalmente implementa (traduce a un lenguaje de programación concreto) uno o
más algoritmos. Un algoritmo puede expresarse de distintas maneras: en forma
gráfica, como un diagrama de flujo, en forma de código como en pseudocodigo o
un lenguaje de programación, en forma explicativa, etc.
Los programas suelen subdividirse en partes
menores, llamadas módulos, de modo que la complejidad algorítmica de cada una
de las partes sea menor que la del programa completo, lo cual ayuda al
desarrollo del programa. Esta es una práctica muy utilizada y se conoce como
"refino progresivo".
Según Niklaus Wirth, un programa está formado por
los algoritmos y la estructura de datos.
Se han propuesto diversas técnicas de programación
cuyo objetivo es mejorar tanto el proceso de creación de software como su
mantenimiento. Entre ellas, se pueden mencionar las siguientes:
- Programacion
Declarativa
- Programación
Estructurada
- Programación
Modular
- Programación
Orientada a objetos
Compilación
El programa escrito en un lenguaje de programación
(fácilmente comprensible por el programador) es llamado programa fuente
y no se puede ejecutar directamente en una computadora. La opción más común es
compilar el programa obteniendo un módulo objeto, aunque también puede
ejecutarse en forma más directa a través de un intérprete informático.
El código fuente del programa se debe someter a un
proceso de traducción para convertirlo en lenguaje máquina, código esté
directamente ejecutable por el procesador. A este proceso se le llama
compilación.
Habitualmente la creación de un programa ejecutable
(un típico.exe para Microsoft Windows o DOS) conlleva dos pasos. El primer paso
se llama compilación (propiamente dicho) y traduce el código fuente escrito en
un lenguaje de programación almacenado en un archivo a código en bajo nivel
(normalmente en código objeto, no directamente a lenguaje máquina). El segundo
paso se llama enlazado en el cual se enlaza el código de bajo nivel generado de
todos los ficheros y subprogramas que se han mandado compilar y se añade el
código de las funciones que hay en las bibliotecas del compilador para que el
ejecutable pueda comunicarse directamente con el sistema operativo, traduciendo
así finalmente el código objeto a código máquina, y generando un módulo
ejecutable.
Estos dos pasos se pueden hacer por separado,
almacenando el resultado de la fase de compilación en archivos objetos (un
típico.obj para Microsoft Windows, DOS o para Unix); para enlazarlos en fases
posteriores, o crear directamente el ejecutable; con lo que la fase de
compilación se almacena sólo temporalmente. Un programa podría tener partes
escritas en varios lenguajes, por ejemplo, Java, C, C++ y ensamblador, que se
podrían compilar de forma independiente y luego enlazar juntas para formar un
único módulo ejecutable.
Programación e ingeniería del
software
Existe una tendencia a identificar el proceso de
creación de un programa informático con la programación, que es cierta cuando
se trata de programas pequeños para uso personal, y que dista de la realidad cuando
se trata de grandes proyectos.
El proceso de creación de software, desde el punto
de vista de la ingeniería, incluye los siguientes pasos:
- Reconocer
la necesidad de un programa para solucionar un problema o identificar la
posibilidad de automatización de una tarea.
- Recoger
los requisitos del programa. Debe quedar claro qué es lo que debe hacer el
programa y para qué se necesita.
- Realizar
el análisis de los requisitos del programa. Debe quedar claro cómo debe
realizar el programa las cosas que debe hacer. Las pruebas que comprueben
la validez del programa se pueden especificar en esta fase.
- Diseñar
la arquitectura del programa. Se debe descomponer el programa en partes de
complejidad abordable.
- Implementar
el programa. Consiste en realizar un diseño detallado, especificando
completamente todo el funcionamiento del programa, tras lo cual la
codificación (programación propiamente dicha) debería resultar inmediata.
- Implantar
(instalar) el programa. Consiste en poner el programa en funcionamiento
junto con los componentes que pueda necesitar (bases de datos, redes de
comunicaciones, etc.).
La ingeniería del software se centra en los pasos
de planificación y diseño del programa, mientras que antiguamente (programación
artesanal) la realización de un programa consistía casi únicamente en escribir
el código, bajo sólo el conocimiento de los requisitos y con una modesta fase
de análisis y diseño.
Referencias históricas
La primera programadora de computadoras conocida
fue Ada Lovelace, hija de Anabella Milbanke Byron y Lord Byron. Anabella
introdujo en las matemáticas a Ada quien, después de conocer a Charles Babbage,
tradujo y amplió una descripción de su máquina analítica. Incluso, aunque
Babbage nunca completó la construcción de cualquiera de sus máquinas, el trabajo
que Ada realizó con éstas le hizo ganarse el título de primera programadora de
computadoras del mundo. El nombre del lenguaje de programación Ada fue escogido
como homenaje a esta programadora.
Este proceso está aplicado a todos los métodos
científicos que actualmente se practican.
Objetivos de la programación
La programación debe perseguir la obtención de
programas de calidad. Para ello se establece una serie de factores que
determinan la calidad de un programa. Algunos de los factores de calidad más importantes
son los siguientes:
- Corrección. Un programa es correcto si
hace lo que debe hacer tal y como se estableció en las fases previas a su
desarrollo. Para determinar si un programa hace lo que debe, es muy
importante especificar claramente qué debe hacer el programa antes de
desarrollarlo y, una vez acabado, compararlo con lo que realmente hace.
- Claridad. Es muy importante que el
programa sea lo más claro y legible posible, para facilitar así su
desarrollo y posterior mantenimiento. Al elaborar un programa se debe
intentar que su estructura sea sencilla y coherente, así como cuidar el
estilo en la edición; de esta forma se ve facilitado el trabajo del
programador, tanto en la fase de creación como en las fases posteriores de
corrección de errores, ampliaciones, modificaciones, etc. Fases que pueden
ser realizadas incluso por otro programador, con lo cual la claridad es
aún más necesaria para que otros programadores puedan continuar el trabajo
fácilmente. Algunos programadores llegan incluso a utilizar Arte ASCII
para delimitar secciones de código. Otros, por diversión o para impedir un
análisis cómodo a otros programadores, recurren al uso de código ofuscado.
- Eficiencia. Se trata de que el
programa, además de realizar aquello para lo que fue creado (es decir, que
sea correcto), lo haga gestionando de la mejor forma posible los recursos
que utiliza. Normalmente, al hablar de eficiencia de un programa, se suele
hacer referencia al tiempo que tarda en realizar la tarea para la que ha
sido creado y a la cantidad de memoria que necesita, pero hay otros
recursos que también pueden ser de consideración al obtener la eficiencia
de un programa, dependiendo de su naturaleza (espacio en disco que
utiliza, tráfico de red que genera, etc.).
- Portabilidad. Un programa es portable
cuando tiene la capacidad de poder ejecutarse en una plataforma, ya sea
hardware o software, diferente a aquélla en la que se elaboró. La
portabilidad es una característica muy deseable para un programa, ya que
permite, por ejemplo, a un programa que se ha desarrollado para sistemas
GNU/Linux ejecutarse también en la familia de sistemas operativos Windows.
Esto permite que el programa pueda llegar a más usuarios más fácilmente.
Ciclo de vida del software
El término ciclo de vida del software describe el
desarrollo de software, desde la fase inicial hasta la fase final. El propósito
de este programa es definir las distintas fases intermedias que se requieren
para validar el desarrollo de la aplicación, es decir, para garantizar que el
software cumpla los requisitos para la aplicación y verificación de los
procedimientos de desarrollo: se asegura de que los métodos utilizados son
apropiados. Estos programas se originan en el hecho de que es muy costoso
rectificar los errores que se detectan tarde dentro de la fase de
implementación. El ciclo de vida permite que los errores se detecten lo antes
posible y por lo tanto, permite a los desarrolladores concentrarse en la
calidad del software, en los plazos de implementación y en los costos
asociados. El ciclo de vida básico de un software consta de los siguientes
procedimientos:
- Definición
de objetivos: definir el resultado del proyecto y su papel en la
estrategia global.
- Análisis
de los requisitos y su viabilidad: recopilar, examinar y formular los
requisitos del cliente y examinar cualquier restricción que se pueda
aplicar.
- Diseño
general: requisitos generales de la arquitectura de la aplicación.
- Diseño
en detalle: definición precisa de cada subconjunto de la aplicación.
- Programación
(programación e implementación): es la implementación de un lenguaje de
programación para crear las funciones definidas durante la etapa de
diseño.
- Prueba
de unidad: prueba individual de cada subconjunto de la aplicación para
garantizar que se implementaron de acuerdo con las especificaciones.
- Integración:
para garantizar que los diferentes módulos se integren con la aplicación.
Éste es el propósito de la prueba de integración que está cuidadosamente
documentada.
- Prueba
beta (o validación), para garantizar que el software cumple con las
especificaciones originales.
- Documentación:
sirve para documentar información necesaria para los usuarios del software
y para desarrollos futuros.
- Mantenimiento:
para todos los procedimientos correctivos (mantenimiento correctivo) y las
actualizaciones secundarias del software (mantenimiento continuo).
El orden y la presencia de cada uno de estos
procedimientos en el ciclo de vida de una aplicación dependen del tipo de
modelo de ciclo de vida acordado entre el cliente y el equipo de desarrolladores.
HISTORIA DE LOS LENGUAJES DE PROGRAMACIÓN
Los primeros lenguajes de programación surgieron de
la idea de Charles Babagge, la cual se le ocurrió a este hombre a mediados del
siglo XIX. Era un profesor matemático de la universidad de Cambridge e inventor
ingles, que la principio del siglo XIX predijo muchas de las teorías en que se
basan los actuales ordenadores. Consistía en lo que él denominaba la maquina
analítica, pero que por motivos técnicos no pudo construirse hasta mediados del
siglo XX. Con él colaboro Ada Lovedby, la cual es considerada como la primera
programadora de la historia, pues realizo programas para aquélla supuesta
maquina de Babagge, en tarjetas perforadas.
Como la maquina no llego nunca a construirse, los
programas de Ada, lógicamente, tampoco llegaron a ejecutarse, pero si suponen
un punto de partida de la programación, sobre todo si observamos que en cuanto
se empezó a programar, los programadores utilizaron las técnicas diseñadas por
Charles Babagge, y Ada, que consistían entre otras, en la programación mediante
tarjetas perforadas. A pesar de ello, Ada ha permanecido como la primera
programadora de la historia. Se dice por tanto que estos dos genios de antaño,
se adelantaron un siglo a su época, lo cual describe la inteligencia de la que
se hallaban dotados.
En 1823 el gobierno Británico lo apoyo para crear
el proyecto de una máquina de diferencias, un dispositivo mecánico para
efectuar sumas repetidas. Pero Babagge se dedico al proyecto de la máquina
analítica, abandonando la maquina de diferencias, que se pudiera programar con
tarjetas perforadas, gracias a la creación de Charles Jacquard (francés). Este
hombre era un fabricante de tejidos y había creado un telar que podía
reproducir automáticamente patrones de tejidos, leyendo la información
codificada en patrones de agujeros perforados en tarjetas de papel rígido.
Entonces Babagge intento crear la máquina que se pudiera programar con tarjetas
perforadas para efectuar cualquier cálculo con una precisión de 20 dígitos.
Pero la tecnología de la época no bastaba para hacer realidad sus ideas. Si
bien las ideas de Babagge no llegaron a materializarse de forma definitiva, su
contribución es decisiva, ya que los ordenadores actuales responden a un
esquema análogo al de la máquina analítica. En su diseño, la máquina constaba
de cinco unidades básicas: 1) Unidad de entrada, para introducir datos e
instrucciones; 2) Memoria, donde se almacenaban datos y resultados intermedios;
3) Unidad de control, para regular la secuencia de ejecución de las
operaciones; 4) Unidad Aritmético-Lógica, que efectúa las operaciones; 5)
Unidad de salida, encargada de comunicar al exterior los resultados. Charles
Babbage, conocido como el "padre de la informática" no pudo completar
en aquella época la construcción del computador que había soñado, dado que
faltaba algo fundamental: la electrónica. El camino señalado de Babbage, no fue
nunca abandonado y siguiéndolo, se construyeron las primeras computadoras.
1.2. LENGUAJES DE MÁQUINA
El lenguaje máquina de una computadora
consta de cadenas de números binarios (ceros y unos) y es el único que
"entienden" directamente los procesadores. Todas las instrucciones
preparadas en cualquier lenguaje de máquina tienen por lo menos dos partes. La primera
es el comando u operación, que dice a la computadora cuál es la
función que va a realizar. Todas las computadoras tienen un código de
operación para cada una de sus funciones. La segunda parte de la
instrucción es el operando, que indica a la computadora dónde hallar o
almacenar los datos y otras instrucciones que se van a manipular; el número de
operandos de una instrucción varía en las distintas computadoras. En una
computadora de operando único, el equivalente binario de "SUMAR
0814" podría hacer que se sume el valor que se encuentra en la localidad
de almacenamiento o dirección 0814 al valor que se encuentra en la
unidad aritmética lógica. En una máquina de dos operandos, la
representación binaria de "SUMAR 0814 8672" podría hacer que se sume
el valor que está en la localidad 8672 al valor que está en la dirección 0814.
El formato de operando único es popular en las microcomputadoras más pequeñas;
la estructura de dos operandos se encuentra en casi todas las demás máquinas.
Según los estándares actuales, las primeras
computadoras eran poco tolerantes. Los programadores tenían que traducir las
instrucciones de manera directa a la forma de lenguaje de máquina que
comprendían las computadoras. Por ejemplo, un programador que escribiera la
instrucción "SUMAR 0814" para una de las primeras máquinas IBM
hubiera escrito:
000100000000000000000000000010111000
Además de recordar las docenas de códigos numéricos
para los comandos del conjunto de instrucciones de la máquina, el programador
tenía que conocer las posiciones donde se almacenan los datos y las
instrucciones. La codificación inicial muchas veces requería meses, por lo que
era costosa y era frecuente que originara errores. Revisar las instrucciones
para localizar errores era casi tan tedioso como escribirlas por primera vez.
Además, si era necesario modificar un programa posteriormente, la tarea podía
llevarse meses.
1.3. LENGUAJES ENSAMBLADORES
A principios de la década de 1950, y con el fin de
facilitar la labor de los programadores, se desarrollaron códigos nemotécnicos
para las operaciones y direcciones simbólicas. La palabra nemotécnico se
refiere a una ayuda para la memorización. Uno de los primeros pasos para
mejorar el proceso de preparación de programas fue sustituir los códigos de
operaciones numéricos del lenguaje de máquina por símbolos alfabéticos, que son
los códigos nemotécnicos. Todas las computadoras actuales tienen códigos
nemotécnicos aunque, naturalmente, los símbolos que se usan varían en las
diferentes marcas y modelos. La computadora sigue utilizando el lenguaje
de máquina para procesar los datos, pero los programas ensambladores
traducen antes los símbolos de código de operación especificados a sus
equivalentes en lenguaje de máquina.
Este procedimiento preparó avances posteriores. Si
la computadora era capaz de traducir símbolos convenientes en operaciones
básicas, ¿por qué no hacer también que realizara otras funciones rutinarias de
codificación, como la asignación de direcciones de almacenamiento a los datos?
La técnica de direccionamiento simbólico permite expresar una dirección
no en términos de su localización numérica absoluta, sino en términos de
símbolos convenientes para el programador.
Durante las primeras etapas del direccionamiento
simbólico, el programador asigna un nombre simbólico y una dirección real a un
dato. Por ejemplo, el programador podría asignar el valor total de mercancía
adquirida durante un mes por un cliente de una tienda de departamentos a la
dirección 0063, y darle el nombre simbólico TOTAL. Se podría asignar el valor
de la mercancía devuelta sin usar durante el mes a la dirección 2047 y dársele
el nombre simbólico CRÉDITO. Así, durante el resto del programa, el programador
se referirá a los nombres simbólicos, más que a las direcciones, cuando
fuera preciso procesar estos datos. Por ejemplo, se podría escribir la
instrucción "S CRÉDITO TOTAL" para restar el valor de las mercancías
devueltas del importa total de compras para obtener el importe de la factura
mensual del cliente. A continuación, el programa ensamblador traduciría la
instrucción simbólica a esta cadena de bits:
Más adelante se hizo otra mejora. Se dejó a la
computadora la tarea de asignar y recordar las direcciones de las
instrucciones. Lo único que tenía que hacer el programador era indicar a la computadora
la dirección de la primera instrucción, y el programa ensamblador se encargaba
de almacenar, de manera automática, todas las demás en forma secuencial a
partir de ese punto. Así, si se agregaba más tarde otra instrucción al
programa, no era necesario modificar las direcciones de todas las instrucciones
que seguían al punto de inserción (como tendría que hacerse en el caso de
programas escritos en lenguaje de máquina). En vez de ello, el procesador
ajustaba automáticamente las localidades de memoria la próxima vez que se
ejecutaba el programa.
En la actualidad, los programadores no asignan
números de dirección reales a los datos simbólicos, simplemente especifican
dónde quieren que se coloque la primera localidad del programa, y el programa
ensamblador se encarga de lo demás: asigna localidades tanto para las
instrucciones como para los datos.
Estos programas de ensamble, o ensamblador,
también permite a la computadora convertir las instrucciones en lenguaje
ensamblador del programador en su propio código de máquina. Un programa de
instrucciones escrito en lenguaje ensamblador por un programador se llama programa
fuente. Después de que el ensamblador convierte el programa fuente en
código de máquina a éste se le denomina programa objeto. Para los programadores
es más fácil escribir instrucciones en un lenguaje ensamblador que en códigos
de lenguajes de máquina, pero es posible que se requieran dos corridas de
computadora antes de que se puedan utilizar las instrucciones del programa
fuente para producir las salidas deseadas.
Los lenguajes ensambladores tienen ventajas
sobre los lenguajes de máquina. Ahorran tiempo y requieren menos atención a
detalles. Se incurren en menos errores y los que se cometen son más fáciles de
localizar. Además, los programas en lenguaje ensamblador son más fáciles de
modificar que los programas en lenguaje de máquina. Pero existen limitaciones.
La codificación en lenguaje ensamblador es todavía un proceso lento. Una
desventaja importante de estos lenguajes es que tienen una orientación a la
máquina. Es decir, están diseñados para la marca y modelo específico de
procesador que se utiliza, y es probable que, para una máquina diferente, se
tengan que volver a codificar los programas.
1.4. LENGUAJES DE ALTO NIVEL
Los primeros programas ensambladores producían sólo
una instrucción en lenguaje de máquina por cada instrucción del programa
fuente. Para agilizar la codificación, se desarrollaron programas ensambladores
que podían producir una cantidad variable de instrucciones en lenguaje
de máquina por cada instrucción del programa fuente. Dicho de otra
manera, una sola macroinstrucción podía producir varias líneas de
código en lenguaje de máquina. Por ejemplo, el programador podría escribir
"LEER ARCHIVO", y el programa traductor produciría una serie
detallada de instrucciones al lenguaje de máquina previamente preparadas, con
lo que se copiaría un registro del archivo que estuviera leyendo el dispositivo
de entrada a la memoria principal. Así, el programador no se tenía que ocupar de
escribir una instrucción por cada operación de máquina realizada.
El desarrollo de las técnicas nemotécnicas y las
macroinstrucciones condujo, a su vez, al desarrollo de lenguajes de alto
nivel que a menudo están orientados hacia una clase determinada de problemas de
proceso. Por ejemplo, se han diseñado varios lenguajes para procesar problemas
científico-matemático, asimismo han aparecido otros lenguajes que hacen
hincapié en las aplicaciones de proceso de archivos.
A diferencia de los programas de ensamble, los
programas en lenguaje de alto nivel se pueden utilizar con diferentes marcas
de computadores sin tener que hacer modificaciones considerables. Esto
permite reducir sustancialmente el costo de la reprogramación cuando se
adquiere equipo nuevo. Otras ventajas de los lenguajes de alto nivel son:
- Son
más fáciles de aprender que los lenguajes ensambladores.
- Se
pueden escribir más rápidamente.
- Permiten
tener mejor documentación.
- Son
más fáciles de mantener.
- Un
programador que sepa escribir programas en uno de estos lenguajes no está
limitado a utilizar un solo tipo de máquina.
Naturalmente, un programa que se escribe en un
lenguaje de alto nivel también tiene que traducirse a un código que pueda
utilizar la máquina. Los programas traductores que pueden realizar esta
operación se llaman compiladores. Éstos, como los programas
ensambladores avanzados, pueden generar muchas líneas de código de máquina por
cada proposición del programa fuente. Se requiere una corrida de compilación
antes de procesar los datos de un problema.
Los compiladores son aquellos cuya función es
traducir un programa escrito en un determinado lenguaje a un idioma que la
computadora entienda (lenguaje máquina con código binario).
Al usar un lenguaje compilado (como lo son los
lenguajes del popular Visual Studio de Microsoft), el programa desarrollado
nunca se ejecuta mientras haya errores, sino hasta que luego de haber compilado
el programa, ya no aparecen errores en el código.
Se puede también utilizar una alternativa diferente
de los compiladores para traducir lenguajes de alto nivel. En vez de traducir
el programa fuente y grabar en forma permanente el código objeto que se produce
durante la corrida de compilación para utilizarlo en una corrida de producción
futura, el programador sólo carga el programa fuente en la computadora junto
con los datos que se van a procesar. A continuación, un programa intérprete,
almacenado en el sistema operativo del disco, o incluido de manera permanente
dentro de la máquina, convierte cada proposición del programa fuente en
lenguaje de máquina conforme vaya siendo necesario durante el proceso de los
datos. No se graba el código objeto para utilizarlo posteriormente.
La siguiente vez que se utilice una instrucción, se
le debe interpretar otra vez y traducir a lenguaje máquina. Por ejemplo,
durante el procesamiento repetitivo de los pasos de un ciclo, cada instrucción
del ciclo tendrá que volver a ser interpretado cada vez que se ejecute el
ciclo, lo cual hace que el programa sea más lento en tiempo de ejecución
(porque se va revisando el código en tiempo de ejecución) pero más rápido en
tiempo de diseño (porque no se tiene que estar compilando a cada momento el
código completo). El intérprete elimina la necesidad de realizar una corrida de
compilación después de cada modificación del programa cuando se quiere agregar
funciones o corregir errores; pero es obvio que un programa objeto compilado
con antelación deberá ejecutarse con mucha mayor rapidez que uno que se debe
interpretar a cada paso durante una corrida de producción.
Se les conoce como lenguajes declarativos en
ciencias computacionales a aquellos lenguajes de programación en los cuales se le
indica a la computadora qué es lo que se desea obtener o qué es lo que se esta
buscando, por ejemplo: Obtener los nombres de todos los empleados que tengan
más de 32 años. Eso se puede lograr con un lenguaje declarativo como SQL.
La programación declarativa es una forma de
programación que implica la descripción de un problema dado en lugar de proveer
una solución para dicho problema, dejando la interpretación de los pasos
específicos para llegar a dicha solución a un intérprete no especificado. La
programación declarativa adopta, por lo tanto, un enfoque diferente al de la
programación imperativa tradicional.
En otras palabras, la programación declarativa
provee el "qué", pero deja el "cómo" liberado a la
implementación particular del intérprete. Por lo tanto se puede ver que la
programación declarativa tiene dos fases bien diferenciadas, la declaración y
la interpretación.
Es importante señalar que a pesar de hacer
referencia a intérprete, no hay que limitarse a "lenguajes
interpretados" en el sentido habitual del término, sino que también se
puede estar trabajando con "lenguajes compilados".
4.1. CARACTERÍSTICAS DE LOS LENGUAJES DE
PROGRAMACIÓN DECLARATIVOS
- Los
lenguajes declarativos están orientados a buscar la solución del problema,
sin preocuparse por la forma de llegar a ello; es decir, el programador
debe concentrarse en la lógica del algoritmo, más que en el control de la
secuencia.
- Los
programas están formados por un conjunto de definiciones o ecuaciones, las
cuales describen lo que debe ser calculado, no en sí la forma de hacerlo.
- Las
variables sólo pueden tener asignado un solo valor a lo largo de la
ejecución del programa, lo cual implica que no puede existir asignación
destructiva. Debido a esto, cobra especial importancia el uso del anidamiento
y la recursividad.
- Las
listas representan la estructura fundamental de datos.
- El
orden de la ejecución no resulta importante debido a que no existen
efectos colaterales; es decir, que al calcular un valor, resulta imposible
afectar el cálculo de otros y con esto se puede afirmar que cualquier
secuencia de ejecución deberá conducir al mismo resultado.
- Las
expresiones o definiciones pueden ser usadas como valores y por lo tanto
se pueden tratar como argumentos de otras definiciones.
- El
control de la ejecución no es responsabilidad del programador.
4.2. DESVENTAJAS DE LA PROGRAMACIÓN DECLARATIVA
La principal desventaja de la programación
declarativa es que no puede resolver cualquier problema dado, sino que está
restringida al subconjunto de problemas para los que el intérprete o compilador
fue diseñado.
Otra desventaja de la programación declarativa está
relacionada con la eficiencia. Dado que es necesaria una fase de interpretación
extra, en la cual se deben evaluar todas las consecuencias de todas las
declaraciones realizadas, el proceso es relativamente más lento que en la
programación imperativa, en que los cambios de estado del sistema están dados
por instrucciones particulares y no por un conjunto de condiciones
arbitrariamente grande.
4.3. VENTAJAS DE LA PROGRAMACIÓN DECLARATIVA
A pesar de lo anterior existen algunas ventajas en
el uso de la programación declarativa. Entre las ventajas se destaca que la
solución de un problema se puede realizar con un nivel de abstracción
considerablemente alto, sin entrar en detalles de implementación irrelevantes,
lo que hace a las soluciones más fácil de entender por las personas. La
resolución de problemas complejos es resuelta por el intérprete a partir de la
declaración de las condiciones dadas.
La programación declarativa es muy usada en la
resolución de problemas relacionados con inteligencia artificial, bases de
datos, configuración, y comunicación entre procesos; sin embargo, ningún
leguaje declarativo se aproxima en popularidad a los lenguajes imperativos.
4.4. EJEMPLOS DE LENGUAJES DECLARATIVOS
Algunos lenguajes declarativos que se pueden
mencionar son:
- PROLOG
- SQL
- HTML
- WSDL (Web Services
Description Language)
- XML
Stylesheet Language for Transformation
4.5. PROGRAMACIÓN LÓGICA
La idea fundamental de la programación lógica
consiste en emplear la lógica como lenguaje de programación.
La lógica no es imperativa porque no sirve para indicar
cómo resolver un problema (órdenes). La lógica es declarativa porque
sirve para especificar qué problema resolver (condiciones).
En la programación lógica, se especifican las
condiciones que satisfacen las soluciones, se deducen las soluciones a partir
de las condiciones y el énfasis de todo está en qué problema resolver. El
problema se describe especificando qué caracteriza a sus posibles soluciones.
La programación lógica, junto con la funcional,
forma parte de lo que se conoce como programación declarativa. En los
lenguajes tradicionales, la programación consiste en indicar cómo
resolver un problema mediante sentencias; en la programación lógica, se trabaja
de forma descriptiva, estableciendo relaciones entre entidades, indicando no
cómo, sino qué hacer. Se establece entonces que la idea esencial de la
programación lógica es: algoritmos = lógica + control. Es decir, un
algoritmo se construye especificando conocimiento en un lenguaje formal (lógica
de primer orden), y el problema se resuelve mediante un mecanismo de inferencia
(control) que actúa sobre aquél.
Al hacer un recorrido por la programación lógica,
aparece como uno de sus lenguajes más representativos, Prolog, que es un
clásico de la inteligencia artificial y que se aplica de múltiples formas en el
desarrollo de software comercial.
4.6. PROGRAMACIÓN FUNCIONAL
La programación funcional es un paradigma de
programación declarativa basado en la utilización de funciones matemáticas. El
objetivo de la programación funcional es conseguir lenguajes expresivos y matemáticamente
elegantes, en los que no sea necesario bajar al nivel de la máquina para
describir el proceso llevado a cabo por el programa.
Los programas escritos en un lenguaje funcional
están constituidos únicamente por definiciones de funciones, entendiendo éstas
no como subprogramas clásicos de un lenguaje imperativo (pues la programación
funcional es declarativa), sino como funciones puramente matemáticas, en las
que se verifican ciertas propiedades como la transparencia referencial
(el significado de una expresión depende únicamente del significado de sus
subexpresiones), y por tanto, la carencia total de efectos laterales.
Otras características propias de estos lenguajes
son la no existencia de asignaciones de variables y la falta de construcciones
estructuradas como la secuencia o la iteración (lo que obliga en la práctica a
que todas las repeticiones de instrucciones se lleven a cabo por medio de
funciones recursivas).
Existen dos grandes categorías de lenguajes
funcionales: los funcionales puros y los híbridos. La diferencia
entre ambos estriba en que los lenguajes funcionales híbridos son menos
dogmáticos que los puros, al permitir conceptos tomados de los lenguajes
imperativos, como las secuencias de instrucciones o la asignación de variables.
En contraste, los lenguajes funcionales puros tienen una mayor potencia
expresiva, conservando a la vez su transparencia referencial, algo que no se
cumple siempre con un lenguaje híbrido.
4.7. PROGRAMACIÓN ORIENTADA A BASES DE DATOS
Las bases de datos son programas que administran
información y hacen más ordenada la información, aparte de hacer la fácil de
buscar y por supuesto de encontrar.
Las características de las bases de datos pueden
ser ventajosas o desventajosas: pueden ayudar a almacenar, organizar,
recuperar, comunicar y manejar información en formas que serían imposibles sin
las computadoras, pero también afecta de alguna manera ya que existen enormes
cantidades de información en bases de datos de las que no se tiene control del
acceso.
Las bases de datos tienen muchos usos: facilitan el
almacenamiento de grandes cantidades de información; permiten la recuperación
rápida y flexible de información, con ellas se puede organizar y reorganizar la
información, así como imprimirla o distribuirla en formas diversas.
Es claro que los lenguajes orientados a bases de
datos son declarativos y no imperativos, pues el problema es "qué"
se quiere hacer o "qué" se necesita buscar y encontrar en la
base de datos, y no se enfatiza el "cómo".
Una base de datos también se puede definir como un banco
de datos o conjunto de datos que pertenecen al mismo contexto, almacenados
sistemáticamente para su posterior uso. En este sentido, una biblioteca puede
considerarse una base de datos compuesta en su mayoría por documentos y textos
impresos en papel e indexados para su consulta.
En la actualidad, y gracias al desarrollo tecnológico
de campos como la informática y la electrónica, la mayoría de las bases de
datos tienen formato electrónico, que ofrece un amplio rango de soluciones al
problema de almacenar datos.
Los sistemas gestores de bases de datos
(SGBD) permiten almacenar y posteriormente acceder a los datos de forma rápida
y estructurada.
4.7.1. TIPOS DE BASES DE DATOS
Las bases de datos pueden clasificarse de varias
maneras, de acuerdo al criterio elegido para su clasificación, que puede ser
según la variabilidad de los datos almacenados o según el contenido.
4.7.1.1 CLASIFICACIÓN DE BASES DE DATOS SEGÚN LA
VARIABILIDAD DE LOS DATOS ALMACENADOS
Esta clasificación depende de cómo los datos
cambian o varían dentro de la base de datos, o si se mantienen estáticos sin
sufrir modificaciones o cambios. Dentro de esta clasificación se tiene lo
siguiente:
- BASES
DE DATOS ESTÁTICAS: Éstas son bases de datos de sólo lectura,
utilizadas primordialmente para almacenar datos históricos que
posteriormente se pueden utilizar para estudiar el comportamiento de un
conjunto de datos a través del tiempo, realizar proyecciones y tomar
decisiones.
- BASES
DE DATOS DINÁMICAS: Éstas son bases de datos donde la información
almacenada se modifica con el tiempo, permitiendo operaciones como actualización
y adición de datos, además de las operaciones fundamentales de consulta.
Un ejemplo de esto puede ser la base de datos utilizada en un sistema de
información de una tienda de abarrotes, una farmacia, un videoclub, etc.
4.7.1.2. CLASIFICACIÓN DE BASES DE DATOS SEGÚN
CONTENIDO
Esta clasificación basa su enfoque en el contenido
o lo que almacena la base de datos, de esta manera:
- BASES
DE DATOS BIBLIOGRÁFICAS: Solo contienen un "representante"
de la fuente primaria, que permite localizarla. Un registro típico de una
base de datos bibliográfica contiene información sobre el autor, fecha de
publicación, editorial, título, edición, de una determinada publicación, etc.
Puede contener un resumen o extracto de la publicación original, pero
nunca el texto completo, porque sino se estaría en presencia de una base
de datos a texto completo (o de fuentes primarias). Como su nombre lo
indica, el contenido son cifras o números. Por ejemplo, una colección de
resultados de análisis de laboratorio, entre otras.
- BASES
DE DATOS DE TEXTO COMPLETO: Almacenan las fuentes primarias, como por
ejemplo, todo el contenido de todas las ediciones de una colección de
revistas científicas.
- DIRECTORIOS: Un ejemplo son las guías
telefónicas en formato electrónico.
- BANCO
DE IMÁGENES, AUDIO, MULTIMEDIA, ETC.
4.7.2. MODELOS DE BASES DE DATOS
Además de la clasificación por la función de las
bases de datos, éstas también se pueden clasificar de acuerdo a su modelo de
administración de datos.
Un modelo de datos es básicamente una
"descripción" de algo conocido como contenedor de datos (algo en
donde se guarda la información), así como de los métodos para almacenar y
recuperar información de esos contenedores. Los modelos de datos no son cosas
físicas: son abstracciones que permiten la implementación de un sistema
eficiente de base de datos; por lo general se refieren a algoritmos, y
conceptos matemáticos.
Algunos modelos con frecuencia utilizados en las
bases de datos son:
- BASES
DE DATOS JERÁRQUICAS: Éstas son bases de datos que, como su nombre
indica, almacenan su información en una estructura jerárquica. En este
modelo los datos se organizan en una forma similar a un árbol (visto al
revés), en donde un nodo padre de información puede tener varios hijos. El
nodo que no tiene padres es llamado raíz, y a los nodos que no tienen
hijos se los conoce como hojas. Las bases de datos jerárquicas son
especialmente útiles en el caso de aplicaciones que manejan un gran
volumen de información y datos muy compartidos permitiendo crear
estructuras estables y de gran rendimiento. Una de las principales
limitaciones de este modelo es su incapacidad de representar
eficientemente la redundancia de datos.
- BASES
DE DATOS DE RED:
Éste es un modelo ligeramente distinto del jerárquico; su diferencia
fundamental es la modificación del concepto de nodo: se permite que un
mismo nodo tenga varios padres (posibilidad no permitida en el modelo
jerárquico). Fue una gran mejora con respecto al modelo jerárquico, ya que
ofrecía una solución eficiente al problema de redundancia de datos; pero,
aun así, la dificultad que significa administrar la información en una
base de datos de red ha significado que sea un modelo utilizado en su
mayoría por programadores más que por usuarios finales.
- BASES
DE DATOS RELACIONAL: Éste es el modelo más utilizado en la
actualidad para modelar problemas reales y administrar datos
dinámicamente. Tras ser postulados sus fundamentos en 1970 por Edgar Frank
Codd, de los laboratorios IBM en San José (California), no tardó en
consolidarse como un nuevo paradigma en los modelos de base de datos. Su
idea fundamental es el uso de "relaciones". Estas relaciones
podrían considerarse en forma lógica como conjuntos de datos llamados
"tuplas". Pese a que ésta es la teoría de las bases de datos
relacionales creadas por Edgar Frank Codd, la mayoría de las veces se
conceptualiza de una manera más fácil de imaginar. Esto es pensando en
cada relación como si fuese una tabla que está compuesta por registros
(las filas de una tabla), que representarían las tuplas, y campos (las
columnas de una tabla).
En este modelo, el lugar y la forma en que se
almacenen los datos no tienen relevancia (a diferencia de otros modelos como el
jerárquico y el de red). Esto tiene la considerable ventaja de que es más fácil
de entender y de utilizar para un usuario esporádico de la base de datos. La
información puede ser recuperada o almacenada mediante "consultas"
que ofrecen una amplia flexibilidad y poder para administrar la información. El
lenguaje más habitual para construir las consultas a bases de datos
relacionales es SQL, Structured Query Language o Lenguaje Estructurado de
Consultas, un estándar implementado por los principales motores o sistemas de
gestión de bases de datos relacionales. Durante su diseño, una base de datos
relacional pasa por un proceso al que se le conoce como normalización (reglas
fundamentales para el buen funcionamiento de una base de datos relacional) de
una base de datos. Durante los años '80 (1980-1989) la aparición de dBASE
produjo una revolución en los lenguajes de programación y sistemas de
administración de datos. Aunque nunca debe olvidarse que dBase no utilizaba SQL
como lenguaje base para su gestión. La normalización de una base de datos
relacional consiste en las siguientes reglas:
- Primera
Forma Normal (1FN): se eliminan los grupos repetitivos. Los
atributos han de ser atómicos. Gráficamente las celdas de la tabla
contienen solo un valor, en cada uno de los atributos sólo se puede
incluir un dato, aunque sea compuesto, pero no se puede incluir una lista
de datos. Se trata de que cada atributo guarde la menor cantidad de
información posible. Para eliminar los grupos repetitivos se pone cada uno
de ellos en una tabla aparte, esa nueva tabla hereda la clave primaria de
la relación en la que se encontraban, se crea una clave foránea para la
nueva tabla.
- Segunda
Forma Normal (2FN): dependencia completa. Está en 2FN si está en
1FN y si sus atributos no principales dependen de forma completa de la
clave principal. Toda relación que tenga como clave sólo un atributo está
en 2FN.
- Tercera
Forma Normal (3FN): dependencia transitiva. Está en segunda forma
normal y todo atributo no primo es implicado por la clave primaria en una
secuencia no transitiva.
- Forma
Normal de Boyce-Codd: una tabla está en FNBC, sí y sólo sí las
únicas dependencias funcionales elementales son aquellas en las que la
Clave primaria determina un atributo.
- Cuarta
Forma Normal (4FN): está en forma normal de Boyce-Codd y se
eliminan las dependencias multivaluadas y se generan todas las relaciones
externas con otras tablas u otras bases de datos.
- Quinta
Forma Normal (5FN): está en cuarta forma normal y toda
dependencia-join viene implicada por claves candidatas.
- BASES
DE DATOS ORIENTADAS A OBJETOS: este modelo, bastante reciente, y propio de
los modelos informáticos orientados a objetos, trata de almacenar en la
base de datos los objetos completos (estado y comportamiento). Una base de
datos orientada a objetos es una base de datos que incorpora todos los
conceptos importantes del paradigma de objetos: encapsulación
(propiedad que permite ocultar la información al resto de los objetos,
impidiendo así accesos incorrectos o conflictos), herencia
(propiedad a través de la cual los objetos heredan comportamiento dentro
de una jerarquía de clases y polimorfismo (propiedad de una
operación mediante la cual puede ser aplicada a distintos tipos de
objetos. En bases de datos orientadas a objetos, los usuarios pueden
definir operaciones sobre los datos como parte de la definición de la base
de datos.
- BASES
DE DATOS DOCUMENTALES: permiten la indexación a texto completo, y en
líneas generales realizar búsquedas más potentes.
- BASE
DE DATOS DEDUCTIVAS: un sistema de base de datos deductivas,
es un sistema de base de datos pero con la diferencia de que permite hacer
deducciones a través de inferencias. Se basa principalmente en reglas y
hechos que son almacenados en la base de datos. También las bases de datos
deductivas son llamadas base de datos lógica, a raíz de que se basan en
lógica matemática.
En ciencias de la computación se llama lenguajes
imperativos a aquellos en los cuales se le ordena a la computadora cómo
realizar una tarea siguiendo una serie de pasos o instrucciones, por ejemplo:
Paso 1, solicitar número.
Paso 2, multiplicar número por dos.
Paso 3, imprimir resultado de la operación.
Paso 4, etc,
El proceso anterior se puede realizar con un
lenguaje imperativo como por ejemplo BASIC, C, C++, Java, Clipper, Dbase, C#,
PHP, Perl, etc.
Dentro de la programación imperativa, se tiene un
conjunto de instrucciones que le indican al computador como realizar una tarea.
Los lenguajes imperativos se basan en comandos u
órdenes que se le dan a la computadora para que haga algo, con el fin de
organizar o cambiar valores en ciertas partes de la memoria.
La ejecución de estos comandos se realiza, en la
mayor parte de ellos, secuencialmente, es decir, hasta que un comando no ha
sido ejecutado no se lee el siguiente.
Según el dominio, o mejor dicho con el propósito
que se utiliza el programa, se puede hablar de lenguajes de dominio específico
y de dominio general.
5.1. LENGUAJES IMPERATIVOS PROCEDURALES
En los lenguajes tradicionales o procedurales, es
la aplicación quien controla qué porciones de código se ejecuta, y la secuencia
en que este se ejecuta. La ejecución de la aplicación se inicia con la primera
línea de código, y sigue una ruta predefinida a través de la aplicación,
llamando procedimientos según sea necesario.
Los lenguajes procedurales están fundamentados en
la utilización de variables para almacenar valores y en la realización de
operaciones con los datos almacenados. Algunos ejemplos son: FORTRAN, PASCAL,
C, ADA, ALGOL,…
En este tipo de lenguajes, la arquitectura consta
de una secuencia de celdas, llamadas memoria, en las cuales se pueden guardar
en forma codificada, lo mismo datos que instrucciones; y de un procesador, el
cual es capaz de ejecutar de manera secuencial una serie de operaciones,
principalmente aritméticas y booleanas, llamadas comandos. En general, un
lenguaje procedural ofrece al programador conceptos que se traducen de forma
natural al modelo de la máquina. El programador tiene que traducir la solución
abstracta del problema a términos muy primitivos, cercanos a la máquina.
Con un lenguaje procedural el usuario (normalmente
será un programador) especifica qué datos se necesitan y cómo obtenerlos. Esto
quiere decir que el usuario debe especificar todas las operaciones de acceso a
datos llamando a los procedimientos necesarios para obtener la información
requerida. Estos lenguajes acceden a un registro, lo procesan y basándose en
los resultados obtenidos, acceden a otro registro, que también deben procesar.
Así se va accediendo a registros y se van procesando hasta que se obtienen los
datos deseados. Las sentencias de un lenguaje procedural deben estar embebidas
en un lenguaje de alto nivel, ya que se necesitan sus estructuras (bucles,
condicionales, etc.) para obtener y procesar cada registro individual.
5.2. ALGUNOS LENGUAJES IMPERATIVOS
Algunos lenguajes de programación imperativos que
se pueden mencionar son:
- BASIC
- C
- C++
- Java
- C#
- PHP
- Perl
En los lenguajes declarativos las sentencias que se
utilizan lo que hacen es describir el problema que se quiere solucionar,
pero no las instrucciones necesarias para solucionarlo. Esto último se
realizará mediante mecanismos internos de inferencia de información a partir de
la descripción realizada.
Los lenguajes imperativos describen paso a paso un
conjunto de instrucciones que deben ejecutarse para variar el estado un
programa y hallar la solución, es decir, un algoritmo en el que se describen
los pasos necesarios para solucionar un problema.
En la Programación Orientada a Objetos (POO u OOP
según siglas en inglés) se definen los programas en términos de "clases de
objetos", objetos que son entidades que combinan estado (es decir,
datos) comportamiento (esto es, procedimientos o métodos) e identidad
(propiedad del objeto que lo diferencia del resto). La programación orientada a
objetos expresa un programa como un conjunto de estos objetos, que colaboran
entre ellos para realizar tareas. Esto permite hacer los programas módulos más
fáciles de escribir, mantener y reutilizar.
De esta forma, un objeto contiene toda la
información, (los denominados atributos) que permite definirlo e identificarlo
frente a otros objetos pertenecientes a otras clases (e incluso entre objetos
de la misma clase, al poder tener valores bien diferenciados en sus atributos).
A su vez, dispone de mecanismos de interacción (los llamados métodos) que
favorecen la comunicación entre objetos (de una misma clase o de distintas), y
en consecuencia, el cambio de estado en los propios objetos. Esta
característica lleva a tratarlos como unidades indivisibles, en las que no se
separan (ni deben separarse) información (datos) y procesamiento (métodos).
Dada esta propiedad de conjunto de una clase de
objetos, que al contar con una serie de atributos definitorios, requiere de
unos métodos para poder tratarlos (lo que hace que ambos conceptos están
íntimamente entrelazados), el programador debe pensar indistintamente en ambos
términos, ya que no debe nunca separar o dar mayor importancia a los atributos
a favor de los métodos, ni viceversa. Hacerlo puede llevar al programador a
seguir el hábito erróneo de crear clases contenedoras de información por un lado
y clases con métodos que manejen esa información por otro (llegando a una
programación estructurada camuflada en un lenguaje de programación orientada a
objetos).
Esto difiere de los lenguajes imperativos
tradicionales, en los que los datos y los procedimientos están separados y sin
relación, ya que lo único que se busca es el procesamiento de unos datos y los
procedimientos están separados y sin relación, ya que lo único que se busca es
el procesamiento de unos datos de entrada para obtener otros de salida. La
programación estructurada anima al programador a pensar sobre todo en términos
de procedimientos o funciones, y en segundo lugar en las estructuras de datos
que esos procedimientos manejan. Los programadores de lenguajes imperativos
escriben funciones y después les pasan los datos. Los programadores que emplean
lenguajes orientados a objetos definen objetos con datos y métodos y después
envían mensajes a los objetos diciendo que realicen esos métodos por sí mismos.
Un objeto se puede definir como un grupo de
procedimientos que comparten un estado. Se define al conjunto de datos como
"estado", y "métodos" como el conjunto de procedimientos
que pueden alterar ese estado. Un programa orientado a objetos es un método de
implementación en el que los programas están organizados como colecciones de
objetos, donde cada uno es una instancia de alguna clase, y donde todas las
clases son miembros de una jerarquía de clases conectadas por relaciones de
herencia. Este tipo de lenguajes son muy recientes en comparación a los
primeros lenguajes de programación que aparecieron.
7.1. CONCEPTOS BÁSICOS DE LA PROGRAMACIÓN ORIENTADA
A OBJETOS
La programación orientada a objetos es una nueva
forma de programar que trata de encontrar la solución a problemas de una forma
que ofrece muchas ventajas y facilidades que no se tenían anteriormente.
Introduce nuevos conceptos, que superan y amplían conceptos antiguos ya
conocidos. Entro ellos destacan los siguientes:
- OBJETO: entidad provista de un
conjunto de propiedades o atributos (datos) y de comportamiento o
funcionalidad ("métodos"). Corresponden a los objetos reales del
mundo que nos rodea, o a objetos internos del sistema (del programa).
- CLASE: definiciones de las propiedades
y comportamiento de un tipo de objeto concreto. La instanciación es la
lectura de estas definiciones y la creación de un objeto a partir de
ellas. Una clase es una colección de objetos similares o la
implementación, declaración o definición de un tipo de objeto. Cada vez
que se construye un objeto de una clase se crea una instancia de esa
clase. Por ejemplo en Visual Basic, se tiene la clase Form, y se pueden
crear instancias de esa clase al tener Form1, Form2, etc. Así se está
creando una instancia de la clase Form.
- MÉTODO: algoritmo asociado a un
objeto (o a una clase de objetos), cuya ejecución se desencadena tras la
recepción de un "mensaje". Desde el punto de vista del
comportamiento, es lo que el objeto puede hacer. Un método puede producir
un cambio en lar propiedades del objeto, o la generación de un
"evento" con un nuevo mensaje para otro objeto del sistema.
- EVENTO: un suceso en el sistema
(tal como una interacción del usuario con la máquina, o un mensaje enviado
por un objeto). El sistema maneja el evento enviando el mensaje adecuado
al objeto pertinente.
- MENSAJE: una comunicación dirigida a
un objeto, que le ordena que ejecute uno de sus métodos con ciertos
parámetros asociados al evento que lo generó.
- PROPIEDAD
O ATRIBUTO:
contenedor de un tipo de datos asociados a un objeto (o a una clase de
objetos), que hace los datos visibles desde fuera del objeto, y cuyo valor
puede ser alterado por la ejecución de algún método.
- ESTADO
INTERNO: es
una propiedad invisible de los objetos, que puede ser únicamente accedida
y alterada por un método del objeto, y que se utiliza para indicar
distintas situaciones posibles para el objeto (o clase de objetos).
En comparación con un lenguaje imperativo, una
"variable no es más que un contenedor interno del atributo del objeto o de
un estado interno, así como la "función" es un procedimiento interno
del método del objeto.
7.2. CARACTERÍSTICAS DE LA PROGRAMACIÓN ORIENTADA A
OBJETOS
Las características más importantes de la
programación orientada a objetos son las siguientes:
- ABSTRACCIÓN: Cada objeto en el sistema
sirve como modelo de un "agente" abstracto que puede realizar
trabajo, informar y cambiar su estado, y "comunicarse" con otros
objetos en el sistema sin revelar cómo se implementan estas características.
Los procesos, las funciones o los métodos pueden también ser abstraídos y
cuando lo están, una variedad de técnicas son requeridas para ampliar una
abstracción.
- ENCAPSULAMIENTO: también llamado "ocultación de la información". Cada objeto está aislado del exterior, es un módulo natural, y cada tipo de objeto expone una interfaz a otros objetos que específica cómo pueden interactuar con los objetos de la clase. El aislamiento protege a las propiedades de un objeto contra su modificación por quien no tenga derecho a acceder a ellas, solamente los propios métodos internos del objeto pueden acceder a su estado. Esto asegura que otros objetos no pueden cambiar el estado interno de un objeto de maneras inesperadas, eliminando efectos secundarios e interacciones inesperadas. Algunos lenguajes relajan esto, permitiendo un acceso directo a los datos internos del objeto de una manera controlada y limitando el grado de abstracción. La aplicación entera se reduce a un agregado o rompecabezas de objetos. Esta característica o propiedad permite por tanto ejecutar la información al resto de los objetos, impidiendo así accesos incorrectos o conflictos.
- POLIMORFISMO: comportamientos diferentes, asociados a objetos distintos, pueden compartir el mismo nombre, al llamarlos por ese nombre se utilizará el comportamiento correspondiente al objeto que se esté usando. O dicho de otro modo, las referencias y las colecciones de objetos pueden contener objetos de diferentes tipos, y la invocación de un comportamiento en una referencia producirá el comportamiento correcto para el tipo real del objeto referenciado. Por ejemplo en Visual Basic, el polimorfismo se da al tener diferentes tipos de objetos (Form, Label, etc.)
HERENCIA: las clases no están aisladas, sino que se relacionan
entre sí, formando una jerarquía de clasificación. Los objetos heredan las
propiedades y el comportamiento de todas las clases a las que pertenecen. La
herencia organiza y facilita el polimorfismo y el encapsulamiento permitiendo a
los objetos ser definidos y creados como tipos especializados de objetos
preexistentes. Estos pueden compartir (y extender) su comportamiento sin tener
que reimplementar su comportamiento. Esto suele hacerse habitualmente agrupando
los objetos en clases y estas en árboles o enrejados que reflejan un
comportamiento común. Cuando un objeto pertenece a más de una clase se dice que
hay herencia múltiple; esta característica no está soportada por algunos
lenguajes (como Java). Con esta propiedad, los objetos heredan comportamientos
dentro de una
jerarquía de clases.
7.3. PRINCIPALES DIFERENCIAS ENTRE LA PROGRAMACIÓN
IMPERATIVA Y LA PROGRAMACIÓN ORIENTADA A OBJETOS
- La
programación orientada a objetos es más moderna, es una evolución de la
programación imperativa plasmada en el diseño de una familia de lenguajes
conceptos que existían previamente, con algunos nuevos.
- La
programación orientada a objetos se basa en lenguajes que soportan
sintáctica y semánticamente la unión entre los tipos abstractos de datos y
sus operaciones (a esta unión se la suele llamar clase).
- La
programación orientada a objetos incorpora en su entorno de ejecución
mecanismos tales como el polimorfismo y el envío de mensajes entre
objetos.
7.4. ALGUNOS LENGUAJES ORIENTADOS A OBJETOS
Entre los lenguajes orientados a objetos más
importantes que se pueden mencionar, aparecen los siguientes:
- Ada
- C++
- C#
- VB.NET
- Clarion
- Delphi
- Eiffel
- Jave
- Lexico
- Objective-C
- Ocaml
- Oz
- PHP
- PowerBuilder
- Pitón
- Ruby
- Smalltalk
C++
C++ es un lenguaje de
programación diseñado a mediados de los años 1980 por Bjarne Stroustrup. La intención de su creación
fue el extender al exitoso lenguaje de
programación C con
mecanismos que permitan la manipulación de objetos.
En ese sentido, desde el punto de vista de los lenguajes
orientados a objetos, el C++ es un lenguaje híbrido.
Posteriormente se añadieron
facilidades de programación genérica,
que se sumó a los otros dos paradigmas que ya estaban admitidos (programación
estructurada y la programación
orientada a objetos). Por esto se suele decir que el C++ es un lenguaje
de programación multiparadigma.
Actualmente existe un
estándar, denominado ISO C++, al que se han adherido la mayoría de los
fabricantes de compiladores más modernos. Existen también algunos intérpretes,
tales como ROOT.
Una particularidad del C++ es
la posibilidad de redefinir los operadores,
y de poder crear nuevos tipos que se comporten como tipos
fundamentales.
El nombre C++ fue
propuesto por Rick
Mascitti en el año 1983, cuando el lenguaje fue utilizado por
primera vez fuera de un laboratorio científico. Antes se había usado el nombre
"C con clases". En C++, la expresión "C++" significa
"incremento de C" y se refiere a que C++ es una extensión de C.
Un ejemplo de
programa, el clásico Hola mundo
A continuación se cita un
programa de ejemplo Hola mundo escrito
en C:
/* Esta cabecera permite usar
los objetos que encapsulan los descriptores stdout
y stdin: cout(<<) y
cin(>>)*/
#include <iostream>
using namespace std;
int main()
{
cout << "Hola
mundo" << std::endl;
cin.get();
}
Al usar la directiva #include estamos diciéndole al compilador que busque e
interprete todos los elementos definidos en el archivo que acompaña la
directiva (en este caso,iostream). Para evitar sobrescribir
los elementos ya definidos al ponerles igual nombre, se crearon los espacios de
nombres o namespace del singular en inglés.
En este caso hay un espacio de nombres llamado std, que es donde
se incluyen las definiciones de todas las funciones y clases que conforman
la biblioteca estándar
de C++. Al incluir la sentencia using namespace std le estamos diciendo al compilador que
usaremos el espacio de nombres std por lo que no tendremos
que incluirlo cuando usemos elementos de este espacio de nombres, como pueden
ser los objetos cout y cin, que representan el flujo de salida estándar
(típicamente la pantalla o una ventana de texto) y el flujo de entrada estándar
(típicamente el teclado).
La definición de funciones es
igual que en C, salvo por la característica de que si main no va a recoger argumentos, no tenemos por
qué ponérselos, a diferencia de C, donde había que ponerlos explícitamente,
aunque no se fueran a usar. Queda solo comentar que el símbolo << se conoce como operador de inserción, y grosso
modo está enviando acout lo que queremos mostrar
por pantalla para que lo pinte, en este caso la cadena "Hola mundo". El mismo operador << se puede usar varias veces en la misma
sentencia, de forma que gracias a esta característica podremos concatenar el
objeto endl al final, cuyo resultado
será imprimir un retorno de línea.
Por último tomaremos una
secuencia de caracteres del teclado hasta el retorno de línea (presionando
ENTER), llamando al método get del objeto cin.
Tipos de datos
C++ tiene los siguientes tipos fundamentales:
·
Caracteres: char (también
es un entero), wchar_t
·
Enteros: short, int, long, long long
·
Números en coma flotante: float, double, long double
·
Booleanos: bool
·
Vacío: void
El modificador unsigned se puede aplicar a enteros para obtener
números sin signo (por omisión los enteros contienen signo), con lo que se
consigue un rango mayor de números naturales.
Tamaños asociados
Según la máquina y el
compilador que se utilice los tipos primitivos pueden ocupar un determinado
tamaño en memoria. La siguiente lista ilustra el número de bits que ocupan los
distintos tipos primitivos en la arquitectura x86.
Otras arquitecturas pueden
requerir distintos tamaños de tipos de datos primitivos. C++ no dice nada
acerca de cuál es el número de bits en un byte, ni del tamaño de estos tipos;
más bien, ofrece solamente las siguientes "garantías de tipos":
·
De acuerdo al estándar C99,
un tipo char debe ocupar exactamente
un byte compuesto de un mínimo de 8 bits independientemente
de la arquitectura de la máquina.
·
El tamaño reconocido de char es de 1.
Es decir, sizeof(char) siempre devuelve 1.
·
Un tipo short tiene al
menos el mismo tamaño que un tipo char.
·
Un tipo long tiene al
menos el doble tamaño en bytes que un tipo short.
·
Un tipo int tiene un
tamaño entre el de short y el de long, ambos inclusive, preferentemente el tamaño de un
apuntador de memoria de la máquina.
·
Un tipo unsigned tiene el
mismo tamaño que su versión signed.
Wchar_t
Para la versión del estándar
que se publicó en 1998, se decidió añadir el tipo de dato wchar_t, que permite el uso de caracteres UNICODE, a diferencia del tradicional char, que contempla simplemente al código de caracteres
ASCII extendido. A su vez, se ha definido para la mayoría de las funciones y
clases, tanto de C como de C++, una versión para trabajar con wchar_t, donde usualmente se prefija el carácter w al
nombre de la función (en ocasiones el carácter es un infijo). Por ejemplo:
·
strcpy -
wstrcpy
·
std::string
- std::wstring
·
std::cout -
std::wcout
Cabe resaltar que en C se
define wchar_t como:
typedef unsigned short wchar_t;
Mientras que en C++ es en sí
mismo un tipo de dato.
La palabra
reservada "void"
La palabra reservada void define en C++ el concepto de no existencia o
no atribución de un tipo en una variable o declaración. Es decir, una función
declarada como void no devolverá ningún
valor. Esta palabra reservada también puede usarse para indicar que una función
no recibe parámetros, como en la siguiente declaración:
int funcion (void);
Aunque la tendencia actual es
la de no colocar la palabra "void".
Además se utiliza para
determinar que una función no retorna un valor, como en:
void funcion (int
parametro);
Cabe destacar que void no es un tipo. Una función como la
declarada anteriormente no puede retornar un valor por medio de return: la palabra clave va sola. No
es posible una declaración del tipo:
void t;
//Está mal
En este sentido, void se comporta de forma ligeramente diferente a
como lo hace en C, especialmente en cuanto a su significado en declaraciones y
prototipos de funciones.
Sin embargo, la forma
especial void * indica que el tipo de datos es un puntero. Por
ejemplo:
void *memoria;
Indica que memoria es un puntero a alguna
parte, donde se guarda información de algún tipo. El programador es responsable de definir
estos "algún", eliminando toda ambigüedad. Una ventaja de la
declaración "void *" es que puede representar a la vez varios
tipos de datos, dependiendo de la operación de cast escogida. La memoria que hemos
apuntado en alguna parte, en el ejemplo anterior, bien podría almacenar un
entero, un flotante, una cadena de texto o un programa, o combinaciones de
éstos. Es responsabilidad del programador recordar qué tipo de datos hay y
garantizar el acceso adecuado.
La palabra
"NULL"
Además de los valores que
pueden tomar los tipos anteriormente mencionados, existe un valor llamado NULL,
sea el caso numérico para los enteros, caracter para el tipo char, cadena de
texto para el tipo string, etc. El valor NULL, expresa, por lo regular, la
representación de una Macro, asignada al valor "0".
Tenemos entonces que:
void*
puntero = NULL;
int entero =
NULL;
bool boleana =
NULL;
char caracter =
NULL;
El valor de las variables
anteriores nos daría 0. A diferencia de la variable "caracter", que
nos daría el equivalente a NULL, '\0', para caracteres.
Principios
Todo programa en C++ debe
tener la función principal main() (a no ser que se
especifique en tiempo de compilación otro punto de entrada, que en realidad es
la función que tiene el main())
int main()
{}
La función principal del
código fuente main debe tener uno de los
siguientes prototipos:
int main()
int main(int argc, char** argv)
int main()
int main(int argc, char** argv)
Aunque no es estándar algunas
implementaciones permiten
int main(int argc, char** argv, char** env)
int main(int argc, char** argv, char** env)
La primera es la forma por
omisión de un programa que no recibe parámetros ni argumentos. La segunda forma
tiene dos parámetros: argc, un número que describe el número de
argumentos del programa (incluyendo el nombre del programa mismo), y argv,
un puntero a un array de punteros, de argc elementos, donde el
elemento argv[i] representa el i-ésimo argumento
entregado al programa. En el tercer caso se añade la posibilidad de poder
acceder a las variables de entorno de ejecución de la misma forma que se accede
a los argumentos del programa, pero reflejados sobre la variable env.
El tipo de retorno de main es un valor entero int.
Al finalizar la función main, debe incluirse el valor de
retorno (por ejemplo, return 0;, aunque el estándar prevé
solamente dos posibles valores de retorno: EXIT_SUCCESS y EXIT_FAILURE,
definidas en el archivo cstdlib), o salir por medio de la
función exit. Alternativamente puede dejarse en blanco, en cuyo
caso el compilador es responsable de agregar la salida adecuada.
El concepto de
clase
Los objetos en C++ son
abstraídos mediante una clase. Según el paradigma de la programación orientada
a objetos un objeto consta de:
1.
Identidad, que lo diferencia de otros objetos
(Nombre que llevara la clase a la que pertenece dicho objeto).
2.
Métodos o funciones miembro
3.
Atributos o variables miembro
Un ejemplo de clase que
podemos tomar es la clase perro. Cada perro comparte unas características
(atributos). Su número de patas, el color de su pelaje o su tamaño son algunos
de sus atributos. Las funciones que lo hagan ladrar, cambiar su
comportamiento... esas son las funciones de la clase.
Este es otro ejemplo de una
clase:
class Punto
{
//por omisión los miembros son
'private' para que sólo se puedan modificar desde la propia clase.
private:
// Variable
miembro privada
int
id;
protected:
// Variables
miembro protegidas
int
x;
int
y;
public:
// Constructor
Punto();
// Destructor
~Punto();
// Funciones
miembro o métodos
int
ObtenerX();
int
ObtenerY();
};
Constructores
Son unos métodos especiales
que se ejecutan automáticamente al crear un objeto de la clase. En su
declaración no se especifica el tipo de dato que devuelven, y poseen el mismo
nombre que la clase a la que pertenecen. Al igual que otros métodos, puede
haber varios constructores sobrecargados, aunque no pueden existir
constructores virtuales.
Como característica especial a
la hora de implementar un constructor, justo después de la declaración de los
parámetros, se encuentra lo que se llama "lista de inicializadores".
Su objetivo es llamar a los constructores de los atributos que conforman el
objeto a construir.
Cabe destacar que no es
necesario declarar un constructor al igual que un destructor, pues el
compilador lo puede hacer, aunque no es la mejor forma de programar.
Tomando el ejemplo de la Clase
Punto, si deseamos que cada vez que se cree un objeto de esta clase las
coordenadas del punto sean igual a cero podemos agregar un constructor como se
muestra a continuación:
class Punto
{
public:
float x; // Coordenadas del punto
float y;
// Constructor
Punto()
: x(0),
y(0){
// Inicializamos las variables "x" e
"y"
}
};
// Main para demostrar el
funcionamiento de la clase
# include <iostream> //
Esto nos permite utilizar "cout"
using namespace std;
int main () {
Punto MiPunto; // creamos un
elemento de la clase Punto llamado MiPunto
cout <<
"Coordenada X: " <<
MiPunto.x <<
endl; // mostramos el valor
acumulado en la variable x
cout <<
"Coordenada Y: " <<
MiPunto.y <<
endl; // mostramos el valor
acumulado en la variable y
getchar();
// le indicamos al programa que espere al buffer de
entrada (detenerse)
return 0;
}
Si compilamos y ejecutamos el
anterior programa, obtenemos una salida que debe ser similar a la siguiente:
Coordenada X: 0 Coordenada Y:
0
Existen varios tipos de
constructores en C++:
1.
Constructor predeterminado. Es el constructor que no
recibe ningún parámetro en la función. Si no se definiera ningún constructor,
el sistema proporcionaría uno predeterminado. Es necesario para la construcción
de estructuras y contenedores de la STL.
2.
Constructor de copia. Es un constructor que recibe
un objeto de la misma clase, y realiza una copia de los atributos del mismo. Al
igual que el predeterminado, si no se define, el sistema proporciona uno.
3.
Constructor de conversión. Este constructor, recibe
como único parámetro, un objeto o variable de otro tipo distinto al suyo
propio. Es decir, convierte un objeto de un tipo determinado a otro objeto del
tipo que estamos generando.
Constructores + Memoria heap Un objeto creado de la
forma que se vio hasta ahora, es un objeto que vive dentro del scope(las llaves
{ }) en el que fue creado. Para que un objeto pueda seguir viviendo cuando se
saque de el scope en el que se creó, se lo debe crear en memoria heap. Para
esto, se utiliza el operador new, el cual asigna memoria para almacenar al objeto
creado, y además llama a su constructor(por lo que se le pueden enviar
parámetros). El operador new se utiliza de la siguiente manera:
int main()
{
Punto *unPunto
= new
Punto(); //esto
llama al constructor que se describe más arriba
delete unPunto; //no hay que
olvidarse de liberar la memoria ocupada por el objeto(ver la sección
destructores, más abajo)
return 0;
}
Además, con el operador new[]
se pueden crear arrays (colecciones o listas ordenadas) de tamaño dinámico:
Punto *asignar(int
cuantos) {
return new
Punto[cuantos];
//asigna un array de 'cuantos' puntos(se llama el
constructor que se muestra más arriba), y se retorna.
}
Destructores
Los destructores son funciones
miembro especiales llamadas automáticamente en la ejecución del programa, y por
tanto no tienen por qué ser llamadas explícitamente por el programador.
Sus principales cometidos son:
·
Liberar los recursos computacionales que el objeto
de dicha clase haya adquirido en tiempo de ejecución al expirar éste.
·
Quitar los vínculos que pudiesen tener otros
recursos u objetos con éste.
Los destructores son invocados
automáticamente al alcanzar el flujo del programa el fin del ámbito en el que
está declarado el objeto. El único caso en el que se debe invocar
explícitamente al destructor de un objeto, es cuando éste fue creado
mediante el operador new, es decir, que éste vive en memoria heap, y no en la
pila de ejecución del programa. La invocación del destructor de un objeto que
vive en heap se realiza a través del operador delete o delete[] para arrays.
Ejemplo:
int main()
{
int *unEntero
= new
int(12); //asignamos un
entero en memoria heap con el valor 12
int *arrayDeEnteros
= new
int[25];
//asignamos memoria para 25 enteros(no estan
inicializados)
delete unEntero; //liberamos la
memoria que ocupaba unEntero
delete[]
arrayDeEnteros; //liberamos la
memoria ocupada por arrayDeEnteros
return 0;
}
Si no se utilizara el operador
delete y delete[] en ese caso, la memoria ocupada por unEntero y arrayDeEnteros
respectivamente, quedaría ocupada sin sentido. Cuando una porción de memoria
queda ocupada por una variable que ya no se utiliza, y no hay forma de acceder
a ella, se denomina un 'memory leak'. En aplicaciones grandes, si ocurren
muchos memory leaks, el programa puede terminar ocupando bastante más memoria
RAM de la que debería, lo que no es para nada conveniente. Es por esto, que el
manejo de memoria heap debe usarse conscientemente.
Existen dos tipos de
destructores pueden ser públicos o privados, según si se declaran:
·
Si es público se llama desde cualquier parte del
programa para destruir el objeto.
·
Si es privado no se permite la destrucción del
objeto por el usuario.
El uso de destructores es
clave en el concepto de Adquirir Recursos es Inicializar.
Funciones miembro
Función miembro es aquella que
está declarada en ámbito de clase. Son similares a las funciones habituales,
con la salvedad de que el compilador realizara el proceso deDecoración de
nombre (Name Mangling en inglés): Cambiará el nombre de la
función añadiendo un identificador de la clase en la que está declarada,
pudiendo incluir caracteres especiales o identificadores numéricos. Este
proceso es invisible al programador. Además, las funciones miembro reciben
implícitamente un parámetro adicional: El puntero this, que referencia al objeto que
ejecuta la función.
Las funciones miembro se
invocan accediendo primero al objeto al cual refieren, con la sintaxis: myobject.mymemberfunction(), esto es un claro ejemplo de
una función miembro.
Caso especial es el de las funciones
miembro estáticas. A pesar de que son declaradas dentro de la clase, con el uso
de la palabra clave static no recibirán el
puntero this. Gracias a esto no es necesario crear ninguna
instancia de la clase para llamar a esta función, sin embargo, sólo se podrá
acceder a los miembros estáticos de la clase dado que estos no están asociados
al objeto sino al tipo. La sintaxis para llamar a esta función estática
es mytype::mystaticmember().
Plantillas
Las plantillas son el
mecanismo de C++ para implantar el paradigma de la programación genérica.
Permiten que una clase o función trabaje con tipos de datos abstractos,
especificándose más adelante cuales son los que se quieren usar. Por ejemplo,
es posible construir un vector genérico que pueda contener cualquier tipo de
estructura de datos. De esta forma se pueden declarar objetos de la clase de
este vector que contengan enteros, flotantes, polígonos, figuras, fichas de
personal, etc.
La declaración de una
plantilla se realiza anteponiendo la declaración template
<typename A,....> a
la declaración de la estructura (clase, estructura o función) deseado.
Por ejemplo:
template <typename
T>
T max(const T &x, const T &y) {
return (x
> y)
? x :
y; //si x > y,
retorna x, sino retorna y
}
La función max() es un ejemplo de
programación genérica, y dados dos parámetros de un tipo T (que puede ser int, long, float, double, etc.) devolverá el mayor de
ellos (usando el operador >). Al ejecutar la función con
parámetros de un cierto tipo, el compilador intentará "calzar" la
plantilla a ese tipo de datos, o bien generará un mensaje de error si fracasa
en ese proceso.
Especialización[editar]
Clases abstractas[editar]
En C++ es posible definir
clases abstractas. Una clase abstracta, o clase base abstracta (ABC), es una
que está diseñada sólo como clase padre de las cuales se deben
derivar clases hijas. Una clase abstracta se usa para representar aquellas
entidades o métodos que después se implementarán en las clases derivadas, pero
la clase abstracta en sí no contiene ninguna implementación -- solamente
representa los métodos que se deben implementar. Por ello, no es posible
instanciar una clase abstracta, pero sí una clase concreta que implemente los
métodos definidos en ella.
Las clases abstractas son
útiles para definir interfaces, es decir, un conjunto de métodos que definen el
comportamiento de un módulo determinado. Estas definiciones pueden utilizarse
sin tener en cuenta la implementación que se hará de ellos.
En C++ los métodos de las
clases abstractas se definen como funciones virtuales puras.
class Abstracta
{
public:
virtual int metodo() = 0;
};
class ConcretaA : public Abstracta
{
public:
int metodo()
{
//haz algo
return foo () + 2;
}
};
class ConcretaB : public Abstracta
{
public:
int
metodo()
{
//otra
implementación
return
baz () -
5;
}
};
En el ejemplo, la clase ConcretaA es una implementación de
la clase Abstracta, y la clase ConcretaB es otra implementación.
Debe notarse que el = 0 es la notación que
emplea C++ para definir funciones virtuales puras.
Espacios de
nombres
Una adición a las
características de C son los espacios de nombre (namespace en
inglés), los cuales pueden describirse como áreas virtuales bajo las cuales
ciertos nombres de variable o tipos tienen validez. Esto permite evitar las ocurrencias
de conflictos entre nombres de funciones, variables o clases.
El ejemplo más conocido en C++
es el espacio de nombres std::, el cual almacena todas las
definiciones nuevas en C++ que difieren de C (algunas estructuras y funciones),
así como las funcionalidades propias de C++ (streams) y los componentes de la
biblioteca STL.
Por ejemplo:
# include <iostream>
// Las funciones en esta
cabecera existen dentro del espacio de nombres std::
namespace mi_paquete{
int mi_valor;
};
int main()
{
int mi_valor = 3;
mi_paquete::mi_valor
= 4;
std::cout
<< mi_valor <<
'\n';
// imprime '3'
std::cout
<< mi_paquete::mi_valor
<< '\n';
// imprime '4'
return 0;
}
Como puede verse, las
invocaciones directas a mi_valor darán acceso solamente a la variable
descrita localmente; para acceder a la variable del espacio de nombresmi_paquete es
necesario acceder específicamente el espacio de nombres. Un atajo recomendado
para programas sencillos es la directiva using namespace, que permite acceder a los nombres
de variables del paquete deseado en forma directa, siempre y cuando no se
produzca alguna ambigüedad o conflicto de nombres.
Herencia
Existen varios tipos de herencia entre
clases en el lenguaje de programación C++. Estos son:
Herencia simple
La herencia en C++ es un
mecanismo de abstracción creado para poder facilitar y mejorar el diseño de las
clases de un programa. Con ella se pueden crear nuevas clases a partir de
clases ya hechas, siempre y cuando tengan un tipo de relación especial.
En la herencia, las clases
derivadas "heredan" los datos y las funciones miembro de las clases
base, pudiendo las clases derivadas redefinir estos comportamientos
(polimorfismo) y añadir comportamientos nuevos propios de las clases derivadas.
Para no romper el principio de encapsulamiento (ocultar datos cuyo conocimiento
no es necesario para el uso de las clases), se proporciona un nuevo modo de
visibilidad de los datos/funciones: "protected". Cualquier cosa que
tenga visibilidad protected se comportará como pública en la clase Base y en
las que componen la jerarquía de herencia, y como privada en las clases que NO
sean de la jerarquía de la herencia.
Antes de utilizar la herencia,
nos tenemos que hacer una pregunta, y si tiene sentido, podemos intentar usar
esta jerarquía: Si la frase <claseB> ES-UN <claseA> tiene sentido,
entonces estamos ante un posible caso de herencia donde clase A será la clase
base y clase B la derivada.
Ejemplo: clases Barco,
Acorazado, Carguero, etc. un Acorazado ES-UN Barco, un Carguero ES-UN Barco, un
Trasatlántico ES-UN Barco, etc.
En este ejemplo tendríamos las
cosas generales de un Barco (en C++)
class Barco {
protected:
char*
nombre;
float
peso;
public:
//Constructores
y demás funciones básicas de barco
};
y ahora las características de
las clases derivadas, podrían (a la vez que heredan las de barco) añadir cosas
propias del subtipo de barco que vamos a crear, por ejemplo:
class Carguero:
public Barco {
// Esta es la manera de especificar que hereda de
Barco
private:
float
carga;
//El resto de cosas
};
class Acorazado:
public Barco {
private:
int
numeroArmas;
int
Soldados;
// El resto de
cosas
};
Por último, hay que mencionar
que existen 3 clases de herencia que se diferencian en el modo de manejar la
visibilidad de los componentes de la clase resultante:
·
Herencia publica (class Derivada: public Base ):
Con este tipo de herencia se respetan los comportamientos originales de las
visibilidades de la clase Base en la clase Derivada.
·
Herencia privada (clase Derivada: private Base):
Con este tipo de herencia todo componente de la clase Base, será privado en la
clase Derivada (las propiedades heredadas serán privadas aunque estas sean
públicas en la clase Base)
·
Herencia protegida (clase Derivada: protected
Base): Con este tipo de herencia, todo componente público y protegido de la
clase Base, será protegido en la clase Derivada, y los componentes privados,
siguen siendo privados.
Herencia múltiple
La herencia múltiple es
el mecanismo que permite al programador hacer clases derivadas a partir, no de
una sola clase base, sino de varias. Para entender esto mejor, pongamos un
ejemplo: Cuando ves a quien te atiende en una tienda, como persona que es,
podrás suponer que puede hablar, comer, andar, pero, por otro lado, como
empleado que es, también podrás suponer que tiene un jefe, que puede cobrarte
dinero por la compra, que puede devolverte el cambio, etc. Si esto lo
trasladamos a la programación sería herencia múltiple (clase empleado_tienda):
class Persona {
...
Hablar();
Caminar();
...
};
class Empleado {
Persona jefe;
int sueldo;
Cobrar();
...
};
class EmpleadoTienda:
public Persona, Empleado {
...
AlmacenarStock();
ComprobarExistencias();
...
};
Por tanto, es posible utilizar
más de una clase para que otra herede sus características.
Sobrecarga de
operadores
La sobrecarga de operadores es
una forma de hacer polimorfismo. Es posible definir el comportamiento de un
operador del lenguaje para que trabaje con tipos de datos definidos por el
usuario. No todos los operadores de C++ son factibles de sobrecargar, y, entre
aquellos que pueden ser sobrecargados, se deben cumplir condiciones especiales.
En particular, los operadores sizeof y :: no son sobrecargables.
No es posible en C++ crear un
operador nuevo.
Los comportamientos de los
operadores sobrecargados se implementan de la misma manera que una función,
salvo que esta tendrá un nombre especial: Tipo de dato de devolución operator<token del operador>(parámetros)
Los siguientes operadores
pueden ser sobrecargados:
·
Operadores Unarios
·
Operador * (de indirección)
·
Operador -> (de indirección)
·
Operador & (de dirección)
·
Operador +
·
Operador -
·
Operador ++
·
Operador --
·
Operadores Binarios
·
Operador ==
·
Operador +
·
Operador -
·
Operador *
·
Operador /
·
Operador %
·
Operador <<
·
Operador >>
·
Operador &
·
Operador ^
·
Operador |
·
Operador []
·
Operador ()
·
Operadores de Asignación
·
Operador =
·
Operador +=
·
Operador -=
·
Operador *=
·
Operador /=
·
Operador %=
·
Operador <<=
·
Operador >>=
·
Operador &=
·
Operador ^=
·
Operador |=
Dado que estos operadores son
definidos para un tipo de datos definido por el usuario, éste es libre de
asignarles cualquiera semántica que desee. Sin embargo, se considera de primera
importancia que las semánticas sean tan parecidas al comportamiento natural de
los operadores como para que el uso de los operadores sobrecargados sea
intuitivo. Por ejemplo, el uso del operador unario - debiera cambiar el
"signo" de un "valor".
Los operadores sobrecargados
no dejan de ser funciones, por lo que pueden devolver un valor, si este valor
es del tipo de datos con el que trabaja el operador, permite el encadenamiento
de sentencias. Por ejemplo, si tenemos 3 variables A,B y C de un tipo T y
sobrecargamos el operador = para que trabaje con el tipo de datos T, hay dos
opciones: si el operador no devuelve nada una sentencia como "A=B=C;"
(sin las comillas) daría error, pero si se devuelve un tipo de datos T al
implementar el operador, permitiría concatenar cuantos elementos se quisieran,
permitiendo algo como "A=B=C=D=...;"
Standard
Template Library (STL)
Los lenguajes de programación
suelen tener una serie de bibliotecas de funciones integradas para la
manipulación de datos a nivel más básico. En C++, además de poder usar las
bibliotecas de C, se
puede usar la nativa STL (Standard Template Library), propia del lenguaje.
Proporciona una serie plantillas (templates)
que permiten efectuar operaciones sobre el almacenado de datos, procesado de
entrada/salida.
Biblioteca de
entrada y salida
Las clases basic_ostream y basic_stream,
y los objetos cout y cin, proporcionan la entrada
y salida estándar de datos (teclado/pantalla). También está disponible cerr,
similar a cout, usado para la salida estándar de errores. Estas clases tienen
sobrecargados los operadores << y >>, respectivamente, con el
objeto de ser útiles en la inserción/extracción de datos a dichos flujos. Son
operadores inteligentes, ya que son capaces de adaptarse al tipo de datos que
reciben, aunque tendremos que definir el comportamiento de dicha entrada/salida
para clases/tipos de datos definidos por el usuario. Por ejemplo:
ostream&
operator<<(ostream&
fs,const Punto&
punto)
{
return fs <<
punto.x <<
"," <<
punto.y;
}
De esta forma, para mostrar un
punto, solo habría que realizar la siguiente expresión:
//...
Punto p(4,5);
//...
cout <<
"Las coordenadas son: "
<< p <<
endl;
//...
Es posible formatear la
entrada/salida, indicando el número de dígitos decimales a mostrar, si los
textos se pasarán a minúsculas o mayúsculas, si los números recibidos están en
formato octal o hexadecimal,
etc.
Fstreams
Tipo de flujo para el manejo
de ficheros. La definición previa de ostreams/istreams es
aplicable a este apartado. Existen tres clases (ficheros de lectura, de
escritura o de lectura/escritura): ifstream,ofstream y fstream.
Como abrir un fichero:
(nombre_variable_fichero).open("nombre_fichero.dat/txt",ios::in);
para abrirlo en modo lectura.
(nombrevariablefichero).open("nombre_fichero.dat/txt",ios::out); para
abrirlo en modo escritura.
Ejemplo:
f.open("datos.txt",ios::in);
Como cerrar el fichero:
nombre_variable_fichero.close();
Ejemplo: f.close();
Leer un fichero:
1-Si es fichero de
texto plano:
#include
<fstream>
#include
<string>
#include
<iostream>
using namespace std;
int main() {
ifstream entrada;
entrada.open("textoPlano.txt");
string unString;
while(entrada >> unString)
cout << "Lei:
" << unString << endl;
return
0;
}
2-Si es un fichero
binario(.dat);
nombre_variable_fichero.read((char*)&nombre_variable,sizeof(tipo_variable));
Ejemplo:
f.read((char*)&e,sizeof(int));
Escribir un fichero:
1-Si es fichero de
texto(.txt):
nombrevariable<<"texto";
donde "texto" puede ser también una variable de cualquier tipo
primitivo, o un string.
Ejemplo: f<<HOLA;
2-Si es un fichero
binario(.dat);
nombre_variable_fichero.write((char*)&nombre_variable,sizeof(tipo_variable));
Ejemplo:
f.write((char*)&e,sizeof(int));
Pueden abrirse pasando al
constructor los parámetros relativos a la ubicación del fichero y el modo de
apertura:
Sstreams
Se destacan dos clases, ostringstream e istringstream.
Todo lo anteriormente dicho es aplicable a estas clases. Tratan a una cadena
como si de un flujo de datos se tratase. ostringstream permite elaborar una
cadena de texto insertando datos cual flujo, e istringstream puede extraer la
información contenida en una cadena (pasada como parámetro en su constructor)
con el operador >>. Ejemplos:
ostringstream s;
s <<
nombre << ","
<< edad <<
"," <<
estatura << ","
<< punto(5,6)
<< endl;
cout <<
s.str();
istringstream s(cadena);
s >>
nombre >> edad >>
estatura >> p;
Contenedores
Son clases plantillas
especiales utilizadas para almacenar tipos de datos genéricos, sean cuales
sean. Todos los contenedores son homogéneos, es decir, una vez que se declaran
para contener un tipo de dato determinado, en ese contenedor, solo se podrán
meter elementos de ese tipo. Según la naturaleza del almacenado, disponemos de
varios tipos:
·
Vectores: Se definen por
·
vector<tipo_de_dato>
nombre_del_vector;
Son arrays (o listas
ordenadas) que se redimensionan automáticamente al agregar nuevos elementos,
por lo que se le pueden agregar "teóricamente", infinitos elementos.
Los vectores nos permiten acceder a cualquier elemento que contenga, mediante
el operador[]. Debe tenerse en cuenta que si se intenta acceder a una posición
que excede los límites del vector, este no hará ningún chequeo, por lo que se
debe ser cuidadoso al utilizar este operador. Para asegurar un acceso seguro al
vector, se puede utilizar el método at(int), que lanza una excepción de tipo
std::out_of_range en caso de que esto ocurra.
Para añadir elementos al final
del vector, se utiliza el método push_back(const T&). Por otro lado, para
eliminar un elemento del final del vector, se debe usar el método pop_back().
#include <vector>
//libreria que contiene a la clase vector
#include <iostream>
using namespace std;
int main()
{
vector<int>
intVector; //crea un vector de
enteros(sin elementos)
intVector.push_back(25);
//agrega el entero 25 al vector
cout <<
"El primer elemento es: "
<< intVector.front()
<<
" y mi vector tiene
" << intVector.size()
<< "
elementos." << endl;
//imprime el primer elemento(retornado por el
método front()
intVector.push_back(32);
//agrego el entero 32 al vector
cout <<
"El primer elemento es: "
<< intVector[0]
<< endl;
//imprime 25
intVector.pop_back(); //elimina el ultimo elemento
del vector(osea 32)
cout <<
"Ahora tengo: " <<
intVector.size() <<
" elementos." <<
endl; //imprimirá 1
return 0;
}
·
Colas dobles: son parecidas a los vectores, pero
tienen mejor eficiencia para agregar o eliminar elementos en las
"puntas".
·
deque<tipo_de_dato>
nombre_de_la_cola;
Además de los métodos
push_back(const T&) y pop_back(), se agregan los métodos push_front(const
T&) y pop_front(), que realizan lo mismo que los ya explicados, pero en el
comienzo de la cola.
#include <deque>
//libreria de deques
using namespace std;
int main() {
deque<int> intDeque;
intDeque.push_front(25);
intDeque.push_back(12);
while(intDeque.size())
intDeque.pop_back();
//borra todos los elementos
return 0;
}
·
Listas: Son eficientes a la hora de agregar
elementos. La diferencia con las colas dobles, es que son más eficientes para eliminar
elementos que no estén en alguna de las "puntas"
·
list<tipo_de_dato>
nombre_de_la_lista;
·
Adaptadores de secuencia.
·
Contenedores asociativos: map y multimap, que
permiten asociar una "clave" con un "valor". map no permite
valores repetidos, mientras que multimap si.
map<tipo_de_llave,
tipo_de_dato> nombre_del_map;
multimap<tipo_de_llave,
tipo_de_dato> nombre_del_multimap;
#include <map>
//libreria que contiene a map y multimap
#include <string>
//libreria de strings
#include <iostream>
//libreria de entrada/salida
using namespace std;
int main() {
map<int, string> intAString;
intAString[1] = "uno";
intAString[10] = "diez";
cout << "En
intAString[1]: " << intAString[1] << endl;
cout << "En
intAString[10]: " << intAString[10] << endl;
return 0;
}
·
Contenedores asociativos: set y multiset, que
ofrecen solamente la condición de "pertenencia", sin la necesidad de
garantizar un ordenamiento particular de los elementos que contienen.
Iteradores
Pueden considerarse como una
generalización de la clase de "puntero". Un iterador es un tipo de
dato que permite el recorrido y la búsqueda de elementos en los contenedores.
Como las estructuras de datos (contenedores) son clases genéricas, y los
operadores (algoritmos) que deben operar sobre ellas son también genéricos
(funciones genéricas), Stepanov y sus colaboradores tuvieron que desarrollar el
concepto de iterador como elemento o nexo de conexión entre ambos. El nuevo
concepto resulta ser una especie de punteros que señalan a los diversos
miembros del contenedor (punteros genéricos que como tales no existen en el
lenguaje).
Algoritmos
Combinando la utilización de
templates y un estilo específico para denotar tipos y variables, la STL ofrece
una serie de funciones que representan operaciones comunes, y cuyo objetivo es
"parametrizar" las operaciones en que estas funciones se ven
involucradas de modo que su lectura, comprensión y mantenimiento, sean más
fáciles de realizar.
Un ejemplo es la función copy, la cual simplemente copia
variables desde un lugar a otro. Más estrictamente, copia los contenidos cuyas
ubicaciones están delimitadas por dos iteradores, al espacio indicado por un
tercer iterador. La sintaxis es:
copy
(inicio_origen, fin_origen, inicio_destino);
De este modo, todos los datos
que están entre inicio_origen y fin_origen, excluyendo el dato ubicado en este
último, son copiados a un lugar descrito o apuntado por inicio_destino.
Un algoritmo muy importante
que viene implementado en la biblioteca STL, es el sort. El algoritmo sort,
ordena cualquier tipo de contenedor, siempre y cuando se le pasen como
argumentos, desde donde y hasta donde se quiere ordenarlo.
#include <vector>
#include <deque>
#include <algorithm>
int main() {
vector<int> intVector;
intVector.push_back(60);
intVector.push_back(12);
intVector.push_back(54);
//para este momento, el vector tiene 60,12,54
sort(intVector.begin(),
intVector.end());
//listo, array ordenado, ahora tiene 12,54,60
/*Notar que si en
vez de un vector, fuese una deque, se ordenaria de la misma manera. */
}
Entre las funciones más
conocidas están swap (variable1, variable2), que simplemente intercambia
los valores de variable1 y variable2; max (variable1,
variable2) y su
símil min (variable1, variable2), que retornan el máximo o
mínimo entre dos valores; find (inicio, fin, valor) que busca valor en el
espacio de variables entre inicio y fin; etcétera.
Los algoritmos son muy
variados, algunos incluso tienen versiones específicas para operar con ciertos
iteradores o contenedores, y proveen un nivel de abstracción extra que permite
obtener un código más "limpio", que "describe" lo que se
está haciendo, en vez de hacerlo paso a paso explícitamente.
C++11
El 12 de agosto de 2011, Herb Sutter,
presidente del comité de estándares de C++, informó la aprobación unánime del
nuevo estándar.2 La publicación del mismo se
espera para algún momento de 2011.
Entre las características del
nuevo estándar se pueden destacar:
·
Funciones lambda;
·
Referencias rvalue;
·
La palabra reservada auto;
·
Inicialización uniforme;
·
Plantillas con número variable de argumentos.
Además se ha actualizado
la biblioteca
estándar del lenguaje.
Diferencias de
tipos respecto a C
En C++, cualquier tipo de
datos que sea declarado completo (fully qualified, en
inglés) se convierte en un tipo de datos único. Las condiciones para que un
tipo de datos T seadeclarado completo son a
grandes rasgos las siguientes:
·
Es posible al momento de compilación conocer el
espacio asociado al tipo de datos (es decir, el compilador debe conocer el
resultado de sizeof(T)).
·
T Tiene al menos un
constructor, y un destructor, bien declarados.
·
Si T es un tipo compuesto, o
es una clase derivada, o es la especificación de una plantilla, o cualquier
combinación de las anteriores, entonces las dos condiciones establecidas
previamente deben aplicar para cada tipo de dato constituyente.
En general, esto significa que
cualquier tipo de datos definido haciendo uso de las cabeceras completas, es un
tipo de datos completo.
En particular, y, a diferencia
de lo que ocurría en C, los tipos definidos por medio de struct o enum son tipos completos. Como tales, ahora son
sujetos a sobrecarga, conversiones implícitas, etcétera.
Los tipos enumerados,
entonces, ya no son simplemente alias para tipos enteros, sino que son tipos de
datos únicos en C++. El tipo de datos bool, igualmente, pasa a ser
un tipo de datos único, mientras que en C funcionaba en algunos casos como un
alias para alguna clase de dato de tipo entero.
Compiladores
Uno de los compiladores libres de C++ es el de GNU,
el compilador G++ (parte del proyecto GCC, que
engloba varios compiladores para distintos lenguajes). Otros compiladores
comunes son Intel C++ Compiler,
el compilador de Xcode, el compilador de Borland C++, el compilador de CodeWarrior
C++, el compilador g++ de Cygwin, el compilador g++ deMinGW,
el compilador de Visual C++, Carbide.c++, entre otros.
Ejemplo: Cmd con
colores
Para cambiar el color de la
interfaz del programa se necesita la libreria "stdlib.h". su
aplicacion sirve para cambiar el color de fondo del cmd y el color de las
letras.
Uso[editar]
#include <stdlib.h>
using namespace std;
system("color
45");
Visual Basic
Visual Basic es
un lenguaje de
programación dirigido
por eventos, desarrollado por Alan Cooper para Microsoft. Este lenguaje de programación es un
dialecto de BASIC, con importantes agregados. Su primera versión
fue presentada en 1991, con la intención de simplificar la
programación utilizando un ambiente de
desarrollo completamente gráfico que facilitara la creación de
interfaces gráficas y, en cierta medida, también la programación misma.
La última
versión fue la 6, liberada en 1998, para la que Microsoft extendió el soporte
hasta marzo de 2008.
En 2001
Microsoft propuso abandonar el desarrollo basado en la API Win32 y
pasar a un framework o marco
común de librerías, independiente de la versión del sistema operativo, .NET Framework, a través de Visual Basic .NET (y otros lenguajes
como C Sharp (C#) de fácil transición de
código entre ellos); fue el sucesor de Visual Basic 6.
Aunque Visual
Basic es de propósito general, también provee facilidades para el desarrollo de
aplicaciones de bases de datosusando Data Access Objects, Remote Data Objects o ActiveX Data Objects.
Visual Basic
contiene un entorno de desarrollo integrado o IDE que
integra editor de textos para
edición del código fuente, undepurador, un compilador (y enlazador) y un editor de interfaces gráficas
o GUI.
Historia
Todas las
versiones de Visual Basic para Windows son muy conocidas, aunque la
Microsoft Visual Basic 1.0 desarrollada para el sistema operativo MS-DOS (ediciones Profesional y Estándar), que data de
1992, fue menos difundida. Esta proveía un entorno que, aunque en modo texto,
incluía un diseñador de formularios en el que se podían arrastrar y soltar
distintos controles.
La última
versión que sólo generaba aplicaciones de 16 bits fue la 3.0, y no incluía una
biblioteca detallada de componentes para toda clase de usos. Durante la
transición de los sistemas Windows 3.11 a Windows 95, en 1995, hizo su aparición la
versión 4.0 de Visual Basic; ésta podía generar programas tanto de 16 como de
32 bits, a partir del mismo código fuente, aunque a costa de un gran aumento en
el tamaño de los archivos necesarios en tiempo de ejecución
("runtime"). Además, se sustituyeron los controles denominados VBX
por los nuevos OCX. Con la siguiente versión, la 5.0, se
estuvo a punto de implementar por primera vez la posibilidad de compilar a
código nativo, obteniendo una mejora de rendimiento considerable. Tanto esa
como la sucesora 6.0 soportaban ciertas características propias de los lenguajes
orientados a objetos, pero carecían de algunas importantes, tales
como herencia y sobrecarga; pero, de hecho, no fue pensado como lenguaje
orientado a objetos. La versión 6.0, que puede generar código ejecutable
directo en 32 bits, continúa aún utilizándose masivamente, y es compatible con
las últimas versiones de los sistemas Windows, como Windows 7 y Windows 8.
Visual Basic
evolucionó para integrar la plataforma .NET; allí perdió su propia identidad como
lenguaje único adquirible, pasando a integrar un paquete de productos, llamado
precisamente Microsoft .NET; dentro de ese paquete o framework se encuentra el
nuevo y llamado Visual Basic .NET,
que trabaja sobre el entorno Microsoft Visual
Studio. Esta nueva versión del lenguaje posee profundas diferencias
en la forma de programar respecto de Visual Basic 6, pero gran semejanza en su
sintaxis básica.
Cabe mencionar
que, aunque fue menos conocido, se desarrolló también una versión gratuita de
Visual Basic 5.0, orientada al desarrollo de controles y componentes; su nombre
específico era Microsoft Visual Basic 5.0 Control Creation Edition (Visual
Basic 5 CCE). También hubo versiones orientadas al desarrollo de aplicaciones
para dispositivos móviles basados en Windows CE y Pocket PC, conocidas como Embedded
(Visual Basic).
Versiones
·
Visual Basic 1.0
para Windows se liberó en mayo de 1991.
·
Visual Basic 1.0
para MS-DOS fue liberada en septiembre
de 1992. Poco popular, este lenguaje no era compatible
con Visual Basic para Windows, ya que constituía en realidad la siguiente
versión de los compiladores BASIC vigentes para DOS, denominados QuickBASIC y BASIC PDS (Profesional
Development System). Usaba una interfaz de texto, con caracteres ASCII extendidos
que daban la apariencia de una interfaz gráfica.
·
Visual Basic 2.0
fue liberado en noviembre de 1992. Venía en versiones
Standard y Professional. El entorno de programación era más fácil de usar que
el anterior, y su velocidad de proceso fue mejorada. En particular, los
formularios se convirtieron en objetos instanciables, sentando así los
conceptos fundamentales para módulos de clase, que más tarde se ofrecerían en
la versión 4.
·
Visual Basic 3.0
salió al mercado en verano de 1993, en versiones Standard y
Profesional. Incluía la versión 1.1 de Microsoft Jet Database Engine, que
permitía acceso a bases de datos Access.
·
Visual Basic
4.0, surgida en agosto de 1995, fue la primera versión
que generaba aplicaciones tanto de 16 como de 32 bits para
Windows. Había incompatibilidades entre las distintas realeases de esta versión
que causaban fallas de instalación y problemas de operación. Mientras las
anteriores utilizaban controles VBX, con la 4.0 se comenzaron a utilizar
controles OLE en
archivos OCX, que más tarde se llamarían
controles ActiveX.
·
En febrero
de 1997, Microsoft lanzó Visual Basic 5.0,
versión que generaba programas de 32 bits exclusivamente. Los programadores que aún preferían
desarrollar aplicaciones en 16 bits debían necesariamente utilizar VB 4.0,
siendo transportables en código fuente a VB 5.0 y viceversa. En la versión 5 se
tenía la posibilidad de crear controles personalizados; también permitía
compilar a código ejecutable nativo de Windows, logrando con ello incrementar
la velocidad de ejecución de los programas generados, más notablemente en los
de cálculo.
·
Visual Basic
6.0, salido a mediados de 1998, muy mejorado,
incrementó el número de áreas1 e incluyó la posibilidad de crear
aplicaciones basadas en Web. Microsoft retiró el
soporte de VB6 en marzo de 2008, pero a pesar de ello
las aplicaciones que genera son compatibles con plataformas más modernas,
como Windows Vista, Windows Server 2008, Windows 7 y Windows 8.2 3
El soporte
estándar para Microsoft Visual Basic 6.0 finalizó el 31 de marzo de 2005, pero
el extendido terminó en marzo de 2008.4 La comunidad de usuarios de
Visual Basic expresó su grave preocupación y se firmó una petición para
mantener el producto vivo.5 Microsoft se ha negado hasta el
momento a cambiar su posición sobre el asunto. Irónicamente, en esa época
(2005) se da a conocer que el software antiespía ofrecido por Microsoft,
"Microsoft AntiSpyware" (parte de la GIANT Company Software), fue
codificado en Visual Basic 6.0; su posterior sustituto, Windows Defender, fue
reescrito en código C++.6
Características
Los compiladores
de Visual Basic generan código que requiere una o más librerías de enlace
dinámico para que funcione, conocidas comúnmente como DLL (sigla
en inglés de dynamic-link library); en algunos casos reside en el archivo
llamado MSVBVMxy.DLL (siglas de "MicroSoft Visual Basic Virtual Machine
x.y", donde x.y es la versión) y en otros en VBRUNXXX.DLL ("Visual
Basic Runtime X.XX"). Estas bibliotecas DLL proveen las funciones básicas
implementadas en el lenguaje, conteniendo rutinas en código ejecutable que son
cargadas bajo demanda en tiempo de ejecución. Además de las
esenciales, existe un gran número de bibliotecas del tipo DLL con variedad de
funciones, tales como las que facilitan el acceso a la mayoría de las funciones
del sistema operativo o
las que proveen medios para la integración con otras aplicaciones.
Dentro del
mismo Entorno de
desarrollo integrado (IDE) de Visual Basic se puede ejecutar el
programa que esté desarrollándose, es decir en modo intérprete (en
realidad pseudo-compila el programa muy rápidamente y luego lo ejecuta,
simulando la función de un intérprete puro). Desde ese entorno también se puede
generar el archivo en código ejecutable (exe);
ese programa así generado en disco puede luego ser ejecutado sin requerir del
ambiente de programación (incluso en modo stand alone),
aunque sí será necesario que las librerías DLL requeridas por la aplicación
desarrollada se encuentren también instaladas en el sistema para posibilitar su ejecución.
El propio Visual
Basic provee soporte para empaquetado y
distribución; es decir, permite generar un módulo instalador que
contiene al programa ejecutable y las bibliotecas DLL necesarias para su
ejecución. Con ese módulo la aplicación desarrollada se distribuye y puede ser
instalada en cualquier equipo (que tenga un sistema operativo compatible).
Así como
bibliotecas DLL, hay numerosas aplicaciones desarrolladas por terceros que
permiten disponer de variadas y múltiples funciones, incluso mejoras para el
propio Visual Basic; las hay también para el empaquetado y distribución, y
hasta para otorgar mayor funcionalidad al entorno de programación (IDE).
Entorno de desarrollo
Existe un único
entorno de desarrollo para Visual Basic, desarrollado por Microsoft: Microsoft
Visual Basic x.0, correspondientes a versiones desde la 1.0 hasta la
6.0, (con respectivas diferencias entre versiones del lenguaje).
El entorno de
desarrollo es muy similar al de otros lenguajes. Realizando una instalación
típica del producto, las características básicas se presentan de la siguiente
forma:
·
En la parte
superior aparecen tres elementos, en este orden: la barra de título donde
figura el nombre del proyecto en curso y su estado (diseño o ejecución);
la barra de menú con
13 opciones desplegables y una barra de
herramientas; esta última se puede personalizar, posibilitando
la inclusión de prácticamente la totalidad de los comandos del IDE.
·
En la parte
central, cubriendo la franja de mayor área, se encuentra el espacio de
trabajo. Éste incluye y muestra las ventanas del proyecto, las
vistas del código fuente de
los módulos, los objetos y los controles que contienen las ventanas de la
aplicación y el panel de controles.
·
El panel de
controles, que aunque es móvil normalmente está ubicado a la derecha, por
defecto cuenta con los siguientes controles:
·
PictureBox: Caja
de imágenes
·
Label: Etiqueta
·
TextBox: Caja de texto
·
Frame: Marco
·
CommandButton:
Botón de comando
·
CheckBox: Casilla de verificación
·
OptionButton: Botón de opción
·
ComboBox: Lista
desplegable
·
ListBox: Lista
·
HScrollBar:
Barra de desplazamiento horizontal
·
VScrollBar:
Barra de desplazamiento vertical
·
Timer: Temporizador
·
DriveListBox:
Lista de unidades de disco
·
DirListBox:
Lista de directorios
·
FileListBox:
Lista de archivos
·
Shape: Figura
·
Line: Línea
·
Image: Imagen
·
Data: Conexión a
origen de datos
·
OLE: Contenedor
de documentos embebidos compatibles con Object Linking
and Embedding
Además de los
listados, se pueden agregar todo tipo de controles de terceros, y hay una gran
cantidad de ellos que se proveen con el propio Visual Basic 6.0. Los controles
vienen embebidos dentro de archivos con extensión OCX.
·
Las ventanas de
proyecto, aunque móviles, se encuentran en el panel lateral derecho y contienen
dos vistas principales:
·
El Explorador
de proyectos, que muestra todos los elementos que componen el proyecto o
grupos de proyectos (formularios, interfaz de controles, módulos de código,
módulos de clase, etc.)
·
El Panel
de propiedades, donde se muestran todos los atributos de los objetos,
controles, formularios, información de módulos clase, entre muchos otros.
·
La Ventana
inmediato, por defecto se encuentra en la parte inferior, aunque puede no
estar visible (se presionan las teclas Ctrl+G, en ese caso, para mostrar la
ventana). Esta ventana resulta una herramienta muy útil a la hora de depurar el
programa o bien para realizar pruebas rápidas, ya que permite imprimir mensajes
de texto desde el código y ejecutar sentencias y comandos simples
inmediatamente (sólo sentencias que se puedan escribir en una sola línea). Por
ejemplo, de la aplicación en curso, se puede consultar el valor de una variable
o llamar a un método declarado en el módulo que se está depurando. Se puede ejecutar
código "al vuelo", por ejemplo con sentencias como:
? sqr(2)
siendo el
signo ? un reemplazo natural del comando Print en Basic, al
ejecutar la sentencia se mostraría por pantalla el valor de la raíz cuadrada de
2. También se pueden usar variables del propio programa, o sentencias de código
tales como:
Msgbox "Prueba de
cuadro de mensaje de error.", vbCritical, "Título
del mensaje"
A la hora de
la depuración puede
ser útil para consultar el valor de variables del programa, o el código de
error como:
? Err.Number
Objetos y eventos
Se designa como
objeto cualquier elemento, por ejemplo, un formulario, una imagen, un control,
tal como una caja de texto; a su vez, los objetos tienen propiedades, que en el
caso de la caja de texto una es la propiedad "text" que se encarga de
contener el texto que aparecerá en la caja. A los objetos se les puede asociar
eventos. Un evento es la ocurrencia de un suceso, comúnmente la acción que
realiza el usuario sobre el objeto, que como resultado puede, por ejemplo,
provocar un cambio en alguna propiedad de un objeto. Por ejemplo: Visual Basic
tiene un evento llamado KeyPress, que ocurre cuando el usuario presiona una
tecla; ese evento se puede asociar a la caja de texto, y en él definirá (por
programación) qué acción se tomará cuando se oprima una tecla.
En síntesis, un
objeto posee propiedades, responde a eventos y puede ejecutar métodos asociados
a él.
Algunos eventos
comunes definidos en Visual Basic son:
·
Click: ocurre
cuando se presiona y suelta un botón del mouse sobre un objeto.
·
DblClick: ocurre
cuando se presiona y suelta dos veces un botón del mouse sobre un objeto.
·
DragDrop: ocurre
al arrastrar y soltar un determinado objeto con el mouse.
·
DragOver: ocurre
si una operación de arrastrar y soltar está en curso.
·
GotFocus: ocurre
cuando un objeto recibe el control o foco, ya sea mediante una acción del
usuario como hacer click en un objeto ventana, o cambiando el foco de objeto
desde el programa, mediante el método SetFocus.
·
LostFocus:
contrario al anterior, este evento ocurre cuando el objeto pierde el enfoque,
sea mediante acción del usuario o efectuado desde la aplicación.
·
KeyDown: ocurre
cuando el usuario mantiene presionada una tecla.
·
KeyUp: ocurre
cuando el usuario deja de presionar una tecla. Este evento sucede precisamente
al terminar el evento KeyDown.
·
KeyPress: ocurre
como cuando se presiona y suelta una tecla.
·
MouseDown:
ocurre cuando el usuario presiona un botón del mouse.
·
MouseUp: se
produce cuando el usuario suelta el botón del mouse.
·
MouseMove: este
evento ocurre mientras el usuario mueve o desplaza el puntero del mouse sobre
un objeto.
Imagínese un
auto como un objeto; el auto tiene diversas propiedades como color, modelo,
etc. Algunas con sólo 2 posibles valores, como encendido y apagado, incluso
otras que a simple vista no se ven, como podría ser la cantidad de gasolina.
Para definir el color de este objeto Auto, según Visual Basic, se haría de la
siguiente manera:
Auto.color = rojo
y para definirle
un evento podría ser como el siguiente ejemplo:
Sub girarllave( )
Auto.encendido=true
end sub.
Ejemplo de código
El siguiente
fragmento de código muestra un cuadro de mensaje, en una ventana, que dice
"¡Hola, mundo!":
Private Sub Form_Load()
MsgBox ("¡Hola, mundo!")
End Sub
Ventajas
Posee una curva de aprendizaje muy rápida.
·
Integra el
diseño e implementación de formularios de Windows.
·
Permite usar con
facilidad la plataforma de los sistemas Windows, dado que tiene acceso
prácticamente total a la API de Windows, incluidas
librerías actuales.
·
Es uno de los
lenguajes de uso más extendido, por lo que resulta fácil encontrar información,
documentación y fuentes para los proyectos.
·
Fácilmente
extensible mediante librerías DLL y componentes ActiveX de otros lenguajes.
·
Posibilita
añadir soporte para ejecución de scripts, VBScript o JScript, en las
aplicaciones mediante Microsoft Script Control.
·
Tiene acceso a
la API multimedia de DirectX (versiones 7 y
8). También está disponible, de forma no oficial, un componente para trabajar
con OpenGL 1.1.7
·
Existe una
versión, VBA, integrada en las aplicaciones de Microsoft Office, tanto Windows como Mac, que
permite programar macros para extender y automatizar funcionalidades en
documentos, hojas de cálculo y bases de datos (Access).
·
Si bien permite
desarrollar grandes y complejas aplicaciones, también provee un entorno
adecuado para realizar pequeños prototipos rápidos.
Inconvenientes
Las críticas
hechas en las ediciones de Visual Basic anteriores a VB.NET son variadas;8 se citan entre ellas:
·
Problema
de versionado asociado con varias librerías runtime DLL,
conocido como DLL Hell
·
Soporte pobre
para programación orientada a objetos9
·
Incapacidad para
crear aplicaciones multihilo, sin tener que
recurrir a llamadas de la API de Windows.
·
La capacidad de utilizar
controles en un sólo formulario es muy limitada en comparación a otras
herramientas. DLL Hell DB, Libro Programando en Visual Basic,2002
Alternativas multiplataforma o externas a
Windows
Existen
múltiples alternativas dentro y fuera de Windows que intentan imitar este
lenguaje y su mecánica de desarrollo. El más conocido y popular es Gambas:
·
Gambas es un
proyecto libre para implementar programación visual con Basic en GNU/Linux.
Está derivado principalmente de Visual Basic, adaptándose a partir de su
lenguaje y su entorno de desarrollo, para implementar su propia variante,
parcialmente compatible con Visual Basic, aportando y enriqueciendo con las
oportunidades que brinda GNU/Linux.
Otras opciones
conocidas son Real Basic o PureBasic, que permiten desarrollar bajo
Windows, Linux, Mac OS e independientemente. PureBasic permite desarrollar también
para Amiga OS. A diferencia de Gambas, estas son
soluciones comerciales y no son libres.
Visual FoxPro
Visual FoxPro es
un lenguaje de
programación procedural, orientado a objetos que
posee un Sistema Gestor de Bases de datos o Database
Management System (DBMS) y Sistema administrador de bases de datos relacionales,
producido por Microsoft.
Características[editar]
Visual FoxPro
ofrece a los desarrolladores un conjunto de herramientas para crear
aplicaciones de bases de datos para el escritorio, entornos cliente/servidor,
tablet PC o para la Web.
Entre sus
características se pueden enumerar:
·
Capacidades para
el manejar datos nativos y remotos.
·
Flexibilidad
para crear soluciones de bases de datos.
·
Lenguaje de
Programación Orientado a objetos.
·
Utilización de
Sentencias SQL en forma nativa.
·
Manejo de
vistas, cursores y control completo de estructuras relacionales.
·
Su propio gestor
de base de datos incorporado. Sin embargo, también puede conectarse con servidores
de base de datos, tales como Oracle, Microsoft SQL Server oMySQL.
·
Cuenta con un
motor de generación de informes renovado y flexible para soluciones más
robustas.
·
Desde la versión
9.0, amplio soporte de XML, tanto como fuente de datos
(por ej., servicios Web basados en XML) como por generar reportes en formato
XML.
La última
versión liberada es la 9.0. Esta cuenta con el SP1 y el (más reciente) SP2 (en inglés) en los que hay algunas
nuevas características y especialmente brindan estabilidad al producto.
En la
actualidad, a pesar de que Microsoft ha decidido no continuar con Microsoft
Visual FoxPro, existe una comunidad de desarrolladores que sigue trabajando en
él, PortalFox y Mundo Visual FoxPro son las más importantes entre los
desarrolladores de habla hispana.
Historia[editar]
Visual FoxPro
proviene de FoxPro, que a su vez deriva de FoxBASE,
creado por Fox
Software en 1984; inicialmente un clon
de dBase, acabó superándolo y, junto a Clipper,
convirtiéndose en una de las estrellas de los lenguajes xBase.
Cuando se
presentó FoxPro 2.0 se incluyeron varias tecnologías que revolucionaron el
mercado de desarrollo de bases de datos las cuales son:
·
La adición de
Tecnología Rushmore hizo posible que tablas tuvieran millones de registros sin
la necesidad de pasar a tecnologías más caras
·
Las
instrucciones SQL que reemplazaban procedimientos completos. SQL fue, y todavía
es, el lenguaje de los datos
·
La presentación
de medios tipo WYSIWYG (What you see
is what you get) que significa: "lo que tu ves es lo que consigues"
que abrió el camino a diseñadores de pantallas e informes.
Microsoft compró
Fox Software en junio de 1992 por 173 millones de dólares. En el momento de la
compra el desarrollo de FoxPro 2.5 estaba casi terminado, añadiéndole la
capacidad de generar ejecutables para Windows. Las versiones de FoxPro 2.6 para
Windows, Mac y Unix se consideran las últimas versiones de FoxPro.
Visual FoxPro 3.0[editar]
En junio
de 19951 aparece Visual FoxPro 3.0,
conocido durante su desarrollo como Taz, es
la primera versión Visual y se considera un punto de ruptura al evolucionar de
un lenguaje procedural a un lenguaje orientado a objetos. Fue lanzado en Standard
Edition (versión recortada sin archivos de runtime distribuibles) y
Professional Edition, con el runtime licenciado y el juego completo de
componentes. Requiere como mínimo de un compatible IBM PC con microprocesador Intel 80386 ejecutando Windows 3.1 / Windows NT 3.5 o superiores, 8 Megabytes de memoria RAM (se recomiendan 12 MB), de 15
a 50 MB de espacio libre en el disco duro, mouse o
equivalente y tarjeta gráfica VGA o
superior. Tiene las siguientes características:2
·
El contenedor de
base de datos, también conocido como DBC, añadió el soporte para procedimientos
almacenados, reglas de datos asociadas a tablas y un conjunto de funciones de
datos adicionales.
·
Las vistas, que
son cursores SQL actualizables, añadieron un método completamente nuevo de
acceso a datos para su procesamiento.
·
Una
implementación completa de programación orientada a objetos
·
Soporte
de Object Linking and Embedding y ActiveX
Más adelante
aparecerá Visual FoxPro 3.0b3 que aporta soporte a los
lenguajes de doble byte (Double Byte Character Set, como el chino o el japonés)
y mejoras en el soporte de ODBC. Además el logotipo para
de utilizar una fuente serif a una sans-serif bold, que utilizará en adelante.
Visual FoxPro
3.0 for Macintosh, conocido durante su
desarrollo como Speedy aparece el mismo año. Será la
última versión de Visual FoxPro para Macintosh. Requiere un equipo Power Macintosh con un microprocesador PowerPC PPC 601 o superior, 8 MB de RAM,
(16 MB de RAM recomendado), 80 MB espacio en disco disponible (instalación
completa) y sistema operativo System 7.1.2 o posterior.
Visual FoxPro 5.0[editar]
En octubre de
1996 aparece Visual FoxPro 5.0, conocido durante su desarrollo
como RoadRunner.
Aunque hubo un desarrollo de Visual FoxPro 4.0 conocido como Renard,
Microsoft decidió cuando finalizó su fase beta que todos los componentes
principales de Microsoft Visual
Studio tuvieran el mismo número de versión, por lo que todo el
trabajo se pasó a la versión 5.0 Presenta un cambio en la estructura de los
proyectos y otros archivos por lo que debe de realizarse una conversión desde
versiones anteriores.4 Trae como novedades:
·
Integración
con Visual SourceSafe
·
Creación desde
VFP de aplicaciones Web
·
Un nuevo
depurador mejorado
·
Capacidad de
crear y usar servidores COM (Component Object
Model que significa Modelo de Objetos Componentes).
·
Mejora del
soporte de ActiveX
Visual FoxPro 6.0[editar]
El 18 de mayo de
1998 aparece Visual FoxPro 6.0, conocido durante su desarrollo
como Tahoe. Tras FoxPro 2.6 para Windows es la
versión con que más aplicaciones FoxPro se han realizado. Se incluye con Microsoft Visual
Studio 6. Requiere de un compatible IBM PC con microprocesador Intel 80486-DX a 66 MHz o
superior (se recomienda un Intel Pentium) ejecutando Windows 95/Windows 98/Windows NT 4.0 con Service Pack 3 o
superior; 16 Megabytes (32
recomendados) de memoria RAM para
Windows95/98; 24 MB (32 recomendados) para Windows NT 4.0; Internet Explorer 4.01 con Service Pack 1
(se incluye en el paquete); 85 MB de espacio libre en el disco duro para una instalación típica,
90 MB para una completa; 43 a 59 MB adicionales si debe instalar IE 4.0; de 57
a 493 MD para el MSDN; unidad de CD-ROM, mouse o equivalente
y tarjeta gráfica VGA o
superior (se recomienda Super VGA).
Aporta mejoras
para Internet y una nueva galería de componentes y clases.
Visual FoxPro 7.0[editar]
El 21 de junio
de 2001 aparece Visual FoxPro 7.0, conocido durante su desarrollo
como Sedona. Trae como novedades:5
·
Soporte de la
tecnología IntelliSense
·
Mejoras del
control del Entorno de
desarrollo integrado (IDE) y un más rápido acceso al código fuente.
·
Más de 50
comandos, funciones y variables del sistema se han mejorado o añadido a Visual
FoxPro 7.0, algunas de las cuales incluyen nuevas capacidades para enlazar
eventos a otros componentes COM.
·
Mejora del
soporte de interoperabilidad con componentes Component Object
Model como Microsoft BizTalk
Server
·
Soporte de
servicios web XML, permitiendo la exportación de datos de Visual FoxPro a XML y
la importación de datos XML en tablas.
·
Nuevo Explorador
de objetos
·
Administrador de
la lista de tareas
·
mejor
rendimiento
Visual FoxPro 8.0[editar]
El 1 de febrero
de 2003 aparece Visual FoxPro 8.0, conocido durante su desarrollo
como Toledo. Trae como novedades:6
·
Manejo de
errores estructurado, mediante TRY... CATCH... FINALLY, escalado de excepciones
usando THROW y gestión del uso de objetos de excepción.
·
Clase
CursorAdapter para el acceso universal a datos en formato Visual FoxPro, XML, Microsoft SQL Server 2000, ODBC y
OLE DB
·
Soporte de
incremento automático en tablas Visual FoxPro
·
Soporte de
Themes de Windows XP
·
Diseño de vistas
mediante SELECT SQL conmutando entre consulta / vista y salida de código
fuente.
·
Controles
avanzados con capacidad de orientación de pestañas en los marcos de página,
cambio automático de ancho de columnas, etc.
·
Soporte GDI+
mejorado pudiendo usar y rotar imágenes en formularios en formato BMP, JPG, GIF normal y
animado, TIFF, WMF y EMF y
otros
·
Bindeo de
eventos
·
Importación y
exportación de XML jerárquico con el apoyo de DiffGrams
entre cursores de Visual FoxPro y DataSets de ADO.NET
·
Publicar y usar
XML Web services basados en SOAP compatible
con .NET via HTTP utilizando Microsoft
SOAP Toolkit 3.0 (incluido).
·
OLE DB
proporciona acceso a datos Visual FoxPro como Microsoft
Visual Studio .NET y Microsoft Office XP.
·
Microsoft SQL Server 2000
Desktop Engine (MSDE) para crear soluciones de escritorio y compartidas
compatibles con Microsoft SQL Server 2000 y migrar a SQL Server 2000
directamente sin modificar el código.
·
InstallShield Express para Visual FoxPro,
para crear instaladores de programas.
Visual FoxPro 9.0[editar]
El 17 de
diciembre del 2004 aparece Visual FoxPro 9.0, conocido durante su
desarrollo como Europa con un
amplio soporte a XML y una mejora notable en los reportes
permitiendo detalles en múltiples bandas, la rotación de texto, y el
encadenamiento de informe. Los informes de salida soportados incluyen XML,
HTML, formatos de imagen, y personalización de la salida de impresión.
En marzo de
2007, Microsoft anunció que no habrá VFP 10,7 con lo que VFP9 es la última
versión comercial de Visual FoxPro. Su soporte está garantizado hasta 2015 y se
han publicado dos Service Packs, el 8 de diciembre de 2005 y el 11 de octubre
de 2007. Se trata del soporte más largo para un producto de Microsoft.
A finales de
marzo de 2007, se origina una campaña grassroots entre la comunidad hispana de
usuarios de FoxPro en MasFoxPro8 para firmar una petición a
Microsoft para continuar con la actualización de Visual FoxPro o liberarlo a la
comunidad como Open Source. El 3 de
abril de 2007, el movimiento tuvo eco en la prensa especializada9
También el 3 de
abril de 2007 Microsoft respondió a las solicitudes de los peticionarios, con
esta declaración de Alan Griver:
"Somos muy
conscientes de la comunidad FoxPro y esto jugó un papel importante en el
anuncio del 13 de marzo. Nunca es una decisión fácil anunciar que no vamos a
sacar otra versión de un producto y es algo que consideramos con mucho cuidado.
"No estamos
anunciando el fin de FoxPro. Obviamente, las aplicaciones de FoxPro seguirán
funcionando. Por algunas de nuestras estimaciones internas, hay más
aplicaciones que se ejecutan en FoxPro 2.6 que en VFP y FoxPro 2.6 no ha
recibido soporte en muchos años. Visual FoxPro 9 será soportado por Microsoft
hasta el año 2015.
"Para que
Microsoft continuara evolucionando la base de FoxPro, tendríamos que comenzar
por la creación de un entorno de desarrollo de 64 bits lo que implicaría una
reescritura casi completa del producto principal. También hemos invertido en la
creación de una base de datos escalable con SQL Server, incluyendo la
libremente disponible SQL Server Express Edition. En cuanto a la formación de
una asociación con terceras partes, hemos escuchado de una serie de grandes clientes
FoxPro que esto haría imposible para ellos seguir utilizando FoxPro, ya que ya
no sería de un proveedor aprobado. Nos pareció que poner el entorno en código
abierto en CodePlex, equilibra las necesidades de la comunidad y los grandes
clientes, y era el mejor camino a seguir."
En el momento
del anuncio del fin de la vida de FoxPro, el trabajo en la próxima versión con
nombre en código Sedna que había comenzado sobre la parte superior de la base de código VFP9 ya había comenzado.
"Sedna" es un conjunto de ampliaciones para VFP 9.0 de los
componentes xBase para soportar una serie de escenarios de interoperabilidad
con varias tecnologías de Microsoft, incluyendo SQL Server 2005, .NET Framework, Windows Vista, Microsoft Office 2007, Windows Search y Team
Foundation Server (TFS). Microsoft liberó Sedna bajo
licencia Shared Source en CodePlex. Microsoft ha aclarado que el núcleo
de VFP seguirá siendo de código cerrado. Sedna fue lanzado el 25 de enero 2008.10 A partir de marzo de 2008, todos
los componentes xBase de VFP 9 SP2 (incluyendo Sedna) están disponibles para el
desarrollo comunitario en CodePlex.
Sedna contiene
seis componentes: VistaDialogs4COM, Upsizing Wizard, Data Explorer, NET4COM, MY
para VFP y VS 2005 Extension para VFP.
Información de Versiones[editar]
Compatibilidad de Sistemas Operativos[editar]
|
Versiones con
Soporte Windows
|
||||||
|
Versión
|
VFP 3.0
|
VFP 5.0
|
VFP 6.0
|
VFP 7.0
|
VFP 8.0
|
VFP 9.0
|
|
Windows 3.x
|
Si
|
No
|
No
|
No
|
No
|
No
|
|
Windows NT 4.0
|
Si
|
Si
|
Si
|
Si
|
Si
|
No11
|
|
Windows 95
|
Si
|
Si
|
Si
|
Sólo ejecutable
|
No
|
No
|
|
Windows 98
|
Si
|
Si
|
Si
|
Si
|
Sólo ejecutable
|
Sólo ejecutable
|
|
Windows Me
|
Si
|
Si
|
Si
|
Si
|
Sólo ejecutable
|
Sólo ejecutable
|
|
Windows 2000
|
Si
|
Si
|
Si
|
Si
|
Si
|
Si
|
|
Windows XP
|
Si
|
Si
|
Si
|
Si
|
Si
|
Si
|
|
Windows Server 2003
|
Si
|
Si
|
Si
|
Si
|
Si
|
Si
|
|
Windows Vista
|
Modo de
compatibilidad
|
Si
|
Si
|
Si
|
Si
|
Si
|
|
Windows 7
|
No
|
Si
|
Si
|
Si
|
Si
|
Si
|
|
Windows 8
|
No
|
No
|
No
|
No
|
No
|
Si
|
Información de archivos ejecutables[editar]
|
Version
|
VERSION() devuelve
|
EXE Size
|
EXE Date
|
DLL Size
|
DLL Name
|
|
VFP 9 SP2 con
Revisiones
|
Visual FoxPro 09.00.0000.7423 para
Windows
|
5,648 kb
|
3 de abril, 2009
|
4,624 kb
|
VFP9R.DLL
|
|
VFP 9 SP2
|
Visual FoxPro 09.00.0000.5721 para
Windows
|
5,648 kb
|
21 de Septiembre, 2007
|
4,624 kb
|
VFP9R.DLL
|
|
VFP 9
|
Visual FoxPro 09.00.0000.2412 for
Windows
|
5,620 kb
|
13 de Diciembre, 2004
|
4,600 kb
|
VFP9R.DLL
|
|
VFP 8
|
Visual FoxPro 08.00.0000.3117 for
Windows
|
5,236 kb
|
25 de Septiembre, 2003
|
4,200 kb
|
VFP8R.DLL
|
|
VFP 7
|
Visual FoxPro 07.00.0000.9465 para
Windows
|
4,260 kb
|
4 de Enero, 2002
|
3,344 kb
|
VFP7R.DLL
|
|
VFP 6
|
Visual FoxPro 06.00.8961.00 para
Windows
|
4,091 kb
|
18 de Agosto, 2000
|
3,295 kb
|
VFP6R.DLL
|
|
VFP 5
|
Visual FoxPro 5.0.0.415 para Windows
|
4,065 kb
|
24 de Enero, 1997
|
3,148 kb
|
VFP500.DLL
|
|
VFP 3
|
Visual FoxPro 03.00.00.0711 para
Windows
|
4,374 kb
|
16 de Diciembre, 1995
|
3,657 kb
|
VFP300.ESL
|
|
FPW 2.6a
|
FoxPro 2.6a para Windows
|
2,444 kb
|
28 de Septiembre, 1994
|
2,946 kb
|
FOXW2600.ESL
|
CREACION DE LA BASE DE DATOS
1.
Ubiquese en la ficha Datos y luego en Base de
Datos y presione el botón
Nuevo
La ventana del Diseñador de Base da datos aparecerá :
Puede utilizar la barra de herramientas del Diseñador para el control de
la Base de Datos.
Descripción de los botones de la Barra de herramientas (Diseñador de
Base de Datos):
Crear 
una nueva tabla.
una nueva tabla.
Agregar una tabla existente
Eliminar una tabla seleccionada
Modificar una tabla seleccionada
Creación de Vistas remotas
Creación de Vistas locales
Editar Procedimientos almacenados
en la Base de Datos
Creación de Conexiones con vistas
remotas
Examinar el contenido la tabla (BROWSE)
Los nombres de las tablas deben ser de una a ocho caracteres de largo y
deben tener la extensión predeterminada .dbf (database file: archivo de
Base de Datos)
Crear una nueva tabla:
1. Click en el botón de Nueva tabla, aparecerá la ventana Nueva Tabla
2.
Se selecciona Nueva Tabla, luego aparece la
ventana de guardar el archivo, seleccione el directorio y el nombre de la tabla
y luego presione el boton de guardar.
La ventana del Diseñador de tablas aparecerá en
pantalla:
Esta es la parte mas importante de la tabla, es aquí donde se define
la estructura de
datos que contendrá dicha tabla. El primer paso es definir los campos, tipos,
tamaño, Formato y Reglas de validación.
a.
Definición de campos:
b. Igual que en las
versiones anteriores, la definición de campos es igual. Se introduce el nombre
del campo (name) el tipo de datos que soportará (Type) y el
tamaño. Los nombres de los campos pueden tener hasta 254 caracteres sin
espacios en blanco
Format (Formato): Es
el formato de salida del campo, ejemplo si fuera númerico 9,999.99 o si
fuera carácter !!!!!!!!!!!!,
para que solo acepte mayusculas
Input mask (Máscara de
entrada): Igual que el Format, lo único que es para la entrada de datos.
Captión (Título): Descripción mas precisa del campo, es de utilidad al
diseñar los Formularios.
c.
Definición del Display
d.
Definición de reglas de validación a nivel de campo
La validación son triggers o eventos que
se ejecutan a nivel de campo. Ejemplo: una validación de un campo que solo
acepte números positivos. (id > 0)
Rule (Regla): Es la regla de validación, ejemplo: id > 0, si
queremos que acepte valores positivos.
Message(Mensaje): Es el mensaje personalizado que queremos que aparezca en
pantalla a la hora de violarse la regla de validación del campo. Ejemplo :
‘Solo se aceptan números positivos’ (nota: el texto debe
escribirse entre comillas).
Default Value : Valor por
defecto del campo. (nota: hay que respetar el tipo de dato del
Campo)
Luego de hacer la definición de los campos, pasamos a la definición de
Indices de la tabla, que será muy importante a la hora de crear las relaciones
entre las tablas.
Los índices facilitan la ubicaciòn en la tabla de un registro especìfico
asì como tambien determinan el tipo de relaciones que existen entre las tablas
Los índices pueden ser CDX o IDX:
Los índices .IDX son índices compactos se crean: "INDEX ON estado to
estado compact" crea un archivo de índice llamado estado.cdx.
Desafortunadamente si alguna vez abre la tabla sin el índice y añade un
registro, éste no se actualizará y tendrá que ser recreado.
Los índices .CDX se crean: "INDEX ON estado tag estado" .
Estos archivos se abren automáticamente junto con las tablas.
La estructura interna de los IDX y los CDX es diferente.
a.
Nombre del Indice (name)
b. Introducir el Nombre
del archivo índice. Es conocido también como TAG (etiqueta).
c.
Type ( tipo de Indice)
Primary : Llave primaria.
Candidate : Llave candidata
Unique : Llave única.
Regular : Llave foránea.
El índice Primary o Principal: garantiza que solo se introduzcan valores
únicos en un campo y determina el orden en el que se procesan los registros.
Cada tabla puede tener únicamente un índice Principal.
El índice Candidate o Candidato: puede ser un candidato para utilizarse
como índice principal, refuerza la unicidad de los valores.
El índice Unique o Unico: almacena un lista de cada valor único en la
tabla índices.
El índice Regular o Normal: puede ser utilizado para ordenar y buscar
datos en consultas e informes. No refuerza la unicidad de los datos
c. Nombre de la Expresión
Nombre de los campos que conforman la clave primaria:
Ejemplo : id, o si son varios campos : id + linea
Nota: si los campos no son del mismo hay que forzarlos al tipo de dato
deseado, ejemplo: si id es carácter y linea,
entoces el nombre de la expresion sería:
Id + STR(linea)
STR() convierte de número a carácter y VAL() convierte de carácter a
númerico.
Después de detallar los índices, se define los eventos de La validación
a nivel de registro y los eventos que se ejecuten a la hora de Insertar un
registro, de actualizar o borrar.
Visual Foxpro tiene 37.767 espacios de trabajo, llamadas áreas de
trabajo porque una tabla deber ser seleccionada para volverla la tabla actual.
Cuando se inicia Visual FoxPro el área de trabajo es la 1 por omisión. Para
abrir una tabla en el área de trabajo 1 cuando ninguna otra tabla está abierta,
tecleamos en la Ventana de Comandos:
USE nombretabla
No necesariamente debe estar en un área de trabajo para abrir una tabla
puede especificar: USE nombretabla IN 3
Sin embargo con mas frecuencia se utiliza: USE nombre tabla IN 0 lo que
significa encuentre el área de trabajo siguiente en la que no se encuentre
abierta una tabla y abre nombretabla ahí.
Cuando se utiliza una tabla Visual FoxPro le asigna un alias, un nombre
de hasta 10 caracteres con el cual se refiere a ella en el programa,
generalmente el alias es el mismo nombre que el de la tabla
Para crear una tabla desde la Ventana de Comandos: CREATE
<nombretabla>
Para modificar una tabla Administrador de
Proyectos | Datos | Base de Datos| Tablas | Seleccionamos la tabla | Modificar.
Desde la Ventana de Comandos: Use tabla | MODIFY ESTRUCTURE
En Visual FoxPro existe la Ventana de comandos ésta funge como la
ventana de MSDOS que puede utilizarse desde Windows con
la finalidad de permitir utilizar comandos del lenguaje para
ejecutar algunas funciones.
Por ejemplo desde Windows desde el explorador podemos examinar el contenido de
un disckette acción que
también podemos hacer si abrimos una ventana de MSDOS y tecleamos DIR A:. Es
decir a pesar de que se pueden tener acceso a la mayoría de los elementos de
Visual FoxPro desde el menú muchas veces es útil simplemente teclear un
comando.
Para activar la Ventana de Comandos auque ella aparece por defecto en el
en el entorno de trabajo tecleamos Ctrl. F2
Para agregar registros a una tabla : Administrador de Proyectos | Datos
| Base de Datos | Tablas | Seleccionamos la tabla | Examinar y luego en el menú
Ver | Modo Añadir
Desde la Ventana de Comandos: Teniendo la tabla activa escribimos
APPEND.
Para ver los registros de una tabla: Administrador de Proyectos | Datos
| Base de Datos | Tablas | Seleccionamos la tabla | Examinar.
Desde la Ventana de Comandos: teniendo la tabla activa escribimos BROWSE.
En Visual Foxpro los registros de una tabla pueden borrarse lógicamente
y físicamente.
Para borrar lógicamente un registro : Administrador de Proyectos | Base
de Datos | Tablas | Seleccionamos la Tabla | Examinar luego con el ratón
hacemos Click en la primera columna de izquierda a derecha, la columna en la
celda seleccionada se colocará de color negro.
Desde la Ventana de Comandos: DELETE (Teniendo seleccionado el registro)
Para ver los registros de una tabla sin que aparezcan los registros
borrados lógicamente:
Primero desde la Ventana de Comandos debemos teclear : SET DELETE ON y
luego desde el Administrador de Proyectos | Datos | Base de Datos | Tablas |
Examinar .
También desde la Ventana de Comandos con el comando BROWSE
Si queremos incluso los registros borrados lógicamente tecleamos en la
Ventana de Comandos SET DELETE OFF y luego tecleamos BROWSE.
Para desmarcar los registros borrados lógicamente (desde la Ventana de
Comandos): Suponemos que anteriormente habían sido borrados los empleados cuyo
sueldo era 15000: DELETE FOR sueldo=15000
Para desmarcar estos registros : RECALL FOR sueldo=15000
Para borrar físicamente registros de una tabla primero deben estar
borrados lógicamente
Y luego desde la Ventana de Comandos tecleamos el comando PACK, para
utilizar este comando la tabla debe ser abierta en modo exclusivo USE
nombretabla EXCLUSIVE .
Algunos comandos para manipular tablas:
List for cedula="12434213" Muestra en
el entorno de trabajo la informacion del registro que cumpla con esta
condición.
List fields cedula,nombre. Muestra en el entorno de trabajo todas las
cédulas y nombres de la tabla seleccionada.
Sum cantidad (suponemos que la tabla activa tiene un campo de tipo
numérico llamado cantidad). Muestra en el entorno de trabajo la suma del campo
cantidad de la tabla activa.
Sum cantidad for cantidad>1000 Obtiene la suma de los campos cantidad
de los registros que cumplen con la condición indicada
Count to Registros for nota>15 (quermos contar los registros de una
tabla cuyo campo nota sea mayor a 15 puntos, guardar este total en una variable
llamada Registros ) Si luego queremos examinar el contenido de la variable
Registros tecleamos ?Registros (signo de interrogación que cierra y luego el
nombre de la variable que queremos examinar)
Comandos SEEK y LOCATE
Los comandos Locate y Seek permiten buscar un registro en particular.
Locate funciona en cualquier campo dentro de una tabla ya sea que esté indexada
o no Seek da por hecho que la clave que está buscando encaja con el índice
actual.
Locate for nombre="Luis" La tabla activa posiciona su cursor
el registro que cumpla con esta condiciòn.
Seek("Luis") ERROR
Set order to nombre (CORRECTO) Primero se debe activar el ìndice
Seek("Luis") y luego hacer la bùsqueda
La funciòn Set filter:
Esta funciòn provoca que Visual FoxPro se comporte como si no existieran
los registros que no coinciden con la expresiòn de filtro, y en las operaciones que
se realicen solo se tomaràn en cuenta las registros que cumplen con la
condiciòn del filtro actual.
Set filter to nota=15
Para desactivar un filtro colocamos set filter to y para
Como moverse en una tabla de VFP
Skip mueve el puntero hacia delante un registro
Skip - 1 mueve el puntero hacia tras un registro
Go top mueve el puntero hacia el primer registro de la tabla
Go bottom mueve el puntero hacia el ùltimo registro de la tabla.
Go 3 mueve el puntero hacia el registro #3 de la tabla
Operaciones Ciclìcas:
Existen una cantidad de mecanismos de ciclos que puede utilizar para
moverse a travès de una tabla. El principal es SCAN
Por ejemplo:
Select Cliente (No
hay necesidad de hacer go top)
Scan
Sueldo=sueldo + 5000
Endscan
Las lìneas de còdigo entre Scan y Endscan se ejecutaràn 1 vez por cada
registro de la tabla.
Lo mismo se puede hacer con :
Select Cliente
Go top
Do While not eof()
Sueldo=sueldo+5000
Skip
Enddo
La instrucciòn FOR:
For i=1 to 10
Cont=cont+1;
endfor
Para eliminar una tabla:
Para eliminar una tabla con los indices principales, valores
predeterminados y reglas de validaciòn asociadas a la tabla use el
comando DROP nombretabla por ejemplo:
Open Database inscripciones
Drop table alumnos
Uso de Funciones:
Str() convierte a String
Val convierte a nùmero
Date() devuelve la fecha del sistema
Hoy=Date()
GetDir() Obtiene el directorio por defecto
Cd GetDir
Imprime el dìa de la semana
?Dow(Date())
Len() Devuelve el nùmero de caracteres de una expresiòn de caracteres
Recno() Obtiene la posiciòn de un registro
Para cerrar abierta en el àrea de trabajo actual utilizamos el
comando USE
Uso de Procedimientos y Funciones:
Procedure Nombreprocedure
*Aquí va el còdigo ejecutable
endproc
Function Nombrefuncion
*aquí va el còdigo ejecutable
endfunc
El valor devuelto de forma predeterminada es verdadero (.t.) pero puede
utilizarse el comando Return
Function semanas(dDate)
Return dDate + 14
Endfunc
Si se incluyen los procedimientos y funciones en un archivo de programa
disttinto, podrà hacer accesibles estos procedimientos y funciones desde su
programa si utiliza el Set procedure to. Por ejemplo: Si tiene un archivo
llamado: FunProc.prg se utiliza el siguiente comando:
Set Procedure to FunProc.prg
Llamado a un procedimiento o
a una fuciòn:
-Utilizar el Do:
Do Miproc
-Incluir delante del nombre de la funciòn un signo (=) e incluir
parentesis despues del nombre de la funciòn. Por ejemplo
=Mifuncion()
Envìo de valores a un Procedimiento o a una Funcion:
Procedure Nombreprocedimiento(eString)
*La linea siguiente muestra un mensaje
messagebox("Mi proc" + eString)
endproc
El paso de paràmetros a una funciòn es exactamente igual.
Para invocar a un procedimiento:
Do nombreprocedimiento with parametro ò
=NombreFunciòn(paràmetro)
Con mùltiples paràmetros:
Procedure nombreproc (dDate, eString,Ntimes)
*Codigo ejecutable
endproc
En la llamada: do nombreproc with Date(), "Hola", 10
Comprobaciòn de Paràmetros en un Procedimiento o una funciòn
Function Semanas (dDate)
If type("dDate")="D"
Return dDate + 14
Else
Messagebox("Requiere un paràmetro de fecha")
Return{} &&Devuelve una fecha vacìa
endif
endfunc
Procedure valores (cStore, dDate2, nDatos)
If parameters()<3
Messagebox("No se han pasado suficientes paràmetros")
Return .f.
Else
If parameters()=3
*Operar con los paràmetros
endif
endif
endproc
Si se especifican dos paràmetros pero llamò al procedimiento con tres
paràmetros, obtendrà un mensaje de erros. Pero si un procedimiento espera mas
paràmetros de los que recibe, los paràmetros adicionales se inicializaràn como
falso (.F.)
Ejercicio Práctico:
Cree la siguiente base de datos con el nombre de scott.
RELACIONES ENTRE TABLAS:
Las relaciones mas comunes entre tablas se definen :
De uno a uno : Ejemplo de una llave primaria a otra llave primaria
De uno a muchos : Ejemplo de una llave primaria a una Regular o Foránea.
Las relaciones entre tablas se crean arrastrando la llave de la tabla a
la llave de otra tabla.
La figura muestra una relación entre las tablas región y
departamento, la relación se leería así : "Una región tiene muchos
departamentos".
Generación de integridad referencial
Reglas que rigen la coherencia de datos, específicamente las relaciones
entre las claves principal y externa de claves de tablas distintas. Visual
Foxpro Resuelve la Integridad Referencial mediante reglas a nivel de campo y a
nivel de registro definidas por el usuario. El Generador de la Integridad
Referencial le ayuda a definir reglas para controlar cómo se insertan
actualizan o eliminan registros de tablas relacionadas.
Desencadenante: código de
evento a nivel de registro que se ejecuta despues de una inserción, una
actualización o una eliminación. Se ocupan para integridad entre las tablas.
El establecimiento de la integridad referencial implica la creación de
un conjunto de reglas para preservar las relaciones definidas entre las tablas
al introducir o eliminar registros.
Si exige la integridad referencial, Visual FoxPro impedirá las acciones siguientes:
·
· Agregar registros a una tabla relacionada cuando no haya ningún
registro asociado en la tabla primaria.
·
· Cambiar valores de una tabla primaria cuando tales cambios supongan
dejar registros huérfanos en una tabla relacionada.
·
· Eliminar registros de una tabla primaria cuando tengan registros
relacionados coincidentes.
Si lo desea, puede escribir sus propios desencadenantes y procedimientos
almacenados para exigir la integridad referencial. Sin embargo, el Generador de
integridad referencial (IR) de Visual FoxPro permite determinar los tipos de
reglas que desea exigir, las tablas a las que desea exigirlas y los eventos del
sistema que harán que Visual FoxPro las compruebe.
El Generador de IR trata múltiples niveles de eliminaciones y
actualizaciones en cascada, y es recomendable como herramienta para asegurar la
integridad referencial.
Para abrir el Generador de IR
1 Abra el Diseñador de bases de datos.
2 En el menú Base de datos, elija Editar integridad
referencial.
Al utilizar el Generador de IR para crear reglas que se van a aplicar a
la base de datos, Visual FoxPro guarda el código generado para exigir las
reglas de integridad referencial como desencadenantes que hacen referencia a
procedimientos almacenados. Para ver este código puede abrir el editor de texto
de procedimientos almacenados en la base de datos. Si desea información sobre
la forma de crear desencadenantes por programa, consulte Uso de desencadenantes
en el capítulo 7, Trabajo con tablas.
Precaución Cuando haga cambios en el diseño de
una base de datos, como modificaciones en sus tablas o alteraciones
en los índices utilizados en una relación persistente, debe volver
a ejecutar el Generador de IR antes de utilizar de nuevo la base de datos. De
esta forma se revisarán el código de procedimiento almacenado y los
desencadenantes utilizados para exigir la integridad referencial, de forma que
reflejen el nuevo diseño. Si no vuelve a ejecutar el Generador de RI, puede que
obtenga resultados inesperados, ya que no se habrán actualizado los
procedimientos almacenados y los desencadenantes para ajustarlos a las
modificaciones.
El Generador IR se muestra cuando:
· Hace doble clic en una línea de
relación entre dos tablas del Diseñador de bases de datos y
elige el botón Integridad Referencial en el cuadro de diálogo Editar
relación.
· Elige Integridad referencial en
el menú contextual del Diseñador de bases de datos.
· Elige Editar integridad
referencial en el menú Base de datos.
Fichas del generador
Reglas para la actualización Especifica reglas para aplicar
cuando se modifica el valor clave de la tabla primaria.
Reglas para la eliminación Especifica las reglas que se
aplican cuando se elimina un registro de la tabla primaria.
Reglas para insertar Especifica las reglas que se aplican cuando
se inserta un nuevo registro o cuando se actualiza un registro existente en la
tabla secundaria.
VISTAS LOCALES:
¿Qué es una vista?
Una vista es un objeto que se crea empleando la instrucción SELECT
de SQL para bases de datos relacionales.
Las vistas pueden ser locales o Remotas
SELECT campos
FROM tablas
WHERE condicion
GROUP BY campos de agrupamiento
ORDER BY campos de ordenamiento
Ejemplo:
SELECT cedula, nombre
FROM Alumnos
ORDER BY nombre
Creación de una vista local.
Clic en el botón para crear vistas locales.
La ventana para agregar las tablas, se utiliza para añadir tablas que se
van a ocupar en la instrucción SELECT – SQL, en este caso estaríamos
seleccionando la parte del FROM. Seleccionemos s_region y luego Agregar. La
tabla se agregará, luego le damos cerrar (close).
Ventana de creación de la vista:
Fields: (Campos) Aquí se seleccionan los campos de la
vista (SELECT campos)
Join : Relaciones entre tablas
Filter : Condición de filtrado (WHERE condición)
Order by :
campos de ordenamiento (ORDER BY)
Group by :
campos de Agrupamiento (GROUP BY)
CREACION DE VISTAS REMOTAS:
Una vista remota es una vista que se hace de otra base de datos vía
ODBC. Esta base de datos puede ser Access, ORACLE,
SQL-SERVER, entre otros.
Crear una vista remota:
Clic en icono para crear vista remotas.
Escoger Nueva Vista (New View)
Si no a creado una conexión es necesario crear en New,
si ya esta creada seleccione la conexión y luego OK.
¿Como crear una conexión?
Si no ha creado la conexión seleccione New
Siga estos pasos cuidadosamente:
1. Seleccione New Data Source (Nueva Fuente de Datos) y
aparecerá la configuración del ODBC:
2. En el folder User DSN Presione el
botón Add (Agregar)
2. 
3.
Escoja de la ventana el Controlador deseado, Ejemplo: Microsoft Access Driver
(*.mdb) y luego el botón Finalizar.
4.
Luego aparece la Ventana de ODBC del controlador que selecciono (En este
caso en de Access)
Escriba el nombre del Data Source (Fuente de datos), Luego seleccione la
Base de Dato a la que hace referencia ( en el boton Select Database)
Luego de haber seleccionado la base de datos, acepte todas las ventanas
que aparecieron anteriormente y detengase en la siguiente ventana:
Luego seleccione de la lista de data source el data source que usted
acaba de crear.
Luego presione Aceptar (OK).
Después le aparece la primera Ventana donde escoge las conexiones, le
aparecerá la conexión que usted ha creado.
Nota: Esta conexión que usted a creado servirá para sesiones futuras.
Seleccione la conexión creada y luego Aceptar (OK)
Luego le aparecerá la ventana donde usted escoge las tablas que
utilizará:
Luego aparecerá la ventana donde se diseña la vista:
El procedimiento para crear la vista es igual a la creación de vista
Locales.
Consultas a la BD usando SELECT-SQL
SELECT - SQL usando dos o mas tablas:
Sintaxis :
SELECT alias1.campo1
,alias2.campo2
,alias3.campo3
FROM tabla1 alias1
,tabla2 alias2
,tabla3 alias3
WHERE alias1.campo1 = alias2.campo2
alias1.campo2 = alias2.campo3
Ejemplo :
Un ejemplo sencillo: si queremos listar el nombre del empleado,
el id del departamento, y el nombre del departamento al
que pertenece el empleado la query (consulta) sería:
SELECT A.nombre AS empleado
,A.dept_id
,B.nombre AS depto
FROM s_emp A
,s_dept B
WHERE A.id = B.region_id
Ejercicios :
Seleccionar el No. depto, apellido, salario y
cargo para los empleados que ganen mas de 100 y el departamento este en 41, 10
y 50
select dept_id
,nombre
,salario
,cargo
from s_emp
where salario > 100
and dept_id IN (41,10,50)
seleccionar el apellido, del empleado, id del depto, y el nombre del
depto.
select a.nombre AS empleado
,b.id
,b.nombre AS depto
from s_emp a
,s_dept b
where a.id = b.dept_id
Seleccionar el apellido del empleado, no del depto, el nombre deldepto
para los depto que esten entre 20 y 50 sin incluirlos.
select a.nombre AS empleado,
b.id,
b.nombre AS depto
from s_emp a, s_dept b
where a.id = b.dept_id
and b.id > 20 and b.id < 50
seleccionar el nombre del empleado no. del depto, nombre del depto, para
los deptos que comiencen con 4 y ordenados el numero de depto y nombre del
empleado desc
select a.nombre AS empleado,
b.id,
b.nombre AS depto
from s_emp a,
s_dept b
where a.id=b.dept_id
and ALLTRIM(STR(b.id)) like '4%'
order by a.nombre asc,
b.id
Seleccionar el nombre del cliente para aquellos empleados que el no del
depto sean 30, 40, 41, 42 y el ( salario sea mayor que 1000 o el depto sea 50 )
select a.nombre AS cliente,
b.nombre AS empleado,
b.salario,
b.id,
b.dept_id
from s_customer a,
s_emp b
where a.emp_id=b.id
and b.dept_id IN (30,40,41,42)
and (b.salario > 1000 or b.dept_id='50')
Otra soluccion:
select a.nombre
from s_customer a
where a.emp_id IN (Select id
from s_emp
where dept_id in (30, 40,41,42)
and (salario > 1000 or dept_id=50 )
Seleccionar el nombre del cliente, nombre de region y el salario para
todos los empleados que el salario sean mayor que 100
select a.nombre AS empleado,
b.nombre AS depto,
a.salario
from s_emp a,
s_dept b
where a.dept_id=b.id
and a.salario > 100
Funciones de grupos
salarios minimos y maximos de los empleados
select max(salario) sal_max,
min(salario) sal_min
from s_emp
Suma, maximo, minimo salario por Departamento
select dept_id,
sum(salario),
max(salario),
min(salario)
from s_emp
group by dept_id
*---
select dept_id,
count(dept_id)
from s_emp
group by dept_id
having dept_id > 20
*---
select dept_id,
sum(salario)
from s_emp
group by dept_id
having sum(salario) between 2000 and 4000
*---
select avg(salario),
min(salario),
max(salario),
sum(salario)
from s_emp
where UPPER(title) like 'SALES%'
*---
select count(nombre),
dept_id
from s_emp
where dept_id=31
group by dept_id
SELECT COUNT(ID),
DEPT_ID
FROM S_EMP
GROUP BY DEPT_ID
SELECT COUNT(ID),
CREDIT_RATING
FROM S_CUSTOMER
GROUP BY CREDIT_RATING
*----
SELECT SUM(SALARIO), CARGO
FROM S_EMP
WHERE upper(TITLE) NOT LIKE 'VP%'
GROUP BY CARGO
*----
SELECT SUM(SALARIO), TITLE
FROM S_EMP
GROUP BY TITLE
*----
SELECT TITLE, SUM(SALARIO)
FROM S_EMP
WHERE UPPER(TITLE) NOT LIKE 'VP%'
GROUP BY TITLE
HAVING SUM(SALARIO)> 5000
*----
Formularios Sencillos
Un Formulario Sencillo, es el que es realizado generalmente utilizando
una sola tabla.
Un ejemplo típico de formularios sencillos son las pantallas de los
catálogos de un Sistema, que solamente tienen la función de
registrar, modificar, eliminar y consultar datos de una tabla.
Por ejemplo vamos a construir una forma sencilla utilizando el Wizard de
Visual Foxpro:
1.
Abra su proyecto
2.
Ubíquese en la pestaña de documentos (document) y luego
en Formas (Forms).
3.
Presione el Botón Nuevo (New).
Aparece la siguiente
ventana:
4.
Seleccione Wizard.
5.
Seleccione Form Wizard y OK.
6.
Luego aparece la ventana donde usted escoge la tabla a utilizar y los
campos de esa tabla.
7.
Una vez seleccionado la tabla y sus respectivos campos, presiones próximo (Next).
8.
Se visualizará la siguiente ventana:
10. Seleccione el estilo de la forma y el tipo de botones a
utilizar en la forma y luego presione próximo (Next).
11. Aparecerá la siguiente ventana:
Para visualizar todas las imágenes faltantes
haga click en el menu superior "Bajar Trabajo".
12. Seleccione el ordenamiento de la tabla, aquí por lo general se
selecciona el índice de la tabla ( los índices aparecen con asterisco *)
13. Introduzca el titulo de la forma y luego Finalizar (Finish)
Visual Foxpro Generará la forma, luego usted puede modificar la forma si
lo desea.
La forma, que creamos con el wizard, quedaría de esta forma:
Nota: Reconstruya el proyecto en la opción Build (botón
del proyecto). Luego Seleccione Rebuild Proyect y OK.
Visual Foxpro, compila su proyecto.
Notará que en la pestaña de clases de su proyecto Visual Foxpro le ha
agregado una clase que
él ocupa para construir formas con el Wizard, el nombre de la clase
es WizStyle.
Formularios Maestro - Detalle
Un formulario maestro detalles es aquel en que entran en juego dos
o más tablas, las cuales tengan una relación de uno a muchos. Ejemplo la
relación de s_region con s_dept ( una región puede tener muchos departamentos).
Se pueden construir formas mestro-detalle utilizando el Wizard, sin
embargo, nosotros utilizaremos la forma manual para
personalizar a nuestro gusto la forma.
Pasos para construir una forma maestro - detalle
Para este ejemplo utilizaremos las tablas s_region y s_dept
1.
Abra su proyecto
2.
Ubíquese en la pestaña de documentos (document) y luego
en Formas (Forms).
3.
Presione el Botón Nuevo (New).
4.
Seleccione Nueva Forma en blanco.
5.
En la forma en blanco presione el botón derecho del ratón y luego Entorno
de Datos (Data Environment)
6. Seleccione las tablas s_region, que será el maestro y
luego la tabla s_dept que será nuestro detalle.
7. Arrastre uno por uno los campos de la tabla s_region a su forma, de
tal manera que queden asi:
8. Luego arrastre toda la tabla s_dept al formulario
1.
Ahora vamos a modificar las propiedades del Grid que hemos insertado:
seleccionan el grid, botón derecho del ratón y luego propiedades. Se sitúan en
la pestaña datos, para modificar las siguientes propiedades con el fin de
establecer la relación entre las dos tablas:
En la clase se explicaron los procedimientos para Incluir Modificar y
Eliminar alumnos a una base de datos de inscripciones. En este este codigo se
estan actualizando clientes el
código es análogo
Boton Incluir:
if thisform.incluir.caption="Incluir"
scatter memvar blank
thisform.incluir.caption="Guardar"
thisform.salir.caption="Cancelar"
thisform.text1.enabled=.t. (Recuerden que los texbox poseen nombres que
se
corresponden con la realidad txtcedula,txtnombre…,
aunque en este ejemplo no se planteen así debe
programarse)
thisform.text2.enabled=.t.
thisform.text3.enabled=.t.
thisform.text4.enabled=.t.
else
if thisform.text1.value<>''
if thisform.text2.value<>''
if thisform.text3.value<>''
if thisform.text4.value<>''
append blank
gather memvar
endif (Pueden mostrarse mensajes de validación de llenar todos
los campos antes de incluir un registro)
endif
endif
endif
thisform.incluir.caption="incluir"
thisform.salir.caption="Salir"
thisform.text2.enabled=.f.
thisform.text3.enabled=.f.
thisform.text4.enabled=.f.
endif
thisform.refresh
Boton Modificar:
if thisform.modificar.caption="Modificar"
thisform.text1.enabled=.f.
thisform.text2.enabled=.t.
thisform.text3.enabled=.t.
thisform.text4.enabled=.t.
thisform.modificar.caption="Guardar"
thisform.salir.caption="Cnacelar"
else
gather memvar
thisform.text1.enabled=.t.
thisform.text2.enabled=.f.
thisform.text3.enabled=.f.
thisform.text4.enabled=.f.
thisform.modificar.caption="Modificar"
thisform.salir.caption="Salir"
endif
Boton Eliminar
(Recuerden que en la ayuda de Visual FoxPro está la información de la
aplicación de la función y/o procedimiento Messagebox)
if messagebox("Esta seguro que
desea eliminar este cliente",36,"Confirmacion")=6
(Implementada como función)
delete
pack
messagebox("El registro fue eliminado",0,"Aviso")
(implementada como procedimiento)
scatter memvar blank
endif
thisform.refresh
Boton Salir:
if thisform.incluir.caption="Guardar"
thisform.text2.enabled=.f.
thisform.text3.enabled=.f.
thisform.text4.enabled=.f.
thisform.incluir.caption="Incluir"
thisform.Salir.caption="Salir"
else
if thisform.modificar.caption="Guardar"
thisform.text1.enabled=.t.
thisform.text2.enabled=.f.
thisform.text3.enabled=.f.
thisform.text4.enabled=.f.
thisform.modificar.caption="Modificar"
thisform.Salir.caption="Salir"
else
thisform.release
endif
endif
Boton Primero:
go top
m.codigo=clientes.codigo
m.nombre=clientes.nombre
m.telefono=clientes.telefono
m.direccion=clientes.direccion
thisform.refresh
Boton Ultimo:
go bottom
m.codigo=clientes.codigo
m.nombre=clientes.nombre
m.telefono=clientes.telefono
m.direccion=clientes.direccion
thisform.refresh
Boton Siguiente
if eof()
thisform.siguiente.enabled=.f.
go bottom
m.codigo=clientes.codigo
m.nombre=clientes.nombre
m.telefono=clientes.telefono
m.direccion=clientes.dirección
frmactcliente.refresh
else
skip 1
m.codigo=clientes.codigo
m.nombre=clientes.nombre
m.telefono=clientes.telefono
m.direccion=clientes.direccion
if thisform.anterior.enabled=.f.
thisform.anterior.enabled=.t.
endif
endif
thisform.refresh
Boton Anterior
if bof()
thisform.anterior.enabled=.f.
go top
else
skip -1
if thisform.siguiente.enabled=.f.
thisform.siguiente.enabled=.t.
endif
endif
m.codigo=clientes.codigo
m.nombre=clientes.nombre
m.telefono=clientes.telefono
m.direccion=clientes.direccion
thisform.refresh
Creación de Clases de Objetos
En Visual Foxpro se pueden crear clases de objetos que pueden de uso muy
común, como por ejemplo el botón salir es muy comun en todas las pantallas.
Pasos para creación de clases:
1. Abra su proyecto
2. Ubíquese en la
pestaña de classes.
3. Presione el
Botón Nuevo (New).
4. Introduzca el nombre
de la clase, el tipo de clase (en este caso Boton de comando) y guardarlo como
curso.
5. Inmediatamente
aparecerá la siguiente pantalla:
6. Personalice el botón
y luego cierre la ventana y sálvelo.
7. 
La clase que usted a creado aparecerá
en la pestaña clases de su proyecto:
La clase que usted a creado aparecerá
en la pestaña clases de su proyecto:
Cómo hacer uso de la clase :
1. 
2. presione el botón
de ver clases y luego agregar (Add) y seleccione la clase que
usted a creado.
2.
Cree o Abra una forma
3.
Aparecerá la clase que usted a creado con el botón de salir
4.
Para poner el botón en la forma, seleccione el botón en la barra de
controles y luego clic en la forma.
En clase se implementó una clase basada en la clase TextBox que cambia
el color de fondo y el color de la letra del Textbox cuando el texbox obtiene o
pierde el focus ( utilizando los procedimientos LosFocus y
GotFocus) de esta manera el usuario identifica mas facilmente el texbox activo
Código del Procedimiento LostFocus de la clase TxtColor (obtenel el
focus)
This.backcolor=rgb(0,0,255) (color de fondo azul)
This.forecolor=rgb(255,255,255) (color de las letras blancas)
Código del Procedimiento GosFocus del la clase TextColor (perder el
focus)
This.backcolor=rgb(255,255,255) (color de fondo blanca)
This.forecolor=rgb(0,0,0) (color de las letras negras)
Soporte de Tecnología ActiveX
Cuando usted instala Visual Foxpro, se instalan una serie de controles
ActiveX soportados por Visual Foxpro.
Un ActiveX, no es más que un control externo, es parecido a una clase ya
que las clases se pueden guardar en un archivo (extensión VCX) y los ActiveX
tienen extensión OCX. La diferencia es que los VCX solo puede ocuparse en
Visual Foxpro, mientras que los OCX se consideran como tecnología abierta, es
decir, pueden ser utilizado por cualquier lenguaje visual como Visual C++
o Visual Basic,
por mencionar algunos.
Estos controles ActiveX, vienen hechos de fabrica, son comercializables
y no son modificables, sin embargo uno puede crear sus propios OCX. Los
lenguajes donde se pueden construir estos OCX actualmente son Visual C++ y
Visual Basic. En visual Foxpro 5.0 usted no puede crear OCX.
Hay que tener mucho cuidado a la hora de comprar un OCX y verificar que
lenguajes soporta, por que algunos OCX no son soportados por algunos lenguajes
visuales incluso con Visual Foxpro.
Cómo hacer uso de los ActiveX en Visual Foxpro:
Un OCX es un objeto por lo cual tiene propiedades y eventos implícitos
en él.
En el curso, utilizaremos dos Controles ActiveX :
·
OutLine control
·
Microsoft Progress Bar Control
OutLine control:
El Outline Control se utiliza para
hacer Arboles como
por Ejemplo: Regiones con departamentos (maestro-detalle)
Cómo agregar un ActiveX a la forma:
1.
Abra o Cree una nueva forma.
2.
Seleccione Ver clases
3.
Seleccione ActiveX Control
4.
Seleccione el control deseado, en este caso el Outline Control y póngalo
en la forma.
5. Vamos a crear una forma maestro detalle utilizando el Outline
Control. El Outline control presentará la información de las Regiones y vamos a
agregar un Grid que serán los departamentos, Algo asi:
Completar Código del Outline control:
|
Método
|
Código
|
|
Init
|
*-------------------------------------
* Cargar el OCX
*-------------------------------------
*--------
pnIndex = 0
THIS.Additem( "Regiones" )
THIS.Indent( pnIndex ) = pnIndex
Select s_region
SCAN
pnIndex = pnIndex + 1
datos = ALLTRIM(name)
THIS.Additem(datos)
THIS.Indent( pnIndex ) = 1
THIS.PictureType(pnindex) = 2
THIS.ListIndex = pnindex
THIS.ItemData(pnIndex) = RECNO()
ENDSCAN
|
|
Click
|
SELECT s_region
GO RECORD THIS.ItemData(THIS.ListIndex)
THISFORM.REFRESH()
|
El último paso es agregar el Grid con la tabla departamentos y
luego establecer la relación con la tabla de regiones.
Progress Bar Control:
Este control permite hacer una barra de progreso:
Propiedades :
|
Propiedad
|
Descripción
|
|
Max
|
Máximo valor de la Barra (númerico)
|
|
Min
|
Mínimo valor de la Barra (númerico)
|
|
Value
|
Valor actual de la barra (númerico)
|
Almacenar objetos OLE en la Base de Datos:
Con Visual Foxpro se pueden almacenar objetos OLE en la Base de Datos,
estos objetos OLE van desde una simple imagen BMP
de Paintbruhs hasta un video clip,
un documento en Word,
una hoja en Excel un
grafico.
Esto se llama OLE Automation (automatización OLE)
¿Qué se necesita para hacer OLE Automation?
Muy sencillo:
·
El campo de la tabla debe ser tipo General
·
Utilizar el control OLE Bound Control de Visual Foxpro
·
Utilizar el Comando APPEND GENERAL
Sintaxis de APPEND GENERAL
APPEND GENERAL Nombre Campo tipo General
[FROM Nombre Archivo]
[DATA Nombre de Variable]
[CLASS Nombre de la Clase OLE]
FROM : Por si deseamos insertar un Archivo existente en el disco
DATA : Si no es un archivo puede ser una variable, entonces se
especifica
aquí.
CLASS : El nombre de la clase de la aplicación al que esta asociada el
archivo
o la variable.
Toda aplicación Windows ( Word, Excel, Graph, Paint,
WordPad, Block de Notas, Power Point,
entre otras) tienen un nombre de clase:
Por mencionar algunos nombres de clases:
|
Aplicación
|
Nombre de la clase
|
|
Paintbrush Picture
|
PAINT.PICTURE
|
|
Documento de Word 97
|
WORD.DOCUMENT
|
|
Hoja de Calculo de Excel
|
EXCEL.SHEET
|
Como conocer el nombre de clase de una aplicación Windows:
1.
Cree un formulario nuevo
Cree un formulario nuevo
2.
Inserte en el formulario el control OLE Container Control
3.
Insertar la Aplicación deseada: (Escoger el objeto y luego OK)
4.
Luego en las propiedades del objeto insertado buscar la propiedad OLECLASS:
Incluir en el Formulario el Objeto OLE:
Diseño de Reportes
Guia rápida visual:
Los informes muestran datos y resumen datos en un formulario
impreso o en pantalla. Los dos componentes principales de los informes son los
datos y el formato. La fuente de datos del informe puede
ser una tabla de base de dato, una consulta o una vista.
El primer paso para diseñar un informe es determinar los datos que se
van a mostrar, y el segundo paso es determinar cuál va a ser el mejor formato
para mostrar ese informe. Puede crear listados que se basen en una única tabla
o en informes complejos.
El Generador de Informes es una herramienta flexible y de fácil uso para
la creación, diseño y modificación de informes.
Pasos para Creación de Informes :
I. Selección de
los datos
Esta es la parte más importante del informe, la selección de datos, hay
que saber qué es lo que quiere el usuario o que el usuario muestre el diseño
del informe que desea, para comenzar a trabajar.
Los datos pueden ser simples (utilizando una sola tabla), como listados
de regiones, listado de departamentos, entre otros; o pueden ser algo mas
complejos (utilizando mas de una tabla) Ejemplo Reportes agrupados, reportes
consolidados, etc.
Los datos se pueden obtener directamente utilizando las tablas o
utilizando SQL para crear cursores, esta última es la más
recomendada para una aplicación multiusuario.
Existen varios tipos de informes entre ellos :
- Listados (Ej. Listados de regiones)
Muestra:
-------------------------------
id name
-------------------------------
01 Region 1
02 Region 2
--------------------------------
- Grupos con detalles ( o maestro detalles)
-------------------------------
Region
Departamento
-------------------------------
Region 1
Departamento a
Departamento b
Region 2
Departamento x
Departamento y
--------------------------------
- Matriciales o consolidados
--------------------------------------------
Rating
Region Excellent Good Poor
--------------------------------------------
Region 1 1 2 0
Region 2 3 0 1
--------------------------------------------
Totales 4 2 1
--------------------------------------------
Creación de Informes usando el entorno de datos:
1. En el administrador de proyectos, seleccione la ficha Documentos.
2. Seleccione Informes
3. Pulse el botón nuevo
4. Pulse el botón nuevo informe.
Aparece el generador de informes y al barra de herramientas Controles de
informes.
5. Seleccione Entorno de datos y seleccione la tabla
6. Arrastre los campos a utilizar del entorno de datos en el informe en
la parte de detalle
7. Introduzca los encabezados del reporte
8. Puede ver como queda el informe con el botón de presentación
preliminar:
Presentación Preliminar :
Menú de Reportes
Titulo/Sumario (Title/Summary):
Muestra el área del Titulo y el Sumario del Informe
Titulo : Aparece solo en la primera pagina del Reporte
Sumario : Aparece solo en la ultima pagina del Reporte
Agrupamiento de datos (Data Grouping)
El agrupamiento de datos se utiliza para informes maestro –
detalle.
Las variables son útiles para hacer cálculos con los datos del reporte y
luego presentarlas en el mismo reporte.
Propiedades de los campos
Cada campo en el Informe posee propiedades :
Creación de Informes usando Cursores SQL:
1. Crear el cursor con el comando SELECT..... FROM .....WHERE....
2. Crear el Informe manualmente, con los nombres de campos del cursor.
3. Correr el Reporte.
Ejemplo:
* Se define una ventana Personalizada
DEFINE WINDOW w_Output ;
FROM 0,0 TO 25,70 ;
TITLE 'Informes - INATEC' ;
CLOSE FLOAT GROW ZOOM SYSTEM
USE IN .\data\s_region IN 0
SELECT id, name
FROM s_region
INTO CURSOR c_region
* Si lo queremos por pantalla
REPORT FORM .\report\pp_detalles ;
PREVIEW WINDOWS w_output ;
NOEJECT NOCONSOLE
* Por Impresora
REPORT FORM .\report\pp_detalles ;
TO PRINTER PROMPT ;
NOEJECT NOCONSOLE
* Hacia un Archivo
REPORT FORM .\report\pp_detalles ;
TO FILE PUTFILE() ;
ASCII
* Cerrar el cursor
USE IN c_region
Integración de la Aplicación
Creación de Menús:
Guía rápida Visual:
Tipos de Menús:
Existen dos tipos de menús : menú y Shortcut.
Creación de Menús:
La creación de menús es un proceso que
conlleva diferentes pasos. Primero, debemos definir las opciones del menú y de
los submenús. Luego, asignar funcionalidad a las opciones de menú. Finalmente,
generar el programa de menús.
Puede l generador de menús de Visual Foxpro para que le ayude a
construir menús rápidamente. El Generador de menús le permite definir la
estructura y funcionalidad de su sistema de menús a través de cuadros de
diálogo de fácil uso y de listas desplegables que puede utilizar para crear y
modificar su sitema de menús.
Definición de las opciones de menú.
Los menús presentan su aspecto con una lista de opciones para iniciar
una actividad. La mayoría de los elementos de menú muestran submenús u opciones
adicionales cuando el usuario selecciona uno de estos elementos. Antes de
generar un menú para una aplicación, tendrá que determinar que selecciones
tendrá disponibles el usuario final y qué opciones de menús pertenecen a otras
opciones de menús (sub menus).
Cómo crear un nuevo menú
1. Aparece la página
otros con las categorías de archivo de Menús, Texto y Otros.
2.
Pulse la ficha de otros en el
Administrador de proyectos.
Pulse la ficha de otros en el
Administrador de proyectos.
3.
Seleccione menús en la lista de categorías
4.
Pulse el botón nuevo y escoja si es Menu o un Shortcut
4. Introduzca las opciones del menu y luego el resultado del menú (
submenu, comando o procedimiento)
5. A la derecha del resultado se encuentra la opción crear o modificar
según el caso. ( crea o modificar los resultados de la opción del menu).
Tipos de Resultados :
Submenu : Si el menú contiene un submenu
Comando : Si la opción de ese menú invoca un comando (Ejemplo:
DO FORM
Regiones, para llamar un formulario;
CLEAR EVENT, por lo general va en la opción Salir)
Procedimiento : Si la opción de ese menú invoca varias líneas de comandos ( un
procedimiento).
Opciones de Menú:
En las opciones del menú se especifican:
·
Teclas de Acceso directo
·
Mensajes del menú
·
Condición de habilita/No habilitar
Generación del menú :
1.
En el menú escoja la opción Menú.
2.
Se le pregunta si desea grabar los cambios ( responda que si)
3.
Luego se le pide que proporcione el archivo de salida del menu ( escoja
la ruta y el nombre del archivo, por lo general son extension MPR) y luego
seleccione generar.
4.
Si existe ya el archivo se le pide si desea re-escribirlo ( seleccione
que si)
Como invocar al menú creado:
Al generar el menú se crea un archivo que por lo general tiene extensión
MPR que contiene el código para desplegar el menú.
La instrucción sería:
DO ruta y nombre del archivo MPR
Ejemplo : DO menu.MPR
·
Para volver a re establecer el menú por default de Visual Foxpro utilice
la instrucción: SET SYSMENU TO DEFAULT
Creación del Ejecutable de la Aplicación.
Primero se tiene que crear un programa de inicio, al cual se le tiene
que decir que ese es el programa que se ejecutara de primero ( esto se hace
haciendo clic derecho en el programa que designemos como principal y escoger la
opción main ( principal) del menú de opciones)
Contenido Ejemplo del programa principal:
CLEAR ALL
* Variables Publicas
PUBLIC w_Output, g_año, gid_area, g_nivel, g_cambio, g_login_entry ;
,g_pass_entry, V_MENU_PRE, V_ERROR, g_acceso
* Definicion de Ventana para los Reportes
DEFINE WINDOW w_Output ;
FROM 0,0 TO 25,70 ;
TITLE 'Informes - BCN' ;
CLOSE FLOAT GROW ZOOM SYSTEM
* Ambiente
SET SYSMENU TO
SET ECHO OFF
SET TALK OFF
SET CENTURY ON
SET CLOCK STATUS
SET DATE brit
SET DELETE ON
SET PATH TO formenu,bmp,prg,data
SET EXCLUSIVE OFF
SET SAFETY OFF
SET REFRESH TO 5
SET REPROCESS TO AUTOMATIC
SET MULTILOCK ON
SET LOCK OFF
SET PROCEDURE TO .\prg\utility
* Fondo de la Pantalla principal
_SCREEN.Picture=".\bmp\fondo.bmp"
_SCREEN.WINDOWSTATE=2
_SCREEN.CLOSABLE=.F.
_SCREEN.CAPTION="Formulación Presupuestaria"
* Base de Datos
OPEN DATA .\SCOTT\scott SHARED
* Llamada al Menu
DO .\menu\menu.mpr
READ EVENT
CLEAR ALL
SET SYSMENU TO DEFAULT
Creación del Ejecutable
En el Administrador de proyectos seleccione la opcion Build, luego la
opción build Executable y luego OK.
·
En las opciones es recomendable seleccionar Recompile All y display
Error, para recompilar todos sus programas y
formularios ; y Por si hay un error mostrarlo al final de la generación del
Ejecutable.
No hay comentarios.:
Publicar un comentario