2. ¿Qué es un lenguaje de programación?

Profesor/a.............ZIGOR ALDAZABAL – MIKEL SORRONDEGUI................... Irakaslea
Alumno/a ....................................................................................................................... Ikaslea
Curso ....................PROGRAMACIÓN EN C++ Y VISUAL BASIC........................ Kustsoa
Alorgune ........................TELECOMUNICACIONES..............................................................
Curso .........2009........... Ikasturte
Instituto Especifico Formación Profesional Superior “BIDASOA” Goi-mailako Berariazko Lanbide Heziketa Institutua
Tfno 943.666010 - Fax 943.615380 Elizatxo 10 - 20303 IRUN (Gipuzkoa) e-mail - secretaria@fpbidasoa.org www.fpbidasoa.org
REV..... FECHA: ......./ ...../ ......
Conceptos de programación
INDICE
1. Conceptos básicos..........................................................3
1.1. Programación....................................................................3
1.2. Algoritmo ........................................................................3
1.3. Programa.........................................................................4
2. ¿Qué es un lenguaje de programación? .................................4
2.1. Generaciones de los lenguajes de programación..........................4
3. Traductores de lenguajes .................................................6
3.1. Compilador ......................................................................6
3.2. Intérprete........................................................................6
4. Objetivos de la programación ............................................6
4.1. Exactitud.........................................................................6
4.2. Claridad ..........................................................................7
4.3. Eficiencia ........................................................................7
5. Programación estructurada, modular y descendente.................8
5.1. Programación modular.........................................................8
5.2. Diseño descendente (“TOP-DOWN”).........................................9
5.3. Programación estructurada ...................................................9
6. Programación estructurada ...............................................9
6.1. Estructuras básicas de control lógico ..................................... 10
6.2. Ventajas de la programación estructurada............................... 11
7. Herramientas de programación ........................................ 12
7.1. Pseudocódigo.................................................................. 12
7.2. Diagramas de flujo ........................................................... 12
7.3. Tipos de estructuras ......................................................... 12
8. Ciclo de programación................................................... 14
8.1. Definición del problema ..................................................... 15
8.2. Análisis del problema ........................................................ 15
8.3. Selección de la mejor alternativa ......................................... 15
8.4. Diagramación.................................................................. 15
8.5. Prueba de escritorio ......................................................... 15
8.6. Codificación ................................................................... 16
8.7. Trascripción ................................................................... 16
8.8. Traducción..................................................................... 16
8.9. Pruebas de ordenador ....................................................... 17
8.10. Documentación externa.................................................... 17
9. Programación Orientada a Objetos .................................... 17
1
Programación
10. Introducción al Lenguaje C ........................................... 18
10.1. Un poco de historia ......................................................... 18
10.2. Características ............................................................... 19
10.3. Desventajas .................................................................. 20
10.4. Aplicaciones .................................................................. 20
10.5. Tipos........................................................................... 20
2
Conceptos de programación
1. Conceptos básicos
1.1. Programación
La programación es una actividad mental compleja que se divide en varias etapas y cuya
finalidad es comprender con claridad el problema que va a resolverse o simularse en el
ordenador, y entender con detalle cuál será el procedimiento mediante el cual el ordenador
obtendrá la solución esperada.
El proceso de resolución de un problema con un ordenador conduce a la escritura de un
programa y a su ejecución en la misma. Aunque el proceso de diseñar programas es
esencialmente un proceso creativo, se pueden considerar una serie de fases o pasos
comunes, que generalmente deben seguir todos los programadores:
Las dos primeras fases conducen a un diseño detallado escrito en forma de algoritmo.
Durante la tercera etapa (codificación) se implementa el algoritmo en un código escrito en
un lenguaje de programación, reflejando las ideas desarrolladas en las fases del análisis y
diseño. La fase de compilación y ejecución traduce y ejecuta el programa. En las fases de
verificación y depuración el programador busca errores de las etapas anteriores y los
elimina. Mientras mas tiempo se gaste en la fase de análisis y diseño menos se gastará en la
depuración del programa. Por ultimo, se debe realizar la documentación correspondiente.
1.2. Algoritmo
La palabra algoritmo se deriva de la traducción al latín de la palabra árabe ALkhOwarÍzmi,
nombre de un matemático y astrónomo árabe que escribió un tratado sobre manipulación de
números y ecuaciones en el siglo IX.
Un algoritmo es un método para resolver un problema mediante una serie de pasos precisos
definidos y finitos. Sus características básicas son:
Preciso Æ Se debe indicar el orden de realización en cada paso
Definido Æ Si se sigue dos veces, obtiene el mismo resultado cada vez
Finito Æ Tiene fin, es decir, un número determinado de pasos
Ejemplos de algoritmos son: instrucciones para montar en una bicicleta, hacer una receta de
cocina, obtener el máximo común divisor de dos números, etc.
Los algoritmos se pueden expresar por fórmulas, diagramas de flujo, o N-S y pseudocódigos.
Esta última representación es la más utilizada en lenguajes estructurados como pascal, c++
etc.
3
Programación
1.3. Programa
No es más que un conjunto de instrucciones que deben ser ejecutadas por el ordenador para
resolver un problema. Todo programa debe cumplir las siguientes pautas:
¾
¾
¾
Tiene una única entrada y salida
Toda sentencia (instrucción) del algoritmo es accesible, es decir, existe al menos un
camino que va desde el inicio al fin del algoritmo, se puede seguir y pasa a través de
dicha sentencia.
No tiene ciclos o bucles infinitos
Los programas pueden ser de dos tipos:
PROGRAMA FUENTE: Es el programa escrito en alguno de los lenguajes y que no ha sido
traducido al lenguaje de la maquina, es decir, el programa que no está en código máquina y
que por lo tanto no puede ser ejecutable.
PROGRAMA OBJETO: Aquel programa que se encuentra en lenguaje máquina y que ya es
ejecutable por esta.
2. ¿Qué es un lenguaje de programación?
Los lenguajes de programación cierran el abismo entre los ordenadores, que sólo trabajan
con números binarios, y los humanos, que preferimos utilizar palabras y otros sistemas de
numeración. Mediante los programas se indica al ordenador qué tarea debe realizar y como
efectuarla, pero para ello es preciso introducir estas ordenes en un lenguaje que el sistema
pueda entender. En principio, el ordenador sólo entiende las instrucciones en código
máquina, es decir, el específico de la computadora. Sin embargo, a partir de éstos se
elaboran los llamados lenguajes de alto y bajo nivel.
Un lenguaje de programación no es más que un conjunto de reglas y estándares para escribir
un programa y permitir así la comunicación usuario / máquina. Se clasifican en tres grandes
categorías: máquina, bajo nivel (ensamblador) y alto nivel.
2.1. Generaciones de los lenguajes de programación.
Lenguaje máquina
También conocido como lenguaje de primera generación es el lenguaje original del
ordenador ya que un programa debe estar escrito en el lenguaje de la máquina para poder
ser ejecutado. Este es generado por software y no por el programador. El programador
escribe en un lenguaje de programación, el cual es traducido al lenguaje de máquina
mediante intérpretes y compiladores.
Fue utilizado en las primeras computadoras y trabaja sin símbolos y hace referencia a las
direcciones reales de la memoria y a los códigos binarios de las instrucciones, interactúa con
el hardware y juntos constituyen el nivel más bajo de programación. Actualmente es
utilizado muy raramente para el desarrollo de programas de aplicación ya que todas las
instrucciones y datos se especifican en ceros y unos (binario) por lo que sus instrucciones son
directamente entendibles por el ordenador y no necesitan traducción posterior para que la
UCP pueda comprender y ejecutar el programa. Como ya se ha indicado, las instrucciones en
lenguaje máquina se expresan en términos de la unidad de memoria mas pequeña, el bit
4
Conceptos de programación
(digito binario 0 o bien 1), en esencia una secuencia de bits que especifican la operación y
las celdas de memoria implicadas en una operación
Estas instrucciones serán fáciles de leer por la computadora y difíciles por un programador, y
viceversa. Esta razón hace difícil escribir programas en código o lenguaje máquina y requiere
buscar otro lenguaje para comunicarse con el ordenador, pero que sea más fácil de escribir y
leer por el programador. Para evitar la tediosa tarea de escribir programas en lenguaje
máquina se ha diseñado otros lenguajes de programación que facilitan la escritura y
posterior ejecución de los programas. Estos programas son los de bajo y alto nivel.
Lenguajes de bajo nivel
Utilizan códigos muy cercanos a los de la máquina, lo que hace posible la elaboración de
programas muy potentes y rápidos, pero son de difícil aprendizaje.
LENGUAJE ENSAMBLADOR. Es un lenguaje de programación de bajo nivel, en que las
instrucciones y las direcciones de memoria están representadas por símbolos. Permite la
utilización de nombres simbólicos en lugar de ceros y unos. De esta manera se podrá utilizar
la palabra "suma" para indicarle al ordenador que se quiere sumar dos números.
Este lenguaje es utilizado raramente para el desarrollo de software de aplicación y con
frecuencia es llamado lenguaje de segunda generación.
Lenguajes de alto nivel
También se les conoce como lenguaje de tercera generación, son de uso mucho más fácil, ya
que en ellos un solo comando o instrucción puede equivaler a millares es código máquina. Es
proceso es muy sencillo:
El programador teclea instrucciones en un editor, que es un programa parecido a un simple
procesador de palabras, estas instrucciones son almacenadas en archivos denominados
programas fuentes (código fuente). Si los programadores necesitan hacer cambios al
programa posteriormente vuelven a correr el editor y cargan el programa fuente para
modificarlo.
El proceso de conversión de programas fuente a programas objeto se realiza mediante un
programa denominado compilador. El compilador toma un programa fuente y lo traduce a
programa objeto y almacena este último en otro archivo.
Este tipo de lenguajes, generalmente se utiliza para el desarrollo de programas o software
de aplicación. Su principal característica es que una instrucción codificada en lenguaje de
alto nivel equivale a varias instrucciones en lenguaje maquinal o ensamblador. Además, las
personas pueden comprender mejor las instrucciones, y esto hace que se reduzcan el tiempo
y el costo para realizar programas. Ejemplos de estos lenguajes son Pascal, Logo, Basic,
Cobol, Fortran, C++.
Lenguaje de cuarta generación (4GL)
Es el lenguaje de muy alto nivel cuya característica principal es permitir a los usuarios con
poco conocimiento sobre computación y lenguajes de programación, desarrollar sus propios
programas de aplicación sin la participación operativa del personal del departamento de
informática. Este tipo de programas o sistemas se conoce como cómputo de usuario final. De
manera común son lenguajes que permiten la interacción directa del usuario en funciones de
consulta y actualización de información.
5
Programación
3. Traductores de lenguajes
Unos programas especiales llamados traductores (compiladores e intérpretes) convierten las
instrucciones escritas en lenguajes de programación en instrucciones escritas en lenguaje
maquina (0 y 1 bits) que esta pueda entender
3.1. Compilador
Un compilador es un programa que traduce el programa fuente (conjunto de instrucciones de
un lenguaje de alto nivel, por ejemplo BASIC o Pascal) a programa objeto (instrucciones en
lenguaje máquina que la computadora puede interpretar y ejecutar). Se requiere un
compilador para cada lenguaje de programación ya que normalmente el compilador analiza
el léxico y verifica la sintaxis del programa, y en una segunda fase hace la traducción. Un
compilador no ejecuta el programa. Una vez compilado el programa, el resultado en forma
de programa objeto será directamente ejecutable.
Presentan la ventaja considerable frente a los intérpretes de la velocidad de ejecución, por
lo que su uso será mejor en aquellos programas probados en los que no se esperan cambios y
que deban ejecutarse muchas veces. En caso de que se opte por un interpretador se debe
considerar que el intérprete resida siempre en memoria.
3.2. Intérprete
Traductor de lenguajes de programación de alto nivel, los intérpretes ejecutan un programa
línea por línea. El programa siempre permanece en su forma original (programa fuente) y el
interprete proporciona la traducción al momento de ejecutar cada una de las instrucciones.
Un intérprete es un programa que procesa los programas escritos en un lenguaje de alto
nivel, sin embargo, está diseñado de modo que no existe independencia entre la etapa de
traducción y la etapa de ejecución.
Un intérprete traduce cada instrucción o sentencia del programa escrito a un lenguaje
máquina e inmediatamente se ejecuta. Encuentran su mayor ventaja en la interacción con el
usuario, al facilitar el desarrollo y puesta a punto de programas, ya que los errores son
fáciles de detectar y sobre todo de corregir.
Es un programa que también realiza el proceso de traducción. El interpretador, a diferencia
del compilador, verifica, traduce y ejecuta instrucción por instrucción sin generar un
programa en lenguaje maquinal en forma ejecutable.
4. Objetivos de la programación
En la preparación de un programa, el programador puede tener que escoger entre soluciones
alternativas en muchos puntos. Cada elección debe hacerse para satisfacer los objetivos y
restricciones de la tarea de programación particular. Aquí asumiremos como apropiados para
toda tarea de programación los siguientes objetivos: Exactitud, claridad y eficiencia
4.1. Exactitud
Un objetivo obvio en la escritura de cualquier programa de ordenador es que tiene que
satisfacer su especificación exactamente. A menudo, sin embargo, a causa de la complejidad
6
Conceptos de programación
de la labor del programa, y de un entendimiento o cuidado inadecuados de parte del
programador, un programa falla en satisfacer alguna parte de su especificación. Un
programador tiene que ser en todo tiempo cuidadoso de la exactitud o pertinencia del
programa para su propósito especificado.
Un factor clave en el logro de exactitud es la simplicidad. Escogiendo el algoritmo o técnica
más simple disponible, es más probable que un programador vea si satisface o no los
requerimientos de la especificación del programa, y es menos probable que la describa
incorrectamente en su programa. La innecesaria complejidad no cumple propósito alguno en
la programación de ordenadores. Algunos programas son, por supuesto, inherentemente
complejos. Para tales programas, el programador debe adoptar un tratamiento sistemático
que controle y limite la complejidad de la que tiene que ocuparse en cada etapa.
4.2. Claridad
Un programa es necesariamente tan complejo como el algoritmo que describe. Sin embargo,
es importante que la forma en que el algoritmo esté descrito, por el texto del programa, no
sea más complicada de lo que es necesario. La claridad del programa es una ayuda
importante para el programador mismo en el diseño y limpieza del programa; y para otros
que puedan tener que leer y alterar el programa en alguna etapa posterior.
La claridad del programa es lograda casi en la misma forma que para cualquier texto escrito,
tal como un ensayo o un libro en los cuales se requiere:
a).- Una separación lógica del texto en partes comprensibles (capítulos, secciones, etc.)
que reflejen la distinción entre los temas que describen, y su presentación en una
secuencia lógica que refleje las relaciones entre ellas;
b).- Una selección cuidadosa de las características del lenguaje, usadas en cada parte
para expresar su sentido propuesto tan precisamente como sea posible;
c).- Otra selección cuidadosa de las palabras usadas para denotar los objetos y conceptos
involucrados;
d).- La inclusión de comentarios y preámbulos para clarificar el texto principal cuando
sea necesario;
Un programador podría ser tan diligente en el uso de éstas técnicas para lograr claridad
como el autor de cualquier texto. En muchos casos, la utilidad de un programa es
determinada tanto por la claridad de su texto como por las cualidades del algoritmo que
describe.
4.3. Eficiencia
El costo de ejecutar un programa de ordenador, es medido normalmente en términos de:
a).- El tiempo tomado por el ordenador para llevar a cabo la secuencia de operaciones
involucradas.
b).- La cantidad de memoria del ordenador usada en hacerlo.
En muchos ambientes (de máquina), el programa competirá con otros programas por el uso
de esos recursos del computador, y es, por tanto, lógico minimizar los requerimientos del
programa para cada uno.
El tiempo tomado para ejecutar el programa, es directamente proporcional al número de
operaciones que el procesador tiene que realizar al hacerlo. El programador debe, por tanto,
escoger un algoritmo que minimice las operaciones implicadas, y tener cuidado de evitar
cualquier operación redundante al expresar el algoritmo como un programa de ordenador.
7
Programación
La memoria usada por el programa durante su ejecución, es determinada por la cantidad de
datos que tienen que ser guardados, y por el número de instrucciones del procesador
requeridas para definir el programa, ya que éstas también tienen que ser guardadas en la
memoria. Para minimizar el almacenamiento usado por su programa, el programador debe,
por tanto, considerar los datos manipulados y el número de operaciones especificadas por el
programa.
Para algunos programas, o partes de programas, el uso eficiente del tiempo o del
almacenamiento puede ser crítico; para otros puede serlo menos. El programador debe estar
enterado de cualquiera de tales requerimientos de eficiencia cuando escriba su programa.
5. Programación estructurada, modular y descendente
Los términos programación modular, programación descendente y programación estructurada
se introdujeron en la segunda mitad de la década de los 60 y a menudo sus términos se
utilizan como sinónimos aunque no significan lo mismo.
5.1. Programación modular
La programación modular es uno de los métodos de diseño más flexible y potentes para
mejorar la productividad de un programa. En programación modular el programa se divide en
módulos (partes independientes), cada una de las cuales ejecuta una única actividad o tarea
y se codifican independientemente de otros módulo. Cada uno de estos módulos se analiza,
codifica y se pone a punto por separado.
Cada programa contiene un módulo denominado programa principal que controla todo lo que
sucede; se transfiere el control a submódulos (posteriormente se denominarán
subprogramas), de modo que ello puedan ejecutar sus funciones; sin embargo, cada
submódulo devuelve el control al modulo principal cuando se haya completado su tarea. Si la
tarea asignada a cada submódulo es demasiado compleja, éste deberá romperse en otros
módulos más pequeños. El proceso sucesivo de subdivisión de módulos continua hasta que
cada módulo tenga solamente una tarea especifica que ejecutar. Esta tarea puede ser
entrada, salida, manipulación de datos, control de otros módulos o alguna combinación de
éstos. Un módulo puede transferir temporalmente (bifurcar) el control a otro modulo; sin
embargo cada modulo debe eventualmente devolver el control al módulo del cual se recibe
originalmente el control.
Los módulos son independientes en el sentido en el que ningún módulo puede tener acceso
directo a cualquier otro módulo excepto el módulo al que llama y sus propios submódulos.
Sin embargo, los resultados producidos por un módulo pueden ser utilizados por cualquier
otro módulo cuando se transfiera a ellos el control.
Dado que los módulos son independientes, diferentes programadores pueden trabajar
simultáneamente en diferentes partes del mismo programa. Esto reducirá el tiempo del
diseño del algoritmo y posterior codificación del programa. Además, un módulo se puede
modificar radicalmente sin afectar a otros módulos, incluso sin alterar su función principal.
La descomposición de un programa en módulos independientes más simples se conoce
también como el método de "divide y vencerás" (divide and conquer). Se diseña cada módulo
con independencia de los demás, y siguiendo un método ascendente o descendente se
llegará hasta la descomposición final del problema en módulos en forma jerárquica.
8
Conceptos de programación
5.2. Diseño descendente (“TOP-DOWN”)
El diseño descendente (top-down) es el proceso mediante el cual un problema se
descompone en una serie de niveles o pasos sucesivos de refinamiento (stepwise). La
metodología descendente consiste en efectuar una relación entre las sucesivas etapas de
estructuración de modo que se relacionasen una con otras mediante entradas y salidas de
información. Es decir, se descompone el problema en etapas o estructuras jerárquicas, de
forma que se puede considerar cada estructura desde dos puntos de vista: ¿qué hacer? y
¿cémo lo hace?
5.3. Programación estructurada
Significa escribir un programa de acuerdo a las siguientes reglas:
¾
¾
¾
El programa tiene un diseño modular.
Los módulos son diseñados de modo descendente.
Cada módulo se codifica utilizando las tres estructuras de control básicas: secuencia,
selección y repetición.
El término programación estructurada se refiere a un conjunto de técnicas que han ido
evolucionando desde los primeros trabajos de Edsgar Dijkstra. Estas técnicas aumentan
considerablemente la productividad del programa reduciendo un elevado grado de tiempo
requerido para escribir, verificar, depurar y mantener los programas. La programación
estructurada utiliza un número limitado de estructuras de control que minimizan la
complejidad de los programas y por consiguiente reducen los errores; hace los programas
más fáciles de escribir, verificar, leer y mantener. Los programas deben estar dotados de
una estructura.
6. Programación estructurada
El creciente empleo de los ordenadores ha conducido a buscar un abaratamiento del
desarrollo de software, paralelo a la reducción del costo del hardware obtenido gracias a los
avances tecnológicos. Los altos costos del mantenimiento de las aplicaciones en producción
normal también han urgido la necesidad de mejorar la productividad del personal de
programación.
La programación estructurada (en adelante simplemente PE), es un estilo de programación
con el cual el programador elabora programas, cuya estructura es la más clara posible,
mediante el uso de tres estructuras básicas de control lógico: SECUENCIA, SELECCIÓN e
ITERACIÓN.
Un programa estructurado se compone de funciones, segmentos, módulos y/o subrutinas,
cada una con una sola entrada y una sola salida. Cada uno de estos módulos (aún en el
mismo programa completo), se denomina programa apropiado cuando, además de estar
compuesto solamente por las tres estructuras básicas, tiene sólo una entrada y una salida y
en ejecución no tiene partes por las cuales nunca pasa ni tiene ciclos infinitos.
La PE tiene un teorema estructural o teorema fundamental, el cual afirma que cualquier
programa, no importa el tipo de trabajo que ejecute, puede ser elaborado utilizando
únicamente las tres estructuras básicas (secuencia, selección, iteración).
9
Programación
6.1. Estructuras básicas de control lógico
Secuencia
Indica que las instrucciones de un programa se ejecutan una después de la otra, en el mismo
orden en el cual aparecen en el programa. Se representa gráficamente como una caja
después de otra, ambas con una sola entrada y una única salida.
Las cajas A y B pueden ser definidas para ejecutar desde una simple instrucción
hasta un módulo o programa completo, siempre y cuando que estos también sean
programas apropiados.
Selección
También conocida como la estructura SI-CIERTO-FALSO, plantea la selección entre dos
alternativas con base en el resultado de la evaluación de una condición o predicado;
equivale a la instrucción IF de todos los lenguajes de programación.
En el diagrama de flujo, C es una condición que se evalúa; A es la
acción que se ejecuta cuando la evaluación de este predicado resulta
verdadera y B es la acción ejecutada cuando indica falso. La
estructura también tiene una sola entrada y una sola salida; y las
funciones A y B también pueden ser cualquier estructura básica o
conjunto de estructuras.
Iteración
También llamada la estructura HACER-MIENTRAS-QUE, corresponde a la ejecución repetida
de una instrucción mientras que se cumple una determinada condición
Aquí el bloque A se ejecuta repetidamente mientras que la condición C se
cumpla o sea cierta. También tiene una sola entrada y una sola salida;
igualmente A puede ser cualquier estructura básica o conjunto de
estructuras.
10
Conceptos de programación
6.2. Ventajas de la programación estructurada
Con la PE, elaborar programas de computador sigue siendo una labor que demanda esfuerzo,
creatividad, habilidad y cuidado. Sin embargo, con este nuevo estilo podemos obtener las
siguientes ventajas:
I. Los programas son más fáciles de entender. Un programa estructurado puede ser leído en
secuencia, de arriba hacia abajo, sin necesidad de estar saltando de un sitio a otro en la
lógica, lo cual es típico de otros estilos de programación. La estructura del programa es
más clara puesto que las instrucciones están más ligadas o relacionadas entre si, por lo
que es más fácil comprender que hace cada función.
II. Reducción del esfuerzo en las pruebas. El programa se puede tener listo para producción
normal en un tiempo menor del tradicional; por otro lado, el seguimiento de las fallas o
depuración (debugging) se facilita debido a la lógica más visible, de tal forma que los
errores se pueden detectar y corregir más fácilmente.
III. Reducción de los costos de mantenimiento.
IV. Programas más sencillos y más rápidos.
V. Aumento en la productividad del programador.
VI. Se facilita la utilización de las otras técnicas para el mejoramiento de la productividad
en programación.
VII. Los programas quedan mejor documentados internamente.
11
Programación
7. Herramientas de programación
Las dos herramientas mas utilizadas comúnmente para diseñar algoritrnos son: diagramas de
flujo y pseudocódigos.
7.1. Pseudocódigo
El pseudocódigo es una herramienta de programación en la que las instrucciones se escriben
en palabras similares al inglés o al español, que facilitan tanto como la escritura como la
lectura del programa. En esencia, el pseudocódigo se puede definir como un lenguaje de
especificaciones de algoritrnos.
Aunque no existen reglas para escritura del pseudocódigo en español, se ha recogido una
notación estándar que ya es muy empleada en los libros de programación en español. Las
palabras reservadas básicas se representarán en letras negritas minúsculas. Estas palabras
son traducción libre de palabras reservadas de lenguajes como BASIC, pascal, etc.
7.2. Diagramas de flujo
Un diagrama de flujo (flowchart) es una representación grafica de un algoritmo. Los símbolos
utilizados han sido normalizados por el Instituto Norteamericano de Normalización (ANSI), y
los más frecuentemente empleados se muestran en la figura.
7.3. Tipos de estructuras
Un programa propio se puede escribir utilizando solamente tres tipos de sentencias:
SECUENCIALES, SELECTIVAS y REPETITIVAS.
12
Conceptos de programación
Estructura secuencial
Diagrama de flujo
Diagrama N-S
Pseudocódigo
Diagrama N-S
Pseudocódigo
Diagrama N-S
Pseudocódigo
Estructuras selectivas
Diagrama de flujo
Estructuras repetitivas
Mientras
Diagrama de flujo
13
Programación
Para
Diagrama de flujo
Diagrama N-S
Pseudocódigo
Diagrama N-S
Pseudocódigo
Hasta
Diagrama de flujo
8. Ciclo de programación
Las siguientes son las etapas que se deben cumplir para resolver con éxito un problema de
programación:
1. Definición del problema.
2. Análisis del problema.
3. Selección de la mejor alternativa.
4. Diagramación.
5. Prueba de escritorio.
6. Codificación.
7. Trascripción.
8. Traducción.
9. Pruebas de ordenador.
10. Documentación externa
14
Conceptos de programación
8.1. Definición del problema
Está dada por el enunciado del problema, el cual debe ser claro y completo. Es importante
que conozcamos exactamente que se desea del ordenador; mientras qué esto no se
comprenda, no tiene caso pasar a la siguiente etapa.
8.2. Análisis del problema
Entendido el problema (que se desea obtener del ordenador), para resolverlo es preciso
analizar:
a. Los datos o resultados que se esperan.
b. Los datos de entrada que nos suministran.
c. El proceso al que se requiere someter esos datos a fin de obtener los resultados
esperados. Áreas de trabajo, fórmulas y otros recursos necesarios.
Una recomendación muy práctica es el que nos pongamos en el lugar del ordenador, y
analizar que es necesario que me ordenen y en que secuencia, para poder producir los
resultados esperados. También da buenos resultados hacer similitudes con la labor de un
empleado que hace el mismo trabajo que deseamos programarle al ordenador.
8.3. Selección de la mejor alternativa
Analizado el problema, posiblemente tengamos varias formas de resolverlo; lo importante es
determinar cual es la mejor alternativa: la que produce los resultados esperados en el menor
tiempo y al menor costo. Claro que aquí también es muy válido el principio de que las cosas
siempre se podrán hacer de una mejor forma.
8.4. Diagramación
Una vez que sabemos cómo resolver el problema, pasamos a dibujar gráficamente la lógica
de la alternativa seleccionada. Eso es precisamente un Diagrama de Flujo: la representación
gráfica de una secuencia lógica de pasos a cumplir por el ordenador para producir un
resultado esperado.
La experiencia nos ha demostrado que resulta muy útil trasladar esos pasos lógicos
planteados en el diagrama a frases que indiquen lo mismo; es decir, hacer una codificación
del programa pero utilizando instrucciones por escrito. Como si le estuviéramos hablando al
computador. Esto es lo que denominaremos Algoritmo o Pseudocódigo.
Cuando logremos habilidad para desarrollar programas, es posible que no elaboremos el
diagrama de flujo; en su lugar podremos hacer directamente el pseudocódigo del programa.
8.5. Prueba de escritorio
Para cercioramos de que el diagrama (y/o el pseudocódigo) esta bien, y, para garantizar que
el programa que codifiquemos luego también funcione correctamente, es conveniente
someterlo a una Prueba de Escritorio. Esta prueba consiste en que damos diferentes datos de
15
Programación
entrada al programa y seguimos la secuencia indicada en el diagrama, hasta obtener los
resultados. El análisis de estos nos indicará si el diagrama esta correcto o si hay necesidad de
hacer ajustes (volver al paso 4). Se recomienda dar diferentes datos de entrada y considerar
todos los posibles casos, incluyendo los de excepción o no esperados, para aseguramos de
que el programa no producirá errores en ejecución cuando se presenten estos casos.
8.6. Codificación
Una vez que hayamos verificado el diagrama mediante las pruebas de escritorio, codificamos
el programa en el lenguaje de ordenador seleccionado. Esto es, colocamos cada paso del
diagrama en una instrucción o sentencia, utilizando un lenguaje que el ordenador reconoce.
Todos los lenguajes de programación proveen facilidades para incluir líneas de comentarios
en los programas. Estos comentarios aclaran lo que se ordena al ordenador y facilitan
entender el programa. Puesto que estos comentarios no son tenidos en cuenta como
instrucciones, y aparecen en los listados del programa, resulta muy conveniente agregar
abundantes comentarios a todo programa que codifiquemos. Esto es lo que se denomina
Documentación Interna.
8.7. Trascripción
El programa codificado es necesario que lo llevemos a un medio que sea aceptado como
entrada por el ordenador: lo grabamos en el un disco duro u otro medio. Este programa es el
que se conoce como Programa Fuente (Source).
8.8. Traducción
Utilizamos ahora un programa de ordenador llamado Compilador o Traductor, el cual analiza
todo el programa fuente y detecta errores de sintaxis ocasionados por fallas en la
codificación o en la trascripción. Las fallas de lógica que pueda tener nuestro programa
fuente no son detectadas por el compilador. Cuando no hay errores graves en la compilación,
el compilador traduce cada instrucción del programa fuente a instrucciones propias de la
máquina (Lenguaje de Maquina), creando el Programa Objeto.
Algunos ordenadores utilizan Interpretadores, (Generalmente para el Lenguaje Basic), en
reemplazo de programas compiladores. La diferencia consiste en que el interpretador recibe,
desde una terminal, sólo una instrucción a la vez, la analiza y, si esta bien, la convierte al
formato propio de la maquina. Si la instrucción tiene algún error, el interpretador llama la
atención de la persona para que corrija dicha instrucción.
Como resultado de la ejecución del compilador, podemos obtener varios listados:
•
•
•
Listado del programa fuente
Listado de los errores detectados
Listado de campos utilizados, etc.
Los errores los debemos corregir sobre el mismo programa fuente, volviendo ha grabar el
fichero fuente. Este paso de la compilación lo repetimos hasta eliminar todos los errores y
obtener el programa ejecutable.
16
Conceptos de programación
8.9. Pruebas de ordenador
Cuando tenemos el programa ejecutable (en lenguaje de maquina), ordenamos al
computador que lo ejecute, para lo cual suministramos datos de prueba, como lo hicimos en
la prueba de escritorio (paso 5). Los resultados obtenidos los analizamos, luego de lo cual
puede ocurrir cualquiera de estas situaciones:
a) La lógica del programa esta bien, pero hay errores sencillos, los cuales los corregimos
modificando algunas instrucciones o incluyendo unas nuevas; el proceso debemos
repetido desde el paso 6.
b) Hay errores ocasionados por fallas en la lógica, lo que nos obliga a regresar a los pasos 4
y 5 para revisión y modificación del diagrama.
c) Hay errores muy graves y lo más aconsejable es que regresemos al paso 2 para analizar
nuevamente el problema, y repetir todo el proceso.
d) No hay errores y los resultados son los esperados. En este caso, el programa lo podemos
guardar permanentemente en una librería o biblioteca del ordenador, para sacado de allí
cuando necesitemos ejecutarlo nuevamente.
8.10. Documentación externa
Cuando el programa ya se tiene listo para ejecutar, es conveniente que hagamos su
documentación externa siguiendo las normas de la instalación. Una buena documentación
incluye siempre:
a. Enunciado del problema.
b. Diagrama de pasada.
c. Narrativo con la descripción de la solución.
d. Relación de las variables o campos utilizados en el programa, cada uno con su respectiva
función.
e. Diagrama del programa.
f. Listado de la última compilación.
g. Resultados de la ejecución del programa.
9. Programación Orientada a Objetos
La programación orientada a objetos no es un concepto nuevo, sus inicios y técnicas de
programación se iniciaron a principios de los 70. Se puede definir programación orientada a
objetos (OOPS) como una técnica de programación que utiliza objetos como bloque esencial
de construcción. La OOPS, es un tipo de programación más cercana al razonamiento humano.
La OOPS surge como una solución a la programación de grandes programas, y para solventar
el mantenimiento de dichas aplicaciones, ya que en la programación estructura el más
mínimo cambio supone la modificación de muchas funciones relacionadas, en cambio con la
OOPS solo es cuestión de añadir o modificar métodos de una clase o mejor, crear una nueva
clase a partir de otra (Herencia).
Concepto de Objeto: Desde un punto de vista general un Objeto es una estructura de datos
de mayor o menor complejidad con las funciones que procesan estos datos. Dicho de otra
forma, sería Datos más un Código que procesa estos datos. A los datos se les denomina
miembros dato y a las funciones miembro o miembro funciones. Los datos están ocultos y
sólo se puede acceder a ellos mediante las funciones miembro.
Clases: Las Clases son como plantillas o modelos que describen como se construyen ciertos
tipos de Objeto. Cada vez que se construye un Objeto de una Clase, se crea una instancia de
esa Clase ("instance"). Una Clase es una colección de Objetos similares y un Objeto es una
17
Programación
instancia de una Clase. Se puede definir una Clase como un modelo que se utiliza para
describir uno o más Objetos del mismo tipo.
Herencia: Una característica muy importante de los Objetos y las Clases es la Herencia, una
propiedad que permite construir nuevos Objetos (Clases) a partir de unos ya existentes. Esto
permite crear "Sub-Clases" denominadas Clases Derivadas que comparten las propiedades de
la Clase de la cual derivan (Clase base). Las Clases derivadas heredan código y datos de la
clase base, asimismo incorporan su propio código y datos especiales. Se puede decir que la
herencia permite definir nuevas Clases a partir de las Clases ya existentes.
Polimorfismo: En un sentido literal, Polimorfismo significa la cualidad de tener más de una
forma. En el contexto de POO, el Polimorfismo se refiere al hecho de que una simple
operación puede tener diferente comportamiento en diferentes objetos. En otras palabras,
diferentes objetos reaccionan al mismo mensaje de modo diferente. Los primeros lenguajes
de POO fueron interpretados, de forma que el Polimorfismo se contemplaba en tiempo de
ejecución. Por ejemplo, en C++, al ser un lenguaje compilado, el Polimorfismo se admite
tanto en tiempo de ejecución como en tiempo de compilación
10. Introducción al Lenguaje C
10.1. Un poco de historia
El lenguaje C fue diseñado en los años sesenta por Dennis Ritchie, de los Laboratorios Bell
con el propósito de ser el lenguaje del sistema operativo UNÍX. La base del C proviene del
BCPL, escrito por Martin Richards, y del B escrito por Ken Thompson en 1970 para el primer
sistema UNIX en un DEC PDP- 7. Estos son lenguajes sin tipos, al contrario que el C que
proporciona varios tipos de datos.
En 1978 Kemighan y Ritchie publican su descripción en el libro "The C Programming
Language", versión que es llamada hoy en día 'K&R C'. Es un libro que explica y justifica
totalmente el desarrollo de aplicaciones en C, aunque en él se utilizaban construcciones en
la definición de funciones, que podían provocar confusión y errores de programación que no
eran detectados por el compilador.
A mediados de los ochenta ya había en el mercado numerosos compiladores C, y muchas
aplicaciones habían sido rescritas a él para aprovechar sus ventajas. Desde su nacimiento se
fue implantando como el lenguaje de programación de sistemas favorito para muchos
programadores, sobre todo por ser un lenguaje que conjugaba la abstracción de los lenguajes
de alto nivel con la eficiencia del lenguaje máquina. Los programadores de sistemas que
trabajaban sobre MS-DOS y Macintosh también utilizaban C, con lo cual la práctica totalidad
de aplicaciones de sistema para microordenadores y para sistemas UNIX está escrito en este
lenguaje.
Durante este periodo de tiempo numerosos fabricantes introducen mejoras en el lenguaje,
las cuales son recogidas por un comité de estandarización ANSI y establecen las
especificaciones de lo que se conoce hoy en día como 'ANSI C'.
El estándar está basado en el manual de referencia original de 1972 y se desarrolla con el
mismo espíritu de sus creadores originales. La primera versión de estándar se publicó en
1988 y actualmente todos los compiladores utilizan la nueva definición. Una aportación muy
importante de ANSI consiste en la definición de un conjunto de librerías que acompañan al
compilador y de las funciones contenidas en ellas. Muchas de las operaciones comunes con el
sistema operativo se realizan a través de estas funciones. Una colección de ficheros de
encabezamiento, headers, en los que se definen los tipos de datos y funciones incluidas en
18
Conceptos de programación
cada librería. Los programas que utilizan estas bibliotecas para interactuar con el sistema
operativo obtendrán un comportamiento equivalente en otro sistema.
A mediados de los ochenta se crea el C++, extensión de C orientada a objetos. El C++ se
convierte en estándar ISO en 1998. En el momento actual, el lenguaje C no va a modificarse
más. Será el C++ el que incorporará nuevos cambios.
10.2. Características
C es un lenguaje de programación de propósito general que ofrece economía sintáctica,
control de flujo y estructuras sencillas y un buen conjunto de operadores. No es un lenguaje
de muy alto nivel y es más bien un lenguaje pequeño, sencillo y que no está especializado en
ningún tipo de aplicación. Esto lo hace un lenguaje potente, con un campo de aplicación
ilimitado y sobre todo, se aprende rápidamente ya que en poco tiempo, un programador
puede utilizar la totalidad del lenguaje.
Nivel medio
El C se encuentra en la jerarquía de lenguajes en un nivel intermedio entre Pascal y el
Ensamblador. Pretende ser un lenguaje de alto nivel con la versatilidad de los de bajo nivel.
El lenguaje C se conoce como un lenguaje compilado. Los compilados convierten el código
fuente en un fichero objeto y éste en un fichero ejecutable. Los interpretados son aquellos
que necesitan del código fuente para funcionar.
Portable
Este lenguaje ha sido estrechamente ligado al sistema operativo UNIX, puesto que fueron
desarrollados conjuntamente. Sin embargo, este lenguaje no está ligado a ningún sistema
operativo ni a ninguna máquina concreta. Se le suele llamar lenguaje de programación de
sistemas debido a su utilidad para escribir compiladores y sistemas operativos, aunque de
igual forma se puede desarrollar cualquier tipo de aplicación.
Una de las características más apreciadas de C es su gran portabilidad, gracias a que deja en
manos de librerías las funciones dependientes de la máquina, por ejemplo, la entrada/salida
no se considera parte del lenguaje en sí, sino que se suministra a través de funciones de
librería. La misma política se sigue con cualquier otro tipo complejo de instrucciones.
Eficiente
C trabaja con tipos de datos que son directamente tratables por el hardware de la mayoría
de los ordenadores actuales, como son los caracteres, números y direcciones. Estos tipos de
datos pueden ser manipulados por las operaciones aritméticas que proporcionan los
ordenadores. No proporciona mecanismos para tratar tipos de datos que no sean los básicos,
debiendo ser el programador el que los desarrolle. Esto permite que el código generado sea
muy eficiente y de ahí el éxito que ha tenido como lenguaje de desarrollo de sistemas. No
proporciona otros mecanismos de almacenamiento de datos que no sea el estático y no
proporciona mecanismos de entrada ni salida. Ello permite que el lenguaje sea reducido y los
compiladores de fácil implementación en distintos sistemas. Por contra, estas carencias se
compensan mediante la inclusión de funciones de librería para realizar todas estas tareas,
que normalmente dependen del sistema operativo.
El compilador debe ser lo más pequeño y eficiente posible. Pocas palabras reservadas, esto
es, un conjunto reducido de sentencias. No existe anidamiento de procedimientos. Con ello
se llegó a un compilador con un poderoso juego de instrucciones, que permite aumentar la
productividad/día de los programadores ya que para escribir un programa se debe escribir
19
Programación
poco texto. Para lograr esto se reduce el número de palabras claves. A pesar de ello el C es
un lenguaje rápido de aprender, que deriva en compiladores sencillos de diseñar, robustos, y
que generan objetos pequeños y eficientes.
10.3. Desventajas
Dentro de las principales críticas que se le achacan podemos destacar:
ƒ
ƒ
ƒ
ƒ
ƒ
ƒ
ƒ
Lo poco estricto que es el lenguaje con la comprobación de los tipos de datos, dejando
esta tarea muchas veces en manos del programador.
El no verificar automáticamente los límites de los vectores.
La repetición que hace de símbolos en operadores diferentes (=,*,-). (Sobrecarga de
operadores).
Es muy poco modular: al no poder anidar funciones, con lo que se dificulta la
estructuración y la abstracción de datos.
La incertidumbre existente en el orden de evaluación de las listas de expresiones y
parámetros.
La facilidad con que los programas pueden derivar hacia ser crípticos.
Es difícil leer código escrito por otras personas
10.4. Aplicaciones
Estas y otras características lo hacen adecuado para la programación en tareas tales como:
ƒ
ƒ
ƒ
ƒ
ƒ
programación de sistemas: sistemas operativos, intérpretes, editores,
ensambladores, compiladores
estructuras de datos y sistemas de bases de datos
aplicaciones científicas
software gráfico
análisis numérico
10.5. Tipos
Algunos de las C existentes son: Quick C, C++, Turbo C, Turbo C ++, Borland C, Borland C++,
Microsoft C ....
20