¡Descarga aprender a programar y más Apuntes en PDF de Informática solo en Docsity!
EEEE SCUELASCUELASCUELASCUELA SSSS UPERIOR DEUPERIOR DEUPERIOR DEUPERIOR DE
IIII NGENIEROS DENGENIEROS DENGENIEROS DENGENIEROS DE
SSSS ANANANAN SSSS EBASTIÁNEBASTIÁNEBASTIÁNEBASTIÁN
TECNUNTECNUNTECNUNTECNUN
APRENDAAPRENDAAPRENDAAPRENDA
AAAA PROGRAMARPROGRAMARPROGRAMARPROGRAMAR
COMOCOMOCOMOCOMO SISISISI ESTUVIERAESTUVIERAESTUVIERAESTUVIERA
ENENENEN PRIMEROPRIMEROPRIMEROPRIMERO
IIII KERKERKERKER AAAA GUINAGAGUINAGAGUINAGAGUINAGA
GGGG ONZALOONZALOONZALOONZALO MMMM ARTÍNEZARTÍNEZARTÍNEZARTÍNEZ
JJJJ AVIERAVIERAVIERAVIER DDDD ÍAZÍAZÍAZÍAZ
Esta publicaciÛn tiene la ˙nica finalidad de facilitar el estudio y trabajo de los alumnos de la asignatura.
Ni los autores ni la Universidad de Navarra perciben cantidad alguna por su ediciÛn o reproducciÛn.
Õndice
- CapÌtulo 1 Los programas ÕNDICE
- 1.1 øQuÈ es un programa?
- 1.2 øQuÈ es un lenguaje de programaciÛn?
- 1.3 Las cuatro patas de la programaciÛn
- 1.4 Lenguajes de programaciÛn....................................................................................
- 1.4.1 Lenguajes de alto y bajo nivel
- 1.4.2 Lenguajes imperativos y funcionales
- 1.4.3 Lenguajes interpretados y compilados
- 1.4.4 Lenguajes que soportan la programaciÛn estructurada....................................
- 1.4.5 Lenguajes fuertemente y dÈbilmente ìtipadosî...............................................
- 1.4.6 Lenguajes que soportan la programaciÛn orientada a objetos.........................
- 1.5 Errores
- 1.5.1 Errores de sintaxis
- 1.5.2 Errores lÛgicos.................................................................................................
- 1.5.3 Debugger
- CapÌtulo 2 Estructuras fundamentales de los datos
- 2.1 IntroducciÛn............................................................................................................
- 2.2 Las variables y las constantes.................................................................................
- 2.3 Tipos de datos.......................................................................................................
- 2.3.1 Variables booleanas.......................................................................................
- 2.3.2 N˙meros enteros
- 2.3.3 N˙meros de coma flotante.............................................................................
- 2.3.4 Caracteres
- 2.4 Datos estructurados
- 2.4.1 Vectores y cadenas de caracteres...................................................................
- 2.4.2 Matrices
- 2.4.3 Estructuras
- CapÌtulo 3 El flujo de un programa
- 3.1 IntroducciÛn..........................................................................................................
- 3.2 El origen de los diagramas de flujo
- 3.3 Elementos de un diagrama de flujo
- 3.4 Desarrollo de un diagrama de flujo para un proceso cotidiano
- 3.5 Instrucciones.........................................................................................................
- 3.6 Operaciones aritmÈtico lÛgicas.............................................................................
- 3.6.1 El operador de asignaciÛn
- 3.6.2 Operadores aritmÈticos o matem·ticos..........................................................
- 3.6.3 Operadores relacionales.................................................................................
- 3.6.4 Operadores lÛgicos
- 3.7 Bifurcaciones
- 3.7.1 Sentencia if
- 3.7.2 Sentencia if else
- 3.7.3 Sentencia if elseif... else m˙ltiple
- 3.8 Bucles Escuela Superior de Ingenieros de San Sebastián
- 3.8.1 Bucle While
- 3.8.2 Bucle For
- 3.8.3 Anidamiento de bucles
- CapÌtulo 4 Funciones o procedimientos
- 4.1 IntroducciÛn..........................................................................................................
- 4.2 Funciones o procedimientos - Ejemplo 1. FunciÛn matem·tica - Ejemplo 2. Derivada numÈrica de la anterior funciÛn matem·tica - Ejemplo 3. FunciÛn que obtiene las raÌces de un polinomio de 2∫ grado........
- CapÌtulo 5 Algoritmos
- 5.1 IntroducciÛn..........................................................................................................
- 5.2 Algoritmos directos - Ejemplo 4. Algoritmo para saber si el n˙mero 5 es primo - Ejemplo 5. Determinar el tipo de raÌces de un polinomio de segundo grado..
- 5.3 Algoritmos iterativos - Ejemplo 6. Determinar iterativamente si un n˙mero N es o no primo............ - Ejemplo 7. Mejora del algoritmo para calcular si un n˙mero N es primo - Ejemplo 8. ObtenciÛn del factorial de un n˙mero N iterativamente - Ejemplo 9. DescomposiciÛn factorial de un n˙mero N...................................
- 5.4 Algoritmos recursivos - Ejemplo 10. ObtenciÛn del factorial de un n˙mero N recursivamente - Ejemplo 11. Determinar recursivamente si un n˙mero N es o no primo - Ejemplo 12. El tri·ngulo de Sierpinski............................................................
- 5.5 Algoritmos de prueba y error................................................................................
- 5.5.1 Algoritmos iterativos de prueba y error.........................................................
- Ejemplo 13. MÈtodo de Newton Rapshon de manera iterativa
- Ejemplo 14. C·lculo de las dimensiones Ûptimas de un cilindro.
- 5.5.2 Algoritmos recursivos de prueba y error
- Ejemplo 15. MÈtodo de Newton-Rapshon de manera recursiva
- Ejemplo 16. El viaje del caballo......................................................................
- Ejemplo 17. El problema de los emparejamientos estables.............................
v
INTRODUCCI”N AL MANUAL
Este manual est· dirigido en primer lugar a los alumnos que cursan primero en la escuela de Ingenieros de San Sebasti·n y se encuentran realizando la asignatura de Informática 1 o Fundamentos de Computadores.
Pretende servir para que las personas nÛveles se introduzcan en la lÛgica de la programaciÛn y, someramente, en los lenguajes de programaciÛn.
Es un libro esencialmente pr·ctico. No porque los ejemplos que en Èl aparecen sirvan para algo, sino porque rehuye de posibles elucidaciones abstractas -aun siendo estas tan necesarias para el desarrollo de la lÛgica computacional.
Es un manual que complementa a la colecciÛn de manuales "Aprenda Informática como si estuviera en Primero" publicados en TECNUN. Estos manuales son muy ˙tiles para introducirse en el lenguaje de programaciÛn del que versan. Sin embargo, este manual no est· orientado a aprender ning˙n lenguaje de programaciÛn, sino a incentivar al lector para que aprenda a razonar los pasos necesarios para realizar una tarea acertadamente. Esto es, para que aprenda a programar.
El sustrato de este manual es la experiencia de los autores y los libros cl·sicos de algoritmia. Los ejemplos que se presentan plantean problemas que no necesitan un conocimiento profundo de matem·ticas para entender su planteamiento y resoluciÛn. Son, en muchos casos, ejemplos universalmente conocidos.
La primera parte del manual, hasta el capÌtulo 4 incluido, esboza el estado del arte y expone los rudimentos necesarios para la programaciÛn. Se enseÒan los elementos com˙nmente utilizados en distintos lenguajes; principalmente, cÛmo se estructura la informaciÛn y como se controla el flujo de un programa. El capÌtulo 5 presenta una agrupaciÛn de algoritmos con ejemplos. Como se ha comentado anteriormente, no es intenciÛn del manual tratar con lenguajes de programaciÛn, pero la necesidad de aplicar los algoritmos que se presentan hace inevitable recurrir a Èstos. En concreto nos hemos decantado por utilizar Matlab debido a sus simplificadoras ventajas.
TipografÌa utilizada
Para indicar... Este manual utiliza... Ejemplo
Variables Negrita M es una matriz LÌneas del programa
Negrita con tamaÒo de letra pequeÒo
i=i+
Funciones Negrita e Itálica La funciÛn sin(Fi) devuelve el seno del ·ngulo Fi.
Capítulo 1 Los programas
1.1 ¿Qué es un programa?
Un programa de ordenador es una secuencia de instrucciones que el ordenador debe seguir para realizar una tarea. Habitualmente, aunque no obligatoriamente, estas instrucciones se aplican sobre un conjunto de datos que sirven como entrada para el programa, y produce como resultado otra serie de datos que se derivan de los primeros al aplicar sobre los datos de entrada las instrucciones.
Debido a las capacidades de los actuales microprocesadores digitales, absolutamente todos los datos se representan de forma numÈrica y digital. Aunque esto pueda parecer inicialmente una limitaciÛn es en realidad la causa de la enorme flexibilidad y poder de las modernas computadoras.
1.2 ¿Qué es un lenguaje de programación?
Como los lenguajes humanos, los lenguajes de programaciÛn son herramientas de comunicaciÛn, pero al contrario que los lenguajes corrientes como el inglÈs o el chino, los destinatarios de los lenguajes de programaciÛn no son sÛlo humanos sino tambiÈn los ordenadores.
El propÛsito general de un lenguaje de programaciÛn es permitir a un ser humano (el programador) traducir la idea de un programa en una secuencia de instrucciones que el ordenador sea capaz de ejecutar.
1.3 Las cuatro patas de la programación
Las cuatro patas de la programaciÛn son:
Los datos
Los bucles
Las bifurcaciones
Las funciones
Los datos que almacena un ordenador son siempre n˙meros. Incluso las letras almacenadas en un ordenador se almacenan como n˙meros; en este caso los n˙meros codifican una letra (por ejemplo, la letra "a" es el n˙mero 97 en la codificaciÛn ASCII). Los datos se pueden almacenar ordenadamente como:
P·gina 2 Aprenda a programar como si estuviera en Primero
Escuela Superior de Ingenieros de San Sebastián
Datos individuales Vectores Matrices Hipermatrices Jugando con estos n˙meros se consiguen hacer los programas. Las herramientas de las que disponen los lenguajes de programaciÛn para jugar con los datos son los bucles y las bifurcaciones, con quienes se controla el flujo del programa.
Por ˙ltimo hay que destacar que la programaciÛn exige orden. El orden se consigue separando las distintas subrutinas que componen el programa y esto se consigue mediante las funciones. El conjunto de las distintas funciones y subrutinas conforman el programa.
1.4 Lenguajes de programación
Existe una cantidad gigantesca de lenguajes de programaciÛn distintos (incluidos muchos dialectos), y muchas formas de clasificarlos. A continuaciÛn se ver·n algunas de las m·s importantes y se nombrar·n algunos de los lenguajes m·s populares, o importantes, en cada una de las categorÌas.
1.4.1 Lenguajes de alto y bajo nivel
Esta clasificaciÛn divide a los lenguajes seg˙n la proximidad de las instrucciones que emplea el programador a las instrucciones que fÌsicamente emplea el procesador de una computadora. Estas ˙ltimas son en general muy sencillas y tienen un valor numÈrico que las define. Aunque es posible crear un programa empleando directamente estos valores numÈricos, en cuanto un programa alcanza unas pocas decenas de instrucciones comienza a ser completamente inmanejable.
P·gina 4 Aprenda a programar como si estuviera en Primero
Escuela Superior de Ingenieros de San Sebastián
1.4.3 Lenguajes interpretados y compilados
El cÛdigo de un programa suele escribirse en uno o varios ficheros de texto. Este cÛdigo que es interpretable por un humano (o al menos debiera serlo) no puede ser ejecutado directamente por el computador.
En los lenguajes interpretados, existe un programa llamado intÈrprete que lee las lÌneas de cÛdigo y las ejecuta inmediatamente. Muchos intÈrpretes admiten dos modos de empleo: interactivo y de script. En el primer caso, el intÈrprete muestra un sÌmbolo y se queda esperando a que el usuario introduzca las lÌneas a ejecutar una a una, ejecut·ndolas inmediatamente. En el segundo, el usuario proporciona uno o m·s ficheros al intÈrprete que ejecutar· todas las lÌneas una tras otra. Matlab es un lenguaje interpretado que admite estas dos formas de ejecuciÛn, la primera se realiza escribiendo el cÛdigo a ejecutar en la ventana de comandos, mientras que la segunda forma es la que se lleva a cabo al emplear ficheros .m. En cambio Visual Basic, que tambiÈn es un lenguaje interpretado, sÛlo admite la segunda forma.
Aunque los lenguajes interpretados suelen ser relativamente sencillos de emplear y son muy flexibles, no suelen ser muy eficientes, ya que se mezcla la tarea de interpretaciÛn y proceso del cÛdigo con la ejecuciÛn de este cÛdigo. Para evitar este problema y que los programas puedan aprovechar completamente los recursos de un ordenador, el cÛdigo de un programa puede ser convertido de forma completa en cÛdigo binario que el procesador pueda ejecutar directamente. Este proceso se denomina compilaciÛn y se emplea en lenguajes que requieran un gran rendimiento como C++.
Adem·s se han desarrollado algunos lenguajes, en particular Java y C#, que en lugar de compilar el cÛdigo a la forma binaria que emplea el procesador concreto de una determinada arquitectura, se compila en un cÛdigo intermedio no ejecutable directamente. Posteriormente, este cÛdigo intermedio se traduce a instrucciones que el procesador puede ejecutar directamente antes de ser ejecutado. Este sistema permite ejecutar programas en cualquier procesador aunque tenga distintas instrucciones^1 siempre que exista el programa que sea capaz de traducir las instrucciones intermedias. En cualquier caso esta flexibilidad tiene un precio, ya que el rendimiento de un programa escrito en uno de estos lenguajes siempre es menor que el de un programa compilado. No obstante, lenguajes con la versatilidad de interpretaciÛn como la que presenta Java, resultan particularmente interesantes para aplicaciones en Internet, donde van a interactuar distintos procesadores a travÈs de la red.
1.4.4 Lenguajes que soportan la programación
estructurada
Estos lenguajes son lenguajes de alto nivel que ofrecen una serie de construcciones de control del flujo del programa como son:
- Las bifurcaciones, donde un bloque de cÛdigo se ejecutar· dependiendo de una condiciÛn.
(^1) Las instrucciones de los x86 de los AMD Athlon o Intel Pentium, son distintas e incompatibles con las
de los procesadores PowerPC que se encuentras en servidores de IBM, los Macintosh de Apple o las futuras Playstation 3 o X Box 2, y a su vez estas son incompatibles con los procesadores Sparc de las estaciones de trabajo de Sun Microsystems, los MIPS de las estaciones de trabajo de Silicon Grafics, los Intel Xscale de los PDA Pocket PC, o de los procesadores Intel Itanium que tambiÈn se emplean en estaciones de trabajo y servidores.
CapÌtulo 1 Los programas P·gina 5
TECNUN-Parque tecnológico de la Universidad de Navarra
- Los bucles, donde un bloque de cÛdigo se ejecutar· de forma repetida o bien mientras que se cumpla una condiciÛn (WHILE) o bien un n˙mero determinado de veces (FOR).
- Las funciones, que son bloques autÛnomos e independientes de cÛdigo que se encargan de realizar una operaciÛn concreta, y que pueden recibir datos de otras partes del programa en forma de par·metros y que pueden devolver uno o m·s valores al terminar de ejecutarse. Entre los lenguajes que soportan la programaciÛn estructurada se encuentra Matlab, C, C++, Fortran, Pascal, Modula, etc.
1.4.5 Lenguajes fuertemente y débilmente “tipados”
Bajo este tÌtulo tan extraÒo se encuentra una de las diferencias m·s deteminantes entre los distintos lenguajes de programaciÛn.
Un lenguaje dÈbilmente ìtipadoî no define de forma explÌcita el tipo de las variables (y por lo tanto las operaciones que son v·lidas con la variable), sino que el tipo de variable se determina durante la ejecuciÛn, en funciÛn de los valores que se les asignan. Matlab pertenece a este grupo de lenguajes:
a= a=îHola mundoî
Como puede observarse, la variable a almacena indistintamente un n˙mero entero (3) y una cadena de caracteres ("Hola mundo"). Por el contrario en un lenguaje fuertemente tipado, se determina de forma explÌcita el tipo de las variables (y de nuevo las operaciones que son v·lidas), el siguiente cÛdigo no es v·lido en un lenguaje fuertemente tipado como C++ (nÛtese que int indica que la variable es un n˙mero entero):
int a=3; a=îHola mundoî; // error no se puede asignar una cadena de caracteres a un entero directamente
1.4.6 Lenguajes que soportan la programación orientada a
objetos
La programaciÛn orientada a objetos supone un cambio de mentalidad a la hora de programar ya que se pasa de trabajar con instrucciones y datos por separado a unirlos en lo que se denomina un objeto. De hecho el tipo de un objeto queda definido por las operaciones que pueden realizarse sobre Èl y no por los datos que contiene. Los tipos de los objetos se pueden definir en estos lenguajes mediante clases. La programaciÛn orientada a objetos permite el desarrollo de aplicaciones enormemente complejas de una forma m·s estructurada y robusta que mediante sÛlo la programaciÛn estructurada (que todos los lenguajes orientados a objetos soportan). Existe una gran cantidad de lenguajes que soportan este paradigma: C++, Java, C#, Simula, Smalltalk, Eiffel, Python, Ada, Lisp, OCaml, etc.
1.5 Errores
Antes de continuar, es importante diferenciar los dos tipos de errores que suelen aparecer con m·s frecuencia cuando se programa en cualquier lenguaje de programaciÛn.
CapÌtulo 1 Los programas P·gina 7
TECNUN-Parque tecnológico de la Universidad de Navarra
El debugger permite comprobar como se ejecuta en la realidad un programa y supone una ayuda inestimable en el desarrollo de programas.
No hay otra alternativa que acostumbrarse a utilizarlo. El perfil de la persona que utilizar el debugger es el siguiente:
- Persona de edad variable que no le gusta perder mucho tiempo programando.
- Antes de programar lee atentamente las especificaciones.
- Dedica tiempo a pensar cÛmo hacer el programa y en cÛmo gestionar la informaciÛn necesaria.
- Sabe lo que quiere programar aunque no lo haya conseguido.
- Sabe lo que tiene que hacer el programa.
- Tiene un papel, folio u hoja a su lado con el esquema del programa. En cambio, el perfil de la persona que NO utiliza el debugger es este:
- Persona joven que se inicia a la programaciÛn y que dispone de mucho tiempo por delante para hacer un programa.
- No entiende lo que Èl mismo ha programado aunque insiste en escribir alguna que otra instrucciÛn por ver si pasa algo.
- Tiende a mantener aquellas lÌneas de cÛdigo que no dan errores y a borrar aquellas lÌneas de las que se queja el PC.
- No suele tener un papel o folio a su lado y, cuando lo tiene, Èste se encuentra en blanco.
P·gina 10 Aprenda a programar como si estuviera en Primero
Escuela Superior de Ingenieros de San Sebastián
2.3 Tipos de datos
Internamente los ordenadores trabajan con una representaciÛn binaria (mediante unos y ceros) de los n˙meros. Esta forma de representar la informaciÛn es muy adecuada a la hora de fabricar los circuitos electrÛnicos ya que:
- Es la forma m·s b·sica de discernir.
- Un 1 y un 0 son muy diferentes elÈctricamente (tradicionalmente son 5 V de diferencia) por lo que es difÌcil que se confundan entre sÌ. Sin embargo hacer un programa directamente con unos y ceros es pr·cticamente imposible. Preferimos utilizar palabras para las instrucciones y n˙meros en base 10. De ahÌ que los lenguajes de programaciÛn ofrezcan la posibilidad de utilizar distintos tipos variables para almacenar la distinta informaciÛn.
A continuaciÛn se especifica la tipologÌa de variables m·s comunes en los distintos lenguajes.
2.3.1 Variables booleanas
Una variable booleana sÛlo puede tener dos valores, verdadero o falso. Para representar una variable booleana sÛlo se necesita un bit (precisamente un bit es la cantidad mÌnima de informaciÛn y sÛlo puede tener dos valores: 1 y 0), haciendo corresponder el valor 1 a verdadero y 0 falso. No obstante, hay que aÒadir que, en general, los computadores no son capaces de trabajar directamente con un solo bit, sino que trabajan con un paquete mÌnimo de 8 bit. Esta cantidad es conocida como byte.
Existe una serie de operadores que permiten trabajar con variables booleanas, de forma que se pueden agrupar y formar expresiones complejas. Los m·s habituales son los siguientes (empleando la sintaxis de Matlab):
Operador and (&): 1 & 1 = 1 1 & 0 = 0 0 & 1 = 0 0 & 0 = 0 Operador or ( | ): 1 | 1 = 1 1 | 0 = 1 0 | 1 = 1 0 | 0 = 0 Operador not (~): ~ 1 = 0 ~ 0 = 1
Estas relaciones se suelen escribir en tablas que muestran los posibles resultados de una de estas operaciones para todas las posibles entradas. Estas tablas reciben el nombre de tablas de verdad. La siguiente tabla muestra la tabla de verdad correspondiente al operador lÛgico AND y OR, respectivamente:
AND verdadero falso verdadero verdadero falso
falso falso falso
El resultado de una operaciÛn AND es verdadero si los dos operandos son verdaderos.
OR verdadero falso verdadero verdadero verdadero
falso verdadero falso
CapÌtulo 2 Estructuras fundamentales de los datos P·gina 11
TECNUN-Parque tecnológico de la Universidad de Navarra
El resultado de una operaciÛn OR es verdadero si, al menos, uno de los dos operandos es verdadero.
2.3.2 Números enteros
Los n˙meros enteros suelen emplearse con gran frecuencia en programaciÛn, ya que su procesamiento es muy r·pido y existen muchas operaciones en las que son imprescindibles como, por ejemplo:
- Como los indices en un vector o matriz
- Como contador del n˙mero de iteraciones en un bucle Debido a limitaciones de memoria no se puede definir un n˙mero con una precisiÛn arbitraria.
Los lenguajes de programaciÛn pueden definir distintos tamaÒos para los enteros; empleando, por ejemplo, 8 bits (para contar desde el 0 hasta el 256), 16 bits (del 0 al 65536 o -32768 a 32761 seg˙n se considere el signo o no), etc.
Como ejemplo con 4 bits y dedicando el primer bit para el signo, una posible representaciÛn binaria es:
Decimal Binario Decimal Binario 0 0000 -1 1111 1 0001 -2 1110 2 0010 -3 1101 3 0011 -4 1100 4 0100 -5 1011 5 0101 -6 1010 6 0110 -7 1001 7 0111 -8 1000 Se puede comprobar que el mayor n˙mero positivo es 2 3 -1 y el menor n˙mero negativo es -2 3. O lo que es lo mismo:
nbits signo
nbitssigno
MIN
MAX
−
−
=−
Donde nbits es el n˙mero de bits de la variable, y signo es 1 si la variable tiene signo o 0 en caso de que sÛlo se consideren n˙meros positivos.
Con los n˙meros enteros se pueden hacer operaciones matem·ticas. Los tÌpicos sÌmbolos empleados en los lenguajes de programaciÛn son:
- + para sumar
- - para restar
- ***** para multiplicar
- / para dividir
CapÌtulo 2 Estructuras fundamentales de los datos P·gina 13
TECNUN-Parque tecnológico de la Universidad de Navarra
- UNICODE UTF-8, es un intermedio entre los dos anteriores. No emplea un n˙mero de bytes fijo para representar los caracteres, pero est· diseÒado de tal forma que los textos escritos mediante esta codificaciÛn sÛlo empleen letras del alfabeto latino con el cÛdigo ASCII. Por motivos que no se explican aquÌ, ya que se escapan del interÈs de este manual, esta codificaciÛn ser· una de las m·s empleadas en el futuro junto a la UTF-16.
2.4 Datos estructurados
Hasta ahora se han visto tipos de variables que representan una entidad indivisible o atÛmica. No obstante en ocasiones puede ser preferible trabajar con variables de una forma agrupada. Por ejemplo, para programar algo para trabajar con n˙meros complejos, es mejor crear un nuevo tipo de variable para representar los n˙meros complejos, donde quede una variable de este tipo definida por su parte real y su parte imaginaria (dos n˙meros de coma flotante). AsÌ mismo, en los programas donde se manipulan muchos datos de la misma naturaleza es m·s sencillo trabajar con una variable que agrupe a su vez a varias variables del mismo tipo en un solo vector.
2.4.1 Vectores y cadenas de caracteres
Un vector es un tipo de variable compuesto por N variables del mismo tipo, por ejemplo un vector de 10 enteros o de 15 n˙meros de coma flotante.
Por lo tanto las caracterÌsticas de un vector son:
- El tipo de los elementos que lo conforman
- El n˙mero de elementos El acceso a los elementos del vector se realiza siempre mediante un Ìndice que es siempre un n˙mero entero positivo. El Ìndice del primer elemento de un vector puede ser 1 o 0 seg˙n el lenguaje de programaciÛn siendo m·s com˙n el segundo.
El siguiente ejemplo muestra la creaciÛn de un vector de n˙meros decimales en Matlab y el acceso al segundo elemento (en Matlab los Ìndices de un vector comienzan con 1): **>> a=[3,5,9,17] a = 3 5 9 17
a(2) ans = 5** Las cadenas de caracteres son un tipo especial de vector en los que cada elemento es un car·cter. Este tipo de variable se suele emplear para almacenar cualquier tipo de texto. En algunos lenguajes de programaciÛn (en especial C++ y C) emplean (internamente) un car·cter especial de cÛdigo para marcar el fin de la cadena de caracteres. El siguiente ejemplo es similar al anterior pero emplea cadenas de caracteres: >> text='Hola mundo' text = Hola mundo text(4) ans = a
P·gina 14 Aprenda a programar como si estuviera en Primero
Escuela Superior de Ingenieros de San Sebastián
2.4.2 Matrices
Las matrices se distinguen de los vectores en que la disposiciÛn de los elementos no es unidimensional sino bidimensional. Las matrices tienen las mismas caracterÌsticas que los vectores salvo que para acceder a los elementos se requieren dos Ìndices en lugar de uno. Las matrices son ampliamente empleadas tanto para representar tablas de datos, rotaciones en el espacio, o incluso im·genes. Se pueden crear matrices de m·s de dos dimensiones, conocidas como hipermatrices.
2.4.3 Estructuras
Todos los elementos de un vector o de una matriz son iguales. Por ejemplo, en un vector de enteros, todos y cada uno de los elementos del vector son enteros. Sin embargo es muy ˙til poder trabajar con variables compuestas por distintos tipos de elementos. Por ejemplo para almacenar los datos de los empleados de una empresa se pueden crear vectores que almacenen por separado el nombre, edad, n˙mero de la seguridad social, etc. aunque es mucho m·s cÛmodo poder trabajar con un nuevo tipo de variable que permitiese agruparlos en una ˙nica entidad y almacenarlos en un ˙nico vector, evitando que aparezcan incoherencias en los datos (por ejemplo si se ordena el vector de nombres de los empleados, hay que trasladar sincronizadamente el resto de datos de los empleados para que sigan refiriÈndose a la persona a la que pertenecen).
Una estructura es una agrupaciÛn de datos de distinto o igual tipo que representan de alg˙n modo una ˙nica entidad. Los componentes de una estructura suelen recibir el nombre de miembros de la estructura y nunca son accesibles a travÈs de un Ìndice.
El siguiente ejemplo muestra la apariencia de una estructura en C++:
struct Empleado { char nombre[10]; // Una cadena de caracteres de tamaÒo 10 int edad; // Un entero int seguridadSocial; };
Aunque Matlab permite la creaciÛn de estructuras, su uso es menos natural que en otros lenguajes de programaciÛn.
Los lenguajes de programaciÛn orientada a objetos como C++, aÒaden a la capacidad de crear variables la capacidad de aÒadir funciones miembro a las estructuras, que en este caso reciben el nombre de clases. Las funciones miembro suelen definir la capacidad (lo que son y lo que pueden hacer) de las variables del tipo que define una clase y reciben el nombre de interfaz de la clase. AsÌ mismo estos lenguajes permiten impedir el acceso a los datos desde su exterior de forma que se puede garantizar la consistencia de los datos, asÌ como ampliar la interfaz de una clase mediante un mecanismo denominado herencia.
