apuntetallerinformatica_v2.pdf

Taller de Informática

U N a M

Fa cu l tad d e In g en i er í a

Apunte de cátedra

UNIVERSIDAD NACIONAL DE MISIONES

FACULTAD DE INGENIERÍA

TALLER DE INFORMÁTICA

Apuntes de Cátedra

INDICE

CONTENIDOS PLANIFICADOS ........................................................................................ 9 CAPITULO 1. Introducción a la Informática .............................................................................. 9 CAPITULO 2. Introducción a la Programación .......................................................................... 9

CAPITULO 3. Algoritmos. .......................................................................................................... 9 CAPITULO 4. Lenguajes de Programación. ............................................................................... 9 CAPITULO 5. Sistemas Operativos. ........................................................................................... 9 CAPITULO 6. Software de Aplicación. ...................................................................................... 9 CAPITULO 7. Conceptos de Redes e Internet. ......................................................................... 10

CAPITULO 1. ................................................................................................................. 11 INTRODUCCION A LA INFORMÁTICA ........................................................................... 11

1.1. LA INFORMÁTICA. CONCEPTOS BÁSICOS. .................. ¡Error! Marcador no definido. 1.2. COMPUTADORA. DEFINICIÓN. ........................................ ¡Error! Marcador no definido. 1.3. ESTRUCTURA ...................................................................... ¡Error! Marcador no definido. 1.4. DATO E INFORMACIÓN ..................................................... ¡Error! Marcador no definido.

1.4.1. Tiempo en las computadoras............................................ ¡Error! Marcador no definido.

1.5. COMPONENTES ................................................................... ¡Error! Marcador no definido.

1.5.1. Unidad Central de Proceso - CPU .................................... ¡Error! Marcador no definido. 1.5.2. Unidad Aritmético-Lógica ............................................... ¡Error! Marcador no definido. 1.5.3. Unidad de Control ............................................................ ¡Error! Marcador no definido.

1.5.4. Almacenamiento Primario ............................................... ¡Error! Marcador no definido. 1.5.5. Almacenamiento secundario ............................................ ¡Error! Marcador no definido.

1.5.6. Dispositivos de Entrada ................................................... ¡Error! Marcador no definido.

1.5.7. Dispositivos de Salida ...................................................... ¡Error! Marcador no definido.

1.5.8. Multimedia ....................................................................... ¡Error! Marcador no definido. 1.6. SOFTWARE ........................................................................... ¡Error! Marcador no definido.

1.6.1. Definición de Software .................................................... ¡Error! Marcador no definido. 1.6.2. Programas de Software .................................................... ¡Error! Marcador no definido.

1.7. CLASIFICACIÓN DEL SOFTWARE ................................... ¡Error! Marcador no definido.

PREGUNTAS DE REPASO ......................................................... ¡Error! Marcador no definido.

CAPITULO 2. ................................................................................................................. 23 INTRODUCCION A LA PROGRAMACION ....................................................................... 23

2.1. ANÁLISIS Y RESOLUCIÓN DE PROBLEMAS. ................................................................ 23

2.1.1. Análisis del Problema ...................................................................................................... 23 2.1.2. Diseño del Algoritmo ....................................................................................................... 23

2.1.3. Implementación del Algoritmo en la Computadora. ........................................................ 24 2.2. ETAPAS EN LA CREACIÓN DE PROGRAMAS. .............................................................. 26

2.2.1. Análisis del Problema. ..................................................................................................... 26

2.2.2. Diseño. ............................................................................................................................. 26 2.2.3. Implementación del Algoritmo en la Computadora ......................................................... 26

2.2.4. Documentación y Mantenimiento. ................................................................................... 27 2.3. PROGRAMAS: CONCEPTO, CARACTERÍSTICAS. ......................................................... 28

2.3.1. Partes de un programa. ..................................................................................................... 28 2.4. TÉCNICAS DE PROGRAMACIÓN. .................................................................................... 29

2.4.1 Programación no Estructurada. ......................................................................................... 29 2.4.2 Programación Procedimental ............................................................................................ 29

2.4.3 Programación Modular ..................................................................................................... 30 2.5. EJERCICIO PARA ILUSTRAR LA METODOLOGÍA ....................................................... 31

PREGUNTAS DE REPASO ......................................................................................................... 32

CAPITULO 3. ................................................................................................................. 33 ALGORITMOS ............................................................................................................... 33

3.1. CONCEPTO. CARACTERÍSTICAS. DISEÑO. ................................................................... 33 3.1.1. Concepto .......................................................................................................................... 33

3.1.2. Características .................................................................................................................. 33 3.1.3. Diseño .............................................................................................................................. 33

3.2. APLICACIÓN DE ESTRATEGIAS DE RESOLUCIÓN DE PROBLEMAS. ..................... 36 3.3. ESTRUCTURAS BÁSICAS: LINEALES, SELECTIVAS Y REPETITIVAS ..................... 38

3.3.1. Estructuras básicas lineales .............................................................................................. 38

3.3.2. Estructuras básicas selectivas........................................................................................... 41 3.3.3. Estructuras de Control Repetitivas ................................................................................... 47

3.4. CONTADORES, INTERRUPTORES Y ACUMULADORES. ............................................ 54 3.4.1. Contador ........................................................................................................................... 54 3.4.2. Acumulador ...................................................................................................................... 54

3.5. ARREGLOS DE DATOS ....................................................................................................... 55 3.5.1. Arreglos Unidimensionales o Vectores............................................................................ 55

3.5.2. Operaciones con Vectores ................................................................................................ 56 3.5.3. Arreglos Bidimensionales o Matrices .............................................................................. 57 3.5.4. Operaciones con Matrices ................................................................................................ 58 Preguntas de Repaso .................................................................................................................. 59

3.6. GUÍA DE EJERCICIOS ......................................................................................................... 60 3.6.1. Ejercicios Algoritmo ........................................................................................................ 60

3.6.2. Ejercicios Expresiones ..................................................................................................... 60 3.6.3. Instrucciones Secuenciales ............................................................................................... 60

3.6.4. Instrucciones de Decisión ................................................................................................ 61 INSTRUCCIONES REPETITIVAS .......................................................................................... 63

3.6.5. Estructura FOR (Controladas por un Contador) .............................................................. 63 3.6.6. Estructuras WHILE y DO WHILE (Controladas por una condición) ............................. 64 ESTRUCTURAS DE DATOS................................................................................................... 65

3.6.7. Vectores ........................................................................................................................... 65 3.6.8. Matrices ............................................................................................................................ 66 3.6.9. Ejercicios Integradores ..................................................................................................... 68

CAPITULO 4. ................................................................................................................. 71 LENGUAJES DE PROGRAMACION ................................................................................. 71

4.1. INTRODUCCIÓN .................................................................................................................. 72 4.1.1. ¿Por qué usar C? .............................................................................................................. 72

4.2. LENGUAJE C......................................................................................................................... 74 4.2.1. Operaciones básicas de programación. ............................................................................ 74 4.2.2. Manejo de Errores. ........................................................................................................... 75

4.3. ESTRUCTURA DE UN PROGRAMA .................................................................................. 77 4.3.1. Directivas del preprocesador ............................................................................................ 77 4.3.2. Declaración de variables globales .................................................................................... 78 4.3.3. Prototipos de funciones .................................................................................................... 78 4.3.4. Declaración de clases ....................................................................................................... 78

4.3.5. Función main() ................................................................................................................. 78 4.3.6. Definición de funciones ................................................................................................... 79 4.3.7. Definición de clases ......................................................................................................... 79

4.4. DATOS, VARIABLES Y CONSTANTES ............................................................................ 80 4.4.1 Datos ................................................................................................................................. 80

4.4.2. Variables .......................................................................................................................... 80

4.4.3 Ejercicios sobre Variables ................................................................................................. 83 4.5. CONSTANTES ....................................................................................................................... 84

4.5.1. Normas para la notación .................................................................................................. 84 4.5.2. Recomendaciones en el uso de la notación. ..................................................................... 87

4.5.3 Constantes carácter. Comentario adicional. ...................................................................... 88 4.5.4. Ejercicios .......................................................................................................................... 90

4.6. OPERADORES ...................................................................................................................... 92 4.6.1. Operadores aritméticos. ................................................................................................... 92 4.6.2. Operadores relacionales ................................................................................................... 94

4.6.3. Operadores lógicos. .......................................................................................................... 94 4.6.4. Operadores de asignación ................................................................................................ 96 4.6.5. Operador "sizeof" ............................................................................................................. 96

4.6.6. Operador condicional (?) ................................................................................................. 96 4.6.7. Operador coma (,) ............................................................................................................ 97

4.7. EXPRESIONES ...................................................................................................................... 98 4.7.1. EXPRESIONES ARITMÉTICAS. ...................................................................................... 98

4.7.2. Expresiones lógicas .......................................................................................................... 99

4.7.3. Ejercicios con operadores y expresiones ....................................................................... 101 4.8. INSTRUCCIONES ............................................................................................................... 103

4.8.1. Bloques........................................................................................................................... 103 4.8.2. Expresiones. ................................................................................................................... 104

4.8.3. Bucles. ............................................................................................................................ 104 4.8.4. Etiquetas. ........................................................................................................................ 106

4.8.5. Sentencias de Selección. ................................................................................................ 107 4.8.6. Sentencias de salto ......................................................................................................... 109

4.8.7. Comentarios. .................................................................................................................. 111 4.8.8. Ejercicios con sentencias. .............................................................................................. 111

4.9. FUNCIONES ........................................................................................................................ 113 4.9.1. Declaración de función. El Prototipo. ............................................................................ 113 4.9.2. Definición de función..................................................................................................... 114

4.9.3. Función main() ............................................................................................................... 115 4.9.4. Ámbito de variables ....................................................................................................... 116

4.9.5. Ejercicios ........................................................................................................................ 117 4.10. ARREGLOS........................................................................................................................ 120

4.10.1. Cadena de caracteres. ................................................................................................... 120 4.10.2. Arreglos ........................................................................................................................ 121 4.10.3. Algoritmos de ordenación: método de la burbuja ........................................................ 123 4.10.4. Ejercicios: cadenas de caracteres. ................................................................................ 123

4.10.5. Ejercicios: arreglos ....................................................................................................... 124 4.11. GUÍA DE EJERCICIOS ..................................................................................................... 127

4.11.1. Guía Practica 1 de C++. Instrucciones secuenciales .................................................... 127

4.11.2. Guía Práctica 2 de C++. Estructuras de Decisión ........................................................ 129 4.11.3. Guía Práctica N° 3 de C++. Estructuras Repetitivas.................................................... 135 4.11.4. Guía Práctica Nº 4 de C++. Arreglos ........................................................................... 139 4.11.5. GUÍA PRÁCTICA Nº 5 DE C++. Funciones .............................................................. 153 4.11.6. GUÍA PRÁCTICA Nº 6 DE C++ ................................................................................ 157

Ejercicios Combinados usando Vectores, Matrices y Funciones ............................................ 157 Ejemplos: ................................................................................................................................. 160 4.11.7. Ejercicios Integradores ................................................................................................. 165

CAPITULO 5. ............................................................................................................... 174 SISTEMAS OPERATIVOS ............................................................................................. 174

5.1. DEFINICIONES ................................................................................................................... 174 5.1.1. Software de sistemas ...................................................................................................... 174

5.1.2. Sistema Operativo .......................................................................................................... 174 5.1.3. Traducción de lenguajes ................................................................................................. 176 5.1.4. Programas de Utilería ..................................................................................................... 176 5.1.5. Sistemas Operativos para Microcomputadoras .............................................................. 176 5.1.6. Historia de los Sistemas Operativos ............................................................................... 176

5.1.7. Tipos de Interfaz con el usuario ..................................................................................... 177 5.1.8. Sistemas operativos actuales .......................................................................................... 177

5.2. SISTEMA OPERATIVO LINUX ........................................................................................ 179 5.3. GUIA INTRODUCTORIA DE COMANDOS DE SHELL ................................................. 180

5.3.1. Iniciando una Sesión ...................................................................................................... 180 5.3.2. Super Shell ..................................................................................................................... 180 5.3.3. ¿Qué es el Shell? ............................................................................................................ 181

5.3.4. ¿Qué es el prompt? ......................................................................................................... 182 5.3.5. Como funciona el Shell: ................................................................................................. 183 5.3.6. Caractéres Especiales o Metacaractéres del Shell .......................................................... 184 5.3.7. ¿Qué es el Sistema de Ficheros? .................................................................................... 184

5.3.8. Comandos....................................................................................................................... 187 5.4. TRUCOS SHELL ................................................................................................................. 193 5.5. Los conceptos de usuarios y permisos .................................................................................. 195

5.5.1. Fijando permisos ............................................................................................................ 196 5.5.2. Bit de Stick ..................................................................................................................... 197

5.5.3. SUID - [Identificación de conjunto de usuario] ............................................................. 198

5.6. TAREAS Y PROCESOS ...................................................................................................... 199

5.6.1. Primer plano y Segundo plano ....................................................................................... 199 5.6.2. Envío a segundo plano y eliminación procesos ............................................................. 200

5.6.3. Sobre los ciclos infinitos ................................................................................................ 201 5.7. USANDO EL EDITOR VI ................................................................................................... 203

5.7.1. Conceptos ....................................................................................................................... 203

5.8. EJERCICIOS DE SISTEMA OPERATIVO ........................................................................ 208 5.8.1. Preguntas sobre Linux .................................................................................................... 208

5.8.2. Ejercicios de comandos básicos shell linux ................................................................... 209

CAPITULO 6. ............................................................................................................... 211 Software de aplicaciones ............................................................................................ 211

A partir de acá hay que organizar títulos y estilos como corresponda. Solo está el contenido, que

también se debe revisar o completar según lo planificado ........................................................... 215

En todo este capitulo faltan lso ejercicios .................................................................................... 215 6.1. Procesador de Textos Writer ................................................................................................. 215

6.1.1. Configuraciones de OpenOffices ................................................................................... 215

Tamaño y Formato del Papel ...................................................................................................... 215

Encabezados y Pie de Página ...................................................................................................... 216

Insertar Numeración de Página ............................................................................................ 216

Nota al Pie ................................................................................................................................... 216

Configuraciones de Párrafos .......................................................................................... 216 Personalizar ................................................................................................................. 217

Uso de las Teclas Rápidas ........................................................................................................... 217

Barras de Herramientas ............................................................................................................. 217

Opciones ...................................................................................................................... 217

Generalidades .............................................................................................................. 218 Como Usar los Encabezados ........................................................................................... 218 Editar “Estilos y Formatos” ............................................................................................ 219 Consejos ...................................................................................................................... 219

Para Encabezados ....................................................................................................................... 219

Para Cuerpo de Textos ................................................................................................................ 219

Numeración en los Encabezados ..................................................................................... 219 Guardar una Plantilla .................................................................................................... 220 Cargar una Plantilla ...................................................................................................... 220 Usar una Plantilla como Predeterminada ........................................................................ 221 Configurar las Imágenes ................................................................................................ 221

Titulo de Imagen ......................................................................................................................... 222

Insertar Formula .......................................................................................................... 223 Editar formulas ........................................................................................................................... 223

Insertar Hojas de cálculo ............................................................................................... 224 Editar las Hojas ........................................................................................................................... 224

Insertar Dibujos ........................................................................................................... 224 Movimiento y selecciones .............................................................................................. 224 Combinaciones de Teclas ............................................................................................... 225 Crear Índices ................................................................................................................ 225

Editar el contenido del índice ..................................................................................................... 225

Editar el estilo del índice ............................................................................................................. 226

Actualizar .................................................................................................................................... 226

Sobre la numeración de las figuras y las gráficas .............................................................. 226 Uso de Referencias ........................................................................................................ 226 Insertar salto de Página ................................................................................................. 226 Barra de estado ............................................................................................................ 226 Guardar como PDF ........................................................................................................ 227

6.2. Hoja de Cálculo Calc ............................................................................................................ 228

CAPITULO 7 ................................................................................................................ 235 CONCEPTOS DE REDES E INTERNET ........................................................................... 235

A partir de acá hay que organizar títulos y estilos como corresponda. Solo está el contenido, que

también se debe revisar o completar según lo planificado ........................................................... 235 7.1. DEFINICIONES ................................................................................................................... 235

7.1.1. Telecomunicaciones ....................................................................................................... 235 7.1.2. Protocolos....................................................................................................................... 236

7.1.3. Tipos de Señales............................................................................................................. 236 7.1.4. Canales de comunicación ............................................................................................... 236

7.1.5. Características de los Canales de Comunicación ........................................................... 237 7.1.6. Funciones del software de telecomunicaciones ............................................................. 238

7.2. REDES DE COMUNICACIONES ...................................................................................... 238 7.2.1. Clasificación................................................................................................................... 238 7.2.2. Topologías de las redes .................................................................................................. 238

7.2.3. Ámbito Geográfico ........................................................................................................ 241 7.2.4. Implementación de una red ............................................................................................ 242

7.3. Conectividad ......................................................................................................................... 243 7.3.1. Definición de Conectividad ........................................................................................... 244 7.3.2. Normas para la Conectividad ......................................................................................... 245 Funciones de cada capa ............................................................................................................ 248 Nombres de los datos en cada capa .......................................................................................... 249

Las capas del modelo de referencia TCP / IP .......................................................................... 249

Gráfico de protocolo TCP/IP ................................................................................................... 251

Comparación modelos: OSI - TCP/IP ......................................................................................... 251 Similitudes ............................................................................................................................... 251 Diferencias ............................................................................................................................... 251

BIBLIOGRAFIA ........................................................................................................... 253 ANEXOS ...................................................................................................................... 255

ANEXO 1. .................................................................................................................................... 255 ESTANDARES PARA DIAGRAMAS DE FLUJO – PSEUDOCÓDIGO ................................ 255 ANEXO 2. OPERADORES ........................................................................................................ 256

2.1. OPERADORES MATEMÁTICOS .................................................................................. 256

2.2. OPERADORES DE RELACIÓN ó COMPARACIÓN ................................................... 256

2.3. OPERADORES LÓGICOS – TABLAS DE VERDAD................................................... 256 2.4. OPERADORES – ORDEN DE PRECEDENCIA ............................................................ 257

2.5. ASOCIATIVIDAD DE OPERADORES.......................................................................... 258 ANEXO 3.- TIPOS DE DATOS EN C++ ................................................................................... 259

3.1. Conversión de tipos de datos ............................................................................................ 259 3.2. Conversión explícita de tipo: ............................................................................................ 260

ANEXO 4.- SISTEMAS NUMÉRICOS ..................................................................................... 262 ¿Que es un sistema Numérico? ................................................................................................ 262

ANEXO 5.- CÓDIGOS ASCII .................................................................................................... 265 Símbolos y nombre ASCII usados corrientemente .................................................................. 266

ANEXO 6.- PALABRAS RESERVADAS EN C ....................................................................... 270 ANEXO 7.- ESTILOS DE NOTACIÓN ..................................................................................... 272

7.1. Comentarios ...................................................................................................................... 272

7.2. Nombres de variables ........................................................................................................ 272

5.3. Notación tipo Húngara ...................................................................................................... 272 ANEXO 8. SUMARIO DE ÓRDENES BÁSICAS LINUX ....................................................... 274 ANEXO 9. ENTORNO ANJUTA ............................................................................................... 276

9.1. Introducción ...................................................................................................................... 276 9.2. Barra de menú ................................................................................................................... 277 9.3. Barra de herramientas ....................................................................................................... 277

9.4. Ventana principal .............................................................................................................. 278 9.5. Teclas Rápidas .................................................................................................................. 279 9.6. Compilar y construir una aplicación ................................................................................. 279

9.7. Ejecutar un programa ........................................................................................................ 280 9.8. Preferencias ....................................................................................................................... 280

CONTENIDOS PLANIFICADOS

CAPITULO 1. Introducción a la Informática - La Informática. Conceptos básicos.

- Hardware. Computadora: Definición, estructura. Dato e Información. Almacenamiento: Definición, características, clasificación. Procesamiento y Funcionamiento de una Computadora.

Periféricos de Entrada y Salida.

- Software. Definición, Clasificación.

CAPITULO 2. Introducción a la Programación - Análisis y resolución de problemas. Estrategias de resolución de problemas. Ubicación de la

programación en la resolución de Problemas.

- Programa: Concepto. Características. Partes de un programa. Elementos básicos de un programa. Etapas en la creación de Programas. Técnicas de programación. La programación estructurada.

- Diseño descendente (top-down). Programación Modular.

CAPITULO 3. Algoritmos. - Algoritmos: Concepto, Características. Diseño. Aplicación de Estrategias de resolución de

problemas.

- Diagrama de flujo: Introducción. Símbolos. Prueba de Escritorio. Estructuras básicas: lineales, selectivas y repetitivas. Estructuras anidadas. Contadores, Interruptores y Acumuladores.

- Introducción a las estructuras de datos. Vectores. Operaciones válidas sobre vectores: recorrido, asignación, actualización, desplazamiento, ordenamiento. Matrices: Formas de recorrido,

almacenamiento.

CAPITULO 4. Lenguajes de Programación. - Lenguajes de Programación. Alto y bajo Nivel. Compiladores. Interpretes. Lenguaje C.

- Convenciones léxicas.

- Estructura de un Programa. Declaraciones. Datos, tipos de datos, variables, Constantes, operadores, expresiones, precedencia de los operadores. Evaluación de expresiones.

- Sentencias. Asignación. Modificación de valores almacenados.

- Sentencias de Control: Condicionales: if, if else, switch, Sentencias Repetitivas: while, do while, for. Sentencias de Salto. Sentencias de Salida: exit, return.

- Arreglos. Vectores y Matrices.

- Funciones: Ámbito de las variables: variables locales y variables globales. Pasaje de parámetros.

- Concepto de Recursividad.

- Pre-procesamiento del C. Bibliotecas.

CAPITULO 5. Sistemas Operativos. - Definición de Sistema Operativo. Clasificación. Conceptos básicos: Interfaces, Procesos, Files

System.

- Linux: Definición. Características. Interfaz. Comandos básicos. Operaciones con archivos y directorios.

CAPITULO 6. Software de Aplicación. - Planilla de Calculo: Generalidades, principios de las planillas de calculo, Utilidades y

características mas utilizadas.

CAPITULO 7. Conceptos de Redes e Internet. - Redes. Conceptos.

- Aplicaciones de Internet: Utilización y Características generales.

TALLER DE INFORMÁTICA CAPITULO 1. Introducción a la Informática

- 11 -

CAPITULO 1.

INTRODUCCION A LA INFORMÁTICA

1.1. OBJETIVOS. Los Objetivos del Curso son aprender a programar en un lenguaje, el lenguaje elegído para esta materia

se llama C++ (C mas mas), en el curso buscaremos que mientras aprendemos a programar tengamos en

mente los siguientes puntos:

- Aprender a Formular Problemas y proponer soluciones.

- No recordar, no memorizar.

- Trabajar en equipo, en forma colaborativa.

- Tratar de divertirse.

- No hay libros de Texto, solo los apuntes de la materia en el sitio Web.

Entonces una de las metas es enseñar a plantear problemas y proponer soluciones de una manera estructurada en un lenguaje (Flujo o C++) que permita que cualquier persona pueda interpretarlo.

La practica en la resolución de problemas, utilizando el razonamiento, permite realizar este tipo de

tareas de una manera rápida.

Todos nosotros en forma cotidiana resolvemos problemas muy complejos 1, lo único que sucede es que

no tenemos la práctica de plantearlos, ni describimos la solución o el camino que usamos para solucionarlo.

1.2. TIPOS DE CONOCIMIENTOS.

En general podemos decir que hay dos Tipos de Conociemientos.

Declarativos: esta compuesto por declaraciones de hechos.

Imperativos: dice como solucionar el problema o como encontrarla solución.

Pensemos en algunos ejemplos de conocimientos y tratemos de determinar en base a la definición de que tipos son.

Ejemplos:

1. Si y es la raiz cuadrada de x, si x al cuadrado es y"

2. Calculo de raiz cuadrada de x:

a) tomo un numero de valor y.

b) Si y*y está cerca de x entonces y es una buena aproximación de la raiz de x.

c) Si no creo una nueva varible y‟ promediando y , y‟=(y+x/y)/2, usando la nueva y‟ nueva vuelvo al paso b.

Veamos otro ejemplo en otro ámbito:

1. Freir un huevo en una sartén.

2. Receta para preparar un huevo frito

a) Buscar un huevo que este a temperatura ambiente, si lo tienen en la heladera, retirarlo unos minutos antes.

a) En una sartén antiadherente ponemos a calentar aceite hasta que humee.

b) Quebrar el huevo y verterlo en la sartén.

c) Agregar sal y pimienta y empujar un poco de aceite sobre la clara.

d) Esperar de 1 a 2 minutos según el gusto del comensal.


- 12 -

Veamos otro más gráfico:

¿Cuales son conocimientos Declarativos y cuales Imperativos?

Creo que no se puede dudar en que los ejemplos 2, son Imperativos, ya que claramente indican un procedimiento de como lograr el cometido.

Como podemos ver en estos dos ejemplos se puede ver claramente que el 2, muestra un procedimiento de como encontrar el valor de y, que sea la raiz cuadrada de x, no es así en el ejemplo 1, en el que solo

serviría para comprobar que y es la raiz de x.

A modo de comentario el procedimiento para el cálculo de la raiz de un número lo propuso Herón de Alejandría ( provincia de Egipto) en el siglo 1, fué un Ingeniero y Matemático.

Definición de g (guest):

Raiz de 25? g = 3, => 3+3= 9, g= (3+25/3)/2= 5.6666 => 5.6666+5.6666=32.11 g= (5.666+25/5.666)/2 = (5.04) 5.04*5.40=25.39

Algoritmo

Es una descripción de como realizar un cómputo, el algoritmo SIEMRPE CONVERGE, TIENE PRINCIPIO Y FIN, por lo tanto lo que tenemos es un conjunto de instruciones, pasos que pueden ser ejecutados y control

de flujo (flow control) y una condicion de cuando terminar.

¿Podríamos diseñar un proceso mecánico que realice la raiz cuadrada?

Definitivamente sí, una manera es diseñar una máquina específica que realice este proceso, por ejemplo una calculadora.

Para poder entender con claridad el por que una máquina puede realizar esto vamos a ver algunos fundamentos que permitan luego entender el porque.

1.3. SISTEMAS NUMÉRICOS

El hombre desde sus orígenes utilizó simbolos para representar cantidades, esto era indispensable para poder comparar, vender, comprar, etc.

Por supuesto no se creó un único sistema a nivel mundía, estos fueron apareciendo en distintos lugares y no necesariamente eran los mismos.

Un sistema de numeración es un conjunto de símbolos y reglas de generación que permiten construir todos los números válidos.


- 13 -

Un primer clasificación tiene que ver con la posición de estos símbolos, en el sistema que conocemos o

aprendemos en primer instancia ; el decimal, la posición del símbolo tiene distinta interpretación , por ejemplo si escribimos : “12”, sabemos que no es lo mismo que “1” y “2” ya que en el primer caso el “1” del

12 tiene una ponderación o peso distinto, justamente la ubicación nos indica que está en la posición de las

decenas y el “2” está en la posición de las unidades. Pero no todos los sistema son como los que conocemos. Por ejemplo el sistema de numeración romano.

En el Sistema Romano la “V” equivale a 5 del Sistema Decimal y la “I” al uno del sistema decimal, pero si escribimos “IV” en el sistema Romano esto equvale al 4 y no al “15” como podríamos esperar.

Entonces tenemos dos divisiones.

- Sistemas de numeración no posicionales

- Sistemas de numeración posicionales

Nos concentraremos en los distintos sistemas de numeración posicionales.

Tal como anticipamos un sistema numérico tiene “SIMBOLOS”, en función de los símbolos usados tienen un nombre, veamos los símbolos de algunos:

Decimal Hexadecimal Octal Binario

0 0 0 0

1 1 1 1

2 2 2 10

3 3 3 11

4 4 4 100

5 5 5 101

6 6 6 110

7 7 7 111

8 8 10 1000

9 9 11 1001

10 A 12 1010

11 B 13 1011

12 C 14 1100

13 D 15 1101

14 E 16 1110

15 F 17 1111

16 10 20 10000

Tabla 1

Veamos algunas observaciones respecto de la tabla anterior.

- Todos los sistemas tiene el “0” cero.

- Los símbolos reutilizan en algún momento.

- Existen algunos símbolos comunes entre los distintos sistemas numéricos.

Ver que por ejemplo en el sistema octal que tiene como símbolos del 0 a 7 (ocho en total, por eso es octal) luego del 7, el numero ocho se debe lograr reutilizando los símbolos, ya que no tiene mas, en

particulae se reutilizanda el 1, pero en otra posición, ma a la derecha: 10(Octal)=8(Decimal).

Para el caso del sistema Binario, la reiteración o reutilización de símbolos, es mas exagerado, ya que

tiene solo dos símbolos (de allí la palabra binario), el cero “0” y el uno “1”, entonces si queremos lograr el 3 (decimal) deberíamos escribir 11(binario).

El elemento simbolo (0 ó 1) del Sistema Numérico Binario es conocidos como: bit , que es un acrónimo de Binary digit (o dígito binario).

El uso de Números binarios es un área de la matemática aplicada al campo de la electrónica ,es la base de los Sistemas Digitales y ello implica también, la base de la Estructura de Computadores u Ordenadores.

En general para cualquier número entero de cualquier sistema numérico se puede de plantear la

siguiente expresión:


- 14 -

Nen base r = dn-1.rn-1+dn-2.r

n-2+dn-3.rn-3+....d1.r

1+d0.r0

Donde N es el Número en la base r (con r= decimal, octal, binario, hexadecimal)

di : son los dígitos que conforman el número, en la posición i.

r: es la base elegida

Veamos como se aplica esta expresión, por ejemplo:

o Decimal: 23710=2.102+3.101+7.100

o Binario: 1010001112=1.28+0.27+1.26+0.25+0.24+0.23+1.22+1.21+1.20=>

1010001112=25610+6410+410+210+110=23710.

o Octal: 3558=3.82+5.81+5.80=19210+4010+510=23710

o Hexadecimal: ED16 = 1410.161+1310.160=22410+1310=23710

Vemos entonces que 23710-decimal =1010001112-binario=3558-octal=ED16-hexa

Esta expresion permite convertir de un sistema numérico a otro, válido para números enteros de sistemas numéricos posicionales.

Tambíen existen otras maneras de convertir, por ejemplo dividiendo. Veamos el caso particular de convertir un Número en Sistema Decimal al Sistema Binario.

7710 = ?

Paso Resto Nro. Binario

1 77/2=38 1-» 1

2 38/2=19 0-» 01

3 19/2=9 1-» 101

4 9/2=8 1-» 1101

5 8/2=4 0-» 01101

6 4/2=2 0-» 001101

7 2/2=1-» 0 1001101

Si formamos un número binario con en resultado del paso 7 y restos de las divisiones por 2 anteriores tendremos:

10011012=7710

Ahora que sabemos de la existencia de diversos sistemas numéricos, veamos algo sobre operaciones lógicas usando el sistema binario.

1.4. Operaciones Lógicas Binarias

Para cada uno de estos sistemas numéricos existen las operaciones matemáticas que se corresponden

con las conocidas en el sistema decimal, solo que la forma en las que se realizan o calculan, difieren de las operaciones decimales.

Vamos a concentrarlos en las operaciones lógicas que serán de mucha utilidad en nuestro curso.

En 1854, el matemático británico George Boole detallo un sistema de lógica, este sistema desempeñaría un papel fundamental en el desarrollo del sistema binario actual, particularmente en el desarrollo de

circuitos electrónicos.

Este sistema se denomino Algebra de Boole1.

1 http://es.wikipedia.org/wiki/%C3%81lgebra_de_Boole


- 15 -

Resumiendo entonces el Algebra de Boole estableció operaciones lógicas en el Sistema Numérico Binario. Veamos cuales son.

La operación “AND” es conocida como un “Y” lógico.

Por ejemplo:

• Hoy es Sábado “Y” es 14 de Enero?. La respuesta SI solo se dará cuando sea Sabado y

sea un día 14 de Enero. Si algunas de estas aternativas no resultan SIMULTANEAMENTE verdaderas o ciertas, la respuesta sería No.

• La persona es alta y de cabello Negro?. La respuesta SI solo se dará cuando sea una persona Alta y sea de cabello Negro. Si algunas de estas aternativas no resultan

SIMULTANEAMENTE verdaderas o ciertas, la respuesta sería No.

Esto se puede plantear en forma binaria de la siguiente manera.

Entrada 1 Entrada 2 Salida

1 1 1

1 0 0

0 1 0

0 0 0

Podemos ver claramete que solo tendremos una salida lógica “1” solo cuando las dos entradas sean “1” SIMULTANEAMENTE.

Notar que implicitamente estamos asociando el “1” a Verdadero (true en Ingles)

La operación “OR” es conocida como “O” lógico.

Veamos algunos ejemplos:

• Hoy es Sábado “O” es 14 de Enero?. La respuesta SI se dará cuando sea Sabado “O” cuando sea 14 de Enero. Con que algunas de estas aternativas sean ciertas o verdaderas la respuesta sería SI o Verdadero.

• La persona es alta “O” de cabello Negro?. La respuesta SI se dará cuando sea una persona Alta “O”

sea de cabello Negro. Con que algunas de estas aternativas sean ciertas o verdaderas la respuesta sería SI o Verdadero.


- 16 -

Entrada a Entrada b Salida

0 0 0

0 1 1

1 0 1

1 1 1

Por último veamos el Operación NOT que sería Negar.

Entrada Salida

1 0

0 1

Esta ultima es muy sencilla y como digimos solo cambia el valor , si era “1” o Verdadero o True, lo convierte en “0” o Falso o False y si la entrada es “=0” (cero) ó False lo convierte en “1” o Verdadero o True.

En este punto, deberíamos tener en claro los distintos sistemas numéricos en particular el Binario y sus

operaciones lógicas, ahora vamos a tratar dejustificar el por que se usa el sistema numérico binario en Informática, mas precisamente en la computadoras.

2.3 El sistema Binario y la relación con la Electrónica.

El objetivo es tratar de establecer la relación entre el Sistema Numérico Binario, Electrónica Digital 2

1. Los sistema electrónicos pueden simular de una manera efectiva y facil , diríamos que casi natural ,los “0” ceros y “1” unos, con niveles de tensión , por ejemplo 0V sería equivalente a un “0” binario o

un Falso y 5V sería equivalente a “1” binario o Verdadero o True

2. Existen circuitos electónicos que implementan la operaciones “AND” , “OR” , “NOT”, del algebra de

boole.

Un Computador u Ordenador está formado por Circuitos Integrados3

Estos Circuitos Integrados (CI), contienen internamente Miles o Millones de “AND” o “OR” Y “NOT”, agrupando varios de estos elementos CI, se consigue armar un equipo electrónico Digital que opere como

una Comutadora u Ordenador.

Finalmente conseguimos establecer una relación entre la Electrónica Digital, el Sistema Binario y el Algebra de Boole, los cuales son la base de una Computadora.

2. La electrónica digital es una parte de la electrónica que se encarga de sistemas electrónicos en los cuales la

información está codificada en dos únicos estados. A dichos estados se les puede llamar "verdadero" o "falso", o más

comúnmente 1 y 0, refiriéndose a que en un circuito electrónico digital hay dos niveles de tensión. y el Algebra de

Boole, y el por que se debe a las siguientes razones. 3 Un circuito integrado (CI), también conocido como chip o microchip, es una pastilla pequeña de material

semiconductor, de algunos milímetros cuadrados de área, sobre la que se fabrican circuitos electrónicos.


- 17 -

2.4 Unidades de Información.

Hasta ahora vimo que desde la Electrónica Digital, se pueden tener dos niveles de tensión que se los

podía interpretar como estados lógicos o bits. Como vimos en la sección 2.1, se necesitan agrupar los “bits” para codificar por ejemplo números en el sistema binario o letras por que no, bueno desde el comienzo se

utilizaron grupos de 8 bits, en la Electrónica Digital y en particular en los sistemas de Computos o Micro computos, esta agrupación se usa ampliamiente y se conoce con el nombre de “byte” (se pronuncia “bait”).

Un error común es confundir bytes y bits, por ejemlpo “KB” (KiloBytes) con “Kb” (Kilobits) , una "B" mayúscula significa Bytes, mientras que una "b" minúscula significa bits. La velocidades de transmisión se

suelen extresar en Kb, por ejemplo un modem puede tener una velocidad de 54kbps (se pronuncia Kilo bits

por Segundo o “cabepese”), en cambio los medios de almacenamientos usan como medida de la capacidad de almacenamiento de pen drives, discos, memorias por ejemplo lo bytes, Megabyte, Kilobytes.

Los prefijos utilizados para los múltiplos del byte4 normalmente son los mismos que los prefijos del Sistema Internacional (K para representar Mil, M para representar Millón, etc), así que también se utilizan los

prefijos binarios.

Esto se debe a que los prefijos del Sistema Internacional se basan en el Sistema decimal (base 10) , y

los prefijos binarios se basan en Sistema binario ,base 2, por ejemplo:

En el Sistema decimal un Kilómetro equivale a 1000 metros.

En el Sistema binario un Kilobyte (se pronucia kbait o kilobait) equivale a 1024 bytes.

2.5 Codificación de Caracteres.

Estas agrupacion de bits conocidas como bytes se utilizó no solamente para tener un sistema numérico,

si no también para codificar o representar simbolos utilizados en la escritura (letras, numeros, etc.).

Existen dos asociaciones o codificaciones de bits para representar las letras, números, símbolos (EDCBIC

y ASCII), la que usaremos es la ASCII. Veamos las codificaciones o representaciones binarias de los simbolos mas usados.

4 http://es.wikipedia.org/wiki/Kilobyte


- 18 -

Vemos en la tabla que para simplificar se escribe el equivalente decimal a continuación de cada nro. binario.

Observación:

• Es importante en este punto entender que una cosa es la representación numérica de un valor, por ejemplo el 1 que en binario sería: 0000 0001, muy diferente de la representación del Símbolo 1 que está en

el teclado, el cual en Ascii sería: 0011 0001.

• Podemos observar que los la representación de los números es correlativa. 0->48, 1->49, 2->50..etc.

• Podemos ver que existe una diferencia de 32 entre “a” y “A”, entre “b” y “B”....etc.

3 Maquina de Von Neumann vs. arquitectura Harward

Como vimos, con la electrónica se pueden resolver operaciones, entre ellas las matemáticas, la calculadora es precisamente un ejemplo de una máquina electrónica que resuelve operaciones, por ejemplo,

el siguiente es una maquina de sumar binaria que suma el bit de la entrada A con el de la B:


- 19 -

Vemos que usando las compuertas vistas, esto sumaría y produciría el acarreo de una suma.

El problema de este circuito, es que solo se podrán resolver las operaciones que fueron implementadas, suma en este caso, esto NO es un diseño no flexible y rapidamente los profecionales se dieron cuenta que sería adecuado poder almacenar los programas u operaciones en otro lugar , de manera que al cambiar esto

se pudiera cambiar compeltamente las operaciones que se quieran realizar, esto se conoció como

"arquitectura de programa almacenado" o arquitectura basada en la Máquina de von Neumann. Así pues, la primera división entre "hardware" y "software".

En la segunda guera mundíal , el Sr. Alan Turing en 1941 , hizo una Computadora de Programa fijo que decodificába un código secreto alemán, pero pese a ser una máquina muy importante desde el punto de

vista histórico, pero solo hacía eso.

Veamos el ejemplo de una máquina de Von Neumann.

La invención de Stored Program Computer hizo realmente importante para la sociedad la computadora,

la idea de almacenar las instrucciones y datos en un lado ( Memoria) , por otro lado está la ALU que es donde se realizan las operaciones , conocida como unidad aritmétia lógica y la Unidad de Control que es la

que interpreta las instrucciones, mueve los datos de la ALU a la memoria y de la memoria a la ALU , realiza las operaciones en la ALU.

Como dijimos esta es la primera vez que aparecen los términos Hardware y Software.

• Hardware: Sería la parte física, lo que se puede tocar, la electrónica, los componentes, etc.

• Software: Sería lo que se almacena en la memoria en un formato binario, no se puede tocar pero está allí.

Una analogía podría ser un CD de música, el disco compacto sería el Hardware, y la música el software.

En la memoria se graban datos e instrucciones, este pequeño set de instrucciones permiten hacer de todo combinandolas, pensemos en una analogía con un Chef, conbiando el orden de los ingredientes puede

lograr distintos gustos o comidas incluso.

Alan Turing estableció que problemas se podían resolver en forma computacional y que se necesitaban

solo algunas instrucciones primarias y con ellas se podía hacer lo que uno quería, como ser:

1. Escribir.

2. Leer.


- 20 -

3. Sumar.

4. Mover a la derecha.

5. Mover a la izquierda.

6. etc.....

A partir de esto podemos decir que hay un “PEQUEÑO SET DE INSTRUCCIONES” o LENGUAJE que me permite resolver problemas, esto es simplemente genial, ya que cambiando el orden o secuencia del set de instrucciones podemos cambiar TOTALMENTE.

Una analogía sería al abecedario, la convianción de 30 letras permite lograr infinitas convinaciones que permiten descrir todo, incluso, describir cosas iguales de maneras distintas.

4 Lenguajes de Programación.

Tenemos que aclarar que este pequeño set de instrucciones que mencionamos en la sección anterior, no es el que se usa en la programación en terminos generales.

Resulta que con el avance surguieron unos lenguajes de alto nivel, que en realidad una instrucción de este lenguaje de alto nivel, se corresponde con un conjunto de sentencias de varias sentencias de bajo nivel, esto facilita la programación, veamos un ejemplo a modo ilustrativo.

a=a+1 move acc, # 0x10A8

inc acc

move #0x10A8, acc

Con esto veríamos por ejemplo que en un lenguaje de alto nivel algo tan sencillo como un incremento en uno de una variable, se corresponde con 3 instrucciones de bajo nivel.!!

Con el correr del tiempo surgieron varios lenguajes de programación, tenemos que aclarar que no sería correcto decir: HAY UN LENGUAJE DE PROGRAMACIÓN MEJOR QUE OTRO, lo que si sería correcto decir, es

que algunos están orientados para algún fin en particular, los que los hacer mejor en esa área.

Resumiento, un Lenguaje de programacion provee un set de instrucciones que en realidad son una combianción del set primitivo de instrucciones.

Lo que hace diferente un programa de otro es la manera en que se convinan esas instrucciones, lo bueno y lo malo de esto es que la computadora con el programa siempre hará exactamente lo que uds. le

digan que haga!!. En otras palabras .. si el programa no funciona... la culpa es del que hizo el programa.

Observación: Es mejor que un amigo incondiconal o una esposa enamorada! , siempre hace lo que le decimos :-).

Veamos algunos nombres de lenguajes de Programación:

BASIC Programación para fines educativos. Lenguaje interpretado

C Programación de sistema. Lenguaje compilado.

C++ Programación de sistema orientado a objeto.Lenguaje compilado.


- 21 -

Cobol Administración. Lenguaje compilado

Fortran Cálculo. Lenguaje compilado

Java Programación orientada a Internet. Lenguaje intermediario

MATLAB Cálculos matemáticos. Lenguaje interpretado

Cálculos matemáticos Cálculos matemáticos. Lenguaje interpretado

LISP Inteligencia artificial. Lenguaje intermediario

Pascal Educación. Lenguaje compilado

PHP Desarrollo de sitios web dinámicos. Lenguaje interpretado

Inteligencia artificial Inteligencia artificial. Lenguaje interpretado

Perl Procesamiento de cadenas de caracteres. Lenguaje interpretado

Phyton De caracter General. Lenguaje interpretado.

4.1 Lenguajes interpretados vs Lenguajes Compilados.

Existen dos grandes divisiones en los lenguajes de programación los interpretados y los compilados.

Un lenguaje interpretado es un lenguaje de programación que está diseñado para ser ejecutado por

medio de un intérprete. Un intérprete o interpretador es un programa informático capaz de analizar y ejecutar el programa. Tal es el caso de Java, Perl, Python, Ruby, ASP, Bash por ejemplo. Entonces uno

escribe un programa, otro lo recorre, realizando lo que indican las instrucciones. Estos programas se suelen llamar Scripts.

Los lenguajes compilados son lenguajes de alto nivel en los que las instrucciones se traducen del lenguaje que solo entiende el procesador, se crea OTRO PROGRAMA, este se llama código de máquina y

este es el que se ejecuta. Este es el caso de C o C++.

Normalmente los lenguajes compilados corren más rápido que los intepretados, pero los programas interpretados tienen más facilidad de depuración y su gran dinamismo, lo que aumenta su rendimiento.

Existe una comparación de los lenguajes basados en la cantidad de palabras o set de instrucciones básicas, en particular tenemos que decir que el C tiene 32 palabras y el C++ un total de 64 palabras. Estas

palabras son conocidas como Reservadas.

4.2 Tipos de Errores.

En general los lenguajes se componen de estructura que se debe respetar, respetando el significado de sus elementos y expresiones, el no cumplimiento de estas reglas puede ocacionar errores del tipo:


- 22 -

• Errores sintácticos

– Ejemplo de Error Sintáctico: (errores tipográficos): “oy ace frio”.

• Errores semánticos

– Ejemplo de Error Semántico (del griego semantikos, "lo que tiene significado") Los errores semánticos son más sutiles. Un error semántico se produce cuando la sintaxis del código es correcta,

pero la semántica o significado no es el que se pretendía. La construcción obedece las reglas del lenguaje, y por ello el compilador o intérprete no detectan los errores semánticos. Los compiladores e

intérpretes sólo se ocupan de la estructura del código que se escribe, y no de su significado. Un error

semántico puede hacer que el programa termine de forma anormal, con o sin un mensaje de error. Hablando en términos coloquiales, puede hacer que el equipo se quede "colgado".Sin embargo, no todos

los errores semánticos se manifiestan de una forma tan obvia

∗ “El burro de mi primo se perdió en la feria”.

∗ int x, z=3, y; y=x+z;

Normalmente los errores del tipo Sintáctico suelen detectarse de una manera muy facil, ya que es un error que no respeta la sintaxis del lenguaje de programación y esto se puede detectar facilmente.

Lo que suele ser mas dificil de establecer es los errores del tipo semántico.

Hay otros tipos de errores como ser:

• Errores de Ejecución

Un error de ejecución se produce cuando el ordenador no puede ejecutar alguna instrucción de forma correcta.

– Ejemplo: 'a' / 2.5, no se puede dividir una letra por 2.5.

• Errores de Lógica

Se denominan lógicos, los errores que no hacen bloquear un programa, pero la lógica que representan

contiene un error, pueden ser derivados de un error de Semántica. Por ejemplo. Si quiero calcular el promedio de tres valores: 5+9+2/3 no es lo mismo que (5+9+2)/3

Cuando los programas no hacen lo que Uds. quieren, probablemente tengan que mirar de nuevo lo que hicieron y corregir este procedimiento es conocido como Debugin o Depuracion.

Que alternativas tenemos cuando un programa no hace lo que queremos:

1) Crash.Termina repentinamente tirando un cartel u error o no.

2) Never stop.nunca termina, puede ser dificil de detectar, se dice que tiene un loop infinito.

3) Run Completion & producir mal la respuesta.

TALLER DE INFORMÁTICA CAPITULO 2. Introducción a la Programación

23

CAPITULO 2.

INTRODUCCION A LA PROGRAMACION

2.1. ANÁLISIS Y RESOLUCIÓN DE PROBLEMAS.

Un problema es un asunto o un conjunto de cuestiones que se plantean para ser resueltas.

La naturaleza de los problemas varía con el ámbito o con el contexto donde están planteados; consideramos aquí sólo aquellos problemas cuya solución se puede calcular utilizando una serie de reglas

introducidas en la computadora.

No existe un método universal que permita resolver cualquier problema.

En general, la resolución de problemas es un proceso creativo donde el conocimiento, la habilidad y la experiencia tienen un papel importante.

El proceder de manera sistemática (sobre todo si se trata de problemas complejos) puede ayudar en la solución.

Un programador de computadoras es una persona que, antes que nada, resuelve problemas. Para ser

bueno deberá resolver los problemas de un modo riguroso y sistemático.

En general, la solución de problemas con la computadora se puede dividir en tres etapas:

Análisis del problema

Diseño del algoritmo

Implementación del algoritmo en la computadora

2.1.1. Análisis del Problema El análisis del problema es la primera fase en la resolución de un problema con la computadora.

El objetivo del análisis es comprender y definir claramente la naturaleza del problema.

En esta etapa es fundamental establecer con claridad que hará el programa que se pretende construir.

No se puede abordar una solución mientras no se sepa adonde se quiere llegar.

Para poder definir el problema con precisión se requiere especificar con detalle cuales serán los datos de

entrada y cuales los datos de salida.

Así pues, el análisis del problema comprende los siguientes aspectos:

Definición del problema.

Especificaciones de entrada.

Especificaciones de salida.

2.1.2. Diseño del Algoritmo Si en la fase de análisis en el proceso de programación se determina qué hace el programa. En la fase

de diseño se determina cómo hace el programa la tarea solicitada; en esta etapa se construye un algoritmo que resuelva el problema analizado utilizando una herramienta algorítmica como el diagrama de flujo o el

pseudocódigo.

Se decide como hará el algoritmo para producir los datos de salida sobre la base de los datos de

entrada. Esto puede requerir de acciones secuenciales, tomas de decisiones y repeticiones de procesos.

Diseño del Algoritmo

Análisis del Problema

Programa de Computadora


24

Para un diseño eficiente del algoritmo es importante abordar la solución mediante una metodología de

diseño.

Los métodos utilizados para el proceso del diseño se basan en el conocido “divide y vencerás” es decir,

la resolución de un problema complejo se realiza dividendo el problema en subproblemas y a continuación dividiendo estos subproblemas en otros de nivel mas bajo, hasta que sea implementada una solución en la

computadora.

Este método se conoce técnicamente como diseño descendente (top-down) o modular.

Cada programa bien diseñado consta de un programa principal (el módulo de nivel mas alto) que llama a subprogramas (módulos) de nivel mas bajo, que a su vez pueden llamar a otros subprogramas.

El diseño del algoritmo es independiente del lenguaje de programación en el que se vaya a codificar

posteriormente.

Definición de Algoritmo

El término deriva de la traducción al latín de la palabra árabe “Alkhowarismi”, 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.

No todos ellos pueden ser ejecutados por la computadora. Consideramos aquellos algoritmos que

expresan soluciones usando reglas cuantitativas cuyas instrucciones pueden ser introducidas en la computadora, a este tipo de algoritmos se denominan Algoritmos Computacionales.

En la resolución de un problema con la computadora la parte pensante está en el algoritmo; así pues la eficacia de un programador no esta en conocer la herramienta de programación, cosa necesaria, sino en

saber resolver problemas con la computadora para lo cual se requiere conocer un concepto conocido como metodología de la programación cuyo eje central es el algoritmo.

Los algoritmos son independientes del lenguaje de programación y de la máquina en la que se ejecuta.

Un Algoritmo es un conjunto ordenado y finito de pasos o instrucciones que

conducen a la solución de un problema.

Características del Algoritmo

preciso, tiene que indicar el orden de realización en cada paso.

definido, es decir, si el algoritmo se prueba dos veces, en estas dos pruebas, se debe obtener el mismo resultado.

finito, es decir, que el algoritmo tiene que tener un número determinado de pasos.

debe producir un resultado en un tiempo finito.

2.1.3. Implementación del Algoritmo en la Computadora.

Esta etapa es relativamente mecánica y consiste en codificar el algoritmo siguiendo las reglas sintácticas y semánticas de un determinado lenguaje de programación.

Al resultado de la codificación se denomina código fuente o programa fuente.

Luego de ello, el programa fuente debe ser ejecutado y probado para verificar si los resultados obtenidos son los esperados.

La verificación del programa se efectúa con una amplia variedad de datos de entrada, llamados datos de test o datos de prueba, que determinarán si el programa tiene errores ("bugs").

Los datos de prueba comprenden: valores normales de entrada, valores extremos de entrada que comprueben los límites del programa y valores de entrada que comprueben aspectos especiales del programa.

Si los resultados obtenidos no son los esperados se procede a depurar el programa. La depuración consiste en encontrar los errores del programa para efectuar las correcciones pertinentes.


25

Así pues, la implementación de un algoritmo en la computadora comprende los siguientes aspectos:

Codificación

Compilación y ejecución

Verificación

Depuración

Documentación

Codificación: Es la escritura en un lenguaje de programación de la representación de un algoritmo, se

ha convertido en un programa fuente.

Compilación y ejecución: El programa fuente debe ser traducido a lenguaje máquina. Este proceso se realiza con el compilador y el sistema operativo. Se obtiene el programa objeto, el cual todavía no es

ejecutable directamente.

Al no existir errores en el programa fuente se debe instruir al sistema operativo para que efectúe la fase de montaje o enlace, del programa fuente con las librerías del programa del compilador. Este proceso de montaje produce un programa ejecutable.

Cuando se ha creado un programa ejecutable este ya se puede ejecutar desde el sistema operativo con solo teclear su nombre.

Programa Fuente

Compilador (traductor)

Programa Objeto

Montador (link)

Programa Ejecutable


26

2.2. ETAPAS EN LA CREACIÓN DE PROGRAMAS.

Retomando los conceptos introducidos en el punto 2.1., los principales pasos o metodología que se debe seguir para resolver problemas aplicando técnicas de programación son:

2.2.1. Análisis del Problema. Consiste en entender de qué se trata el problema planteado y esbozar su posible solución, concluyendo

con una clara definición de tres aspectos:

1º) ¿qué es lo que nos piden?, es decir, la definición del resultado o solución deseada (para qué).

2º) ¿cómo obtener lo que nos piden? (qué hacer).

3º) ¡qué necesitamos para obtener los resultados pedidos? (con qué).

En resumen, determinar: las operaciones o procesos que se van a realizar (qué hacer) y sus respectivas entradas (con qué) y salidas (para qué).

Entrada: son los argumentos (variables o constantes) que se requieren para resolver un problema.

Salida: son los resultados (argumentos) que se desean obtener una vez resuelto el problema.

Proceso: es el procedimiento(s) u operación(es) que deben efectuarse sobre las entradas para obtener las salidas deseadas.

Puede ser de gran utilidad elaborar una tabla de especificación de argumentos requeridos en la solución del problema que contemple los siguientes aspectos:

descripción del argumento identificador tipo condición restricción

En la tabla aparecen detalladas bajo qué restricciones se ha de operar

2.2.2. Diseño. Consiste en diseñar cómo hace el programa la tarea solicitada. En forma general consiste en dividir el

programa en subprogramas y cada subprograma en módulos.

Ir de lo más general a lo más específico.

El criterio de descomposición más utilizado es el de tipo funcional, el cual produce una estructura

jerárquica en la que cada módulo ejecuta una o más funciones.

2.2.3. Implementación del Algoritmo en la Computadora El item Implementación del Algoritmo en la Computadora del punto 2.1. se puede descomponer en:

a) Codificación.

Es la escritura en un lenguaje de programación de la representación del algoritmo desarrollado en la

etapa de diseño. El resultado de la codificación es un programa fuente.


27

b) Compilación y Ejecución.

Es el proceso de traducción del programa fuente al lenguaje de máquina. Este proceso se realiza con el

compilador y el Sistema Operativo. El resultado, si no hay errores, es la obtención del programa objeto que todavía no es ejecutable directamente. Luego, mediante el Sistema Operativo se realiza la carga del

programa objeto con las librerías del programa compilador, el resultado es un programa ejecutable. Cuando el programa ejecutable se ha creado, se puede ejecutar el programa desde el Sistema Operativo

generalmente con sólo teclear su nombre. Si no hay errores se obtiene como salida los resultados del

programa.

c) Verificación y Depuración.

Es el proceso de probar que el programa trabaje correctamente y cumpla con los requerimientos del usuario.

Verificar: es el proceso de ejecución del programa con una amplia variedad de datos de entrada (test o pruebas) que determinarán si el programa tiene errores.

Depurar: es el proceso de encontrar los errores del programa y corregir o eliminar dichos errores.

Tipos de Errores:

a) Errores de compilación: suelen ser errores de sintaxis.

b) Errores de ejecución: suelen ser instrucciones que la computadora comprende pero que no puede

ejecutar. Ejemplo: divisiones por cero, raíces negativas, etc.

c) Errores de lógica: se producen en la lógica del programa, en el diseño del algoritmo. Se detectan porque los resultados son incorrectos.

2.2.4. Documentación y Mantenimiento. Consta de la descripción de los pasos a dar en el proceso de resolución de un problema.

El mantenimiento consiste en la actualización de los programas con los cambios requeridos por el

usuario o corrección de posibles errores futuros.

Gráficamente la metodología puede ilustrarse de la siguiente manera:


28

2.3. PROGRAMAS: CONCEPTO, CARACTERÍSTICAS.

Una vez que la solución de un problema ha sido expresada mediante un algoritmo el paso siguiente es convertirlo a programa para lo cual se elige un lenguaje de programación.

Un programa es la implementación de un algoritmo en un determinado lenguaje

de programación.

Un programa puede considerarse como una secuencia de acciones o

instrucciones que manipulan un conjunto de objetos, los datos.

2.3.1. Partes de un programa.

Contiene dos bloques:

Bloque de declaraciones: en él se especifican todos los objetos que utiliza el programa

(constantes, variables, tablas, registros, archivos, etc.).

Bloque de instrucciones: constituido por el conjunto de operaciones que se han de realizar para

la obtención de los resultados deseados.

Partes principales de un programa

Dentro del bloque de instrucciones de un programa podemos diferenciar tres partes fundamentales:

Entrada de datos: la constituyen todas aquellas instrucciones que toman datos de un dispositivo externo, almacenándolos en la memoria central para que puedan ser procesados.

Proceso: está formado por las instrucciones que modifican los objetos a partir de su estado

inicial hasta el estado final, dejando éstos disponibles en la memoria central.

Salida de resultados: conjunto de instrucciones que toman los datos finales de la memoria

central y los envían a los dispositivos externos.


29

2.4. TÉCNICAS DE PROGRAMACIÓN.

2.4.1 Programación no Estructurada. Comúnmente, las personas empiezan a aprender a programar escribiendo programas pequeños y

sencillos consistentes en un solo programa principal. Aquí "programa principal" se refiere a una secuencia de

comandos o instrucciones que modifican datos que son a su vez globales en el transcurso de todo el programa.

Programación no Estructurada => El programa principal opera directamente sobre datos globales.

Ésta técnica de programación ofrece desventajas una vez que el programa se hace suficientemente grande. Por ejemplo, si la misma secuencia de instrucciones se necesita en diferentes situaciones dentro del

programa, la secuencia debe ser repetida.

Esto ha conducido a la idea de extraer estas secuencias, darles un nombre y ofrecer una técnica para llamarlas y regresar desde estos procedimientos.

2.4.2 Programación Procedimental Con la programación procedimental se pueden combinar las secuencias de instrucciones repetibles en un

solo lugar.

Una llamada de procedimiento se utiliza para invocar al procedimiento, después de que la secuencia es procesada, el flujo de control continúa exactamente después de la posición donde la llamada fue hecha.

Ejecución de procedimientos => Después del procesamiento, el flujo de controles procede donde la llamada fue hecha.

Al introducir parámetros así como procedimientos de procedimientos (sub procedimientos) los programas ahora pueden ser escritos en forma más estructurada y libres de errores.

Por ejemplo, si un procedimiento ya es correcto, cada vez que es usado produce resultados correctos.

Por consecuencia, en caso de errores, se puede reducir la búsqueda a aquellos lugares que todavía no han sido revisados.

Programa

principal

datos

Programa

principal

Procedimiento


30

De este modo, un programa puede ser visto como una secuencia de llamadas a procedimientos. El

programa principal es responsable de pasar los datos a las llamadas individuales, los datos son procesados por los procedimientos y, una vez que el programa ha terminado, los datos resultantes son presentados.

Así, el flujo de datos puede ser ilustrado como una gráfica jerárquica, un árbol, como se muestra en la siguiente figura para un programa sin sub procedimientos.

Programación Procedimental => El programa principal coordina las llamadas a procedimientos y pasa los datos apropiados en forma de parámetros.

Para resumir: tenemos ahora un programa único que se divide en pequeñas piezas llamadas

procedimientos o funciones. Para posibilitar el uso de procedimientos generales o grupos de procedimientos también en otros programas, aquéllos deben estar disponibles en forma separada. Por esa razón, la

programación modular permite el agrupamiento de procedimientos dentro de módulos.

2.4.3 Programación Modular En la programación modular, los procedimientos con una funcionalidad común son agrupados en

módulos separados. Un programa por consiguiente, ya no consiste solamente de una sección. Ahora está dividido en varias secciones más pequeñas que interactúan a través de llamadas a procedimientos y que

integran el programa en su totalidad.

Programación Modular => El programa principal coordina las llamadas a procedimientos en módulos

separados y pasa los datos apropiados en forma de parámetros.

Cada módulo puede contener sus propios datos. Esto permite que cada módulo maneje un estado interno que es modificado por las llamadas a procedimientos de ese módulo. Sin embargo, solamente hay un

estado por módulo y cada módulo existe sólo una vez en todo el programa.

Programa

principal datos

módulo 1

datos + datos 1

procedim. 1

módulo 2

datos + datos 2

procedim. 2 procedim. 3

Programa

principal

datos

Procedimiento 2

Procedimiento 3


31

2.5. EJERCICIO PARA ILUSTRAR LA METODOLOGÍA

1. Planteamiento del problema

Calcular la resistencia combinada cuando tres resistencias (R1, R2 y R3) están conectadas en paralelo. La fórmula de la resistencia combinada es:

El programa debe producir la siguiente salida: Resistencia Combinada en Ohmios es: XXX

2. Análisis

a) Especificación funcional: suponiendo que llamo RC a la Resistencia Combinada, del análisis deduzco que requiero de R1, R2 y R3 (entradas) para poder realizar el cálculo (proceso) de la RC (salida).

b) Especificación de los argumentos: se trata de la documentación de los argumentos utilizados.

argumentos identificador tipo condición restricción

Resistencia 1 R1 real Variable >0



Resistencia Combinada RC real Variable >0

3. Diseño

Especificación del Programa:

Nombre del Programa: resistencia

Función: Calcular la Resistencia Combinada de 3 resistencias conectadas en paralelo-

Argumentos: R1, R2, R3, RC

Argumentos de Entrada: R1, R2, R3

Argumentos de Salida: RC

Lenguaje de Programación: C++

Algoritmo: puede utilizarse pseudocódigo o diagrama de flujo.

Diagrama de flujo o algoritmo gráfico:

INICIO

R1, R2, R3

RC

FIN

32

4. Codificación en C++

/* PROGRAMA CALCULO DE RESISTENCIA

Programa escrito por: NN

Fecha: 99/99/99 */

//Este programa calcula la resistencia combinada de tres resistencias conectadas en paralelo

#include <iostream>

using namespace std;

int main()

{

float R1,R2,R3,RC;

cout << “Ingrese los valores de las 3 resistencias”;

cin >> R1;

cin >> R2;

cin >> R3;

RC = 1 / (1/R1+1/R2+1/R3);

cout << “La resistencia combinada en ohmnios es” << RC;

return 0;

}

5. Edición

Tipear el programa anterior (programa fuente) en el computador.

6. Compilación y Ejecución del programa editado

Para la obtención de los resultados previa corrección de posibles errores de sintaxis o de ejecución.

7. Verificación y Depuración de los resultados

Para corregir los posibles errores de lógica que puedan existir.

8. Documentación

9. Mantenimiento

PREGUNTAS DE REPASO 1. ¿Cuáles son las etapas para la solución de problemas con la computadora?

2. ¿Qué es un algoritmo? ¿Qué características tiene que tener?

3. ¿Cuáles son los pasos para poner un programa en funcionamiento?

4. ¿Qué es un programa? ¿Cuáles son las partes de un programa?

5. Nombre las características de las técnicas de programación.

6. Aplicar la metodología propuesta en el punto para resolver el siguiente problema: “¿Cuántas

horas tardará en llenarse un estanque de 270.480 litros si 4 bombas vierten 23 litros por minuto

cada una?”

TALLER DE INFORMÁTICA CAPITULO 3. Algoritmos

33

CAPITULO 3.

ALGORITMOS

“Quien quiere hacer algo encuentra un medio;

quien no quiere hacer nada encuentra una excusa”.

Proverbio chino

3.1. CONCEPTO. CARACTERÍSTICAS. DISEÑO.

3.1.1. Concepto El término deriva de la traducción al latín de la palabra árabe “Alkhowarismi”, 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.

No todos ellos pueden ser ejecutados por la computadora. Consideramos aquellos algoritmos que expresan soluciones usando reglas cuantitativas cuyas instrucciones pueden ser introducidas en la computadora, a este tipo de algoritmos se denominan Algoritmos Computacionales.

En la resolución de un problema con la computadora la parte pensante está en el algoritmo; así pues la eficacia de un programador no esta en conocer la herramienta de programación, cosa necesaria, sino en

saber resolver problemas con la computadora para lo cual se requiere conocer un concepto conocido como metodología de la programación cuyo eje central es el algoritmo.

Los algoritmos son independientes del lenguaje de programación y de la máquina en la que se ejecuta.

Un Algoritmo es un conjunto ordenado y finito de pasos o instrucciones que

conducen a la solución de un problema.

3.1.2. Características

preciso, tiene que indicar el orden de realización en cada paso.

definido, es decir, si el algoritmo se prueba dos veces, en estas dos pruebas, se debe obtener el

mismo resultado.

finito, es decir, que el algoritmo tiene que tener un número determinado de pasos.

debe producir un resultado en un tiempo finito.

3.1.3. Diseño

Existen diferentes técnicas utilizadas durante el diseño para la representación de algoritmos:

a. Pseudocódigo.

b. Diagrama de flujo de datos.

a) Pseudocódigo

Se trata de un lenguaje informal que describe el proceso.

34

El pseudocódigo es una herramienta algorítmica que permite escribir pseudoprogramas (una imitación de

un programa real) utilizando un lenguaje de pseudoprogramación que es una imitación de los lenguajes de programación de alto nivel. Debe ser: claro, inequívoco e informal.

Pseudocódigo es una combinación de símbolos (+, -, *, /, %, >, >=, <, <=, !=,

==, y, o, no), términos (Leer, Imprimir, Abrir, Cerrar, Hacer...Mientras, Mientras...Hacer, Para...Mientras, etc) y otras características comúnmente

utilizadas en uno o más lenguajes de alto nivel.

No existen reglas que determinen que es o no es un pseudocódigo, sino que varía de un programador a

otro.

El objetivo del pseudocódigo es permitir al programador centrarse en los aspectos lógicos de la solución

evitando las reglas de sintaxis de un lenguaje de programación. Posteriormente el pseudocódigo debe ser traducido a programa usando un lenguaje de programación.

Por Ejemplo:

Diseñe un algoritmo que permita hallar la suma y el promedio de tres nº

En castellano: En inglés:

INICIO

LEER numero1, numero2, numero3

suma = numero1 + numero2 + numero3

promedio = suma / 3

IMPRIMIR suma, promedio

FIN

BEGIN

READ numero1, numero2, numero3

suma = numero1 + numero2 + numero3

promedio = suma / 3

WRITE suma, promedio

END

b) Diagrama de flujo de datos

Se trata de un diagrama visual con una serie limitada de elementos con significado que permiten

formalizar de forma gráfica un algoritmo. Los significados son muy variados.

Los diagramas de flujo definen el concepto de flujo de datos, que nos indica la dirección que siguen los

datos en el proceso (de arriba hacia abajo, como si se tratara de líquido que fluye de arriba abajo).

Un diagrama de flujo es un diagrama que utiliza símbolos (cajas) estándar y que

tiene los pasos del algoritmo escrito en esas cajas unidas por flechas,

denominadas líneas de flujo, que indican la secuencia en que se deben ejecutar.

Los elementos más utilizados en un diagrama de flujo representan: Proceso, Decisión, Conectores, Fin,

Entrada/Salida, Dirección del Flujo.

En resumen:

En un diagrama de flujo siempre encontramos:

Una caja de “Inicio”

Otra caja de “Fin”

Otras cajas en forma de rombo, paralelogramos, rectangulares.

Cada símbolo representa el tipo de operación a ejecutar y el diagrama representa la secuencia en que se

deben ejecutar dichas operaciones. Más adelante veremos en detalle la simbología utilizada en los diagramas de flujo.


35

Las líneas de flujo representan el flujo secuencial de la lógica del programa.

El rectángulo significa algún tipo de proceso en la computadora, acciones a

realizar.

El paralelogramo es un símbolo de entrada que representa cualquier tipo de

entrada de datos al programa.

Este es un símbolo de salida que representa cualquier tipo de salida del programa.

El rombo es una caja de decisión que representa respuestas sí/no o diferentes

alternativas.

Cada diagrama comienza y finaliza con un símbolo terminal.

Por Ejemplo:

Diseñe un algoritmo que permita hallar la suma y el promedio de tres nº.

V

F

Inicio

N1 0

N2 0

N3 0

Leer

N1, N2,

N3

PROM (N1 + N2 + N3) / 3

Imprimir PROM

Fin


36

3.2. APLICACIÓN DE ESTRATEGIAS DE RESOLUCIÓN DE PROBLEMAS.

Es imposible enseñar a resolver problemas (es casi como enseñar a ser inteligente). Para resolver problemas no existen fórmulas mágicas; no hay un conjunto de procedimientos o métodos que aplicándolos lleven necesariamente a la resolución del problema, aún en el caso de que tenga solución. Pero de ahí no

hay que sacar en consecuencia una apreciación ampliamente difundida en la sociedad: la única manera de

resolver un problema sea por "ideas luminosas", que se tienen o no se tienen.

Es evidente que hay personas que tienen más capacidad para resolver problemas que otras de su misma

edad y formación parecida, que suelen ser las que aplican (generalmente de una manera inconsciente) toda una serie de métodos y mecanismos que suelen resultar especialmente indicados para abordar los

problemas.

El conocimiento y la práctica de los mismos es justamente el objeto de la resolución de problemas, y hace que sea una facultad entrenable, un tema en el que se puede mejorar con la práctica. Pero para ello

hay que conocer los procesos y aplicarlos de una forma planificada, con método.

Es ya clásica, y bien conocida, la formulación que hizo Polya (1945) de las cuatro etapas esenciales

para la resolución de un problema, que constituyen el punto de arranque de todos los estudios posteriores:

1º) Comprender el problema

Se trata de entender cuál es el problema que tenemos que abordar, dados los diferentes lenguajes que hablan el usuario que solicita y el informático.

Para ello se debe:

- Leer el enunciado despacio.

- Responder a las preguntas ¿Cuáles son los datos? (lo que conocemos) y ¿Cuáles son las incógnitas? (lo que buscamos)

- Hay que tratar de encontrar la relación entre los datos y las incógnitas.

- Si se puede, se debe hacer un esquema o dibujo de la situación.

2º) Trazar un plan para resolverlo

Hay que plantear el plan para resolver el problema de una manera flexible y recursiva, alejada del mecanicismo.

- ¿Este problema es parecido a otros que ya conocemos?

- ¿Se puede plantear el problema de otra forma?

- Imaginar un problema parecido pero más sencillo.

- Suponer que el problema ya está resuelto; ¿cómo se relaciona la situación de llegada con la de partida?

- ¿Se utilizan todos los datos cuando se hace el plan?

3º) Poner en práctica el plan

También hay que plantearla de una manera flexible y recursiva, alejada del mecanicismo. Y tener en cuenta que el pensamiento no es lineal, que hay saltos continuos entre el diseño del plan y su puesta en

práctica.

- Al ejecutar el plan se debe comprobar cada uno de los pasos.

- ¿Se puede ver claramente que cada paso es correcto?

- Antes de hacer algo se debe pensar: ¿qué se consigue con esto?


37

- Se debe acompañar cada operación matemática de una explicación contando lo que se hace y para qué

se hace.

- Cuando se tropieza con alguna dificultad que nos deja bloqueados, se debe volver al principio,

reordenar las ideas y probar de nuevo.

4º) Comprobar los resultados

Es la etapa más importante en la vida diaria, porque supone la confrontación con el contexto del resultado obtenido por el modelo del problema que hemos realizado, y su contraste con la realidad que

queríamos resolver.

- Leer de nuevo el enunciado y comprobar que lo que se pedía es lo que se ha averiguado.

- Debemos fijarnos en la solución. ¿Parece lógicamente posible?

- ¿Se puede comprobar la solución?

- ¿Hay algún otro modo de resolver el problema?

- ¿Se puede hallar alguna otra solución?

- Se debe acompañar la solución de una explicación que indique claramente lo que se ha hallado.

- Se debe utilizar el resultado obtenido y el proceso seguido para formular y plantear nuevos problemas.

Otras posibles etapas en la resolución de problemas son:

a) Análisis:

1. Trazar un diagrama.

2. Examinar casos particulares.

3. Probar a simplificar el problema.

b) Exploración:

1. Examinar problemas esencialmente equivalentes.

2. Examinar problemas ligeramente modificados.

3. Examinar problemas ampliamente modificados.

c) Comprobación de la solución obtenida:

1. ¿Verifica la solución los criterios específicos siguientes?:

a) ¿Utiliza todos los datos pertinentes?

b) ¿Está acorde con predicciones o estimaciones razonables?

c) ¿Resiste a ensayos de simetría, análisis dimensional o cambio de escala?

2. ¿Verifica la solución los criterios generales siguientes?:

a) ¿Es posible obtener la misma solución por otro método?

b) ¿Puede quedar concretada en casos particulares?

c) ¿Es posible reducirla a resultados conocidos?

d) ¿Es posible utilizarla para generar algo ya conocido?


38

3.3. ESTRUCTURAS BÁSICAS: LINEALES, SELECTIVAS Y REPETITIVAS

Cada proceso está compuesto de subprocesos y estos últimos a su vez, se componen de otros subprocesos más elementales. Es así como los programas están formados por un conjunto de funciones, estas por subfunciones y así sucesivamente hasta llegar a las operaciones elementales del procesador u

operaciones de máquina.

Las instrucciones son construcciones de lenguaje máquina (cadenas finitas de

dígitos) que permiten invocar a las operaciones elementales.

Por cada operación disponible hay una y sólo una instrucción.

En la mayoría de programas que se utilizan actualmente el resultado que deseamos que nos devuelva la computadora dependerá de los valores iniciales introducidos por el usuario de nuestra aplicación.

En la programación interactiva el usuario del programa puede interactuar con el programa e introducir datos mientras se ejecuta el programa.

Para facilitar la entrada de datos, la computadora debe indicar al usuario el momento en que debe introducir los datos; se deben visualizar mensajes interactivos con indicaciones al usuario.

3.3.1. Estructuras básicas lineales

3.3.1.1. Instrucción de lectura

Existen instrucciones que sirven para introducir valores en nuestras aplicaciones.

Los dispositivos de entrada permiten que el usuario interactúe con la máquina. Por medio de los

dispositivos de entrada el usuario ingresa los datos a procesar en el sistema.

Las instrucciones de entrada son operaciones que dan acceso al programador a las funciones básicas de

los dispositivos de E, permitiéndole capturar datos de los dispositivos de entrada y asignarlos a variables para operar con ellos.

Los datos se pueden almacenar en memoria de tres formas diferentes:

* asociados con constantes

* asignados a una variable con una sentencia de asignación

* asignados a una variable con una sentencia de lectura.

La instrucción de entrada o lectura de datos permite asignar valores desde

dispositivos para almacenarlos en memoria.

Algunos ejemplos de dispositivos de entrada son: teclado, mouse, etc.

La operación de entrada se representa de la siguiente manera:

Diagrama de Flujo

Pseudocódigo

LEER (“Mensaje”, lista de variables) ó READ (“Mensaje”, lista de variables)

Lista de variables


39

Con esta instrucción el programa se detiene y el sistema pide un valor haciendo aparecer una ventana con un “Mensaje”, el usuario deberá introducir el valor que se le pide.

3.3.1.2. Instrucción de escritura

A medida que se realizan cálculos en el programa, se necesitan visualizar los resultados. Esto se conoce como operación de escritura o salida.

En la instrucción de salida se pueden incluir además mensajes de texto y variables.

La instrucción de salida o escritura de datos permite visualizar resultados

mediante los dispositivos de salida.

Algunos ejemplos de dispositivos de salida son: monitor, impresora, etc.

La operación de salida se representa de la siguiente manera:

Diagrama de Flujo

Pseudocódigo

IMPRIMIR(“Mensaje”, lista de variables) ó

WRITE (“Mensaje”, lista de variables)

Por Ejemplo:

El clásico "Hola Mundo": imprimirá en pantalla la frase 'Hola Mundo'.

Diagrama de Flujo

Pseudocódigo

INICIO

IMPRIMIR(“HOLA MUNDO”)

FIN

Por Ejemplo:

Operaciones de Entrada / Salida: El algoritmo permite sumar dos números ingresados por el usuario

Lista de variables

INICIO

FIN

“HOLA MUNDO”

40

Diagrama de Flujo

Pseudocódigo

INICIO

IMPRIMIR('Introduce el primer número:')

LEER (num1)

IMPRIMIR('Introduce el segundo número:')

LEER (num2)

IMPRIMIR ('El total es: ' , num1 + num2)

FIN

Esto debe visualizar en pantalla lo siguiente:

Introduce el primer número: 89 <Intro presionado por el usuario>

Introduce el segundo número: 1 <Intro presionado por el usuario>

El total es: 90

3.3.1.3. Instrucción de asignación

Se debe pensar en una variable como una posición de memoria, cuyo contenido puede variar. La forma de modificar el contenido de una variable es mediante el uso de una operación de asignación.

La instrucción de asignación consiste en dar a una variable el valor de una

expresión, el valor de otra variable o el valor de una constante. La asignación tiene efecto destructivo en el sentido que destruye el valor previo de la variable

que recibe la asignación.

La operación de asignación es la forma de darle valores a una variable. Se la conoce también como sentencia o instrucción de asignación cuando hablamos de un lenguaje de programación.

La operación de asignación se representa de la siguiente manera:

Diagrama de Flujo

Pseudocódigo

Nombre_de_variable expresión

Se demuestra en pseudocódigo con el símbolo (Una flecha apuntando hacia el identificador, donde se

desea guardar el valor).

En la parte izquierda de la asignación se pone el nombre de la variable que se quiere modificar.

INICIO

FIN

“Introduce el primer número:”

num1

“Introduce el segundo número:”

Num2

“El total es: ”, num1 + num2

Nombre_de_variable expresión

41

La parte derecha contiene una expresión que le dará el nuevo valor a la variable, y por lo tanto debe

tener el mismo tipo que la variable.

La sentencia de asignación se ejecuta en dos pasos:

1º) la computadora calcula el valor de la expresión que aparece del lado derecho del operador, obteniéndose un valor de tipo específico.

2º) el valor se almacena en la variable cuyo nombre aparece a la izquierda del operador de asignación, reemplazando el valor que tenía anteriormente.

Por Ejemplo:

A 16,8

Esto significa que a la variable A se le ha asignado el valor 16,8. La operación es destructiva, ya que el valor que tuviera la variable antes de la asignación se pierde y se reemplaza por el nuevo valor.

Inicial 'La‟ se asigna La a la variable Inicial

Interruptor true se asigna el valor true (verdadero) a Interruptor

Num ( 100 * 3 ) / 2 se realiza el cálculo que aparece a la a la izquierda del operador de

asignación y luego se asigna el resultado a la variable Num.

Información adicional

Es posible utilizar el mismo nombre de variable en ambos lados de la expresión.

Por Ejemplo:

A A * 0,21

En este ejemplo, el valor de la variable A se multiplica por 0,21 y a continuación el resultado se asigna a la misma variable A.

Reglas de Asignación

1) Una variable en el lado derecho de una sentencia de asignación debe tener un valor antes de que la

sentencia de asignación se ejecute. Hasta que un programa le da un valor a una variable, esa variable no tiene valor. Por ejemplo: Si x no tiene un valor antes de ejecutar y <- x+1, se producirá un error lógico.

2) En la izquierda de una sentencia de asignación solo pueden existir variables, no una expresión.

Por ejemplo: NO es valido lo siguiente: Valor_Neto - Tasas 34015

3) La asignación tiene efecto destructivo en el sentido que destruye el valor previo de la variable que recibe la asignación.

Cuidado:

En las instrucciones de asignación NO se pueden asignar valores a una variable de tipo diferente del suyo; esto señalará un error.

3.3.2. Estructuras básicas selectivas

En la solución de la mayoría de los problemas algorítmicos se requieren efectuar tomas de decisiones

que conducen a la ejecución de una o más acciones dependiendo de la verdad o falsedad de una o más condiciones. Como consecuencia de esto, se producen cambios en el flujo de control del programa. Dicho

flujo de control implica rutas que deben ser seleccionadas.

Las expresiones lógicas toman el valor verdadero y falso, por lo tanto, se necesita una sentencia de

control para la toma de decisiones.

Una instrucción condicional es aquella que nos permite "preguntar" sobre el entorno que nos rodea,

pudiendo así actuar según la respuesta obtenida. Estas respuestas siempre serán Verdaderas o Falsas, pudiendo así tomar, en un principio, dos caminos diferentes.

42

Las estructuras selectivas o estructuras de decisión son estructuras de

programación que se utilizan cuando se desea ejecutar una acción dependiendo

de si una expresión es verdadera o falsa.

Las estructuras selectivas o de selección se clasifican en:

Estructura de selección simple (IF).

Estructura de selección doble (IF - ELSE).

Estructura de selección múltiple (CASE)

3.3.2.1. Estructura de Selección Simple: IF

En la estructura de selección simple IF ( SI ), evalúa una condición lógica y:

a) Si la condición es verdadera se ejecuta la acción A. La acción A puede ser una acción simple (una sola acción) o una acción compuesta (un conjunto de acciones).

b) Si la condición es falsa, no se hace nada.

En el caso de acciones compuestas, estas serán encerradas entre llaves.

La estructura de Selección Simple es cuando la expresión lógica contenida por

los paréntesis es verdadera, se ejecutan las instrucciones dentro de la estructura de selección, cuando es falsa, el programa ignora la estructura y se sigue

ejecutando la instrucción siguiente a la estructura de control.

Diagrama de Flujo

Pseudocódigo

Acción simple

IF( condición )

acción A

Acción compuesta

IF( condición ){

acción A1

acción A2

…

acción An

}

Por Ejemplo:

Se desea cambiar el signo de un número únicamente en caso que sea negativo.

IF( numero < 0 )

numero = -1 * numero

Si el número no es negativo, simplemente esta estructura se pasaría por alto y se continuaría en la

siguiente instrucción después del IF.

3.3.2.2. Estructura de Selección Doble: IF - ELSE

La estructura de selección doble IF (SI) – ELSE (SINO) evalúa una condición lógica y:

Si la condición es verdadera, ejecuta la acción A.

Si la condición es falsa, ejecuta la acción B.


43

Tanto la acción A como la acción B pueden ser acciones simples (una sóla acción) o acciones compuestas (un conjunto de acciones).

La estructura de selección if/else permite que el programador especifique la ejecución de una acción

distinta cuando la condición es falsa.

La estructura de Selección Doble (if / else) es una estructura que permite

bifurcar el flujo de ejecución según el argumento del if. Esta sentencia ejecuta el código correspondiente al if si se cumple la condición de su argumento, de no

ser así ejecuta el código correspondiente al else. El else es opcional.

Por Ejemplo:

Se desea saber si una persona es mayor o menor de edad.

IF( edad >= 18 )

IMPRIMIR "Mayor de edad"

ELSE

IMPRIMIR "Menor de edad"

Esto imprime "Mayor de edad" si la persona tiene 18 años ó más e imprime "Menor de edad" si la persona tiene menos

de 18 años. En cualquiera de los casos, después de

efectuar la impresión, se ejecutará la primera instrucción que sigue a la estructura IF...ELSE.

Estructura de Selección Doble

Diagrama de Flujo

Pseudocódigo

Acciones simples

IF( condición )

acción A

ELSE

Acción B

Acciones compuestas

IF( condición ){

acción A1

...

acción An

}

ELSE{

Acción B1

…

acción Bn }

Explicaremos línea a línea la estructura:

Primera línea: IF( condición ) En esta línea pondremos la (condición) que nos interesa evaluar.

Segunda línea: Acción A Línea o líneas donde pondremos las instrucciones a efectuar en caso

de que la condición sea VERDADERA.

Tercera línea: ELSE A partir de aquí tendremos las instrucciones que se ejecutarán cuando la condición sea FALSA.

Cuarta línea: Acción B Línea o líneas donde pondremos las instrucciones a efectuar en caso de que la condición sea FALSA.

Quinta línea: } Línea que nos indica el final de la estructura condicional.


44

La tercera y cuarta línea son opcionales, ya que puede haber un momento en el que al mirar una

condición nos interese solo una de las posibles respuestas.

3.3.2.3. Estructura de Selección: Doble en Cascada

Se dice que varias estructuras de selección doble están en cascada cuando la instrucción que sigue a un ELSE es otro IF a excepción del último ELSE. No hay límite en cuanto al número de estructuras de

selección doble que pueden ponerse en cascada.

Funcionamiento

Las condiciones se evalúan en orden descendente pasando de una a otra si la anterior resulta falsa. En

el momento que se encuentra una condición verdadera, se efectúa la acción correspondiente a dicha condición y se corta el resto de la estructura. Si todas las condiciones resultan falsas se efectúa la acción

correspondiente al último SINO

Selección doble en cascada: Forma 1

IF( condición C1 ) acción A1

ELSE IF( condición C2 )

acción A2

ELSE IF( condición C3 )

acción A3 …

ELSE Acción An

Selección doble en cascada: Forma 2

IF( condición C1 )

acción A1 ELSE IF( condición C2 )

Acción A2 ELSE IF( condición C3 )

Acción A3

… ELSE

Acción An

45

Por Ejemplo:

Diseñe un algoritmo que determine si un número es negativo, positivo o cero.

Algoritmo (Formato 1)

INICIO

REAL n

LEER n

IF ( n > 0 )

IMPRIMIR "Positivo"

ELSE

IF ( n < 0 )

IMPRIMIR "Negativo"

ELSE

IMPRIMIR "Cero"

END

Algoritmo (Formato 2)

INICIO

REAL n

LEER n

IF ( n > 0 )

IMPRIMIR "Positivo"

ELSE IF ( n < 0 )

IMPRIMIR "Negativo"

ELSE

IMPRIMIR "Cero"

END

3.3.2.4. Estructuras de Selección: Anidadas

Se dice que una estructura IF (o IF-ELSE) esta anidada cuando esta contenida dentro de otra estructura IF o dentro de otra estructura IF-ELSE. No existe límite en cuanto al nivel de anidamiento.

Por ejemplo, una estructura IF con tres niveles de anidamiento tendría el siguiente formato:

IF( condición C1 ){

acción A1

IF( condición C2 ){

acción A2

IF( condición C3 )

acción A3

}

}

INICIO

n > 0

“Negativo“

“Positivo “

n < 0

“Cero“

FIN

n

“Ingrese nº: “

n


46

En general, el anidamiento podría evitarse usando el operador lógico "y".

Así, la anterior selección SI anidada puede descomponerse en tres estructuras de selección simple no anidadas consecutivas, como se muestra a continuación.

IF( condición C1 )

acción A1

IF( condición C1 and condición C2 )

acción A2

IF( condición C1 and condición C2 and condición C3 )

acción A3

La estructura de selección doble en cascada es un caso especial de la estructura IF...ELSE anidada.

Cuidado!!

Es muy importante que se utilice un buen sangrado en cada sentencia selectiva, para que sea más

legible el código, y además que se comente el código, para que no te pierdas si llevas escritas varias líneas, y también por si alguna otra persona, desea actualizar tu código.

3.3.2.5. Estructura de Selección Múltiple: CASE

La estructura de selección múltiple CASE permite elegir una ruta de entre varias rutas posibles, usando

para ello una variable denominada selector.

El selector se compara con una lista de constantes enteras o de carácter C1, C2, ..., Cn para cada una de

las cuales hay una acción A1, A2, ..., An y:

Si el selector coincide con una constante de la lista, se ejecuta la acción correspondiente a dicha

constante.

Si el selector no coincide con ninguna constante de la lista, se ejecuta la acción Df correspondiente al ELSE, si es que existe.

Las acciones A1, A2, A3, ..., An pueden ser acciones simples( una sola acción) o acciones compuestas (un conjunto de acciones).

Pseudocódigo de la estructura de selección múltiple

CASE ( selector ){

C1 : acción A1

C2 : acción A2

…

Cn : acción An

ELSE: acción Df

}

La estructura de Selección Múltiple CASE es una sentencia que se utiliza para

elegir entre diferentes alternativas. Se compone de varias sentencias simples,

cuando se ejecuta, una y solo una de las sentencias simples se selecciona y

ejecuta. El valor del selector debe ser un tipo ordinal, y los valores constantes

deben tener el mismo tipo que el selector.

http://www.geocities.com/david_ees/Algoritmia/#Selección Doble en Cascada


47

Esta estructura es muy útil en el momento en el que debemos tomar diferentes decisiones de una misma condición.

Funcionamiento:

En el lugar donde aparece la palabra selector pondremos la condición a evaluar.

El selector puede ser una variable, una instrucción o cualquier cosas que en el programa tome diferentes valores.

En el lugar de C1, C2, etc. pondremos los diferentes valores que puede tomar la condición según los

cuales el programa debe hacer una u otra cosa.

Pueden existir tantos valores como se necesite.

Después de las líneas donde pondremos los diferentes valores que puede tomar la condición colocaremos las instrucciones que queremos que se realicen. Piensa que estas instrucciones pueden ser solo una operación o toda una serie de instrucciones anidadas, tan complejas como lo requiera el programa que

estamos realizando.

3.3.3. Estructuras de Control Repetitivas

Los procesos repetitivos son la base del uso de las computadoras. En estos procesos se necesita

normalmente contar los sucesos, acciones o tareas internas del ciclo.

Una estructura cíclica o estructura repetitiva es aquella que le permite al

programador repetir un conjunto o bloque de instrucciones un número determinado de veces mientras una condición dada sea cierta o hasta que una

condición dada sea cierta.

Se debe establecer un mecanismo para terminar las tareas repetitivas. Dicho mecanismo es un control

que se evalúa cada vez que se realiza un ciclo. La condición que sirve de control puede ser verificada antes o después de ejecutarse el conjunto de instrucciones o sentencias. En caso de que la verificación o

evaluación resulte verdadera se repite el ciclo o caso de ser falsa lo terminará.

Son aquellas estructuras que permiten que una o varias sentencias se ejecuten repetidamente.

Las Estructuras Repetitivas o Iterativas son aquellas en las que las acciones se

ejecutan un número determinado de veces y dependen de un valor predefinido o

el cumplimiento de una determinada acción.

a) Bucle

Es la estructura de control que permite la repetición de una serie determinada de sentencias.

Es importante tener en cuenta cuántas veces se repite el bucle y cuál es el cuerpo del bucle.

El cuerpo del bucle lo constituyen la serie de sentencias que pueden ser de

cualquier tipo (secuencial, de decisión o repetitivo) las cuales serán repetidas n veces, pudiendo ser n conocido o desconocido. Cuando n es desconocido, el

número de veces que debe repetirse el cuerpo del bucle estará condicionado por

una expresión lógica.


48

Un bucle no es más que una serie de instrucciones que se repiten.

Podemos tener dos tipos de bucles según lo que nos interese comprobar:

El bucle que se repite mientras se cumple una condición determinada, y

El bucle que se realiza hasta que se cumple la condición que marcamos.

Cuidado

A la hora de utilizar un bucle, sea del tipo que sea, debemos ir con cuidado y pensar cuando debe

acabar ya que si no tuviéramos en cuenta esto podríamos entrar en un bucle sin fin, o sea que iríamos repitiendo las mismas líneas teniendo que abortar la aplicación, para poderla finalizar.

Por esto es de suma importancia que pensemos, antes de hacer nada, en qué momento, cómo, dónde y por qué debe acabar el bucle.

b) Características de las Estructuras Repetitivas

Las estructuras repetitivas permiten representar aquellas acciones que pueden descomponerse en otras sub-acciones primitivas.

Es una estructura con una entrada y una salida en la cual se repite una acción un número determinado o indeterminado de veces

En una Estructura Repetitiva While (Mientras) se repite una acción mientras se cumpla la condición que controla el bucle. La característica principal de esta estructura es que la condición es evaluada siempre

antes de cada repetición.

La Estructura Repetitiva For (Desde) permite que las instrucciones las cuales contiene en su ámbito, se ejecuten un número de veces determinado.

Entre las estructuras repetitivas se encuentran:

3.3.3.1. Estructura While (mientras)

Mediante esta estructura el cuerpo del bucle se repite mientras se cumpla una determinada condición (en otras palabras, mientras el resultado de la evaluación de la expresión lógica sea verdadero).

La condición se evalúa siempre al principio de cada iteración. Esto implica que, si el resultado de su

evaluación es falso desde el comienzo de la estructura, el bucle no se ejecuta nunca.

La Estructura Repetitiva While, es aquélla en que el cuerpo del bucle se repite

mientras se cumple una determinada condición.

Se usa cuando no se conoce el número de iteraciones.

49

La representación sería:

Diagrama de Flujo

Pseudocódigo

While (condición)

{

Acción S1

Acción S2

…

acción Sn

}

Explicaremos línea a línea este bucle:

Primera línea: WHILE (condición) {En esta línea pondremos la <condición> que se debe dar para que

se ejecute el bucle. En el momento que la condición sea Falsa se terminará el bucle y se continuará con las siguientes instrucciones.

Segunda línea: Acciones Línea o líneas donde pondremos las instrucciones a efectuar en caso de que la condición sea VERDADERA.

Tercera línea: } Fin del bucle Mientras. De aquí se pasa a la primera línea del bucle para volver a mirar la condición.

En esta estructura no tenemos ninguna línea que sea opcional.

Por Ejemplo:

Contar los números enteros positivos introducidos por teclado. Se consideran dos variables enteras NUMERO y CONTADOR (contará el número de enteros positivos). Se supone que se leen números positivos

y se detiene el bucle cuando se lee un número negativo o cero.

INICIO

Contador = 0

LEER (numero)

WHILE (numero > 0)

{

contador = contador + 1

LEER (numero)

}

IMPRIMIR ('El número de enteros positivos es: ', contador)

END

INICIO

FIN

Cont=0

“Ingrese nº: “

num

Cont=Cont+1

Cont

num

nu

m

50

3.3.3.2. Estructura Do … while (Hacer … mientras)

Esta estructura se ejecuta mientras se cumpla una condición determinada que se comprueba al final del bucle. Se ejecuta al menos una vez.

El Estructura Repetitiva Do … While se repite mientras el valor de la expresión

booleana de la condición sea verdadera, pero, a diferencia de la estructura

While, la condición se evalúa al final del bucle.

Pseudocódigo en inglés

DO

{

<acciones>

…

}

WHILE <condición>

La estructura de bucle Do ... While tiene un pequeño matiz que la hace diferente a la estructura While. Tanto una como la otra se utilizan frecuentemente, pero cada una de ellas va bien según el caso, estas estructuras pueden hacer su uso muy diferente. La condición se evalúa después de realizar las instrucciones

y no antes como pasaba en el caso del While.

Cuidado!!!

En la estructura Do…While primero ejecutaría las instrucciones y después miraría si se cumple o no la condición, con lo que tenemos que tener mucho cuidado ya que las instrucciones como mínimo se

ejecutarán una vez (las veces restantes ya dependerán de la condición).

Por Ejemplo:

Preguntar una letra y cantidad de repeticiones. Repetir en pantalla tantas veces como se indique.

INICIO

CHAR letra

INT x, n

x = 1

IMPRIMIR („Ingrese la letra: „)

LEER (letra)

IMPRIMIR („Cuántas veces quieres repetirlo?: „)

LEER (n)

DO

{

IMPRIMIR (x , ‟- „, letra)

x = x + 1

}

WHILE (x < n)

FIN

V

F

INICIO

FIN

x = 1

“Ingrese letra y cantidad“

letra, n

x = x + 1

num >

0

x, “-“, letra

51

3.3.3.3. Estructura For (Desde/Para)

Esta sentencia incluye una expresión que especifica el valor inicial de un índice, otra expresión que

determina cuando se continúa o no el bucle y una tercera expresión que permite que el índice se modifique al final de cada pasada.

La Estructura For ejecuta las acciones del cuerpo del bucle un número específico

de veces y de modo automático controla el número de iteraciones o pasos a

través del cuerpo del bucle.

La forma general de esta sentencia es:

for (expresión 1; expresión 2; expresión 3) sentencia

en donde:

expresión 1 (expresión de asignación), inicializa algún parámetro (llamado índice) que controla

la repetición del bucle;

expresión 2 (expresión lógica), representa una condición que debe ser satisfecha para que se

continúe la ejecución del bucle;

expresión 3 (expresión unitaria o expresión de asignación), modifica el valor del parámetro

inicialmente asignado por la expresión

La ejecución de la sentencia for sucede de la siguiente forma:

1. Se inicializan los parámetros.

2. Se evalúa la expresión lógica.

Si el resultado es distinto de cero (verdadero), se ejecuta la sentencia, se evalúa la expresión que da

lugar a la progresión de la condición y se vuelve al punto 2.

Si el resultado de 2, es cero (falso), la ejecución de la sentencia for se da por finalizada y se continúa en la siguiente sentencia del programa.

En muchas ocasiones se conoce de antemano el número de veces que se desean ejecutar las acciones de un bucle. En estos casos en el que el número de iteraciones es fija, se debe usar la estructura for. Esta

estructura se usa cuando se desea ejecutar un bucle un número determinado de veces, cuyo número se conoce por anticipado.

En la ejecución del FOR participan tres elementos:

V : variable de control del bucle,

Vi : valor inicial,

Vf : valor final

Existen dos formas de utilizar las estructuras de control repetitivas:

a) Con INCREMENTO DEL CONTADOR (Vi < Vf):

Pseudocódigo

FOR (V= Vi, V < Vf , V= V +1)

Sentencia;

FOR(V= Vi, V < Vf , V= V +1)

{

Sentencia 1;

Sentencia 2;

Sentencia N

}

Diagrama de Flujo

52

Cuando Vi es menor que Vf el valor de V se incrementa de uno en uno desde el valor de Vi hasta el valor

de Vf. Por cada valor que V toma, el cuerpo del bucle se ejecuta una vez.

Para representar la estructura FOR se puede utilizar el símbolo indicado o plantear el algoritmo con una estructura tipo WHILE, donde siempre aparece el inicio de la variable contador, la condición de fin y el incremento del contador.

Gráficamente sería:

FOR (V= Vi, V < Vf , V= V +1)

Sentencia;

b) Con DECREMENTO DEL CONTADOR (Vi > Vf):

Pseudocódigo

FOR (V= Vi, V > Vf , V= V - 1)

Sentencia;

FOR (V= Vi, V > Vf , V= V - 1)

{

Sentencia1;

…

Sentencia N

}

Cuando Vi es mayor que Vf el valor de V se decrementa de uno en uno desde el valor de Vi hasta el valor de Vf. Por cada valor que V toma, el cuerpo del bucle se ejecuta una vez.

Información adicional:

V debe ser de tipo ordinal (entero, carácter, lógico u otro tipo ordinal) o subrango.

V, Vi, Vf deben ser todas del mismo tipo, pero el tipo real no está permitido.

Vi, Vf pueden ser expresiones o constantes.

No se debe modificar el valor de V, Vi, Vf dentro del cuerpo del bucle.

INICIO

FIN

V = Vi

V = V + 1

V ‹ Vf

Sentencia/s


53

3.3.3.4. Bucles anidados

Son denominados todos aquellos bucles que estén contenidas dentro de otro bucle. Cuando se anidan bucles, se debe tener cuidado que el bucle interior esté contenido completamente dentro del bucle exterior.

Todos los tipos de bucles pueden anidarse, sea entre sí o entre cada uno de éstos (while, repeat o for).

Si los bucles se cruzan no serán válidos. Es decir, es incorrecto si los bucles anidados se construyen de la siguiente forma:

While, Repeat o For

While, Repeat o For

Fin While, Repeat o For

Fin While, Repeat o For

El primer bucle que se abra debe ser el último en

cerrarse. Lo que es equivalente a

decir, que el último bucle en

abrirse debe ser el primero en cerrarse y así tantas

veces como sea necesario.

Primer bucle abierto

NO puede ser el primer bucle en cerrarse.

INCORRECTO


54

3.4. CONTADORES, INTERRUPTORES Y ACUMULADORES.

La computadora sigue una serie de instrucciones, pero esas instrucciones tienen que operar sobre una serie de datos.

La computadora típica sólo procesa una instrucción a la vez, por lo que necesita 'espacios de memoria' donde guardar o depositar, a modo de cajones, los diversos datos con los que trabaja. Aquí es donde entran

en juego las variables y constantes.

Hay ciertas variables que realizan operaciones especiales de asignación: el contador y el acumulador

3.4.1. Contador

Un contador es una variable que se incrementa en una unidad o en una cantidad

constante.

Por Ejemplo:

Contador 25 x 50

Contador Contador + 1 x x + 5

Al ejecutar las sentencias de asignación, los nuevos valores de Contador y N son

25+1=26 y 50+5 =55.

3.4.2. Acumulador

El acumulador es una variable que se incrementa en una cantidad variable.

Por Ejemplo:

Suma Suma + x

Donde x es una variable; si x = 7 y Suma = 40, el nuevo valor de Suma será 47


55

3.5. ARREGLOS DE DATOS

Un arreglo de datos es una colección de datos organizados de un modo particular. Tienen un único nombre de variable, que representa todos los elementos, los cuales se diferencian por un índice o subíndice.

Por Ejemplo:

Notas de los estudiantes.

NOTAS nombre del arreglo

NOTAS[0] nombre del primer elemento del arreglo NOTAS

NOTAS[n-1] nombre del elemento n del arreglo NOTAS 0, 1, 2, 3, ... n-1 índices o subíndices del

arreglo (pueden ser enteros, no negativos, variables o expresiones enteras)

Un arreglo es un conjunto de elementos del mismo tipo agrupados en una sola

variable. Es una estructura de datos en la que se almacena una colección de

datos del mismo tipo

Cada posición de almacenamiento en un arreglo es llamada un elemento del arreglo.

Para ingresar a un elemento en particular, utilizamos un índice.

Existen arreglos unidimensionales, bidimensionales, etc.

Físicamente, un arreglo es un conjunto de localidades de memoria contiguas donde la dirección más

baja corresponde al primer elemento y la dirección más alta al último.

En un arreglo de n elementos, éstos ocuparan desde la casilla 0 hasta la n-1.

Por sí mismo, el nombre del arreglo apunta a la dirección del primer elemento del arreglo.

Cuidado!!!

En un arreglo de n elementos, éstos ocuparan desde la casilla 0 hasta la n-1.

Por Ejemplo:

Si tuviera un arreglo A de N = 10 elementos,

Notación matemática:

A1, A2, A3, …. , AN

A1, A2, A3, …. , A10

Notación computacional:

A[0], A[1], A[2], … , A[N-1]

A[0], A[1], A[2], … , A[9]

Clasificación de los arreglos

Los arreglos se clasifican en:

UNIDIMENSIONALES (vectores o listas) y

MULTIDIMENSIONALES (Ejemplo, los bidimensionales son las tablas o matrices).

3.5.1. Arreglos Unidimensionales o Vectores

Un arreglo de una sola dimensión es un arreglo que tiene solamente un subíndice.

Un subíndice es un número encerrado en corchetes a continuación del nombre del arreglo. Este

número puede identificar el número de elementos individuales en el arreglo.


56

Los arreglos unidimensionales o vectores son una lista o columna de datos

del mismo tipo, a los que colectivamente nos referimos mediante un nombre.

Deben cumplir lo siguiente:

- Estar compuestos por un número de elementos finitos.

- Ser de tamaño fijo: el tamaño del arreglo debe ser conocido en tiempo de compilación.

- Debe ser homogéneo: todos los elementos son del mismo tipo.

- Son almacenados en posiciones contiguas de memoria, a cada una de los cuales se les puede acceder directamente.

- Cada elemento se puede procesar como si fuese una variable simple ocupando una

posición de memoria.

Los vectores listan un número finito N de elementos homogéneos. Se hace referencia a los elementos por un conjunto de índices constituidos por números consecutivos. Se almacenan en memoria en celdas

consecutivas.

Donde:

N es la longitud del arreglo.

Homogéneos: todos los elementos son del mismo tipo.


Dado un vector denominado Z de 6 elementos, cada uno de sus elementos se designará por ese mismo

nombre diferenciándose únicamente por su correspondiente subíndice.

Z 5 7 4 9 3 1

Z0 Z1 Z2 ... Z5

Declaración del Vector

nombre_arreglo = tipo_dato [subíndice]

Donde:

nombre_arreglo: es un identificador válido.

subíndice: es un ordinal, por ejemplo [3]

tipo_dato: tipo de cada elemento del vector.

Por Ejemplo:

cod = CHAR [10] ;

nom = CHAR [ 60];


Las declaraciones de índices (tipo_índice) NO pueden contener variables.

3.5.2. Operaciones con Vectores

3.5.2.1. Lectura

Tienen que utilizarse estructuras de repetición para leer todos los elementos del vector. Es la carga de

los datos en los elementos del vector.

57

Por Ejemplo:

Notas = INT [30]

FOR (I = 0 ; I < 30 ; I = I + 1)

LEER ( Notas [I] );

3.5.2.2. Escritura

Es la muestra o impresión de los datos de cada elemento del vector.

Por Ejemplo:

Notas = INT [30]

FOR (I = 0 ; I < 30 ; I = I + 1)

IMPRIMIR (NOTAS[I] );

3.5.2.4. Búsqueda

Es la operación que permite encontrar la posición de un elemento con determinado valor o un elemento con determinado valor de índice.

Por Ejemplo:

INT x

Notas = INT [30]

IMPRIMIR („Ingrese el valor a buscar:‟)

LEER (x)

FOR (I = 0 ; I < 30 ; I = I + 1)

{

IF (NOTAS[I]==x)

IMPRIMIR („Encontró: „, NOTAS[I], „ en la posición‟ , I);

}

3.5.2.5. Orden

Es la operación que organiza los elementos de la lista según se indique. Existen varios métodos para ordenar los elementos de un arreglo que se verán más adelante.

3.5.2.6. Intercalación

Es la operación que combina los elementos de más de una lista según se indique.

3.5.3. Arreglos Bidimensionales o Matrices

Son arreglos con dos índices, los cuales deben ser ordinales o de tipo subrango.

Fi

las

Columnas

0 1 2 3 4 5

0 X[0,0] X[0,1] X[0,2]

1

2

3 X[3,0] X[3,5]

58

Un arreglo bidimensional es un arreglo de arreglos unidimensionales. Un

arreglo bidimensional tiene dos subíndices.

Al igual que para los arreglos unidimensionales, el nombre del arreglo define el nombre de sus elementos sólo que éstos se identifican por sus respectivos subíndices.

Un Arreglo Bidimensional es un conjunto de m x n elemento, cada uno

identificado por medio de dos índices [i, j] tal que, 1 < i < m y 1 < j < n. Es un

conjunto de m filas y n columnas, en el que el elemento A[i,j] se encuentra en la

fila i-ésima y en la columna j-ésima.

Por Ejemplo:

Así si el arreglo mostrado en la figura anterior se denomina X, cada uno de sus elementos se denominarán, por ejemplo:

X[0,0] elemento de la fila 0 columna 0



Así hasta identificar los 24 elementos del arreglo X de este ejemplo.

Se definen de la siguiente manera:

Identificador = tipo_elemento [indice1, indice2];

indice1: indica la cantidad de filas

indice2: indica la cantidad de columnas

Por Ejemplo:

parciales = float [37,4];


Reserva 148 posiciones de memoria (datos reales): 37 filas y 4 columnas.

Así parciales[i,j] se refiere al elemento del arreglo parciales referenciado mediante la fila i y la columna j.

3.5.4. Operaciones con Matrices

3.5.4.1. Lectura

Tienen que utilizarse estructuras de repetición para leer los elementos del arreglo. Si en el vector la lectura era por orden secuencial, en las matrices se puede realizar la lectura por filas o por columnas.

Por Ejemplo:

A = int[4,3];

FOR (i = 0 ; i < 4 ; i = i + 1)

FOR (j = 0 ; j < 3 ; j = j + 1)

LEER ( A[i,j]);

Los valores deben ser introducidos por filas o por columnas. En este ejemplo, se introducen por filas.

59

30

12

30 12 46 46

A = 84 10 3 84

6 8 11 10

3

6

8

11

3.5.4.2. Escritura

FOR (j = 0 ; j < 3 ; j = j + 1)

FOR (i = 0 ; i < 4 ; i = i + 1)

IMPRIMIR (x[i,j]);

Los valores deben ser mostrados por filas o por columnas. En este ejemplo, se introducen por columnas.

Preguntas de Repaso

1. ¿Qué es un diagrama de flujo?

2. ¿Cuáles son los símbolos que utilizan los diagramas de flujo para representar las distintas

operaciones?

3. ¿Cuáles son las estructuras lineales? Explique cada una utilizando un ejemplo.

4. ¿Cuáles son las estructuras selectivas? Explique cada una utilizando un ejemplo.

5. ¿Cuáles son las estructuras repetitivas? Explique cada una utilizando un ejemplo.

6. ¿Qué diferencias hay entre un contador y un acumulador?

7. ¿Qué es un arreglo?

8. ¿Cómo se identifica el primero y el último elemento de un arreglo de N elementos?


60

3.6. GUÍA DE EJERCICIOS

3.6.1. Ejercicios Algoritmo 1. Enumerar las acciones necesarias para realizar lo siguiente:

Calcular el producto de dos números utilizando la calculadora.

Llamar a un amigo desde un TE público.

Cambiar una lámpara eléctrica que se encuentra quemada.

Preparar mate amargo.

2. Plantear el algoritmo para hallar el valor de la variable A, sabiendo que es el promedio de B y C.

3. Proponer un algoritmo que dadas las variables Q, R, S y T, permita intercambiar sus valores de

modo que Q tenga el valor original de R, ésta el de S, S el de T y finalmente T el valor original de Q.

3.6.2. Ejercicios Expresiones

1. Si A = 5 y B = 10. ¿Qué valor asume C en cada caso?

B A C

3)- (A / A) - (B C

B 5* A C

A - 2 ̂5 / 1 / 2 / B 6 / 3* 2 / 4 C

2 / B)* (A* 4 25 A B C

B / 20 - B) / (A A ̂B C

5* A 2 / B - A C

3 ̂A) - (B 5* B* A C

3.6.3. Instrucciones Secuenciales

1. Escribir un algoritmo que lea dos números e imprima su suma.

2. Escribir un algoritmo que lea un número y escriba su cuadrado.

3. Escribir un algoritmo que calcule y muestre el cubo de un número ingresado.

4. Escribir un algoritmo que permita ingresar el perímetro de un círculo y luego calcule y muestre el radio del mismo.

5. Escribir un algoritmo que intercambie dos valores numéricos ingresados por teclado.

6. Escribir un algoritmo que halle el promedio de tres valores A, B, C. El mismo debe emitir los tres valores por separado y luego el valor promedio.

7. Convertir una cantidad expresada en dólares a pesos y mostrar el resultado. El algoritmo debe permitir ingresar la cantidad y el valor de la cotización del dólar. Realizar prueba de escritorio.

8. Convertir una temperatura dada en la escala Celsius e imprímase en su equivalente Fahrenheit. (F = (9/5) C + 32)

9. Diseñe un algoritmo para convertir una longitud dada en centímetros a pies. Considere que 1 pie = 30.48 centímetros.

10. Una institución benéfica europea ha recibido tres donaciones en soles, dólares y marcos. La

donación será repartida en tres rubros: 60% para la implementación de un centro de salud, 30% para un comedor de niños y el resto para gastos administrativos. Diseñe un algoritmo que

determine el monto en euros que le corresponde a cada rubro. Considere que: 1 dólar = 3.52 soles, 1 dólar = 2.08 marcos, 1 dólar = 1.07 euros.


61

11. En una competencia atlética de velocidad el tiempo se mide en minutos, segundos y centésimas

de segundo y el espacio recorrido se mide en metros. Diseñe un algoritmo para determinar la velocidad promedio de un atleta en km/h Considere que: 1 hora = 60 minutos, 1 minuto = 60

segundos, 1 segundo = 100 centésimas de segundo, 1 kilómetro = 1000 metros.

12. El sueldo neto de un vendedor se calcula como la suma de un sueldo básico de $ 250 más el 12% del monto total vendido. Diseñe un algoritmo que determine el sueldo neto de un vendedor conociendo el monto de las tres ventas que hizo en el mes.

13. Diseñe un algoritmo que exprese la capacidad de un disco duro en megabytes, kilobytes y bytes, conociendo la capacidad del disco en gigabytes. Considere que: 1 kilobyte = 1024 bytes, 1

megabyte = 1024 kilobyte, 1 gigabyte = 1024 megabytes.

14. Hacer un algoritmo que calcule la cantidad de horas, minutos y segundos entre dos eventos, de

los cuales se ingresarán la hora (expresada en horas, minutos y segundos) y la fecha (expresada en día, mes y año) en que ocurrieron.

15. Una bomba de agua puede extraer 800 litros de agua por hora. Realizar un algoritmo que calcule el tiempo necesario para extraer todo el líquido de un tanque del que se saben sus

medidas: altura y radio (éstas se ingresarán por teclado).

16. Determinar la velocidad de un automóvil que se desplaza a una velocidad constante si se conoce la distancia recorrida y el tiempo utilizado. Mostrar la velocidad encontrada. Ambos datos se

ingresan por teclado

17. Un pintor sabe que con una pintura determinada puede pintar 3,6 metros cuadrados con cada medio litro. Sabiendo la altura y el largo de la pared a pintar, realizar un algoritmo que informe cuantos litros de pintura necesitará para la pared en cuestión. Los datos de la pared se

ingresarán en metros.

18. Teniendo como dato la hipotenusa y el ángulo que forma la misma con la base de un triángulo rectángulo calcular y mostrar los lados y ángulos restantes.

19. Un motor de un 50rpm y tiene una Rueda conectada que tiene una relación de 1a 2 (una vuelta

del motor dos vueltas de la rueda). Realizar un algoritmo que calcule la distancia recorrida por la goma en una hora teniendo en cuenta de que el radio de la rueda es de 32 centímetros

20. Dados los catetos de un triángulo rectángulo, calcular e imprimir su hipotenusa. Fórmula de

cálculo: 22 b a h , donde a y b son los catetos, h es la hipotenusa.

21. Una maratón tiene 26 millas y 385 yardas. Realizar un algoritmo que permita convertir la distancia de la maratón a kilómetros, sabiendo que 1 milla tiene 1760 yardas.

3.6.4. Instrucciones de Decisión

1. Escriba un algoritmo que determine si un número ingresado es positivo, negativo o cero.

2. Escriba un algoritmo que permita leer dos valores numéricos A y B. Si A es mayor que B debe realizar la suma de ambos, caso contrario, se hace el producto.

3. Escriba un algoritmo que permita ingresar valores numéricos A, B, C, D, E y decir si su promedio es mayor que o igual a 10.

4. Hacer un programa que permita ingresa dos números y el símbolo de la operación (+,-,*,/). obteniéndose el correspondiente resultado. Si el símbolo no es correcto deberá imprimir un mensaje que indique “Error en símbolo”.

5. Escriba un algoritmo capaz de encontrar el máximo de dos valores (M y N)

6. Escriba un algoritmo capaz de encontrar el máximo de tres valores (R, S y T).

7. Escribir un algoritmo que permita ingresar tres números distintos entre sí y los muestre en

pantalla ordenados de mayor a menor y de menor a mayor.

8. Desarrollar un algoritmo que permita realizar la suma de dos horas distintas (HH, MM, SS).

Tener en cuenta que si la hora supera 24 se debe contar un día.

9. Leer los lados de un rectángulo y el radio de un círculo. Determinar si las áreas de ambas figuras son o no iguales.

10. Diseñe un algoritmo que permita ingresar la hora actual del día en tres variables, HH, MM y SS y determine cuantas horas, minutos y segundos restan para las 23:59:00.


62

11. Diseñe un algoritmo que permita ingresar dos valores X e Y, luego determine qué porcentaje es

X de Y.

12. El promedio de prácticas de un curso se calcula en base a cuatro notas de las cuales se elimina

la nota menor y se promedian las tres notas más altas. Diseñe un algoritmo que determine la nota eliminada y el promedio de un estudiante.

13. Diseñe un algoritmo que lea tres longitudes y determine si forman o no un triángulo. Si es un triángulo determine de que tipo de triángulo se trata entre: equilátero (si tiene tres lados

iguales), isósceles (si tiene dos lados iguales) o escaleno (si tiene tres lados desiguales). Considere que para formar un triángulo se requiere que: "el lado mayor sea menor que la suma

de los otros dos lados".

14. Ingresar un número C y determinar si pertenece al intervalo [A, B] con A y B ingresados por

teclado.

15. Una compañía dedicada al alquiler de automóviles cobra $30 hasta un máximo de 300 km de distancia recorrida.

16. Para más de 300 km y hasta 1000 km, cobra $30 más un monto adicional de $ 0.15 por cada kilómetro en exceso sobre 300. Para más de 1000 km cobra $30 más un monto adicional de $

0.10 por cada kilómetro en exceso sobre 1000. Los precios ya incluyen el 18% del impuesto general a las ventas, IGV.

Diseñe un algoritmo que, ingresando la distancia recorrida, determine el monto a pagar por el alquiler de un vehículo y el monto incluido del impuesto.

Basándose en el año de fabricación y el peso del automóvil en una fábrica se determina la tarifa de registro según la siguiente tabla:

Año

(modelo)

Peso (lb.) Categoría

de Peso

Tarifa de

Registro

1970 o

anterior

Menos de 2.700 1 $ 11.600

2.700 a 3.800 2 $ 23.200

Más de 3.800 3 $ 34.800

1971 a 1979 Menos de 2. 700 4 $ 13.000

2.700 a 3.800 5 $ 26.000

Más de 3.800 6 $ 39.000

1980 o

posterior

Menos de 3.500 7 $ 12.000

3.500 o más 8 $ 46.000

El programa debe ingresar el año y el peso del auto e imprimir la categoría y la tarifa.

17. El cuadrante en el cual se ubica una línea dibujada desde el origen está determinado por el ángulo que la línea forma con el eje positivo de x en la siguiente forma:

Ángulo del eje positivo de x Cuadrante

Entre 0 y 90 grados I

Entre 90 y 180 grados II

Entre 180 y 270 grados III

Entre 270 y 360 grados IV

El programa debe ingresar el ángulo de la línea como dato de entrada y desplegar el cuadrante

apropiado, según la tabla dada. Si el ángulo es exactamente 0, 90, 180 o 270 grados, la línea resultante no se ubica en ningún cuadrante sino en cada uno de los ejes respectivos.


63

INSTRUCCIONES REPETITIVAS

3.6.5. Estructura FOR (Controladas por un Contador)

1. Escribir un algoritmo que permita ingresar 10 números y calcule el promedio.

2. Ingresar 5 juegos de cuatro valores cada uno. Calcular y emitir el promedio de cada juego.

3. Dados 10 números, escribir un algoritmo que imprima:

a. la suma de los números positivos de la lista

b. cantidad de números negativos de la lista

c. promedio de los números positivos.

4. Desarrollar un algoritmo que determine en un conjunto de cien números la cantidad de

negativos, cuántos son mayores de 50 y cuántos están comprendidos entre 25 y 45.

5. Escribir un algoritmo que calcule la suma de los cuadrados de los 10 primeros números naturales.

6. Ingresar dos números y calcular el producto de los mismos por sumas sucesivas.

7. Calcular la suma de los números pares, la suma de los números impares comprendidos entre 1 y N, donde N es un número ingresado por teclado. (recordar que el incremento puede ser de 2).

8. Escribir un algoritmo que imprima la tabla de multiplicar del 2.

9. Escribir un algoritmo que imprima todas las tablas de multiplicar (desde la del 2 hasta la del 9).

10. Escribir un algoritmo que imprima la suma de los 1000 primeros números naturales, es decir, 1 + 2 + 3 + 4 + ... + 998 + 999 + 1000.

11. Escriba un algoritmo para imprimir las coordenadas (X - Y) de una función cuadrática, de la

forma Y = aX + bX + c haciendo variar X en el intervalo [-20, 20] con un incremento de 2.

12. Escribir un algoritmo que calcule el factorial de un número. El factorial de un número N se

simboliza: N!, donde N! = N * (N-1)!. Sólo existen factoriales de números naturales y el cero. Se define 0! = 1.

Ej: 5! = 5 * 4 * 3 * 2 * 1 * 1.

13. Leer 10 valores numéricos. Calcular e informar: La suma de los valores positivos y el producto de los valores negativos. (Ignorar los valores nulos)

14. Leer una lista de 50 números y emitir: el valor mínimo de la lista, el valor máximo de la lista y la ubicación del máximo dentro de la lista.

15. Dada una lista de 50 valores numéricos, indicar si esta ordenada en forma ascendente.

16. Diseñe un algoritmo para calcular el resultado de la suma de los 100 primeros términos de la siguiente serie:

S = 1 – 1/3 + 1/9 – 1/27 + 1/81

17. Realizar un algoritmo que convierta un número ingresado por teclado (en sistema decimal) a su equivalente en sistema binario.

18. Construir el algoritmo que realice la operación inversa al del ejercicio anterior.

19. Escribir un algoritmo que permita el ingreso de dos números x y n, y calcule xn, por multiplicaciones sucesivas. Hacer las consideraciones necesarias para que funcione. Tener en

cuenta casos particulares.

20. Escribir un algoritmo que permita ingresar el promedio de un curso y luego las calificaciones de

un grupo de 50 alumnos. Se necesita saber cuántos alumnos tienen una calificación superior al promedio del grupo. Realizar prueba de escritorio para 10 alumnos.

21. Escribir un programa que permita ingresar dos valores A y B que determinan un intervalo, luego ir acumulando los valores que se ingresan a continuación siempre y cuando estos pertenezcan al

intervalo.

22. Se leen 30 valores (comprendidos entre 5 y 40), que representan la temperatura máxima de

cada uno de los días de un mes. Se pide hallar e informar :

La temperatura máxima del mes y el día que se produjo. (Se supone única)

Cuántos días la temperatura supero los 25º C.


64

El promedio de las temperaturas máxima del mes.

23. Se ingresan las notas de 40 alumnos. Por cada alumno se ingresa:

número de matrícula : 4 dígitos (1-9999)

asistencia : 1, presente; 0, ausente

calificación: 2 dígitos (0-10).

A partir de esta información se debe calcular e informar:

Cantidad y % de alumnos presentes.

Promedio de calificaciones de alumnos presentes.

% de alumnos aprobados (sobre el total de alumnos presentes).

Número de matrícula del alumno de mayor calificación. (Si hay varios alumnos con esa calificación: calificación y cantidad de alumnos en esa situación).

3.6.6. Estructuras WHILE y DO WHILE (Controladas por una condición)

1. Realizar un algoritmo que permita calcular la suma de los números ingresados mientras que el valor acumulado no supere el valor 100. Mostrar el valor acumulado antes de superar 100.

2. Ingresar juegos de cuatro valores cada uno. Calcular y emitir el promedio de cada juego. El proceso finaliza al encontrarse un juego cuyo primer valor es 0 (cero).

3. Leer una lista de números que finaliza cuando se ingresar el número 0 (cero), al finalizar emitir

el valor mínimo de la lista.

4. Leer una lista de números que finaliza cuando se ingresar el número 0 (cero), al finalizar emitir el valor máximo de la lista.

5. Leer una lista de números que finaliza cuando se ingresar el número 0 (cero), al finalizar emitir el valor máximo de la lista, y la ubicación del máximo dentro de la lista. (Suponer un único

máximo).

6. Escribir un programa que permite ingresar dos valores A y B que determinan un intervalo, luego

ir acumulando los valores que se ingresan a continuación siempre y cuando estos pertenezcan al intervalo. El ingreso de números finaliza cuando ingresa el 99.

7. Diseñar el algoritmo para resolver una ecuación de segundo grado Ax2 + Bx + C = y. El algoritmo deberá ingresar A, B y C e ir ingresando x. El programa finaliza cuando ingresa x = 99.

8. Se tienen los siguientes datos sobre nacimientos en una ciudad: sexo (“F” ó “M”) y fecha de nacimiento (DD y MM). Se pide realizar un algoritmo que informe cuántos son varones y cuántas

son mujeres, cuántos nacimientos hubo en el primer semestre y cuántos en el segundo. El final de lectura de datos viene dado por una lectura del sexo en blanco.

9. Realizar un algoritmo que determine si una serie de números ingresada por teclado es ascendente. El final de la serie viene dado por un número negativo. (Ej: 1, 5, 5, 10, 11, 12, 12,

20, -1 es una serie ascendente).

10. Diseñar un Diagrama de Flujo de Datos (DFD) que permita el ingreso de datos de tipo carácter hasta que se ingrese un espacio en blanco; al final informar si algún dato fue numérico (un

dígito de „0‟ a „9‟) y si se ingresaron datos numéricos, cuántos fueron.

11. Diseñar un DFD que permita el ingreso de N números; al final informar la sumatoria de los números. N se ingresa al principio por teclado.

12. Diseñar un DFD que permita el ingreso de números e informe si se ingresaron o no números

negativos. El ingreso de números finaliza cuando ingresa el 99.

13. Diseñar un DFD que permita calcular el promedio de N notas introducidas por teclado, siendo N

un valor introducido por el usuario. Además ha de indicar si ha habido algún 10, el número de reprobados y de aprobados.

14. Diseñar un DFD que permita el ingreso de números, muestre el valor acumulado, el promedio y si ingresó el 0 (cero). El final del ingreso se da cuando ingresa el número 100 o la suma de los

ingresados supere el valor 100.

15. Diseñar un DFD que permita mostrar en pantalla una rutina de selección del siguiente menú: 1.- Suma 2.- Resta 3.- Producto 4.- División S.- Salir. El usuario podrá elegir cualquier alternativa,


65

luego ingresar A y B y realizar la operación seleccionada. Solamente con “S” podrá Salir. Tener

en cuenta que si elige 4.- División deberá reingresar el denominador hasta que ingrese un valor diferente a 0 (cero). Si ingresa un número negativo o mayor que 4 deberá informar “Opción no

válida”.

16. Diseñar un DFD que permita el ingreso de N números y al finalizar muestre el menor, el mayor y la posición en que se ingresó cada uno. N se ingresa al principio por teclado. AYUDA: hacer primero el mayor, después agregarle la posición, después complicarlo con todo.

17. Realizar un algoritmo que imprima los N primeros números de la serie de Fibonacci. N se ingresa por teclado.

18. Calcular la serie de Fibonacci. Ingresar N y generar la serie hasta que el último término sea menor a N.

19. Dado un conjunto de números positivos, determinar el mayor de ellos:

a. cuando se tiene como dato su cantidad o tamaño del conjunto

b. cuando el conjunto de datos finaliza con un valor negativo.

ESTRUCTURAS DE DATOS.

3.6.7. Vectores 1. Efectuar un algoritmo que permita la carga de un vector de 10 elementos.

2. Efectuar un algoritmo que permita la muestra de los elementos de un vector de 10 elementos.

3. Diseñar un algoritmo que cargue un vector A con 10 elementos numéricos y realice las siguientes modificaciones:

a. Asignar el valor 11,2 a la tercer posición del vector A

b. Asignar el valor del elemento de la octava posición del vector A en la segunda posición

c. Intercambiar el elemento de la cuarta posición, con el de la novena posición del vector A

4. Efectuar un algoritmo que permita el ingreso por teclado de los 30 elementos de un vector numérico, duplicar sus valores y luego imprimirlos en el orden ingresado.

5. Efectuar un algoritmo que permita el ingreso por teclado de los 30 elementos de un vector numérico y luego imprimirlos en el orden inverso al ingresado.

6. Efectuar un algoritmo que permita el ingreso por teclado de los 30 elementos de un vector

numérico y luego imprimir:

a. La suma del contenido de los elementos.

b. La cantidad de elementos que sean mayores que 15.

7. Crear un vector de 70 elementos donde cada elemento del vector sea igual a su posición.

8. Cargar un vector de 50 elementos e informar: cual es el mayor elemento, el menor, y la posición de ambos. Considere que los valores no se repiten.

9. Escribir un algoritmo que permita cargar un vector que contenga las notas de un curso de 20 alumnos (controlar que las notas válidas son entre 0 y 10) indicando:

a. la nota más alta y la nota más baja

b. el promedio de notas

c. el número de notas superiores al promedio

d. la cantidad de alumnos aprobados (notas >= a 4)

e. la cantidad de alumnos reprobados.

Al finalizar, mostrar todas las notas y los resultados de los cálculos.

10. Cargar un vector con 100 datos numéricos, al finalizar la carga calcular y mostrar:

a. promedio de los números positivos

b. promedio de los números negativos

c. la suma de los elementos que ocupan las posiciones pares del vector

d. la suma de los elementos que ocupan las posiciones impares del vector.


66

11. Confeccione un algoritmo que permita leer tres vectores de igual dimensión y luego los sume en

un cuarto vector.

12. Cargar un vector con 100 datos numéricos, luego ingresar un número X y buscar e informar si X

se encuentra en el vector, mostrando como resultado: “Existe el elemento en la posición ..” o bien, “El elemento x no existe”.

13. Cargar un vector con 100 datos numéricos, luego ingresar un número X y buscar e informar si X se encuentra en el vector y si se encuentra, cuantas veces aparece.

14. Efectuar un algoritmo que permita el ingreso por teclado de los 30 elementos de un vector numérico y luego imprima cada elemento del vector que vaya precedido inmediatamente por un elemento nulo.

15. Cargar un vector con las alturas de los N alumnos de un curso. Determinar la media y luego informar cuantos alumnos son más altos que la media y cuántos mas bajos.

16. Hacer un programa que permita realizar la suma y el producto de dos vectores de 10 elementos. El usuario elige la operación a realizar. Ambos vectores ya están cargados.

17. En un colegio secundario, se maneja la información de las notas de un curso con tres vectores de longitud N llamados trim1, trim2 y trim3. Los componentes de los vectores son las notas del

primero, segundo y tercer trimestre respectivamente, para cada alumno. Se pide generar un cuarto vector de nombre prom donde cada componente sea el promedio de los elementos

homólogos de los tres vectores, al finalizar mostrar los tres mejores promedios del curso.

18. Los elementos de un vector numérico de 10 posiciones están relacionados con la siguiente

expresión: A[i+1] = i*A[i]+i*2 y siendo A[1] = 1. Realizar un algoritmo para calcular los elementos de este vector.

19. Efectuar un algoritmo que permita el ingreso por teclado de los 30 elementos un vector numérico. Luego mostrar:

a. La posición (índice) del primer elemento menor que 0.

b. El valor y posición del mayor elemento.

20. Dado dos vectores A y B de N y M componentes, realizar un algoritmo que permita cargar dichos vectores, luego generar un nuevo vector de nombre C que contenga los componentes comunes

de los dos anteriores y mostrar C.

21. Cargar dos vectores: uno con el número de empleado y otro con las horas trabajadas por cada empleado. Cada vector tendrá N. Se pide:

a. Promedio de horas trabajadas.

b. Imprimir los números de empleados que trabajaron más horas que el promedio general.

c. Imprimir el número de empleado que más horas trabajó y el número de empleado que

trabajó menos horas.

22. Realizar un algoritmo que almacene en un vector los 20 primeros números primos, al finalizar la

carga mostrar el vector cargado.

23. Realizar un algoritmo que vaya solicitando al usuario la posición dentro del vector que desea cargar y luego el valor a cargar. Deberá indicar con un mensaje cuando ese elemento ya haya

sido cargado y cuando el vector esté completamente cargado.

24. Ordenar un vector de 5 elementos de menor a mayor.

25. Ordenar un vector de N elementos de menor a mayor.

26. Dado un vector de N elementos buscar e imprimir.

a. La cantidad de veces que se encuentra cada número dentro del Vector.

b. La cantidad de números distintos dentro del Vector.

27. Cargar un vector de orden N. Se ingresan luego 10 números por teclado. Determinar cuántos de estos números ingresados están presentes en el vector.

28. Cargar dos vectores A y B, luego buscar y mostrar cuantos elementos en común tienen.

3.6.8. Matrices 1. Elaborar un algoritmo que permita cargar números en una matriz de N x M por filas.

2. Elaborar un algoritmo que permita cargar números en una matriz de N x M por columnas.


67

3. Elaborar un algoritmo que permita cargar números en una matriz de 6 x 6. Imprimir al final la

suma de las columnas.

4. Elaborar un algoritmo que permita el ingreso de números en una matriz de 10 x 10 e imprima

los elementos de la misma recorriendo por fila y al final de cada fila imprima la suma de esta última.

5. Elaborar un algoritmo que lea números en una matriz cuadrada de 10 x 10. Calcular e imprimir la suma de los elementos de su diagonal principal.

6. Hacer un algoritmo que me permita cargar los elementos de la diagonal principal de una matriz de 10 x 10 a un vector.

7. Elaborar un algoritmo que genere una matriz cuadrada de 10 x 10 en la cual se asigne ceros a

todos sus elementos, excepto a los de la diagonal principal, donde asignará unos.

8. Elaborar un algoritmo que cree una matriz cuadrada de 10 x 10 en la cual cargue ceros a todos

sus elementos, excepto a los de la diagonal secundaria, donde se asignarán números leídos por teclado.

9. Elaborar un algoritmo que cargue números en dos matrices de 5 x 5. Calcular en una tercera matriz la suma de los elementos de las dos anteriores. Al final mostrar las tres matrices.

10. Hacer un DF que me permita cargar una matriz de M x N, luego calcule y muestre el mayor y menor elemento de cada fila.

11. Hacer un DF que me permita cargar una matriz de M x N, luego calcule y muestre el menor

elemento de cada columna y la posición en la que se encuentra.

12. Se deben cargar las notas de cada uno de los 40 alumnos de un curso. Cada alumno tiene 5 notas donde las notas de un alumno corresponden a una fila de una matriz. Elaborar un

algoritmo que calcule e imprima el promedio de cada alumno.

13. En una matriz se tienen las 7 notas correspondientes a cada una de las asignaturas de los 30 alumnos de un curso. Elaborar un algoritmo que calcule e imprima las notas y el promedio de cada alumno. Cada alumno cursa como mínimo 3 materias y como máximo las 7.

14. Elaborar un algoritmo que cargue números en una matriz de 5 x 10. Calcular la suma de cada una de sus filas y columnas dejando dichos resultados en dos vectores, uno de 5 elementos para

las filas y otro de 10 elementos para las columnas.

15. Elaborar un algoritmo que permita ingresar números en una matriz en las posiciones

correspondientes al triángulo superior (de la diagonal principal hacia la derecha) teniendo en cuenta que el resto de la matriz debe permanecer en 0.

16. Elaborar un algoritmo que permita ingresar números en dos matrices una de 5 x 4 y la otra de 4 x 3. Calcular en una tercera matriz el producto de los elementos de las dos anteriores, la matriz

resultado será de 5 x 3. Al final imprimir las tres matrices.

Nota: Para poder multiplicar matrices, el número de filas de una matriz debe coincidir con el

número de columnas de la otra (no necesariamente deben ser cuadradas). El producto está definido por la fórmula: c[i,j] = ∑a[i,k] * b[k,j]

17. Elaborar un algoritmo que permita determinar si una matriz cuadrada A ya cargada es identidad. Nota: Una matriz es considerada “identidad” si cada elemento a[i,j] = a[j,i].

18. Cargar una matriz de M x N elementos y generar un vector con los valores de una fila indicada por teclado. No olvidarse de validar el número de fila ingresado.

19. Elaborar un algoritmo que permita ingresar los datos de una matriz de 10 x 5 y genere la matriz

transpuesta.

20. En una agencia de quiniela se tienen los valores de los números ganadores y los premios de los

mismos. Los datos están cargados en una matriz de 365 filas y dos columnas (una fila para cada día). En la primer columna el número ganador y en la segunda el monto del premio. Realizar un

algoritmo que determine cuántas fueron las ocurrencias de cada número y que monto de dinero le correspondió a cada número.

21. Se carga una matriz de 50 x 3 con los siguientes datos sobre nacimientos en una ciudad: sexo (1: Masculino 2: Femenino), mes y año de nacimiento. Al finalizar la carga se pide que informe:

a. cantidad de varones y cantidad de mujeres

b. cantidad de nacimientos en el primer semestre

c. cantidad de nacimientos en el segundo semestre

d. cantidad de personas que actualmente son mayores de 5 años.


68

22. En una matriz de dimensiones 4 x 4 se pide que encuentre la ubicación del mayor y menor

elemento. Mostrar la matriz completa y las ubicaciones encontradas con los valores respectivos.

23. Lea una matriz de N x M (variables ingresadas por teclado) e indique:

a. cantidad de elementos positivos

b. cantidad de elementos negativos

c. cantidad de ceros

d. mayor elemento que contiene la matriz y cuantas veces figura dicho elemento

24. Hacer un diagrama que permita cargar una matriz de 5 x 5 y ordene cada columna de mayor a menor.

25. Hacer un diagrama que permita cargar una matriz de 5 x 5, luego ingrese un número de fila, validarlo y, por último ordene la fila indicada de mayor a menor.

26. Cargar dos matrices MAT1 y MAT2 ambas cuadradas de orden N. Intercambiar los elementos de la diagonal principal.

27. Leer una matriz de dimensiones N x M y realizar y mostrar:

a. un vector llamado POS que contendrá los elementos positivos de la matriz

b. un vector llamado NEG que contendrá los elementos negativos de la matriz

c. el mayor elemento del vector POS

d. el menor elemento del vector NEG

e. el promedio de los elementos de la matriz, del vector POS y del vector NEG

f. la matriz original y los dos vectores.

3.6.9. Ejercicios Integradores 1.- Diseñar un DFD que permita mostrar por pantalla el siguiente menú:

1. Factorial de un Nº

2. División de dos números A y B.

3. Salir.

El usuario debe ingresar la opción que desea realizar. Sólo podrá salir del programa si ingresa 3.

Si elije 1 deberá pedir al usuario que ingrese un número luego deberá calcular el factorial y

mostrar el resultado. Debe tener en cuenta que: el nro. debe ser positivo (el programa deberá pedir que ingrese el número hasta que ingrese un nro. positivo).

Si elije 2 deberá pedir al usuario que ingrese dos números A y B y calculará A dividido B. Debe tener en cuenta que: el nro. B debe ser diferente de cero (el programa deberá pedir que

ingrese el número hasta que ingrese un nro. distinto de cero).

Si ingresa cualquier otro nro. Deberá informar “ERROR” y mostrar nuevamente el menú.

2.- Diseñar un DFD que permita el ingreso de 20 notas (NOTA) e informe:

a) la mayor nota ingresada (MA),

b) la menor nota ingresada (ME),

c) la cantidad de aprobados (mayores o iguales a 4) (CA),

d) el promedio de las notas (PN) y

e) la posición de la mayor (PM).

Realizar la prueba de escritorio para 5 notas utilizando los siguientes valores:

NOTA MA ME CA PN PM Otras

variables…..

1º 4.25

-5.30

-3.75

2º 7.50

3º 10.00

4º 6.30

5º 2.45


69

Tener en cuenta que: Las notas ingresadas no se repiten. Se debe respetar el nombre de las

variables. Si necesita más variables aclarar para qué utiliza cada una. Las notas ingresadas deben ser validadas. Se debe controlar que las notas ingresadas sean válidas, si no lo son se debe

reingresar la nota; o sea que en total se tendrán 20 notas válidas (entre 0.00 y 10.00 inclusive).

Indicar el sentido de las flechas y líneas de flujo, el V/F de los rombos.

3. Una empresa de servicios de encomiendas realiza un control semanal de los volúmenes de carga que transporta, el empleado responsable de llevar adelante el registro debe cargar la

cantidad de bultos por día que sale desde el depósito (verificar que los datos que ingresa el usuario correspondan a una cantidad valida).

Una vez almacenado en el registro, se deberá obtener el promedio semanal de las cargas. (Bultos por día que sale desde el depósito).

Luego se deberá encontrar los días en que la carga transportada supere al promedio semanal obtenido, e informar cuantos son.

Un ejemplo: Lunes Martes Miércoles Jueves Viernes Sábado Domingo

125 325 100 85 300 510 150

Promedio semanal: 227.86 bultos transportados, esto es 228.

Superan el promedio los días martes, viernes y sábado.

Informar: 3 días.

4. Una empresa de transporte lleva un control mensual de los pasajes vendidos Oberá - Bs As. El encargado de ventas necesita cargar y almacenar los datos correspondientes a la cantidad de pasajes vendidos mensualmente, durante el transcurso de un año. (Verificar que los datos que

ingresa el usuario correspondan a una cantidad válida). Una vez almacenados los datos se

quiere realizar un estudio estadístico para el mes de Mayo y determinar e informar cuando se venden más pasajes los días pares o impares:

Pasajes días pares. (Esto es: 0, 2,4,…, 28,30)

Pasajes días impares. (Esto es: 1, 3,5,…, 29,31)

Un ejemplo: Carga matriz de 31x12. D/A 1 2 3 4 5 6 7 8 9 .. .. 26 27 28 29 30 31

Ene

Feb

Mar

Abr

May

Jun

…

…

Oct

Nov

Dic

Suma días pares: 380. Suma días impares: 530.

Informar: Días impares.

5. Una empresa de transporte lleva el control de las ventas de pasajes por cada unidad que realiza

la línea Oberá- Buenos Aires. Esta línea permite la venta de tarifas intermedias.

El encargado de ventas necesita cargar y almacenar los datos correspondientes a una unidad de transporte con un total de 36 butacas.

Estado de butacas: Libre = 0, Ocupado = 1. (Verificar dato ingresado valido).

Tarifa por butacas vendidas: x $. (Verificar dato ingresado valido).


70

Una vez cargado los datos, se quiere obtener:

a) la cantidad de butacas ocupadas y libres de la unidad de transporte.

b) el importe total en $ de los pasajes vendidos.

Se conoce el costo de un pasaje Oberá- Buenos Aires cuesta: $130.

c) Determine cuántos viajan a Buenos Aires, y cuántos con tarifa intermedia.

Un ejemplo: Carga matriz de 36x2. Corresponde a una unidad de transporte.

Asiento 1 2 3 4 5 6 7 8 9 10 .. .. 31 32 33 34 35 36

Estado 0 0 0 1 1 0 0 1 0 1 .. .. 0 0 1 1 1 1

Tarifa $ 0 0 0 90 90 0 0 70 0 80 .. .. 0 0 130 130 90 90

Butacas libres: 7

Butacas ocupadas: 36-7=29

Importe total: X $

TALLER DE INFORMÁTICA CAPITULO 4. Lenguajes de Programación

71

CAPITULO 4.

LENGUAJES DE PROGRAMACION

El objetivo de este apunte es proporcionar de una guía para aprender a programar bajo el

Entorno Gráfico del Sistema Operativo Linux en Lenguaje C.

Para ello, luego de varios intentos y pruebas sobre las aplicaciones a utilizar en el ámbito del

Software Libre, se optó por la Distribución de Linux Ubuntu y, como interface de IDE (Integrated Development Environment), el Anjuta. Este apunte está destinado a los alumnos de los cursos de

Taller de Informática y Computación de la Facultad de Ingeniería de Oberá.

Como aclararación se expone que el apunte fue realizado mediante la compilación / edición de

materiales extraídos fundamentalmente de Internet. En algunos casos con modificaciones parciales y, en otros, modificaciones totales. Otro aporte utilizado, sobre todo en la organización de los

temas, fue obtenido de Libros; finalmente, se utilizaron los ejemplos de guías y apuntes de las Cátedras de años anteriores. En conclusión, este apunte es el resultado del trabajo de muchas

personas, organizado de la manera más apropiada para el dictado de las asignaturas mencionadas

y poder conseguir los objetivos propuestos en las mismas.

Los ejemplos de código de este apunte fueron probados sobre:

gcc versión 4.0.3 (Ubuntu 4.0.3-1ubuntu5) Ubuntu 6.06 LTS - la versión Dapper Drake - publicada en junio de 2006. Anjuta 1.2.4a (http://anjuta.org/)

El libro se divide en partes, la Parte 1 incluye los capítulos que se desarrollan en la Materia

Taller de Informática. La Parte 2 y 3 son los temas que conjuntamente con la Parte 1 deben ser vistos en la Materia Computación.

En los Apéndices fueron dispuestos materiales que se considera pueden ser importantes como consulta o complemento.

Imágenes utilizadas a lo largo del texto


72

4.1. INTRODUCCIÓN EL lenguaje C fue creado por Dennis Ritchie en los laboratorios de la Bell Telephone en 1972. El

mismo fue pensado para desarrollar un Sistema Operativo llamado UNIX. Este lenguaje es el

sucesor del lenguaje llamado B (de allí el nombre C).

Debido a la flexibilidad y poder de programación, se extendió rápidamente y empezaron a surgir distintas versiones. Como consecuencia de esto nace un comité llamado ANSI (American

National Estándar Institute) el cuál define lo que se conoce como Standard C o como Estándar

ANSI C.

4.1.1. ¿Por qué usar C?

Es poderoso y flexible: dadas las características del lenguaje, permite el desarrollo de proyectos como sistemas operativos, procesadores de texto, hojas de cálculo, etc.

Es un lenguaje común: como está muy difundido su uso, existe una amplia variedad de

compiladores y accesorios útiles para el programador.

Es transportable: se puede correr en cualquier tipo de computadora, esta ventaja se ve aumentada con el Estándar C.

Posee pocas palabras clave: la base sobre la cual está construida la funcionalidad del lenguaje tiene pocas palabras claves.

Es modular: el código puede y debe ser escrito en módulos llamado funciones que pueden ser utilizadas y re-utilizadas por otras aplicaciones o programas.

El lenguaje C++ es una versión mejorada del C, lo que significa que tiene todo lo que tiene el Estándar C más agregados para la Programación Orientada a Objetos.

¿Que diferencia hay entre C y C++? C++ es súper conjunto de C, es decir que C es un conjunto de C o C está contenido por C++.

El C++ incorpora nuevas características sin comprometer ninguna de las bondades del C, entre las cosas que se agregó son el concepto de clases, herencia, funciones virtuales del lenguaje

Simula67 y sobrecarga de operadores del Algol68 (características que veremos en detalle en el curso).

¿Quien creó y cuando el C++?

El C++ fue desarrollado por Bjarne Strousrup, en los laboratorio de Bell a principios de los 80,

esto es 10 años después que el Lenguaje C.

¿Son compatibles los programas de C con C++?

Uno de los grandes aciertos de C++, fue mantener la compatibilidad con C, de este modo cualquier programa hecho en C puede ser considerado también como un programa de C++.

¿Hay un Estándar para el C++?

Sí. En forma resumida, el ANSI define un conjunto de reglas; cualquier compilador de C o de C++ debe cumplir esas reglas, si no, no puede considerarse un compilador de C o C++. Estas

reglas definen las características de un compilador en cuanto a palabras reservadas del lenguaje,

comportamiento de los elementos que lo componen, funciones externas que se incluyen, etc. Un programa escrito en ANSI C o en ANSI C++, podrá compilarse con cualquier compilador que

cumpla la norma ANSI. Se puede considerar como una homologación o etiqueta de calidad de un compilador.


73

¿Hay características no estándares en C++?

Si, todos los compiladores incluyen, además del ANSI, ciertas características no ANSI, por ejemplo librerías para gráficos. Pero mientras no usemos ninguna de esas características, sabremos

que nuestros programas son transportables, es decir, que podrán ejecutarse en cualquier ordenador y con cualquier sistema operativo. Por eso el desarrollo de un programa bajo, por

ejemplo Dev C++ de Bloodshed, podría no compilarse bajo Anjuta.


74

4.2. LENGUAJE C Para poder crear un programa en lenguaje C debemos realizar una serie de pasos que nos

permitirán pasar de nuestro programa escrito en código fuente a nuestro archivo ejecutable.

El lenguaje C es compilado, esto significa que un programa compilador lee el código fuente completo escrito por el programador, lo convierte en código objeto también conocido como código binario o código máquina. Una vez compilado, el linker enlazará las librerías dentro de su código

objeto y así obtendrá, finalmente el programa ejecutable. Veamos en detalle cada uno de estos

conceptos.

4.2.1. Operaciones básicas de programación.

4.2.1.1. Creación del fichero fuente.

Los programas en C y C++ se escriben con la ayuda de un editor de textos (pico ó vi) del

mismo modo que cualquier texto corriente.

Los ficheros que contienen programas en C o C++ en forma de texto se conocen como fichero fuente, y el texto del programa que contiene se conoce como programa fuente.

El usuario siempre escribirá programas fuentes y los guardaremos en ficheros fuentes.

Los programas fuente no pueden ejecutarse. Son ficheros de texto, pensados para que ser

comprendidos por los seres humanos, pero incomprensibles para los ordenadores.

4.2.1.2. Creación del fichero objeto.

Para obtener un programa ejecutable hay que seguir algunos pasos.

El primer paso es compilar o traducir el programa fuente a su código objeto equivalente. Este es el trabajo que hacen los compiladores de C y C++.

Consiste en obtener un fichero equivalente a nuestro programa fuente comprensible para el ordenador, este fichero se conoce como fichero objeto,

y su contenido como código objeto.

Los compiladores son programas que leen un fichero de texto que contiene el programa fuente y generan un fichero que contiene el código objeto. El código objeto no tiene ningún significado

para los seres humanos, al menos no directamente. Además es diferente para cada ordenador y para cada sistema operativo.

Por lo tanto, existen diferentes compiladores para diferentes sistemas operativos y para cada tipo de ordenador.

Estas tareas las realizaremos, como mencionamos con anterioridad, con el IDE Anjuta, pero se podrían realizar en modo de consola, utilizando un compilador por ejemplo g++.

4.2.1.3. Creación del fichero ejecutable.

Uso de librerías. Junto con los compiladores de C y C++, se incluyen ciertos ficheros llamados librerías.

Las librerías contienen código objeto de programas que permiten hacer cosas comunes como, por ejemplo, leer desde el teclado, escribir en pantalla, manejar números, realizar funciones matemáticas, etc.


75

Las librerías están clasificadas por el tipo de trabajos que hacen, hay librerías de entrada y salida, matemáticas, de manejo de memoria, de manejo de textos, etc.

Hay un conjunto de librerías muy especiales, que se incluyen con todos los compiladores de C y de C++. Son las librerías ANSI o estándar. Pero también hay librerías no estándar, y dentro de éstas hay librerías públicas y comerciales. En este curso sólo usaremos librerías ANSI.

Ficheros ejecutables y enlazadores.

Cuando obtenemos el fichero objeto, aún no hemos terminado el proceso.

El fichero objeto, a pesar de ser comprensible para el ordenador, no puede ser ejecutado.

Hay varias razones para eso:

1. Nuestros programas usaran, en general, funciones que estarán incluidas en librerías externas, ya sean ANSI o no. Es necesario combinar nuestro fichero objeto con esas

librerías para obtener un ejecutable.

2. A menudo, nuestros programas estarán compuestos por varios ficheros fuente y, de cada uno de ellos, se obtendrá un fichero objeto. Es necesario unir, todos los ficheros objeto

más las librerías, en un único fichero ejecutable.

3. Hay que dar ciertas instrucciones al ordenador para que cargue en memoria el programa y los datos y para que organice la memoria de modo que se disponga de una pila de tamaño adecuado. La pila es una zona de memoria que usa el programa para intercambiar datos

con otros programas o con otras partes del propio programa. Veremos esto con más detalle

durante el curso.

Existe un programa que hace todas estas cosas, se trata del "link", o enlazador.

El enlazador toma todos los ficheros objeto que componen nuestro programa, los combina con los ficheros de librería que sea necesario y crea un fichero ejecutable.

Una vez terminada la fase de enlazado, ya podremos ejecutar nuestro programa.

4.2.2. Manejo de Errores.

Por supuesto, somos humanos, y por lo tanto nos equivocamos. Los errores de programación pueden clasificarse en varios tipos, dependiendo de la fase en que se presenten.

Pueden ser:

Errores de sintaxis.

Warnings o avisos.

Errores de enlazado.

Errores de ejecución.

Errores de diseño.

4.2.2.1. Errores de sintaxis.

Los errores de sintaxis son errores en el programa fuente. Pueden deberse a palabras

reservadas, palabras mal escritas, expresiones erróneas o incompletas, variables no definidas, etc.

Los errores de sintaxis se detectan en la fase de compilación. El compilador, además de generar

el código objeto, nos dará una lista de errores de sintaxis. De hecho nos dará sólo una cosa o la otra, ya que si hay errores no es posible generar un código objeto.


76

4.2.2.2. Warnings o Avisos.

Además de errores, el compilador puede dar también Avisos o Warnings.

Los avisos son errores, pero no lo suficientemente graves como para impedir la generación del código objeto. No obstante, es importante corregir estos avisos, ya que el compilador tiene que

decidir entre varias opciones, y sus decisiones no tienen por qué coincidir con lo que el programador pretende. Las decisiones se basan en las directivas que los creadores del compilador

decidieron durante su creación.

4.2.2.3. Errores de enlazado.

El programa enlazador también puede encontrar errores que normalmente se refieren a

funciones que no están definidas en ninguno de los ficheros objetos ni en las librerías. Puede que hayamos olvidado incluir alguna librería, algún fichero objeto o que hayamos olvidado definir

alguna función o variable, o lo hayamos hecho mal.

4.2.2.4. Errores de ejecución.

Aunque se haya obtenido un fichero ejecutable, es posible que se produzcan errores.

En el caso de los Errores de ejecución normalmente no obtendremos mensajes de error, sino

que simplemente el programa terminará bruscamente. Estos errores son más difíciles de detectar y corregir.

Existen programas auxiliares para buscar estos errores, son los llamados depuradores o debuggers. Estos programas permiten detener la ejecución de nuestros programas, inspeccionar

variables y ejecutar nuestro programa paso a paso. Esto resulta útil para detectar excepciones, errores sutiles, y fallos que se presentan dependiendo de circunstancias distintas.

4.2.2.5. Errores de diseño.

Finalmente los errores más difíciles de corregir y prevenir.

Si nos hemos equivocado al diseñar nuestro algoritmo, no habrá ningún programa que pueda ayudar al programador a corregir los errores de diseño. Contra estos errores sólo cabe practicar, pensar. Puede ayudar a solucionar este tipo de errores la opción depurar que generalmente poseen

los compiladores del lenguaje C.

77

4.3. ESTRUCTURA DE UN PROGRAMA

Los programas de computadoras varían sustancialmente en cuanto al propósito, estilo y complejidad. Pero la mayoría debe: ingresar y almacenar datos, procesar los datos para almacenar

los resultados deseados y mostrar, almacenar o imprimir los resultados obtenidos.

Cada dato utilizado durante la ejecución del programa deberá ser descrito para que el

compilador lo reconozca, sepa cómo almacenarlo y recuperarlo; se deberá reservar memoria para que pueda almacenar la cantidad de datos necesarios.

Una vez almacenados los datos, éstos deberán procesarse. El proceso varía según el propósito del programa.

Finalmente, los datos procesados deberán ponerse a disposición del usuario. Cuando se utiliza el lenguaje C para escribir un programa se debe tener en cuenta que:

Todos los programas poseen una función main() que indica el punto donde se inicia la ejecución. La ejecución finaliza cuando se encuentra el final de main.

Debe declarar todas las variables antes de usarlas.

Las partes más importantes de un programa en C son:

Directivas del pre-procesador: #include y #define.

Declaración de variables globales.

Prototipos de funciones.

Declaración de clases.

Función main.

Definición de funciones.

Definición de clases.

4.3.1. Directivas del preprocesador Las líneas que comienzan con el símbolo # son indicaciones para el compilador o directivas del

preprocesador.

Sintaxis:

#include <archivo.h>

La directiva include le indica al compilador que lea y compile el contenido del archivo con

extensión .h que contiene las descripciones de las funciones de librería utilizadas a lo largo del programa.

Por ejemplo:

#include <stdio.h>

Le indica al compilador que compile el contenido del archivo stdio.h.

Sintaxis:

#define nombre valor


78

La directiva define determina un reemplazo o sustitución. La directiva le indica al compilador que cada vez que en el programa aparezca nombre sea reemplazado por valor. Esta sentencia

resulta útil cuando son programas largos y nombre se utiliza varias veces ya que, si cambia el valor de nombre se debe modificar una sola vez al principio del programa.

Por ejemplo: #define NUMERO 5.3

Le indica al compilador que cada vez que aparezca NÚMERO en el programa sea sustituido por 5.3.

4.3.2. Declaración de variables globales

Las expresiones que permiten realizar cálculos dentro de los programas están formadas por variables, constantes y operadores.

Las variables se deben declarar antes de ser utilizadas en el programa, ya que el compilador debe conocer qué tipo de dato es una variable antes de poder compilar cualquier sentencia que la use.

El lugar donde se declara una variable afecta mucho la manera en que otras partes del programa pueden utilizarla.

Las reglas que determinan cómo se puede usar una variable basada en el lugar en que fue declarada se llaman reglas de alcance del lenguaje.

Si la variable se declara en ésta zona del programa, fuera de todas las funciones, incluyendo la función main(), se denomina variable global y se puede utilizar en cualquier parte del programa.

4.3.3. Prototipos de funciones

Antes de utilizar una función en el programa, ésta se debe definir.

En esta porción del programa se definen las funciones a utilizar indicando el nombre de la

función, el número y tipos de argumentos que utilizará durante la ejecución. Finaliza cada sentencia con punto y coma (;).

Esta definición se realiza mediante los prototipos de funciones.

4.3.4. Declaración de clases

Lugar dentro de los programas donde se deben crear las nuevas clases, se les debe asignar un nombre utilizando las sentencias struc, union o class de C++.

4.3.5. Función main()

Todos los programas escritos en C poseen una función llamada main(). Es la función que se ejecuta en primer lugar cuando comienza a funcionar el programa. El programa posee una sola

función main().

En la siguiente línea aparece una llave { que indica el grupo de instrucciones que definen lo que sucederá cuando se ejecute el programa.


79

Cada grupo de sentencias finaliza con una llave }.

4.3.6. Definición de funciones

Esta zona contiene el código para cada función declarada. El encabezamiento de la definición será exactamente igual a la declaración, excepto que no finaliza con punto y coma (;).

4.3.7. Definición de clases

En esta parte del programa se deben definir los objetos o instancias de la clase declarada en la zona 4.3.4.


80

4.4. DATOS, VARIABLES Y CONSTANTES

4.4.1 Datos

Como se había mencionado en el capítulo 3, “Cada dato utilizado durante la ejecución del programa deberá ser descrito para que el compilador lo reconozca, sepa cómo almacenarlo y

recuperarlo; se deberá reservar memoria para que pueda almacenar la cantidad de datos necesarios.”

La declaración de cada ítem de datos consiste en indicar qué tipo de dato es y darle un nombre que lo identifique.

En C hay tipos básicos de datos: carácter (character), entero (integer), punto flotante (floating point) y puntero (point); aunque, en cada versión del lenguaje, pueden aparecer más o menos tipos de datos.

Por ejemplo, en C sólo existen cinco tipos fundamentales y los tipos enumerados, C++ añade un séptimo tipo, el bool, y el resto de los tipos son derivados de ellos.

Los números son los datos fundamentales utilizados por los programas de computadoras. El contenido de la memoria consiste en números binarios almacenados en grupos de 8 bits (1 byte) o

16 bits (2 bytes o 1 word). Aún cuando un programa de computadora trabaje con letras o gráficos, básicamente está involucrando una serie de números almacenados en memoria.

Los diferentes tipos de datos dependen, en realidad, de la cantidad de bytes que ocupen en memoria.

Para obtener información más detallada acerca de los tipos de datos, la cantidad de memoria reservada remitirse al APENDICE Tipos de datos

Cuando se desea definir ítems de datos que almacenen palabras (dos o más caracteres) nos encontramos ante el tipo de dato “string” o cadena de caracteres.

Por ejemplo:

`hola´

´Juan Pérez´

Este tipo de datos merece un desarrollo especial por ello se verá en el capítulo 9 que estudia el tema de arreglos.

4.4.2. Variables

El ítem de dato llamado variable, se refiere a un espacio de memoria cuyo contenido se

modificará de acuerdo a las circunstancias durante la ejecución del programa.

Cada variable utilizada en el programa deberá ser declarada antes de ser utilizada.

La declaración de una variable le indica al lenguaje que se pretende utilizar una variable

particular y qué tipo de dato almacenará. La declaración se forma por un tipo de dato seguido de uno o más nombres de variables.


81

La inicialización de una variable significa asignarle al espacio de memoria reservado un valor particular. Resulta conveniente realizarlo porque cuando se declara una variable, el espacio de

memoria reservado, podrá contener cualquier valor.

4.4.2.1. Identificadores

Un identificador es el nombre que permite identificar un espacio de memoria mediante un

nombre válido para el lenguaje.

El lenguaje C es flexible pero posee ciertas reglas que debemos respetar cuando definimos identificadores para las variables que utilizaremos en el programa.

Reglas para dar nombre a las variables:

Sólo se pueden usar letras (mayúsculas o minúsculas), números y ciertos caracteres no alfanuméricos, como el '_', pero nunca un punto, coma, guión, comillas o símbolos matemáticos o interrogaciones.

El primer carácter no puede ser un número.

C y C++ distinguen entre mayúsculas y minúsculas, de modo que los identificadores número y Número son diferentes.

Los primeros 32 dígitos son significativos, esto significa que La_cantidad_total_de_dinero_en_mi_cuenta y

La_cantidad_total_de_dinero_en_mi_banco serán consideradas como la misma variable.

4.4.2.2. Declaración de variables

Una característica del C es la necesidad de la declaración de las variables que se usarán en el programa. Aunque esto resulta chocante para los que se aproximan al C desde otros lenguajes de

programación, es en realidad una característica muy importante y útil de C, ya que ayuda a conseguir códigos más compactos y eficaces, y contribuye a facilitar la depuración, la detección y

corrección de errores.

Sintaxis:

[tipo] [lista_de_identificadores];

Tipo debe ser un tipo de datos válido y lista_de_identificadores puede ser uno o más

identificadores separados por coma (,). La declaración de variables puede considerarse como una sentencia. Desde este punto de vista, la declaración terminará con un ";".

Por ejemplo:

int numero;

float promedio, final;

char letra;

También es posible inicializar las variables dentro de la misma declaración.

Por ejemplo:

int a = 1234;

82

bool seguir = true, encontrado;

char letra = „k‟;

Se declarara las variables "a", "seguir", "encontrado" y “letra”; y además se inicia los valores de "a" en 1234, “seguir” en "true" y “letra” con „k‟.

En C, contrariamente a lo que sucede con otros lenguajes de programación, las variables no inicializadas tienen un valor indeterminado, contienen lo que normalmente se denomina "basura", también en esto hay excepciones como veremos más adelante.

4.4.2.2.1. Declaración de una variable de tipo entero (integer).

[signed |unsigned] [short | long | long long ] int <identificador o nombre>

[signed |unsigned] long long [ int ] <identificador o nombre>

[signed |unsigned] long [ int ] <identificador o nombre >

[signed |unsigned] short [ int ] <identificador o nombre >

4.4.2.2.2. Declaración de una variable de tipo punto flotante (float).

float <identificador o nombre >

4.4.2.2.3. Declaración de una variable de tipo punto flotante doble precisión (double).

[long] double <identificador o nombre >

4.4.2.2.4. Declaración de una variable sin tipo (void).

void <identificador o nombre >

Este es una variable especial que indica la ausencia de tipo. Se usa en funciones que no devuelven ningún valor, también en funciones que no requieren parámetros, aunque este uso sólo

es obligatorio en C, y opcional en C++, también se usará en la declaración de punteros genéricos.

4.4.2.2.5. Declaración de una variable de tipo enumerado (enum).

enum [<identificador_de_enum>] { <nombre> [= <valor>], ...} [lista_de_variables];

Este tipo nos permite definir conjuntos de constantes, normalmente de tipo int, llamados datos de tipo enumerado.

Las variables declaradas de este tipo sólo podrán tomar valores entre los definidos.

El identificador de tipo es opcional, y nos permitirá declarar más variables del tipo enumerado en otras partes del programa. La lista de variables también es opcional. Sin embargo, al menos uno

de los dos componentes opcionales debe aparecer en la definición del tipo enumerado.

Varios identificadores pueden tomar el mismo valor, pero cada identificador sólo puede usarse

en un tipo enumerado.

Por ejemplo:

enum tipo_horas {una=1, dos, tres, cuatro, cinco, seis, siete, ocho, nueve, diez, once, doce, trece=1, catorce, quince, dieciseis, diecisiete, dieciocho, diecinueve, veinte, veintiuna, veintidós, veintitrés, veinticuatro =0};

83

En este caso, una y trece valen 1, dos y catorce valen 2, etc. Y veinticuatro vale 0. Como se ve en el ejemplo, una vez se asigna un valor a un elemento de la lista, los siguientes toman valores

correlativos. Si no se asigna ningún valor, el primer elemento tomará el valor 0.

4.4.2.2.6. Declaración de una variable de tipo boleana (boolean).

bool <identificador o nombre>

Las variables de este tipo sólo pueden tomar dos valores "true" o "false". Sirven para evaluar expresiones lógicas.

Este tipo de variables se puede usar para almacenar respuestas, por ejemplo: ¿Posees carnet de conducir? O para almacenar informaciones que sólo pueden tomar dos valores, por ejemplo:

¿qué mano usas para escribir?

En estos casos debemos acuñar una regla, en este ejemplo, podría ser:

diestro->"true", zurdo->"false".

4.4.2.3. Inicialización de variables

En C se pueden asignar valores a la mayoría de las variables a la vez que se las declara.

La inicialización de una variable se realiza poniendo un signo igual y una constante después del

identificador.

Sintaxis:

[tipo] [identificador = constante];

Por ejemplo:

char a = „p‟; int num = 0;

4.4.3 Ejercicios sobre Variables

1) ¿Cuáles de los siguientes son tipos válidos de variables? Marcar la opción correcta.

a) unsigned char Sí No

b) long char Sí No

c) unsigned float Sí No

d) double char Sí No

e) signed long Sí No

f) unsigned short Sí No

g) signed long int Sí No

h) long double Sí No

i) enum dia {lunes, martes, miercoles, jueves, viernes, sabado, domingo}; Sí No

j) enum color {verde, naranja, rojo}; enum fruta {manzana, fresa, naranja, platano};Sí No

k) long bool Sí No

84

4.5. CONSTANTES Las constantes son muy similares a las variables, con la diferencia que éstas solo pueden tomar

un valor en el momento de la declaración, luego cualquier intento de modificación será tomado

como un error por parte del compilador.

Las constantes se declaran del mismo modo que las variables, solamente se debe anteponer la sentencia “const” antes del tipo de dato.

Por ejemplo:

const int mayor = 25;

4.5.1. Normas para la notación

Veremos las reglas que rigen la escritura de las constantes en C según diversos sistemas de

numeración y que uso tiene cada uno.

¿Por qué es necesaria la notación?

En todos los casos, especificar el tipo de la constante tiene como objetivo evitar que se realicen

conversiones de tipo durante la ejecución del programa, obligando al compilador a hacerlas durante la fase de compilación.

Por ejemplo:

float x = 0.0;

if(x <= 1.0f) x += 0.01f;

Si en el ejemplo hubiéramos escrito "if(x <= 1)...", el compilador almacenaría el 1 como un entero, y durante la fase de ejecución se convertirá ese entero a float para poder compararlo con x,

que es float. Al poner "1.0" estamos diciendo al compilador que almacene esa constante como un

valor en coma flotante.

Lo mismo se aplica a las constantes long, unsigned y char.

4.5.1.1. Constantes "int".

En C se usan tres tipos de numeración para la definición de constantes numéricas, el decimal, el

octal y el hexadecimal, según se use la numeración en base 10, 8 ó 16, respectivamente.

Por ejemplo:

El número 127, se representará en: notación decimal como 127 octal como 0177 hexadecimal como 0x7f.

En notación octal se usan sólo los dígitos del '0' al '7'.

En la notación hexadecimal se usan 16 símbolos, los dígitos del '0' al '9' tienen el mismo valor que en decimal, para los otros seis símbolos se usan las letras de la 'A' a la 'F', indistintamente en

mayúsculas o minúsculas. Sus valores son 10 para la 'A', 11 para la 'B', y sucesivamente, hasta 15 para la 'F'.

Según el ejemplo el número 0x7f, donde "0x" es el prefijo que indica que se trata de un número en notación hexadecimal, sería el número 7F, es decir,

85

7F=7*16+15=127. Del mismo modo que el número 127 en notación decimal sería, 1*10²+2*10+7=127.

En octal se usa como prefijo el dígito 0. El número 0177 equivale a 0177=1*8²+7*8+7=127.

Hay que tener mucho cuidado con las constantes numéricas, en C y C++ no es el mismo

número el 0123 que el 123, aunque pueda parecer otra cosa. El primero es un número octal y el

segundo decimal.

La ventaja de la numeración hexadecimal es que los valores enteros requieren dos dígitos por cada byte para su representación. Así un byte puede tomar valores hexadecimales entre 0x00 y 0xff, dos bytes entre 0x0000 y 0xffff, etc. Además, la conversión a binario es casi directa, cada

dígito hexadecimal se puede sustituir por cuatro bits, el '0x0' por '0000', el '0x1' por '0001', hasta el

'0xf', que equivale a '1111'. En el ejemplo el número 127, o 0x7f, sería en binario '01111111'.

Con la numeración octal es análogo, salvo que cada dígito agrupa tres bits.

Así un byte se puede tomar valores octales entre 0000 y 0377, dos bytes entre 0000000 y

0177777, etc. Además, la conversión a binario es casi directa, cada dígito octal se puede sustituir por tres bits, el '0' por '000', el '1' por '001', hasta el '7', que equivale a '111'. En el ejemplo el

número 127, o 0177, sería en binario '01111111'.

De este modo, cuando trabajemos con operaciones de bits, nos resultará mucho más sencillo escribir valores constantes usando la notación hexadecimal u octal.

Por ejemplo, resulta más fácil predecir el resultado de la siguiente operación:

A = 0xaa & 0x55;

Que:

A = 170 & 85;

En ambos casos el resultado es 0, pero en el primero resulta más evidente, ya que 0xAA es en binario 10101010 y 0x55 es 01010101, y la operación "AND" entre ambos números es 00000000,

es decir 0.

Ahora se propone al alumno intentarlo con los números 170 y 85.-

4.5.1.2. Constantes "long".

Para trabajar con valores constantes "long" debemos usar el sufijo "L". Esto resulta conveniente, sobre todo, al utilizar las constantes en expresiones condicionales y, por coherencia, también en expresiones de asignación.

Por ejemplo:

long x = 123L;

if(x == 0L) cout << "Valor nulo" << endl;

Puede suceder que el compilador nos señale un error cuando usemos constantes long sin

añadir el sufijo L.

86

Por ejemplo:

if(x == 1343890883) cout << "Número long int" << endl;

Esta sentencia hará que el compilador emita un error ya que no puede usar un tamaño mayor sin una indicación explícita.

Hay casos en los que los tipos "long" e "int" tienen el mismo tamaño, en ese caso no se

producirá error, pero no podemos predecir que nuestro programa se compilará en un tipo concreto de compilador o plataforma.

4.5.1.3. Constantes "long long".

Para trabajar con valores constantes "long long" debemos usar el sufijo "LL", sobre todo

cuando esas constantes aparecen en expresiones condicionales o de asignación.

Por ejemplo:

long long x = 16575476522787LL;

if(x == 1LL) cout << "Valor nulo" << endl;

Como cuando se utilizan constantes long, a menudo recibiremos errores del compilador cuando

usemos constantes long long sin añadir el sufijo LL.

Por ejemplo:

if(x == 16575476522787) cout << "Número long long" << endl;

Esta sentencia hará que el compilador emita un error ya que no puede usar un tamaño mayor sin una indicación explícita.

4.5.1.4. Constantes "unsigned".

Del mismo modo, cuando trabajamos con valores constantes "unsigned" debemos usar el sufijo

"U" para las mismas situaciones que hemos indicado para las constantes "long".

Por ejemplo:

unsigned int x = 123U;

if(x == 3124232U) cout << "Valor encontrado" << endl;

4.5.1.5. Constantes "unsigned long".

En una constante, es posible utilizar los modificadores "unsigned" y "long", en ese caso debemos usar el sufijo "UL" para las mismas situaciones que hemos indicado para las constantes

"long" y "unsigned".

Por ejemplo:

unsigned long x = 123456UL;

if(x == 3124232UL) cout << "Valor encontrado" << endl;

4.5.1.6. Constantes "unsigned long long".

También es posible combinar, en una constante, los modificadores "unsigned" y "long long", en ese caso debemos usar el sufijo "ULL", para las mismas situaciones que hemos indicado para las

constantes "long long" y "unsigned".

87

Por ejemplo:

unsigned long long x = 123456534543ULL;

if(x == 3124232ULL) cout << "Valor encontrado" << endl;

4.5.1.7. Constantes "float".

También existe una notación especial para las constantes en punto flotante.

En este caso consiste en añadir ".0" a aquellas constantes que puedan interpretarse como

enteras. Si se usa el sufijo "f" se tratará de constantes en precisión sencilla, es decir "float".

Por ejemplo:

float x = 0.0;

if(x <= 1.0f) x += 0.01f;

4.5.1.8. Constantes "double".

Si no se usa el sufijo “f”, se tratará de constantes de precisión doble, es decir tipo "double".

Por ejemplo:

double x = 0.0;

if(x <= 1.0) x += 0.01;

4.5.1.9. Constantes "long double".

Si se usa el sufijo "l" se tratará de constantes en precisión máxima, es decir "long double".

Por ejemplo:

long double x = 0.0L;

if(x <= 1.0L) x += 0.01L;

4.5.1.10. Constantes "char".

Las constantes de tipo "char" se representan entre comillas sencillas, por ejemplo 'a', '8', 'F'.

4.5.2. Recomendaciones en el uso de la notación.

4.5.2.1. Constantes enteras.

En general podemos combinar los prefijos "0" y "0x" con los sufijos "L", "U", y "UL". Aunque es

indiferente usar los sufijos en mayúsculas o minúsculas, es preferible usar mayúsculas, sobre todo con la "L", ya que la 'l' minúscula puede confundirse con un uno '1'.

4.5.2.2. Constantes punto flotante.

Se recomienda añadir el .0, cuando la constante se pueda confundir con un entero.

Usar la notación exponencial


88

También podemos usar notación exponencial, donde el formato exponencial consiste en un número, llamado mantisa, que puede ser entero o con decimales, seguido de una letra 'e' o 'E' y

por último, otro número (entero) que es el exponente de una potencia de base 10.

Por ejemplo:

double x = 10e4;

double y = 4.12e2;

double pi = 3.141592e0;

Los valores anteriores se representarían:

x = 10 x 104 = 100000

y = 4,12 x 102 = 412

pi = 3.141592 x 100 = 3.141592

Al igual que con los enteros, es indiferente usar los sufijos en mayúsculas o minúsculas, pero es preferible usar mayúsculas, sobre todo con la "L", ya que la 'l' minúscula puede confundirse con un

uno '1'.

4.5.3 Constantes carácter. Comentario adicional.

Si has pensado que una constante char se representa con 'k', tal vez, después de un rato te

preguntes ¿cómo se representa la constante que consiste en una comilla sencilla?

Existen ciertos caracteres, entre los que se encuentra la comilla sencilla, que no pueden ser representados con la norma general. Para eludir este problema existe cierto mecanismo, llamado

secuencias de escape. En el caso comentado, la comilla sencilla se define como '\', y la barra

descendente se define como '\\'.

Además de estos caracteres especiales existen otros.

4.5.3.1. Código ASCII.

El código ASCII es el conjunto de caracteres que puede ser representado por el tipo "char", consta de 128 o 256 caracteres.

El código ASCII de 128 caracteres utiliza 7 bits, actualmente ha quedado prácticamente obsoleto ya que no admite caracteres como la 'ñ' o la 'á' pero, aún se usa en ciertos equipos

antiguos donde el octavo bit se usa como bit de paridad en las transmisiones serie.

El código ASCII de 256 caracteres utiliza los 8 bits y, si recordamos, el tipo "char" tiene siempre

un byte (8 bits) y esto no es por casualidad.

En este conjunto existen, además de los caracteres alfabéticos, en mayúsculas y minúsculas,

los numéricos, los signos de puntuación y los caracteres internacionales, ciertos caracteres no imprimibles, como el retorno de línea, el avance de línea, etc.

Veremos estos caracteres y cómo se representan como secuencia de escape, en hexadecimal, el nombre ANSI y el resultado o significado.

89

Los tres últimos son realmente comodines para la representación de cualquier carácter.

El \nnn sirve para la representación en notación octal. Para la notación octal se usan tres

dígitos. Hay que tener en cuenta que, análogamente a lo que sucede en la notación hexadecimal, en octal se agrupan los bits de tres en tres. Por lo tanto, para representar un carácter ASCII de 8

bits, se necesitarán tres dígitos. En octal sólo son válidos los símbolos del '0' al '7'.

Según el ejemplo anterior, para representar el carácter 127 en octal usaremos la cadena '\177', y en hexadecimal '\x7f'. También pueden asignarse números decimales a variables de tipo char.

Por ejemplo:

char A;

A = 'a';

A = 97;

A = 0x61;

A = '\x61';

A = '\141';

En este ejemplo todas las asignaciones son equivalentes y válidas.

#include <iostream>


int main()

{char opc0='A'; //Ascii de A expresado como Caracter

char opc1=65 ; //Ascii de A expresado en Decimal

char opc2= 0101; //Ascii de A expresado en Octal

char opc3 = 0x41; //Ascii de A expresado en Hexadecimal

cout << opc0 <<endl;


90



return 0;

}

La salida de este programa muestra por pantalla 4 veces la A.

4.5.3.2. Carácter nulo.

El carácter nulo se usa en C para indicar la terminación de las cadenas de caracteres, por lo tanto es muy útil y de uso frecuente.

Para hacer referencia a él se usa frecuentemente su valor decimal, es decir char A = 0, aunque es muy probable que lo encuentres en libros o en programas como '\000', es decir en notación

octal.

4.5.3.3. Carácter EOF.

EOF viene del inglés "End Of File", este carácter se usa en muchos ficheros como marcador de

fin de fichero, sobre todo en ficheros de texto. Aunque dependiendo del sistema operativo este

carácter puede cambiar, por ejemplo en MS-DOS es el carácter "0x1A", el compilador siempre lo traduce y devuelve el carácter EOF cuando un fichero se termina.

4.5.4. Ejercicios

1) si debe almacenar el dato, ¿qué tipo de constante debería utilizar en cada caso? Marcar la

opción correcta.

a) '\x37'

1. char

2. long

3. int

4. float

b) 123UL

1. unsigned

2. int

3. long

4. unsigned long

c) 34.0

1. int

2. double

3. float

4. long

d) 6L

1. int


91

2. long

3. double

4. char

e) 67

1. char

2. unsigned

3. int

4. float

f) 0x139

1. char

2. unsigned

3. int

4. float

g) 0x134763df23LL

1. long

2. unsigned

3. int

4. long long

5.

Para la creación de identificadores en la escritura del código fuente se recomienda ver APENDICE ESTILOS DE NOTACIÓN.

92

4.6. OPERADORES

Los operadores son elementos que disparan ciertos cálculos cuando son aplicados a variables o a otros objetos en una expresión.

Un operador es un símbolo que le dice al compilador que realice manipulaciones matemáticas o lógicas específicas.

El lenguaje C tiene las siguientes clases de operadores: aritméticos, relacionales, lógicos y sobre bits.

Hay varios tipos de operadores, clasificados según el tipo de objetos sobre los que actúan.

Los tipos de operadores que veremos son:

Operadores Aritméticos.

Operadores Relacionales.

Operadores Lógicos.

Operadores de Asignación.

Operador sizeof.

Operador condicional.

Operador coma.

4.6.1. Operadores aritméticos.

Los operadores aritméticos se utilizan para crear expresiones matemáticas.

4.6.1.1. Operadores aritméticos unitarios.

Los operadores aritméticos unitarios que utiliza el C son: '+', '-','++', '--'

Sintaxis:

+ <expresión>

- <expresión>

<variable> ++ /* post-incremento */

++ <variable> /* pre-incremento */

<variable>-- /* post-decremento */

-- <variable> /* pre-decremento */

Operadores '+' y '-„

Los operadores aritméticos unitarios '+' y '-' asignan valores positivos o negativos a la expresión

a la que se aplican.

Operadores '++' y '--'

Los otros dos operadores unitarios '++' y '--' son un tanto especiales, ya que sólo pueden trabajar sobre variables, pues implican una asignación.

El primero ('++') incrementa el valor del operando y el segundo ('--') lo decrementa, ambos en

una unidad.

93

Existen dos modalidades, dependiendo de que se use el operador en la forma de prefijo o de sufijo.

En su forma de prefijo, el operador es aplicado antes de que se evalúe el resto de la expresión; en la forma de sufijo, se aplica después de que se evalúe el resto de la expresión.

Por ejemplo:

en las siguientes expresiones "a" vale 100 y "b" vale 10:

c = a + ++b;

En este primer ejemplo primero se aplica el pre-incremento, y b valdrá 11 a continuación se evalúa la expresión "a+b", que dará como resultado 111, y por último se asignará este valor a c,

que valdrá 111.

Por ejemplo:

c = a + b++;

En este segundo ejemplo primero se avalúa la expresión "a+b", que dará como resultado 110, y se asignará este valor a c, que valdrá 110.

Finalmente se aplica en post-incremento, y b valdrá 11.

Los operadores unitarios sufijos (post-incremento y post-decremento) se evalúan después de que se han evaluado el resto de las expresiones.

En el primer ejemplo primero se evalúa ++b, después a+b y finalmente c=<resultado>.

En el segundo ejemplo, primero se evalúa a+b, después c = <resultado> y finalmente b++.

Es muy importante no pensar o resolver las expresiones C como ecuaciones matemáticas, NO SON EXPRESIONES MATEMATICAS.

No veas estas expresiones como ecuaciones, NO SON ECUACIONES.

4.6.1.2. Operadores aritméticos binarios.

Los operadores binarios que utiliza el lenguaje C son: ' +', ' - ', ' * ', ' / ', „ % '

Sintaxis:

<expresión> + <expresión> /*Sintaxis de operador suma */

<expresión> - <expresión> /* Sintaxis de operador resta */

<expresión> * <expresión> /* Sintaxis de operador multiplicación */

<expresión> / <expresión> /* Sintaxis de operador división */

<expresión> % <expresión> /* Sintaxis de operador resto */

Evidentemente se trata de las conocidas operaciones aritméticas de suma, resta, multiplicación y división y los operadores se comportan como en cualquier lenguaje de computadoras.

Debemos tener en cuenta, por ejemplo, que el operador división ( / ) aplicado a un entero truncará (perderá) cualquier resto.

94

Por ejemplo:

10 / 3 será igual a 3 para la división entera.

El operador módulo '%', devuelve el resto de la división entera del primer operando entre el segundo. Por esta razón no puede ser aplicado a operando en coma flotante (ya que al ser números de punto flotante no hay resto!!).

4.6.2. Operadores relacionales Los operadores relacionales permiten determinar las relaciones que un valor o cantidad puede

tener con otro.

Aquí resulta clave la idea de verdadero o falso. En C cualquier valor distinto de cero es verdadero, y cero (0) es falso. Así, las expresiones que utilizan operadores relacionales devolverán

como resultado 0 si es falsa y 1 si es verdadera la expresión.

A continuación mostramos los operadores relacionales y su sintaxis:

En las expresiones, "E1 <operador_relacional> E2, los operandos (E1, E2) tienen algunas restricciones, pero de momento nos conformaremos con que sean de tipo aritmético. El resto de las

restricciones las veremos cuando conozcamos los punteros y los objetos.

Es un error frecuente utilizar el “=” en lugar del “==”, observar que el “=” es para ASIGNAR; y

el “==” es para COMPROBAR LA IGUALDAD.

4.6.3. Operadores lógicos.

Los operadores lógicos conforman expresiones lógicas y se utilizan para determinar cómo se presentan las relaciones entre las expresiones involucradas.

La siguiente tabla presenta los operadores lógicos y su sintaxis:


95

4.6.3.1. Operador && o AND.

El operador "&&" equivale al "AND" o "Y"; devuelve "true" sólo si las dos expresiones evaluadas son "true" o distintas de cero, en caso contrario devuelve "false" o cero. Si la primera

expresión evaluada es "false", la segunda no se evalúa.

Generalizando, con expresiones AND con más de dos expresiones, la primera expresión falsa

interrumpe el proceso e impide que se continúe la evaluación del resto de las expresiones. Esto es lo que se conoce como "cortocircuito", y es muy importante, como veremos posteriormente.

El operador && se usa según la siguiente tabla de verdad, donde se representa “true” con 1 y “false” con 0.

4.6.3.2. Operador || u OR.

El operador "||" equivale al "OR" u "O inclusivo"; devuelve "true" si cualquiera de las expresiones evaluadas es "true" o distinta de cero, en caso contrario devuelve "false" o cero. Si la

primera expresión evaluada es "true", la segunda no se evalúa.

El operador || se usa según la siguiente tabla de verdad, donde se representa l

4.6.3.3. Operador ! o NOT.

El operador "!" es equivalente al "NOT", o "NO", y devuelve "true" sólo si la expresión evaluada es "false" o cero; en caso contrario devuelve "false".

La expresión "!E" es equivalente a (0 == E).

El operador ! se usa según la siguiente tabla de verdad, donde se representa “true” con 0 y “false” con 1.

96

4.6.4. Operadores de asignación

La asignación consiste en un nombre de variable, seguido de un signo igual y el valor a ser asignado.

Por ejemplo: a = 14;

El operador asigna el valor de la izquierda (14) a la variable (a) que está a la derecha del operador asignación (=).

Existen varios operadores de asignación, el más evidente y el más usado es el "=", pero no es el único.

Los operadores de asignación y sus diferentes usos se describen a continuación:

4.6.5. Operador "sizeof"

El operador “sizeof” es un operador del tiempo de compilación.

Este operador tiene dos usos diferentes. Devuelve el tamaño de la variable o tipo que está como operando. Si el operador funciona sobre un tipo de dato, éste deberá ir entre paréntesis.

Sintaxis:

sizeof <expresión>

sizeof (nombre_de_tipo)

En ambos casos, el resultado es una constante entera que da el tamaño en bytes del espacio de memoria usada por el operando, que es determinado por su tipo.

El espacio reservado por cada tipo depende de la plataforma.

En el primer caso, el tipo del operando es determinado sin evaluar la expresión, y por lo tanto sin efectos secundarios.

Por ejemplo:

si el operando es de tipo "char", el resultado es 1.

A pesar de su apariencia, sizeof() NO es una función, sino un OPERADOR.

4.6.6. Operador condicional (?)

El operador "?:", se trata de un operador ternario (es decir tiene TRES operandos)

97

Sintaxis:

<expresión lógica> ? <expresión> : <expresión>

En la expresión E1? E2:E3, primero se evalúa la expresión E1, si el valor es verdadero ("true"), se evaluará la expresión E2 y E3 será ignorada, si es falso ("false"), se evaluará E3 y E2 será ignorada.

Hay ciertas limitaciones en cuanto al tipo de los argumentos:

E1 debe ser una expresión lógica.

E2 y E3 deben ser de tipo aritmético.

E2 y E3 deben ser de estructuras o uniones compatibles.

E2 y E3 deben ser de tipo "void".

Por ejemplo:

max = (a >=b) ? a : b;

A la variable max se le asigna el mayor valor.

#define max (a,b) (((a) > (b)) ? (a) : (b))

De este ejemplo sólo nos interesa la parte de la derecha. La interpretación es: si "a" es mayor que "b", se debe evaluar "a", en caso contrario evaluar "b", en resumen, evalúa siempre el

máximo!!

4.6.7. Operador coma (,)

El operador coma se utiliza para encadenar diversas expresiones. Provoca una secuencia de

operaciones a realizar, se puede pensar como “hacer esto y luego esto”.

Tiene una doble función: separa elementos de una lista de argumentos de una función. puede ser usado como separador en expresiones "de coma".

Ambas funciones pueden ser mezcladas, pero hay que añadir paréntesis para resolver las ambigüedades y provocar errores, ya que el operador coma tiene precedencia más baja, por

ejemplo, que el operador de asignación.

Sintaxis:

E1, E2, ... , En

En una expresión "de coma", cada operando es evaluado como una expresión, pero los

resultados obtenidos se tienen en cuenta en la próxima evaluación.

Por ejemplo:

x = (y=3,y+1);

En primer lugar asigna el valor 3 a la variable y, y después asigna el valor 4 a la variable x.


98

4.7. EXPRESIONES

La combinación de variables, constantes definidas o números con uno o más operadores dan como resultado un valor. Esta combinación recibe el nombre de expresión.

Una expresión es, según el diccionario, un "conjunto de términos que representan una cantidad", entre nosotros es cualquier conjunto de operadores y varios operando, que dan como

resultado una cantidad.

Operando es cada una de las cantidades, constantes, variables o expresiones que intervienen en una expresión.

Existe una división, en los operadores, atendiendo al número de operando que afectan. Según esta clasificación pueden ser unitarios, binarios o ternarios, los primeros afectan a un solo

operando, los segundos a dos y los ternarios como era de esperar a tres.

Las variables y constantes se pueden procesar utilizando operaciones y funciones adecuadas a

sus tipos.

Cada expresión toma un valor que se determina tomando los valores de las variables y

constantes implicadas y la ejecución de las operaciones indicadas.

Las expresiones se pueden clasificar, según los tipos de objetos que manipulan, en:

Aritméticas: cuyo resultado sería de tipo numérico.

Lógicas: cuyo resultado sería de tipo lógico.

Carácter: cuyo resultado sería de tipo carácter.

4.7.1. EXPRESIONES ARITMÉTICAS.

Una expresión aritmética es un conjunto de variables y/o constantes unidas o relacionadas por

paréntesis y operadores aritméticos.

Son análogas a las fórmulas matemáticas. Las variables y constantes son numéricas (enteras o

punto flotante) y las operaciones son aritméticas.

Por ejemplo:

sueldo = sueldo_base + 0.15 * monto_ventas

e = a*b*b / 3 + (a*a + b) / (b + c)

Cuando se utilizan expresiones aritméticas se debe tener en cuenta que:

Si en una operación ambos operando son enteros, entonces el resultado de la operación es un entero.

Si en una operación uno o ambos operando son reales, entonces el resultado de la operación es un real.

El operador “/” produce un cociente entero si los dos operando son enteros. Esto significa que se pierde la parte decimal si la división no es exacta. Esta es una consecuencia de la nota 1.

El operador “/” produce un cociente float si uno o los dos operando son float. Esta es una consecuencia de la nota 2.


99

Por ejemplo:

7 / 2 es igual a 3 y no 3.5 como lo es matemáticamente. Esto debido a que 7 y 2 son enteros y al dividir dos enteros se pierde la parte fraccionaria, no se redondea.

En cambio:

7.0 / 2 es igual a 3.5 ya que si uno o los dos operando son reales, entonces el resultado es real. En este caso 7.0 es real.

4.7.1.1. Reglas de Precedencia.

Las expresiones que tienen dos o más operando requieren reglas matemáticas que permitan determinar el orden de las operaciones.

Las Reglas de Prioridad o Precedencia son las reglas matemáticas que permiten determinar el orden de las operaciones.

Son:

Las operaciones que están encerradas entre paréntesis se evalúan primero. Si aparecen varios paréntesis anidados, se evalúan primero los paréntesis interiores.

En caso de coincidir varios operadores de igual prioridad, el orden se determina de izquierda a derecha.

Las operaciones aritméticas dentro de una expresión suelen seguir el siguiente orden de prioridad:

Para más detalle sobre operadores y reglas de precedencia ver

APENDICE. Precedencia de Operadores.

4.7.2. Expresiones lógicas Una expresión lógica o booleana es un conjunto de variables y/o constantes unidas mediante

operadores lógicos y operadores relacionales.

Las expresiones lógicas se forman combinando constantes lógicas, variables lógicas y otras

expresiones lógicas, utilizando operadores lógicos y relacionales; y su valor siempre es verdadero o falso.

Una expresión lógica solo puede tomar uno de dos valores: verdadero o falso.

Las expresiones lógicas son ampliamente utilizadas en las estructuras selectivas y las estructuras repetitivas.

100

4.7.2.1. Expresiones comparativas.

El formato general para las comparaciones es:

<Expresión1> operador de relación <Expresión2>

y el resultado será verdadero o falso.

Por Ejemplo:

Si A = 4 y B = 3 A > B da como resultado Verdadero

(A – 2) < (B – 4) da como resultado Falso.

Los operadores de relación se pueden aplicar a los tipos de datos estándar: entero, punto flotante, carácter ó lógico.

Aplicación en datos tipo carácter

La aplicación en valores numéricos es evidente; pero cuando deba comparar datos de tipo carácter, se requiere de una secuencia de ordenación de los caracteres, similar al orden creciente o

decreciente.

La ordenación suele ser alfabética y se recurre al código normalizado ASCII, donde:

„0‟ < „1‟ < „2‟ < „3‟ ....

„A‟ < „B‟ < „C‟ ....

„a‟ < „b‟ < „c‟ ....

Aplicación en datos tipo lógico.

Cuando se utilizan los operadores de relación con valores lógicos, Falso < Verdadero.

Por ejemplo:

Si tenemos la expresión Falso < Verdadero, dará como resultado Verdadero

Aplicación en datos tipo punto flotante

Cuando se utilizan los operadores = ó <> en valores punto flotante, es importante recordar que estos valores no se pueden almacenar exactamente, debido a la precisión aritmética limitada de las computadoras.

Así, lo aconsejable es excluir a los valores punto flotante en este tipo de comparaciones.

4.7.2.2. Expresiones lógicas.

En las expresiones lógicas se pueden mezclar operadores de relación y lógicos.

Por Ejemplo:

(1 < 5) and (5 < 10) da como resultado Verdadero.

(5 < 10) or („A‟ < „B‟) da como resultado Verdadero.


101

Para más detalle sobre operadores y reglas de precedencia ver APENDICE. Precedencia de Operadores.

Al igual que en las expresiones aritméticas, los paréntesis se podrán utilizar y tendrán prioridad

sobre cualquier operación.

Por Ejemplo:

not 4 > 6 da como resultado ERROR, ya que el operador NOT no se aplica sobre el 4.

not(4 > 6) da como resultado Verdadero

4.7.3. Ejercicios con operadores y expresiones

1) Suponiendo los siguientes valores iniciales para las variables: x = 2; y = 6; z = 9; r = 100;

s = 10; a = 15; b = 3; ¿Cuáles son los valores correctos en cada expresión? Marcar la opción correcta.

a) x += 10;

12

10

11

b) s *= b;

9

13

30

c) r /= 0;

infinito

1

error

d) y += x + 10;

8

12

18

e) z -= a*b;

-36

-18

36

102

2) Usar expresiones equivalentes para las siguientes, usando operadores mixtos.

a) x = 10 + x - y;

x += 10-y

x -= y+10

x += 10+y

b) r = 100*r;

r *= 100*r

r *= 100

r += 100

c) y = y/(10+x);

y /= 10*x

y /= 10 + y/x

y /= 10+x

d) z = 3 * x + 6;

z += 6

z *= 3

no es posible

3) Evaluar las siguientes expresiones. Siendo: x = 10; y = 20; z = 30;

a) z = x - y, t = z - y;

z=-10, t=-30

t=10

z=30, t=-30

b) (x < 10) && (y > 15)

true

false

c) (x <= z) || (z <= y)

true

false

d) !(x+y < z)

true

false

e) (x+y != z) && (1/(z-x-y) != 1)

true

false

error


103

4.8. INSTRUCCIONES

El elemento que nos está faltando para poder comenzar a escribir nuestros propios programas son las sentencias o instrucciones.

Un programa contiene las acciones o instrucciones que resolverán el problema. Las instrucciones describen la secuencia de pasos con el que se quiere solucionar el problema

planteado.

Existen instrucciones de diversos tipos que nos permitirán enfrentarnos a todas las situaciones posibles en programación.

Los tipos de sentencias son:

Bloques

Expresiones

Llamadas a función

Asignación

Nula

Bucles

while

do while

for

Etiquetas

Etiquetas de identificación

case

default

Selección

if...else

switch

Saltos

break

continue

goto

return

Veamos cada una de ellas.

4.8.1. Bloques. Una sentencia compuesta o un bloque es un conjunto de sentencias, que puede estar vacía,

encerrada entre llaves " {}”.

Sintácticamente, un bloque se considera como una única sentencia.

104

También se usa en variables compuestas, como veremos en el capítulo de variables II, y en la definición de cuerpo de funciones.

Los bloques pueden estar anidados hasta cualquier profundidad.

4.8.2. Expresiones. Una expresión seguida de un punto y coma (;), forma una sentencia de expresión.

La forma en que el compilador ejecuta una sentencia de este tipo es evaluando la expresión. Cualquier efecto derivado de esta evaluación se completará antes de ejecutar la siguiente

sentencia.

Sintaxis:

<expresión>;

4.8.2.1. Llamadas a función.

La sentencia de llamada a función es la manera de ejecutar las funciones que se definen en otras partes del programa o en el exterior de éste, ya sea una librería estándar o particular.

La llamada a función se forma con el nombre de la función, una lista de parámetros entre paréntesis y un ";".

4.8.2.2. Asignación.

Una instrucción de asignación consiste en dar a una variable el valor de una expresión, el valor de otra variable o el valor de una constante.

La sentencia de asignación se utiliza para almacenar valores a variables o constantes.

Es una operación que sitúa un valor determinado en una posición de memoria.

Sintaxis:

<variable> <operador de asignación> <expresión>;

La expresión de la derecha es evaluada y el valor obtenido es asignado a la variable o constante de la izquierda. El tipo de asignación dependerá del operador utilizado, estos operadores ya los vimos en el capítulo anterior.

En la parte izquierda de la asignación se pone el nombre de la variable que se quiere modificar. La parte derecha contiene una expresión que le dará el nuevo valor a la variable, y por lo tanto

debe tener el mismo tipo que la variable.

4.8.2.3. Nula.

La sentencia nula consiste en un único ";". Sirve para usarla en los casos en los que el compilador espera que aparezca una sentencia, pero en realidad no pretendemos hacer nada.

Veremos ejemplos de esto cuando lleguemos a los bucles.

4.8.3. Bucles. Un bucle es la estructura de control que permite la repetición de una serie determinada de

sentencias. Es importante tener en cuenta cuántas veces se repite el bucle y cuál es el cuerpo del

bucle.

105

El cuerpo del bucle lo constituyen la serie de sentencias que pueden ser de cualquier tipo (secuencial, de decisión o repetitivo) las cuales serán repetidas n veces, pudiendo ser n conocido o

desconocido. Cuando n es desconocido, el número de veces que debe repetirse el cuerpo del bucle estará condicionado por una expresión lógica.

Un bucle no es más que una serie de instrucciones que se repiten.

A la hora de utilizar un bucle, sea del tipo que sea, debemos ir con cuidado y pensar cuando debe acabar ya que si no tuviéramos en cuenta esto podríamos entrar en un bucle sin fin, iríamos

repitiendo las mismas líneas teniendo que abortar la aplicación, para poder finalizar la ejecución del programa.

Por esto, es de suma importancia que pensemos, antes de hacer nada, en qué momento, cómo, dónde y por qué debe acabar el bucle.

4.8.3.1. Bucle "while".

Es la sentencia de bucle más sencilla, y sin embargo es tremendamente potente.

Sintaxis:

while (<condición>) <sentencia/s>;

La sentencia o el grupo de sentencias es ejecutado repetidamente mientras la condición sea verdadera, ("while" en inglés significa "mientras").

Si no se especifica condición se asume que es "true", y el bucle se ejecutará indefinidamente.

Si la primera vez que se evalúa la condición resulta falsa, la/s sentencia/s no se ejecutarán

ninguna vez.

Por ejemplo:

while (x < 100) x = x + 1;

Se incrementará el valor de x mientras x sea menor que 100.

Este ejemplo puede escribirse, usando el C con propiedad y elegancia, de un modo más compacto:

while (x++ < 100);

Aquí vemos el uso de una sentencia nula, observa que el bucle simplemente se repite, y la sentencia ejecutada es ";", es decir, nada.

4.8.3.2. Bucle "do while".

Esta sentencia va un paso más allá que el "while".

Sintaxis:

do <sentencia/s> while(<condición>);

106

La/s sentencia/s es ejecutada repetidamente mientras la condición resulte verdadera.

Si no se especifica condición se asume que es "true", y el bucle se ejecutará indefinidamente.

A diferencia del bucle "while", la evaluación se realiza después de ejecutar la sentencia, de

modo que se ejecutará al menos una vez.

Por ejemplo:

do

x = x + 1;

while (x < 100);

Se incrementará el valor de x hasta que x valga 100.

4.8.3.3. Bucle "for".

Por último, el bucle "for", es el más elaborado.

Sintaxis:

for ( [<inicialización>]; [<condición>] ; [<incremento>] )

<sentencia/s>

La/s sentencia/s es ejecutada repetidamente hasta que la evaluación de la condición resulte falsa.

Antes de la primera iteración se ejecutará la iniciación del bucle, que puede ser una expresión o una declaración.

En este apartado se iniciarán las variables usadas en el bucle. Estas variables pueden ser declaradas en este punto, pero en ese caso tendrán validez sólo dentro del bucle "for".

Después de cada iteración se ejecutará el incremento de las variables del bucle.

Todas las expresiones son opcionales, si no se especifica la condición se asume que es verdadera.

Por ejemplo:

for (int i = 0; i < 100; i = i + 1);

Como las expresiones son opcionales, podemos simular bucles "while":

for(;i < 100;) i = i +1;

for(;i++ < 100;);

O bucles infinitos:

for(;;);

4.8.4. Etiquetas. Los programas C y C++ se ejecutan secuencialmente, aunque esta secuencia puede ser

interrumpida de varias maneras.

Las etiquetas son la forma en que se indica al compilador en qué puntos será reanudada la

ejecución de un programa cuando haya una ruptura del orden secuencial.

107

4.8.4.1. Etiquetas de identificación.SACAR?????

Las etiquetas de identificación sirven como puntos de entrada para la sentencia de salto "goto".

Sintaxis:

<identificador>: <sentencia>

Estas etiquetas tienen el ámbito restringido a la función dentro de la cual están definidas.

Veremos su uso con más detalle al analizar la sentencia "goto".

4.8.4.2. Etiquetas "case" y "default".

Estas etiquetas se circunscriben al ámbito de la sentencia "switch", y se verá su uso cuando

estudiemos ese apartado.

Sintaxis:

switch(<variable>)

{

case <expresión_constante>: [<sentencias>][break;]

. . .

[default: [<sentencias>]]

}

4.8.5. Sentencias de Selección.

Las sentencias de selección permiten controlar el flujo del programa, seleccionando distintas sentencias en función de diferentes valores.

4.8.5.1. Sentencia "if...else".

Implementa la ejecución condicional de una sentencia.

Sintaxis:

if (<condición>) <sentencia1>;

if (<condición>) <sentencia1>; else <sentencia2>;

Si la condición es "true" se ejecutará la sentencia1, si es "false" se ejecutará la sentencia2.

El "else" es opcional, y no pueden insertarse sentencias entre la sentencia1 y el "else".

Se pueden declarar variables dentro de la condición.

Por ejemplo:

if ( int val = func(arg))...

En este caso, la variable "val" sólo estará accesible dentro del ámbito de la sentencia "if" y, si existe, del "else".

108

4.8.5.2. Sentencia "switch".

Cuando se usa la sentencia switch el control se transfiere al punto etiquetado con el "case" cuya expresión constante coincida con el valor de la variable del "switch".

A partir de ese punto todas las sentencias serán ejecutadas hasta el final del "switch", es decir hasta llegar al "}". Esto es así porque las etiquetas sólo marcan los puntos de entrada después de

una ruptura de la secuencia de ejecución, pero no marcan las salidas.

Esta característica nos permite ejecutar las mismas sentencias para varias etiquetas distintas, y

se puede eludir usando la sentencia de ruptura "break" al final de las sentencias incluidas en cada "case".

Si no se satisface ningún "case", el control parará a la siguiente sentencia después de la etiqueta "default". Esta etiqueta es opcional y si no aparece se abandonará el "switch".

No te preocupes, con un ejemplo se aclarará.

Sintaxis:

switch (<variable>)

{

case <expresión_constante>: [<sentencias>] [break;]

. . .

[default : [<sentencia>]]

}

Por ejemplo:

switch(letra)

{

case 'a':

case 'e':

case 'i':

case 'o':

case 'u':

EsVocal = true;

break;

default:

EsVocal = false;

}

En este ejemplo letra es una variable de tipo "char" y EsVocal de tipo "bool".

Si el valor de entrada en el "switch" corresponde a una vocal, EsVocal saldrá con un valor verdadero, en caso contrario, saldrá con un valor falso.

El ejemplo ilustra el uso del "break", si letra es 'a', se cumple el primer "case", y la ejecución continúa en la siguiente sentencia, ignorando el resto de los "case" hasta el "break".

Otro ejemplo:

Menor1 = Menor2 = Menor3 = Mayor3 = false;

switch (numero)

{

109

case 0:

Menor1 = true;

case 1:

Menor2 = true;

case 2:

Menor3 = true;

break;

default:

Mayor3 = true;

}

Veamos qué pasa en este ejemplo si número vale 1.

Directamente se reanuda la ejecución en "case 1:", con lo cual Menor2 tomará el valor "true", lo mismo pasará con Menor3.

Después aparece el "break" y se abandona el "switch".

4.8.6. Sentencias de salto Las sentencias de salto permiten romper la ejecución secuencial de un programa.

4.8.6.1. Sentencia de ruptura "break".

El uso de esta sentencia dentro de un bucle pasa el control a la primera sentencia después de la sentencia de bucle.

Un ejemplo de aplicación es dentro de la sentencia "switch".

Sintaxis:

break

Ejemplo:

y = 0;

x = 0;

while (x < 1000)

{

if (y == 1000) break;

y++;

}

x = 1;

En este ejemplo el bucle no terminaría nunca si no fuera por la línea del "break", ya que x no

cambia.

Después del "break" el programa continuaría en la línea "x = 1".

4.8.6.2. Sentencia “continue".

El uso de la sentencia continue dentro de un bucle permite pasar el control al final de la

sentencia de bucle, justo al punto donde se evalúa la condición para la permanencia en el bucle.

110

Sintaxis:

continue

Ejemplo:

y = 0;

x = 0;

while (x < 1000)

{

x++;

if (y >= 100) continue;

y++; }

En este ejemplo la línea "y++" sólo se ejecutaría mientras "y" sea menor que 100, en cualquier otro caso el control pasa a la línea "}", con lo que el bucle volvería a evaluarse.

4.8.6.3. Sentencia de salto "goto". SACAR???

Con el uso de la sentencia goto el control del programa se transfiere directamente al punto etiquetado con el identificador especificado.

El "goto" es un mecanismo que está en guerra permanente, y sin cuartel, con la programación estructurada.

El "goto" no se usa, se incluye aquí porque existe, pero siempre que se pueda debe ser eludido. Existen otros mecanismos para hacer todo aquello que pueda realizarse con un "goto".

Sintaxis:

goto <identificador>

Ejemplo:

x = 0;

Bucle:

x++;

if (x < 1000) goto Bucle;

Este ejemplo emula el funcionamiento de un bucle "for" como el siguiente:

for(x = 0; x < 1000; x++);

4.8.6.4. Sentencia de retorno "return".

La sentencia return sale de la función donde se encuentra y devuelve el control a la rutina que

la llamó, opcionalmente con un valor de retorno.

Sintaxis:

return [<expresión>]

Ejemplo:

int Paridad(int x)

{

if (x % 2) return 1;

return 0;

}

111

Este ejemplo ilustra la implementación de una función que calcula la paridad de un parámetro. Si el resto de dividir el parámetro entre 2 es distinto de cero, implica que el parámetro es impar, y

la función retorna con valor 1. El resto de la función no se ejecuta. Si por el contrario el resto de dividir el parámetro entre 2 es cero, el parámetro será un número par y la función retornará con

valor cero.

4.8.6.5. Sobre las sentencias de salto y la programación estructurada.

En general, es una buena norma huir de las sentencias de salto. Lo dicho para la sentencia "goto" es válido en general para todas las sentencias de salto, salvo el "return" y el "break", este

último tiene un poco más de tolerancia, sobre todo en las sentencias "switch", donde resulta imprescindible.

4.8.7. Comentarios.

Los comentarios ayudan a seguir el funcionamiento del programa durante la depuración o en la actualización del programa, además de documentarlo.

No se trata propiamente de un tipo de sentencias, pero me parece que es el lugar adecuado

para introducir este concepto.

En C pueden introducirse comentarios en cualquier parte del programa, Los comentarios en C

se delimitan entre /* y */, cualquier cosa que escribamos en su interior será ignorada por el compilador, sólo está prohibido su uso en el interior de palabras reservadas o en el interior de

identificadores.

Por ejemplo:

main(/*Sin argumentos*/void) está permitido

ma/*función*/in(void) es ilegal

La función de los comentarios es aclarar y documentar, no entorpecer el código.

En C++ se ha incluido otro tipo de comentarios, que empiezan con //. Estos comentarios no tienen marca de final, sino que terminan cuando termina la línea.

Por ejemplo:

void main (void) // Esto es un comentario

{

}

Las llaves {} no forman parte del comentario.

4.8.8. Ejercicios con sentencias. 1) Mostrar los sucesivos valores de la variable x en los siguientes bucles:

a) int x=0;

while(x < 5) x += 2;

0,2,4,6

0,2,4

0,2,4,6,8

112

b) int x=10;

do x++; while(x < 10);

10

10,11

11

c) bool salir = false;

int x = 13;

while(!salir) {

x++;

salir = x%7;

}

13,14

13,14,15

13

d) int x = 6;

do {

switch(x%3) {

case 0: x=10; break;

case 1: x=17; break;

case 2: x=5; break;

}

} while(x != 5);

6,10,17

6,10,17,5

6,10,17,10,5

e) int x=0, y=0;

do {

if(x>4) { x %= 4; y++; }

else x++;

} while(y < 2);

0,1,2,3,4,5,1,2,3,4,5,1

0,1,2,3,4,5,1,2,3,4,5

0,1,2,3,4,5,1,2,3,4,5,1,2

f) int x=0, y=1;

while(y != 3) {

x++;

if(x<3) continue;

x=y; y++;

}

0,1,2,3,1,2,3,2,3

0,1,2,3,1,2,3,2

0,1,2,3,1,2,3,2,3,2

113

4.9. FUNCIONES

Las funciones son un conjunto de instrucciones que realizan una tarea específica. En general

toman unos valores de entrada, llamados parámetros y proporcionan un valor de salida o valor de retorno; aunque tanto unos como el otro pueden no existir.

Al igual que con las variables, las funciones pueden declararse y definirse.

Una declaración es simplemente una presentación.

Una definición contiene las instrucciones con las que realizará su trabajo la función.

4.9.1. Declaración de función. El Prototipo. La declaración de una función se realiza mediante una sentencia conocida con el nombre de

prototipo.

Un prototipo consiste en una definición de la función sin cuerpo y terminado con un ";".

Sintaxis:

<tipo> func (<lista de declaración de parámetros>);

Por ejemplo:

int Intervalo(int a, int b); /*Prototipo de la función Intervalo*/

El prototipo sirve para indicar al compilador los tipos de datos de retorno y los tipos de datos de

los parámetros que recibe la función, de modo que compruebe si son del tipo correcto cada vez que se use esta función dentro del programa, o para hacer las conversiones de tipo cuando sea

necesario.

Los nombres de los parámetros son opcionales, y se incluyen como documentación y ayuda en

la interpretación y comprensión del programa.

El ejemplo de prototipo anterior sería igualmente válido y se podría poner como:

int Intervalo (int,int); /*Prototipo de la función Intervalo */

El prototipo del ejemplo indica que en algún lugar del programa se definirá una función

"Intervalo" que admite dos parámetros de tipo "int" y que devolverá un valor de tipo "int". No es necesario escribir nombres para los parámetros, ya que el prototipo no los usa. En otro lugar del

programa habrá una definición completa de la función.

Normalmente se aconseja:

Copiar el prototipo de la función y pegar como una definición eliminando el “;” del final de línea de esta manera no se comenten errores.

PERO si hacemos esto utilizando la última forma de indicar el prototipo de la función (es decir sin dar nombres a las variables) no sirve, ya que en la definición de la función

necesitamos dar un nombre a la variable para poder usarla.

Las funciones se declaran como prototipos dentro del programa, o se incluyen estos

prototipos desde un fichero externo, (usando la directiva "#include")


114

La definición de la función se hace más adelante; lo habitual es hacerlo después de la función "main".

Los programas complejos se escriben normalmente usando varios ficheros fuente. Estos ficheros se compilan separadamente y se enlazan juntos. Esto es una gran ventaja durante el desarrollo y depuración de grandes programas, ya que las

modificaciones en un fichero fuente sólo nos obligarán a compilar ese fichero fuente, y

no el resto, con el consiguiente ahorro de tiempo.

La definición de las funciones puede hacerse dentro de los ficheros fuente o enlazarse desde librerías precompiladas. La diferencia entre una declaración y una definición es

que la definición posee un cuerpo de función.

En C++ es obligatorio el uso funciones prototipo, y aunque en C no lo es, resulta altamente recomendable.

4.9.1.1. Funciones extern y static.

Hay funciones que son "extern" por defecto. Esto quiere decir que son accesibles desde cualquier punto del programa, aunque se encuentren en otros ficheros fuente del mismo programa.

En contraposición las funciones declaradas "static" sólo son accesibles dentro del fichero fuente donde se definen.

4.9.2. Definición de función La definición de una función se compone de las siguientes secciones, aunque pueden

complicarse en ciertos casos:

Tipo de almacenamiento

Tipo de valor de retorno

Modificadores opcionales

Nombre de la función

Lista de parámetros (entre paréntesis)

Cuerpo de la función

4.9.2.1. Tipo de almacenamiento.

Opcionalmente, una palabra que especifique el tipo de almacenamiento, puede ser "extern" o

"static". Si no se especifica es "extern".

4.9.2.2. Tipo de valor de retorno.

El tipo del valor de retorno puede ser "void" si no necesitamos valor de retorno.

En C, si no se establece, por defecto será "int", aunque en general se considera de mal gusto omitir el tipo de valor de retorno.

En C++ es obligatorio indicar el tipo del valor de retorno.

115

4.9.2.3. Modificadores opcionales.

Los modificadores tienen un uso muy específico, de momento no entraremos en este particular,

lo veremos en capítulos posteriores.

4.9.2.4. Nombre de la función.

Para el nombre de la función, resulta muy útil y recomendable, poner nombres que indiquen, lo más claramente posible, qué es lo que hace la función, y que permitan interpretar qué hace el

programa con sólo leerlo.

Cuando se precisen varias palabras para conseguir este efecto existen varias reglas aplicables

de uso común. Una consiste en separar cada palabra con un "_", la otra, que yo prefiero, consiste en escribir la primera letra de cada palabra en mayúscula y el resto en minúsculas.

Por ejemplo, si hacemos una función que busque el número de teléfono de una persona en una base de datos, podríamos llamarla "busca_telefono" o "BuscaTelefono".

4.9.2.5. Lista de parámetros.

Entre paréntesis se deben incluir las declaraciones de parámetros separados por coma (,).

Los parámetros de una función son los valores de entrada (y en ocasiones también de salida).

Para la función se comportan exactamente igual que variables, y de hecho cada parámetro se declara igual que una variable.

Una lista de parámetros es un conjunto de declaraciones de parámetros separados con comas. Puede tratarse de una lista vacía.

En C es preferible usar la forma "func(void)" para listas de parámetros vacías.

En C++ este procedimiento se considera obsoleto, se usa simplemente "func()".

4.9.2.6. Cuerpo de función.

El cuerpo de función representa el código que será ejecutado cuando se llame a la función.

El cuerpo de la función se encierra entre llaves "{}"

4.9.3. Función main() Una función muy especial es la función "main".

Se trata de la función de entrada, y debe existir SIEMPRE. Será la función que tome el control cuando se ejecute un programa en C.

Existen reglas para el uso de los valores de retorno y de los parámetros de la función "main", pero de momento la usaremos como "int main()" o "int main(void)", con un entero como valor de retorno y sin parámetros de entrada.

En Linux la función main() DEBERÁ retornar un valor sino el compilador indicará un error.

Ejemplo de función:

/* Esta función devuelve el mayor de dos números */

# include <iostream>


int Mayor (int a, int b); /* Prototipo de función Mayor */

int main()

{ int x,y; /*variables locales x e y*/

cout << endl << "Ingrese un entero: ";

116

cin >> x;

cout << endl << "Ingrese otro entero: ";

cin >> y;

cout<< endl <<"El mayor valor es :" << Mayor(x,y)<< endl; /*Llamada*/

return 0;

}

int Mayor (int a, int b) /* Definición de función Mayor */

{ if (a >=b) return a;

else return b; }

4.9.4. Ámbito de variables Dependiendo de dónde se declaren las variables, podrán o no ser accesibles desde distintas

partes del programa.

4.9.4.1. Variables locales.

Las variables declaradas dentro de una función, y recuerda que "main" también es una función, sólo serán accesibles desde esa función. Esas variables son variables locales o de ámbito local de

esa función.

Las variables declaradas dentro de un bucle, serán accesibles sólo desde el propio bucle, serán

de ámbito local del bucle.

4.9.4.2. Variables globales.

Las variables declaradas fuera de las funciones, normalmente antes de definir las funciones, en la zona donde se declaran los prototipos, serán accesibles desde todas las funciones.

Diremos que esas variables serán globales o de ámbito global.

Por ejemplo:

int EnteroGlobal; // Declaración de una variable global

int Funcion1(int a); // Declaración de un prototipo

int main()

{

int EnteroLocal; // Declaración de una variable local de main:

EnteroLocal = Funcion1(10); // Acceso a una variable local:

EnteroGlobal = Funcion1(EnteroLocal); // Acceso a una valiable global:

return 0;}

int Funcion1(int a)

{ char CaracterLocal; // Variable local de funcion1

// Desde aquí podemos acceder a EnteroGlobal, y también //a CaracterLocal pero no a EnteroLocal

if (EnteroGlobal != 0)

return a //EnteroGlobal;

else

return 0;}

117

De modo que en cuanto a los ámbitos locales tenemos varios niveles:

<tipo> funcion(parámetros) // (1)

{

<tipo> var; // (2)

for(<tipo> var;...) // (3)

...

return var;

}

(1) los parámetros tienen ámbito local a la función.

(2) las variables declaradas aquí, también.

(3) las declaradas en bucles, son locales al bucle.

Es una buena costumbre inicializar las variables locales.

Cuando se trate de variables estáticas se inicializan automáticamente a cero.

4.9.5. Ejercicios 1-) En el ejemplo, ¿qué ámbito tiene cada una de las variables? Marcar la opción

correcta

float s,i;

int main()

{

int x;

x=10;

for(int i=0; i<x; i++)

Mostrar(i);

i = 0.0;

while(x>0) {

i *= 10.3;

x--;

}

return 0;

a) La variable de tipo float s tiene ámbito

global

local en main

local en bucle

b) La variable de tipo int i tiene ámbito

global

local en main

local en bucle

c) La variable de tipo float i tiene ámbito

global

local en main


118

local en bucle

d) La variable de tipo int x tiene ámbito

global

local en main

local en bucle

2-) ¿Cuáles de los siguientes prototipos son válidos?

a) Calcular (int, int, char r); Sí No

b) void Invertir(int, unsigned char) Sí No

c) void Aumentar (float valor); Sí No

d) float Negativo (float int); Sí No

e) int Menor (int, int, int); Sí No

f) char Menu (int opciones); Sí No

3-) Preguntas sobre la estructura de un programa. Marcar la opción correcta.

a) ¿Entre qué zonas harías las declaraciones de variables globales?

Antes de la zona de las directivas del preprocesador.

Entre la zona de las directivas del preprocesador y las declaraciones de prototipos.

Después de la definición de la función "main".

b) ¿Qué aparecería normalmente justo después de la definición de la función "main"?

Las directivas del preprocesador.

Los prototipos de funciones.

Las definiciones de funciones.

4-) Identifique las siguientes partes de las funciones. Marcar la/s opción/es

correcta/s.

Encabezado o Definición de la Función.

Cuerpo de la Función ó Enunciados de la Función.

Prototipo de la Función.

Argumentos de la Función.

Tipos de Argumentos de la Función.

Tipo de Argumento retornado por la Función.

5-) Escribir el código fuente de un programa que contenga una función que reciba un entero y devuelva P si es POSITIVO y N si es NEGATIVO.

6-) Escribir el código fuente de un programa que desde main se llame a una función que recibe dos argumentos enteros y devuelve un valor booleano, siendo TRUE si el mayor argumento es

divisible por el menor o FALSE si el mayor argumento no es divisible por el mayor.

7-) Escribir el código fuente de un programa que desde main se llame a una función que recibe como argumento dos números reales, y retorna el menor que es mostrado en main.

8-) Escribir el código fuente de un programa que desde main se llame a una función pasando como argumento un valor entero, esta función calcula los coeficientes de la serie de “Fibonacci”

hasta el entero pasado; y retorna la suma de los términos que se muestra desde main.

Ej: N=6 , la serie será = 0 – 1 – 1 – 2 – 3 – 5. La suma mostrada en main será S=12.


119

9-) Escribir el código fuente de un programa que permita definir tres funciones, una que detecta si un carácter es una Vocal , otra que detecta si es Consonante y otra si es un Dígito, todas

devuelven el valor TRUE o FALSE y desde main se debe indicar si el tipo de char ingresado es : vocal, consonante ó dígito.

Se puede suponer en principio para simplificar que los caracteres ingresados son TODO minúsculas. Sugerencia: Mirar la tabla de caracteres ASCII.

10-) Escribir el código fuente de un programa que desde main se llame a una función la cual recibe un par de números y retorna el resto de la división del mayor dividido el menor.

Sugerencia: usar el operador () ? : .

11-) Escribir el código fuente de un programa que desde main se llame a una función que recibe como argumento un número entero, calcula y muestra desde la misma función los divisores

de ese número retornando un valor TRUE, si el número no es primo y FALSE si es primo.

12-) Se dice que un número entero es perfecto, si la suma de sus divisores incluyendo el 1 es igual a sí mismo.

Ej: 6 = 3 + 2+ 1 , ver que 3,2,1 son divisores de 6.

Escribir una función que reciba un entero, y retorne TRUE para el caso de que el número sea un “entero perfecto”.

13-) Escribir el código fuente de un programa que desde main se llame a una función menú que no recibe ningún argumento y que retorne la opción de menú elegida, ésta se mostrará desde

main. Los ítems del menú deberían ser por ej. 1,2,3,4 y 5 para salir, o A,B,.. y F para Finalizar. Controlar que sólo salga con la opción indicada.

14-) Escribir el código fuente de un programa que desde main se llame a una función menú (similar al ejercicio 13), las opciones del menú serán:

1: Cargar un vector y luego presentar nuevamente el menú, (todas las funciones refieren al vector)

2: Ordenar.

3:Buscar el mayor.

4:Calcular el promedio.

5:Salir.

Cada uno de estos puntos se debe realizar con una función. No usar variables globales. Usar pasaje de valores a funciones por referencia para el caso de ordenar!!.

15-) Escribir el código fuente de un programa que desde main llame a una función la cual itera (sin hacer nada) mientras se introduzca la letra “s” y se detiene cuando se introduce la letra “n”.

Ver que s y n son MINUSCULAS!!.

16-) Escribir el código fuente de un programa que desde main copie usado la función “strcpy” de un string.

17-) Escriba una función que reciba la cantidad de elementos a acumular y retorne el valor acumulado.

Ej: recibe 4, y luego se ingresan, dentro de la función cuatro números, 1, 3, 3, 2 deberá retornar a main el total acumulado=9.

18-) Escriba una función que reciba la cantidad de elementos a promediar y retorne el promedio. Ej: recibe 3, luego se ingresan, dentro de la función tres valores, 10, 5, 15 y deberá retornar a main el promedio=10.

120

4.10. ARREGLOS

Un arreglo es un conjunto de elementos del mismo tipo agrupados en una sola variable. Es una

estructura de datos en la que se almacena una colección de datos del mismo tipo

Los arreglos poseen ciertas características particulares:

Cada posición de almacenamiento en un arreglo es llamada un elemento del arreglo.

Para ingresar a un elemento en particular, utilizamos un índice.

Tienen un único nombre de variable, que representa todos los elementos, los cuales se diferencian por un índice o subíndice.

Existen arreglos unidimensionales, bidimensionales y tridimensionales.

Físicamente, un arreglo es un conjunto de localidades de memoria contiguas donde la dirección más baja corresponde al primer elemento y la dirección más alta al último.

En un arreglo de n elementos, éstos ocuparan desde 0 hasta la n-1.

Por sí mismo, el nombre del arreglo apunta a la dirección del primer elemento del arreglo.

4.10.1. Cadena de caracteres. Antes de comenzar a desarrollar el tema de los arreglos o "arrays", veremos un caso especial de ellos.

Se trata de las cadenas de caracteres o "strings" (en inglés).

Una cadena, en C, es un conjunto de caracteres, o valores de tipo "char", terminados con el carácter nulo, es decir el valor numérico 0.

Internamente se almacenan en posiciones consecutivas de memoria.

Este tipo de estructuras recibe un tratamiento especial, y es de gran utilidad y de uso continuo.

Una cadena puede almacenar informaciones como nombres de personas, mensajes de error, números de teléfono, etc.

Sintaxis para definir una variable tipo cadena:

char <identificador> [<longitud máxima>];

En este caso los corchetes no indican un valor opcional, sino que son realmente corchetes, por eso están en negrita.

Durante el tratamiento de variables tipo cadena tener en cuenta que:

Cuando se declara una cadena hay que tener en cuenta que tendremos que reservar una posición para almacenar el carácter nulo.

Por ejemplo:

Si queremos almacenar la cadena "HOLA", tendremos que declarar la cadena como:

char Saludo[5]; // Cuatro caracteres para "HOLA" y uno para '\000'.

Es posible hacer referencia a cada uno de los caracteres individuales que componen la cadena,

simplemente indicando la posición.

Por ejemplo:

Saludo[2]; //Hace referencia al 3º carácter de la cadena, la 'L'.

Los índices tomarán valores empezando en el cero.

Por ejemplo:

Saludo[0]; //Hace referencia al 1º carácter de la cadena, la 'H'.

La asignación directa sólo está permitida cuando se hace junto con la declaración.

121

Por ejemplo:

char Saludo[5];

Saludo = "HOLA"

Esta modalidad producirá un error en el compilador, ya que una cadena definida de este modo se considera una constante, como veremos en el capítulo de "arrays" o arreglos.

La manera correcta de asignar una cadena es:

char Saludo[5];

Saludo[0] = 'H';

Saludo[1] = 'O';

Saludo[2] = 'L';

Saludo[3] = 'A';

Saludo[4] = '\000';

O bien:

char Saludo[5] = "HOLA";

Si parece un sistema engorroso, no te preocupes, en próximos capítulos veremos funciones que facilitarán la asignación de cadenas.

Existen muchas funciones para el tratamiento de cadenas, como veremos, que permiten compararlas,

copiarlas, calcular su longitud, imprimirlas, visualizarlas, guardarlas en disco, etc. Además, frecuentemente, nos encontraremos a nosotros mismos creando nuevas funciones que básicamente hacen un tratamiento de

cadenas.

4.10.2. Arreglos Empezaremos con los tipos de datos estructurados, los arrays.

Los arrays o arreglos permiten agrupar datos usando un mismo identificador.

Todos los elementos de un array son del mismo tipo, y para acceder a cada elemento se usan

subíndices.

Sintaxis:

<tipo> <identificador>[<núm_elemen>][[<núm_elemen>]...];

Los valores para el número de elementos deben ser constantes, y se pueden usar tantas dimensiones como queramos, limitado sólo por la memoria disponible.

Cuando sólo se usa una dimensión se suele hablar de listas o vectores, cuando se usan dos, de tablas o matrices.

Ahora podemos ver que las cadenas de caracteres son un tipo especial de arrays. Se trata en realidad de arrays de una dimensión de objetos de tipo char.

Los subíndices son enteros, y pueden tomar valores desde 0 hasta <número de elementos>-1.

Esto es muy importante, y hay que tener mucho cuidado.

Por ejemplo:

int Vector[10];

Creará un array con 10 elementos enteros; podremos acceder a los elementos Vector[0] a Vector[9].

Como subíndice podremos usar cualquier expresión entera.

122

En general C++ no verifica el ámbito de los subíndices. Si declaramos un array de 10 elementos, no

obtendremos errores al acceder al elemento 11.

Sin embargo, si asignamos valores a elementos fuera del ámbito declarado, estaremos accediendo a

zonas de memoria que pueden pertenecer a otras variables o incluso al código ejecutable de nuestro programa, con consecuencias generalmente desastrosas.

Por ejemplo:

int Tabla[10][10];

char DimensionN[4][15][6][8][11];

...

DimensionN[3][11][0][4][6] = DimensionN[0][12][5][3][1];

Tabla[0][0] += Tabla[9][9];

Cada elemento de Tabla, desde Tabla[0][0] hasta Tabla[9][9] es un entero.

Del mismo modo, cada elemento de Dimensión N es un carácter.

4.10.2.1. Inicialización de un arreglo.

Los arrays pueden ser inicializados junto con la declaración.

Por ejemplo:

float R[10] = {2, 32, 4.6, 2, 1, 0.5, 3, 8, 0, 12};

float S[] = {2, 32, 4.6, 2, 1, 0.5, 3, 8, 0, 12};

int N[] = {1, 2, 3, 6};

int M[][3] = { 213, 32, 32, 32, 43, 32, 3, 43, 21};

char Mensaje[] = "Error de lectura";

char Saludo[] = {'H', 'o', 'l', 'a', 0};

En estos casos no es obligatorio especificar el tamaño para la primera dimensión, como ocurre en los

ejemplos de las líneas 2, 3, 4, 5 y 6.

En estos casos la dimensión que queda indefinida se calcula a partir del número de elementos en la lista de valores iniciales.

En el caso 2, el número de elementos es 10, ya que hay diez valores en la lista.

En el caso 3, será 4.

En el caso 4, será 3, ya que hay 9 valores, y la segunda dimensión es 3: 9/3=3.

Y en el caso 5, el número de elementos es 17, 16 caracteres más el cero de fin de cadena.

4.10.2.2. Operadores utilizados con arreglos.

Ya hemos visto que se puede usar el operador de asignación con arrays para asignar valores iniciales.

El otro operador que tiene sentido con los arrays es sizeof.

Aplicado a un array, el operador sizeof devuelve el tamaño de todo el array en bytes.

Podemos obtener el número de elementos dividiendo ese valor entre el tamaño de uno de los

elementos.

Por ejemplo:

#include <iostream>


int main()

{

int array[231];

cout << "Número de elementos: " << sizeof(array)/sizeof(int) << endl;

123

cout << "Número de elementos: " << sizeof(array)/sizeof(array[0]) << endl;

cin.get();

return 0;

}

Las dos formas son válidas, pero la segunda es, tal vez, más general.

4.10.3. Algoritmos de ordenación: método de la burbuja Una operación que se hace muy a menudo con los arrays, sobre todo con los de una dimensión, es

ordenar sus elementos.

Dedicaremos más capítulos a algoritmos de ordenación, pero ahora veremos uno de los más usados, aunque no de los más eficaces, se trata del método de la burbuja.

Consiste en recorrer la lista de valores a ordenar y compararlos dos a dos.

Si los elementos están bien ordenados, pasamos al siguiente par, si no lo están los intercambiamos, y pasamos al siguiente, hasta llegar al final de la lista.

El proceso completo se repite hasta que la lista está ordenada.

Veamos el método utilizando un ejemplo:

Ordenar la siguiente lista de menor a mayor:

15 | 3 | 8 | 6 | 18 | 1

Empezamos comparando 15 y 3. Como están mal ordenados los intercambiamos, la lista quedará:

3 | 15 | 8 | 6 |18 | 1

Tomamos el siguiente par de valores: 15 y 8, y volvemos a intercambiarlos, y seguimos el proceso...

Cuando lleguemos al final la lista estará así:

3 | 8 | 6 |15| 1| 18

Empezamos la segunda pasada, pero ahora no es necesario recorrer toda la lista. Si observas verás que el último elemento está bien ordenado, siempre será el mayor, por lo tanto no será necesario incluirlo en la

segunda pasada.

Después de la segunda pasada la lista quedará:

3 | 6 | 8 | 1| 15 |18

Ahora es el 15 el que ocupa su posición final, la penúltima, por lo tanto no será necesario que entre en las comparaciones para la siguiente pasada.

Las sucesivas pasadas dejarán la lista así:

3ª) 3 | 6 | 1| 8 | 15 | 18

4ª) 3 |1 | 6 | 8 | 15 | 18

5ª) 1 | 3 | 6| 8 | 15 | 18

4.10.4. Ejercicios: cadenas de caracteres. Teniendo en cuenta la asignación que hemos hecho para la cadena Saludo, se muestran varias versiones

de una función que calcule la longitud de una cadena, ¿cuáles de ellas funcionan y cuáles no? Marcar la opción correcta.

a) int LongitudCadena (char cad[])


124

{

int l = 0;

while(cad[l]) l++;

return l;

}

Sí No

b) int LongitudCadena (char cad[])

{

int l;

for(l = 0; cad[l] != 0; l++);

return l;

}

Sí No

c) int LongitudCadena (char cad[])

{

int l = 0;

do {

l++;

} while(cad[l] != 0);

return l;

}

Sí No

4.10.5. Ejercicios: arreglos

1-) Hacer un programa que lea diez valores enteros en un array desde el teclado y calcule y muestre: la suma, el valor promedio, el mayor y el menor.

2-) Hacer un programa que lea diez valores enteros en un array y los muestre en pantalla. Después ordenar de menor a mayor y vuelva a mostrar. Finalmente ordenar de mayor a menor y los muestre por

tercera vez. Para ordenar la lista usar una función que implemente el método de la burbuja y que tenga como parámetro de entrada el tipo de ordenación, de mayor a menor o de menor a mayor. Para el array

usar una variable global.

3-) Hacer un programa que contenga una función con el prototipo bool Incrementa (char numero[10]);.

La función debe incrementar el número pasado como parámetro en una cadena de caracteres de 9 dígitos. Si la cadena no contiene un número, debe devolver “false”, en caso contrario debe devolver “true”, y la cadena debe contener el número incrementado. Si el número es "999999999", debe devolver "0".

Cadenas con números de menos de 9 dígitos pueden contener ceros iniciales o no.

Ej: la función debe ser capaz de incrementar tanto la cadena "3423", como "00002323".

La función "main" llamará a la función Incrementar con diferentes cadenas.

4-) Hacer un programa que contenga una función con el prototipo bool Palindromo(char palabra[40]);.

La función debe devolver true si la palabra es un palíndromo, y false si no lo es.

Una palabra es un palíndromo si cuando se lee desde el final al principio es igual que leyendo desde el principio, por ejemplo: "Otto", o con varias palabras "Anita lava la tina", "Dábale arroz a la zorra el abad",

“La ruta nos aportó otro paso natural”.

En estos casos debemos ignorar los acentos y los espacios, pero no es necesario que tu función haga eso, bastará con probar cadenas como "anitalavalatina", o "dabalearrozalazorraelabad".

La función no debe hacer distinciones entre mayúsculas y minúsculas.

5-) Escribir el código fuente de un programa que permita la carga de un string definido de no mas de 20 caracteres e indique cuántos caracteres se tipearon.

125

Alternativa 1) suponer que no hay espacios en blanco, por ej. si se tipea asfhe<Enter>, debería indicar 5

caracteres.

Alternativa 2) debería contar la cantidad caracteres ingresados incluidos los espacio en blanco, por ej.

Juan Jorge<Enter>, debería indicar 10 caracteres.

Resolución Alternativa 2:

#include <iostream>


int main()

{

int i=1;

char mensaje [21];

cout << " Ingrese un texto de no mas de 20 caracteres" << endl;

cin.getline (mensaje,21);

while (mensaje[i]!=0)i++;

cout <<endl <<"El arreglo tiene: " << i << " caracteres";

return 0;

}

6-) Escribir un código de programa que llame desde main a una función pasando por referencia el nombre de un array y desde esa función se mostrará por pantalla el array escrito de atrás para adelante.

Ej: se ingresa desde main Juan Pablo y desde la función se deberá mostrar: olbaP nauJ.

#include <iostream>


int main()

{

int i=1;

char mensaje [21];

cout << " Ingrese un texto de no mas de 20 caracteres" << endl;

cin.getline (mensaje,21);

while (mensaje[i]!=0)i++;

cout <<endl <<"El arreglo tiene: " << i << " caracteres"<< endl;

while((i+1)!=0){cout << mensaje[i] ;--i;}

cout << endl;

return 0;

}

7-) Escribir el código que permita la carga de un arreglo de dos dimensiones.

8-) Escribir el código que permita cargar un vector y luego mostrar el mayor y menor elemento, SIN

ordenar.

9-) Hacer un programa que cargue 25 valores enteros en un arreglo de 5 x 5, y luego muestre primero la suma de cada fila y luego la suma de cada columna.

10-) Escribir el código que permita cargar un vector y luego ordenar de mayor a menor.

11-) Escribir el código que permita la carga de una arreglo de dos dimensiones de 3 x 3 y que luego

ordene todas las filas de mayor a menor.

12-) Escribir el código que permita cargar un arreglo de 3 x 3 y que busque el menor elemento de cada columna y muestre su valor y posición (fila, columna).

13-) Escribir el código que permita cargar un arreglo de 3 x 3, luego busque los elementos que se repiten, y los muestre.

Ej: la salida sería: “Elementos repetidos: 3 , 5, 12”

Alternativa: indicar la cantidad de veces que se repiten cada número.


126

Ej: Elementos repetido 3 – 2 veces, 5 – 1 vez, 12 - 5 veces.

14-) Escribir el código que permita cargar un arreglo de 10 elementos, primero se deberá ingresar la posición y luego el valor. Se deberá controlar que el índice o posición del arreglo no exceda al valor máximo

del arreglo.

Alternativa: Verificar si el elemento ya ha sido cargado.

15-) Escribir el código que permita la carga de los 5 primeros elementos de un arreglo de 10 elementos

y luego lo complete copiando el primero al ultimo lugar, el segundo al ante ultimo lugar. Luego deberá mostrar el arreglo cargado.

Ejemplo: se ingresa 1|3|5|2|4 el arreglo mostrado deberá quedar: 1|3|5|2|4|4|2|5|3|1

16-) Escribir el código que permita cargar un arreglo de 3 x 3, pero que sólo permita cargar los elemento de la diagonal principal; el resto lo complete con ceros.

17-) Escribir el código que permita cargar un arreglo de 3 x 3, pero que sólo permita cargar los elemento de la diagonal principal y el triángulo superior, luego deberá completar el triángulo inferior de

manera de lograr una matriz simétrica.

Si se ingresan: 1, 2, 3, 7, 5 ,4.

Ej de matriz simétrica:

1 2 3

2 7 5

3 5 4

18-) Escribir el código que permita cargar un arreglo de 3 x 3, y que luego cargue un vector columna con el promedio de cada fila.

19-) Escribir el código que permita cargar dos arreglos de 3 x 3 de nombre MatA y MatB y, que luego, presente un menú, como el siguiente:

1) Suma las Matrices MatA+MatB.

2) Resta las Matrices MatA-Matb.

3) Cargar MatA.

4) Cargar MatB.

5) Salir.

127

4.11. GUÍA DE EJERCICIOS

4.11.1. Guía Practica 1 de C++. Instrucciones secuenciales NOTA: Ejemplos compilados con Anjuta Versión 1.2.4a, bajo Ubuntu 10

Ejemplo N° 1:

Diseñe un programa que permita el ingreso de los lados de un rectángulo y calcule y muestre el área del

mismo.

1- #include <iostream> // esta línea carga una librería, que es necesaria porque las

// declaraciones que permiten el acceso a "cout" y "cin" (línea 7 y 8) están en una librería externa.

2- using namespace std;

3- int main() /* esta es la función principal, todos los comandos que estén dentro de las llaves se van a ejecutar (de la línea 4 a la 14) */

4- {

5- int a=0; // Se "crean" (declaran) las variables "enteras" llamadas 6- int b=0; /* a, b y Area, que se van a utilizar en el programa y se las */

7- int Area=0; // inicializa con el valor cero

8- cout << "ingrese el valor del ancho de un rectángulo: "; /* La función cout de la línea 8 muestra en pantalla el texto que esta dentro de las comillas */

9- cin >> a; /* espera que el usuario cargue por teclado un número y lo */

/* guarda en la variable a */ 10- cout << endl << "ingrese el valor del largo de un rectángulo: ";

/* Un método muy útil para cout es "endl", que hará que la siguiente salida se imprima en una nueva línea.

*/

11- cin >> b; // carga por teclado un valor y lo guarda en la variable b

12- Area = a*b; // esto es un proceso, multiplica a*b y lo guarda en Area

13- cout << endl << "el area del rectangulo es: " << Area << " m²"; /* muestra en pantalla el contenido de la variable Area */

14- return (0); } // valor de retorno de la función main al sistema.

INICIO

FIN

a = 0 ; b =0 Area = 0

area

Area = a*b

a

b

Inicio el programa.

Declaro e inicializo las variables a, b y Area.

Cargo por teclado a.

Cargo por teclado b.

Calculo el area: Area = a*b.

Muestro el resultado (se muestra en

pantalla el valor de Area).

Finalizo el programa.

128

Ejercicio Nº 1:

Modificar el programa del ejemplo 1 para que se puede ingresar un número por teclado, que utilizará

una variable llamada numero, y muestre el cuadrado del mismo. Sugerencia: no borre los enunciados del programa que no necesita, use doble barra para deshabilitarlos.

Ejercicio Nº 2:

Modificar nuevamente el programa del ejemplo 1 para que permita ingresar tres números por teclado y muestre la suma de los mismos. Sugerencia: usar cuatro variables enteras.

Ejercicio Nº 3:

Convertir una medida en cm., que se ingresa por teclado, a su equivalente en pies, y mostrar el

resultado de la conversión.

Nota: el programa planteado mas abajo contiene errores y faltan sentencias, deberá encontrarlos y corregirlos. Sugerencia: copie el programa sin modificarlo, compile para ver que tipo de errores genera el

compilador y corrijalos de uno en uno.

1-

2- int main();

3- 4- float Centimetro, float Pulg;

5- cout >> “ingrese una medida en cm: 6- cin >> centimetro ;

7- pulg = centimetro x 0.3937; 8- cout >> " La medida en pulgadas vale: " << pulg;

9-

Ejercicio Nº 4:

Se ingresa por teclado el radio de una circunferencia y se debe calcular y mostrar en pantalla el perímetro y la superficie de la misma. Sugerencia: usar variables de tipo flotante.

Ejercicio Nº 5:

Para un algoritmo, dados los catetos de un triángulo rectángulo, calcular e imprimir su hipotenusa.

Fórmula de cálculo: h² = a² + b² , donde a y b son los catetos, h es la hipotenusa.

Para calcular la raíz cuadrada agregue la librería “cmath” y utilice la función “sqrt(vari)” que permite calcular la raíz cuadrada de una variable (en este caso llamada “vari”).

Ejercicio Nº 6:

Un pintor sabe que con una pintura determinada puede pintar 3,6 metros cuadrados con cada medio

litro. Sabiendo la altura y el largo de la pared a pintar , realizar un algoritmo que informe cuantos litros de

pintura necesitará para la pared en cuestión. Los datos de la pared se ingresarán en metros.

Ejercicio Nº 7:

Una bomba de agua puede extraer 800 litros de por hora, realizar un algoritmo que calcule el tiempo

necesario para extraer todo el líquido de un tanque del que se saben sus medidas altura y radio. Estas se ingresarán por teclado.

Ejercicio Nº 8:

Convertir una temperatura dada en la escala Celsius e imprímase en su equivalente Fahrenheit. (°F =

(9/5) °C + 32).

Ejercicio Nº 9:

Diseñe un algoritmo que exprese la capacidad de un disco duro en megabytes, kilobytes y bytes,

conociendo la capacidad del disco en gigabytes.

Considere que: 1 kilobyte = 1024 bytes, 1 megabyte = 1024 kilobyte, 1 gigabyte = 1024 megabytes.

Ejercicio Nº 10:

Determinar la velocidad de un automóvil que se desplaza a una velocidad constante si se conoce la distancia recorrida y el tiempo utilizado, ambos datos se ingresan por teclado y el algoritmo deberá mostrar

la velocidad.

129

4.11.2. Guía Práctica 2 de C++. Estructuras de Decisión

Ejemplo Nº 1

Escriba un algoritmo que determine y muestre en pantalla si un número ingresado por teclado es positivo,

negativo o cero.

1- #include <iostream>


3- int main() /* función principal, se ejecuta todo lo que esta dentro de las llaves */ 4- {

5- int valor; /*Se declara una variable de tipo entero llamada "valor" que se va a utilizar

para guardar el numero ingresado por teclado */ 6- cout << "Ingrese un numero: ";

7- cin >> valor;

8- if(valor>0) cout << endl << "El numero es positivo";

9- if(valor<0)

10- cout << endl << "El numero es negativo";

11- if(valor==0) 12- {

13- cout << endl << "El numero es cero";

14- cout << endl << "El numero vale cero"; 15- }

16- cin.get(); // Otro método para "cin" es get(), que sirve para leer un carácter, pero que nos

17- cin.get(); // puede servir para detener la ejecución de un programa.

18- return (0); 19- }

valor

NO

Valor = 0

El número es

negativo

El número es

positivo SI

INICIO

Ingrese un número

Valor > 0

El número es

cero SI

FIN

NO

Valor < 0 SI

NO

El número

vale cero

130

Ejemplo Nº 2:

Identificar los cambios respecto del ejemplo 1 y analizar de que manera afecta al programa.



3- int main()

4- { 5- int valor;

6- cout << "Ingrese un numero: "; 7- cin >> valor;

8- if (valor>0) cout << endl << "El numero es positivo";

9- else

10- {

11- if (valor<0) 12- cout << endl << "El numero es negativo";

13- else 14- cout << endl << "El numero es cero";

15- }

16- return (0); 17- }

valor

NO

El número es

negativo

El número es

positivo

SI

INICIO

Ingrese un

número Valor >

0

FIN

NO

Valor <

0

SI

El número es

cero

131

Ejemplo Nº 3:

Identificar los cambios respecto del ejemplo 1 y del ejemplo 2. Analizar de que manera afecta al

programa y cual de los tres es el más óptimo para resolver este problema en particular.

1- #include <iostream> 2- using namespace std;

3- int main()

4- {

5- int valor;

6- cout << "Ingrese un numero: "; 7- cin >> valor;

8- if (valor>0) cout << endl << "El numero es positivo";

9- else if (valor<0) 10- cout << endl << "El numero es negativo";

11- else

12- cout << endl << "El numero es cero";

13- return (0);

14- }

Recuerde que aunque en los diagrama de flujo aquí presentados no aparece la declaración de las variables (por una razón de espacio), todas las variables que utilizara el programa deben declararse y

eventualmente inicializarse.

valor

NO

El número es

negativo

El número es

positivo

SI

INICIO

Ingrese un

número

Valor >

0

FIN

NO

Valor <

0

SI

El número es

cero

132

Ejemplo Nº 4:

Crear un programa para que, mediante un menú (implementando una estructura del tipo switch), permita al usuario realizar la suma, la resta o el producto de dos números ingresados previamente por

teclado. Al final mostrar la operación realizada (“suma”, “resta” ó “producto”), y el resultado de la operación.

1- #include<iostream>


3- int main()

4- { 5- int a=0,b=0,resul=0;

6- char selec; /*se debe declarar una variable de tipo carácter al comienzo del programa para utilizarla con la función switch*/ 7- cout <<"Ingrese el primer nro: ";

8- cin >> a; 9- cout << "Ingrese el segundo nro: ";

10- cin >> b;

11- cout<<"elija una opcion:"<< endl;

12- cout<<"a -SUMA"<< endl; 13- cout<<"b -RESTA"<< endl;

14- cout<<"c -MULTIPLICACION"<< endl; 15- cout<<"d -Salir"<< endl << endl;

16- cin >> selec;

17- switch(selec) 18- {

19- case 'a': //se indica entre comillas los valores de salida ya que la variable selec es de tipo 20- resul = a+b; // caracter.

21- cout << "El resultado de la suma es: "<< resul;

22- break;

23- case 'b': 24- cout << "El resultado de la resta es:" << a-b;

25- break;

26- case 'c':

27- cout << "El resultado del producto es:" << a*b; 28- break;

29- case 'd':

30- cout << "no se ha realizado ninguna operacion";

31- break; 32- }

33- }


133

Ejercicio Nº 1:

Ingresar un número C y determinar si pertenece al intervalo cerrado [A,B] con A y B ingresados por teclado.

Ejercicio Nº 2:

Escribir un programa fuente en C, utilizando la sentencia IF, que permita ingresar por teclado los límites de un intervalo cerrado A y B. Deberá asegurarse de que A sea menor que B, en caso contrario, intercambiar los valores. Luego, deberá ingresar un número C.

Finalmente, mostrar por pantalla uno de los siguientes mensajes, reemplazando, por el valor, donde aparece el nombre de la variable:

- “C es menor que A.”

- “C pertenece al intervalo A, B”

- “C es mayor que B.”

a

INICIO

Ingrese el

primer numero

b

Ingrese el segundo

numero

selec

? 'a' 'b' 'c' 'd'

resul = a+b

El resultado de

la suma es:

“resul”

El resultado de

la resta es:

“a-b”

El resultado

del producto

es: “a*b”

FIN

Diagrama de flujo del ejemplo Nº 4

selec

Elija una opción:

a -SUMA

b -RESTA

c -MULTIPLICACION

d -Salir


134

Ejercicio Nº 3:

Se leen dos valores enteros A, B. Si A es mayor que B se realiza la suma de ambos, caso contrario, se

hace el producto y se muestra el resultado en pantalla ademas de la operación realizada (“suma” ó “producto”).

Ejercicio Nº 4:

Diseñe un programa que:

- Permita la carga por teclado de los lados de un rectángulo y el radio de un círculo.

- Determine el área de cada figura.

- Muestre en pantalla el área mayor y a que figura pertenece.

Ejercicio Nº 5:

Modifique el programa del ejercicio anterior para que:

- Utilice la directiva define para utilizar el valor de en el calculo del área de la circunferencia.

(#define PI 3.141592).

- Considere el caso de que las dos áreas sean iguales, y en tal caso, que muestre un mensaje en la pantalla indicándolo y el valor del área. (ingrese Radio = 1, Lado1 = 1, Lado2 = 3.141592, para comprobar

el caso de que las dos áreas calculadas sean iguales).

Ejercicio Nº 6:

Escribir un programa a modo de calculadora que permita mostrar al usuario un menú con las siguientes opciones:

1- Operación suma.

2- Operación resta.

3- Operación producto.

4- Operación división.

5- Raíz cuadrada.

6- Operación Potencia.

7- Logaritmo natural.

8- Salir del programa.

Luego mediante la función SWITCH, deberá realizar la opción seleccionada, teniendo en cuenta las siguientes consideraciones:

Para guardar el resultado de la división de dos enteros se necesita una variable de tipo flotante.

Para obtener los resultados de las siguientes operaciones puede recurrir a las funciones a las que se hace referencia:

Las tres funciones mencionadas se encuentran en la librería cmath.

Ejercicio Nº 7:

Escribir un algoritmo que dado un importe de dinero, calcule e informe cuánto corresponde pagar de

impuesto, en cuántas cuotas y el valor de las mismas. Tener en cuenta los siguientes datos:

El IMPUESTO es el 10% del importe dado.

Si el importe es mayor que $500 y menor o igual que $1000, se paga en dos cuotas.

Si el importe es mayor a $1000 en tres cuotas.

Raiz cuadrada sqrt(x) Operacion Potencia pow(x,y) Logaritmo Natural log(x)

135

Ejercicio Nº 8:

Diseñe un algoritmo que permita ingresar dos valores X e Y y determinar que porcentaje es X de Y.

Ejercicio Nº 9:

Escribir un algoritmo que permita ingresar tres números distintos entre si e imprima el mayor de ellos.

4.11.3. Guía Práctica N° 3 de C++. Estructuras Repetitivas

Ejemplo Nº 1:

Escribir un algoritmo que permita el ingreso de dos números enteros y calcule el

producto de los mismos (multiplicación) por sumas sucesivas (Ejemplo: 5x2 = 2+2+2+2+2).


3- int main() 4- {

5- int a,b,cont,PRO=0;

6- cout << "Ingrese un numero: "; 7- cin >> a;

8- cout << endl << "Ingrese el segundo numero: ";

9- cin >> b;

10- for (cont=1 ; cont<=a ; cont++) 11- PRO = PRO + b;

12- cout<<endl<<"El producto de "<<a<<"por"<<b<<" vale "<<PRO;

13- }

INICIO

PRO = 0

a

Ingrese un

numero

FIN

El producto

de a por b

vale PRO

PRO=PRO+b

cont = cont+1

cont<=a SI

NO

cont = 1

Ingrese el

segundo

numero

b

136

Ejercicio Nº 1:

Escriba un algoritmo que permita el ingreso de dos números enteros, llamados “base” y “exponente”,

y calcule la potencia por multiplicaciones sucesivas.

Hacer las consideraciones necesarias para que funcione. Tener en cuenta casos particulares. (Ejemplo:

25= 2x2x2x2x2).

Ejemplo Nº 2:

Escribir un algoritmo que permita ingresar un número entero del 1 al 10 e imprima la tabla de

multiplicar del número ingresado.


3- int main()

4- {

5- int tabla,i,z; 6- cout << "Ingrese la tabla que desea calcular: ";

7- cin >> tabla;

8- for(i=0;i<=10;i++)

9- { 10- z=tabla*i;

11- cout << endl << z; 12- }

13- }

Ejercicio Nº 2:

Modificar el programa del ejemplo anterior para que imprima las tablas de multiplicar desde la

seleccionada (mediante el ingreso de un número entero), hasta la del 10 inclusive.

Se debe verificar que el numero ingresado este comprendido en el intervalo del 1 al 10.

Nota: para este ejercicio necesitara dos ciclos FOR, uno anidado dentro del otro.

tabla

INICIO

i; z; tabla;

Ingrese la tabla

que desea

calcular

i = i+1

z

z=tabla*i

FIN

i<=10 SI

NO

i = 0

137

Ejemplo Nº 3:

Realizar un algoritmo que permita acumular números que se ingresan por teclado hasta que la suma de los mismos sea inmediatamente superior a 1000, y muestre el resultado en pantalla. Se deberá poder

ingresar números decimales (“float”).


3- int main() 4- {

5- float num, suma=0;

6- cout << "Ingrese los números a sumar: ";

7- while (suma <= 1000)

8- { 9- cin >> num;

10- suma=suma+num; 11- }

12- cout << endl << "La suma es: " << suma;

13- }

Ejercicio Nº 3:

Modificar el programa anterior para que muestre el último resultado de la suma antes de sobrepasar el valor de 1000. (Ejemplo: 400 + 500 + 200 → debería mostrar: 900).

Ejercicio N° 4:

Escribir un programa para que permita sumar los números positivos que se ingresan por teclado hasta

que se ingresa el -1, que es la condición de finalización del programa, y muestre el resultado de la suma.

Ejemplo N° 4:

Escribir un programa para que permita sumar los números enteros que se ingresan por teclado hasta que se ingresa el 0, que es la condición de finalización del programa, y muestre el resultado de la suma.

INICIO

suma=0; num;

Ingrese los

números a

sumar

La suma

es “suma”

FIN

suma<=1000 SI

NO

num

suma=suma+num

138


3- int main() 4- {

5- float num, suma=0;

6- cout << "Ingrese los números a sumar: ";

7- do

8- { 9- cin >> num;

10- suma=suma+num; 11- } while (num != 0);

12- cout << endl << "La suma es: " << suma;

13- }

Véase en este caso la utilidad del ciclo do...while. Como la variable de entrada es la que se chequea en cada ciclo para la condición de salida, y en el primer ciclo no se puede hacerlo sin antes realizar el

ingreso de un valor, el ciclo do...while reordena la secuencia de pasos dentro del bucle del while, con lo que podemos primero ingresar un valor y después chequear la condición de salida.

Ejercicio Nº 5:

Leer 10 valores enteros. Calcular e informar:

La suma de los valores positivos.

El producto de los valores negativos. (Ignorar los valores nulos)

Ejercicio Nº 6:

Realizar un algoritmo que permita el ingreso de números positivos hasta que se ingresa el cero, y

muestre el mayor de los números ingresados.

Ejercicio Nº 7:

Realizar un algoritmo que muestre en pantalla los términos de la serie de fibonachi. Se deberá ingresar un número entero que será la cantidad de términos de la serie a mostrar.

INICIO

suma=0; num;

Ingrese los números a

sumar

La suma es “suma”

FIN

num != 0 SI

NO

num

suma=suma+num

139

El número ingresado deberá ser mayor o igual a 1 y menor o igual a 50, si no cumple esa condición se

deberá pedir el ingreso de un nuevo valor.

Ejercicio Nº 8:

Diseñe un algoritmo para calcular el resultado de la suma de los 100 primeros términos de la siguiente

serie: S = 1 – 1/3 + 1/9 – 1/27 + 1/81

Ejercicio Nº 9:

Escribir un programa que permita ingresar dos valores A y B que determinan un intervalo, luego ir

acumulando los valores que se ingresan a continuación siempre y cuando estos pertenezcan al intervalo. El

programa finaliza cuando se ingresan tres valores fuera del intervalo.

Ejercicio Nº 10:

Escribir un programa que permita el ingreso de números que estén comprendidos en el intervalo 0 y 99

inclusive ([0,99]), los números mayores a 99 deben ser ignorados. Se asegura al menos el ingreso de un (1)

número dentro del intervalo. La carga finaliza al ingresar un numero negativo. Sobre los números ingresados el programa deberá mostrar el mayor valor ingresado, el menor valor ingresado, el promedio y la cantidad

de números ingresados (se consideran solo aquellos que se encuentran dentro del intervalo).

4.11.4. Guía Práctica Nº 4 de C++. Arreglos

Ejemplo Nº 1:

Escribir un algoritmo que permita la carga de un vector “Vec1” de 10 elementos.

Nota: Considerar que los elementos del vector son números enteros.



3- int main() 4- {

5- int Vec1[10]; // Declaración del arreglo Vec1 de una // dimensión y diez elementos enteros. 6- int i;

8- for(i=0;i<10;i++)

9- {

10- cout << "ingrese el elemento " <> Vec1[i];

12- }

13- return (0);

14- }

INICIO

Vec1[10]

Vec1[i

]

Ingrese el

elemento i:

FIN

i = i+1

i < 10 SI

NO

i = 0

140

Ejercicio Nº 1:

Modificar el programa anterior para que muestre los elementos del vector una vez finalizada la carga.

Ejercicio Nº 2:

Escribir un algoritmo que permita la carga de un vector “Vector2” de 10 elementos y busque cuantas

veces aparece un numero N en el mismo. El numero N a buscar se ingresara por teclado una vez finalizada la carga del vector.

Nota: no modificar el vector.

Ejercicio Nº 3:

Modificar el programa del ejercicio 1 para que permita buscar el elemento mayor, el menor y calcule el

promedio de los elementos.

Observación: Nótese la diferencia entre el método de búsqueda del elemento mayor de un vector que se

encuentra cargado y la búsqueda del elemento mayor a medida que se van ingresando una serie de escalares por teclado.

Ejemplo Nº 2:

Realizar un algoritmo que permita la carga de un vector “Vect3” de N elementos y ordene el mismo de

mayor a menor.

Razonar acerca de la eficiencia de los cuatro métodos planteados y en que condiciones.

Nota: el numero N, que es la cantidad de elementos del vector, se define como una constante al inicio del programa.

Método Nº 1: burbuja con bandera


3- #define N 10

4- int main() 5- {

6- int i, bandera, temp; 8- int Vect3[N];

9- for(i=0;i<N;i++)

10- { 11- cout << "ingrese el elemento " <> Vect3[i]; 13- }

14- do 15- {

16- bandera = 0;

17- for(i=0;i<N-1;i++) 18- {

19- if(Vect3[i] < Vect3[i+1]) 20- {

21- temp = Vect3[i];

22- Vect3[i] = Vect3[i+1]; 23- Vect3[i+1]=temp;

24- bandera = 1; 25- }

26- } 27- }while(bandera!=0);

28- return(0); 29- }

141

Diagrama de flujo del ejemplo Nº 2, método 1 INICIO

Vec3[N]

SI

Vect3[i]

Ingrese el elemento

i:

i = i+1

i<10 SI

NO

i = 0

FIN

bandera≠0 SI

NO

bandera=0

Vect3[i] <

Vect3[i+1]

SI

NO

bandera=1

i < N-1

NO

i = 0

temp=Vect3[i]

Vect3[i]=Vect3[i+1]

Vect3[i+1]=temp

i = i+1

142

Método Nº 2: vuelve el contador a cero cada vez que ordena un elemento.



3- #define N 10

4- int main() 5- {

6- int i, temp;

8- int Vect3[N];

9- for(i=0;i<N;i++)


12- cin >> Vect3[i];

13- }

14- for(i=0;i<N-1;i++) 15- {

16- if(Vect3[i] < Vect3[i+1]) 17- {



21- i = -1; // se debe reinicializar en -1 el contador debido al 22- } // incremento automático del bucle for.

23- }

24- return(0);

25- }

143

Diagrama de flujo del ejemplo Nº 2, método 2:

SI

FIN

Vect3[i]

<

Vect3[i+1]

SI

NO

i = -1

i < N-1

NO

temp=Vect3[i]

Vect3[i]=Vect3[i+1]

Vect3[i+1]=temp

i = i+1

i = 0

INICIO

Vec3[N]

Vect3[i]

Ingrese el

elemento i:

i = i+1

i < 10 SI

NO

i = 0

144

Método Nº 3: burbuja con dos for.


2- using namespace std; 3- #define N 10

4- int main()

5- {

6- int i, j, temp;

8- int Vect3[N];

9- for(i=0;i<N;i++) 10- {

11- cout << "ingrese el elemento " <> Vect3[i]; 13- }

16- for(j=0;j<N;j++)

{

17- for(i=0;i<N-1;i++) 18- {

19- if(Vect3[i] < Vect3[i+1]) 20- {



25- } 26- }

27- }

28- return(0);

29- }

145


SI

INICIO

Vec3[N]

Vect3[i]

Ingrese el

elemento i:

i = i+1

i<10 SI

NO

i = 0

FIN

j < N SI

NO

Vect3[i]

<

Vect3[i+1]

SI

NO

i<N-1

NO

i = 0

temp=Vect3[i]

Vect3[i]=Vect3[i+1]

Vect3[i+1]=temp

i = i+1

j = 0

j = j+1

146

Método Nº 4: comparación de uno contra todos



3- #define N 10

4- int main() 5- {

6- int i, j, temp;

8- int Vect3[N];

9- for(i=0;i<N;i++)


12- cin >> Vect3[i];

13- }

14- for(j=0;j<N-1;j++) 15- {

17- for(i=j+1;i<N;i++) 18- {

19- if(Vect3[j] < Vect3[i])

20- { 21- temp = Vect3[i];

22- Vect3[i] = Vect3[j]; 23- Vect3[j]=temp;

25- }

26- } 27- }

28- return(0);

29- }

147


INICIO

Vec3[N]

i = 0

FIN

j < N-1 SI

NO

SI

temp=Vect3[i]

Vect3[i]=Vect3[j]

Vect3[j]=temp

j = j+1

SI

Vect3[i]

Ingrese el

elemento i:

i = i+1

i<10 SI

NO

Vect3[j]

<

Vect3[i]

NO

i<N

NO

i = j+1

i = i+1

j = 0

148

Ejemplo Nº 3:

Realizar un algoritmo que permita la carga (por filas) de una matriz, llamada “matris”, de “filas x

columnas” elementos y ordene los elementos de cada fila de menor a mayor.

Observación: el ordenamiento de una sola fila de una matriz es muy similar al ordenamiento de un

vector. Utilice como base del código alguno de los desarrollados en el ejemplo Nº 2.

NO

INICIO

matris [filas][columnas]

F = 0

F < filas

SI

C = 0

SI

matris [F][C]

Ingrese el

elemento (F,C):

C < columnas

C = C+1

NO

F = F+1

1

149

NO

F = 0

F < filas

SI

C = 0

SI

F = F+1

1

C < columnas-

1

matris[F][C] <

matris[F][C+1]

C = C+1

temp = matris[F][C]

matris[F][C] =

matris[F][C+1]

matris[F][C+1] =temp

bandera = 1

SI

NO NO

Bandera = 0

Bandera

!= 0

SI

NO FIN

150

Código fuente del programa del ejemplo Nº 3:


2- using namespace std; 3- #define filas 4

4- #define columnas 4

5- int main() 6- {

7- int F, C, temp;

8- char bandera;

9- int matris [filas] [columnas]; // declaración del arreglo en base a las etiquetas “filas” y // “columnas”.

10- for(F=0;F<filas;F++)

11- { 12- for(C=0;C<columnas;C++)

13- { 14- cout << "ingrese el elemento " << "(" << F << "," << C << ")";

15- cin >> matris [F][C]; 16- }

17- }

18- do

19- { 20- bandera = 0;

21- for(F=0;F<filas;F++) 22- {

23- for(C=0;C<columnas-1;C++) 24- {

25- if (matris[F][C] < matris[F][C+1])

26- { 27- temp = matris[F][C];

28- matris[F][C] = matris[F][C+1]; 29- matris[F][C+1] =temp;

30- bandera = 1; 31- }

32- }

33- }

34- } while (bandera != 0);

35- return(0);

36- }

Ejercicio Nº 4:

Modificar el programa del ejemplo 3 para que permita visualizar la matriz una vez que ha sido ordenada.

Ejercicio Nº 5:

Modificar el programa del ejemplo 3 para utilizar alguno de los otros métodos posibles de

ordenamiento.

151

Ejemplo Nº 4:

Realizar un algoritmo que realice la carga (por columnas) de una matriz, llamada “MAT”, de “M x N”

elementos y que permita el ingreso de dos números que definen un intervalo cerrado, una vez ingresados, el programa debe informar al usuario cuantos valores dentro de la matriz están dentro de ese intervalo.


3- #define N 5

4- #define M 5

5- int main() 6- {

7- int f, c, temp, cantidad=0;

8- int matris [M] [N];

9- for(C=0;C<N;C++)

10- { 11- for(F=0;F<M;F++)

12- {

13- cout << "ingrese el elemento " << "(" << F << "," << C << ")"; 14- cin >> matris [F][C];

15- } 16- }

17- cout << "ingrese los extremos de un intervalo cerrado : ";

18- cin >> a >> b;

19- if (a < b)

20- { temp = a; 21- a = b;

22- b = temp;

23- }

24- for(F=0;F<M;F++) 25- {

26- for(C=0;C<N;C++)

27- { 28- if ( matris[F][C] > a && matris[F][C] < b )

29- cantidad = cantidad + 1; 30- }

31- }

32- return(0);

33- }

152

Diagrama de flujo del ejemplo Nº 4:

Observación: se ha omitido la carga del arreglo, que se puede ver en el ejemplo 3.

NO F < M

SI

C = 0

SI

F = F+1

1

C < N

matris[F][C] > a &&

matris[F][C] < b

C = C+1

cantidad = cantidad +1

SI

NO NO

FIN

Ingrese los extremos de

un intervalo cerrado

a b

a < b SI

temp = a

a = b b = temp

NO

F = 0

153

Ejercicio Nº 6:

Escribir un programa que posibilite al usuario la carga de una matriz de “M x N” elementos, luego se

ingresa un numero e informa cuantos valores mayores al numero ingresado existen en cada fila del arreglo.

Ejercicio Nº 7:

Hacer un programa que permita cargar una matriz de “M x N”, calcule y muestre el mayor y menor elemento de cada columna.

Ejercicio Nº 8:

Cargar una matriz de “M x N” y generar:

1) Un vector con el contenido de la suma de cada fila.

2) Copiar todos los valores de una fila de la matriz, indicada por teclado, a un vector.

3) Un vector con la cantidad de elementos negativos de cada columna.

Ejercicio Nº 9:

Escribir un programa que encuentre la ubicación del mayor y el menor elemento de una matriz de “M x N”. Mostrar la matriz completa y las ubicaciones encontradas con los valores respectivos.

Ejercicio Nº 10:

Realizar un diagrama de flujo que permita la carga de dos matrices y luego mediante la selección de

una opción permita el cálculo de la suma o el producto de las mismas y luego muestre la matriz resultado.

4.11.5. GUÍA PRÁCTICA Nº 5 DE C++. Funciones

Ejemplo Nº 1:

Escribir el código fuente de un programa que tenga una función llamada “primera” que reciba un

número entero y devuelva a “main” el carácter “P” si el numero es positivo y “N” si es negativo.


2- using namespace std; 3- char primera (int num); /*prototipo de la función primera, la palabra “char” delante de la

función indica que esta devuelve un carácter al punto desde donde se hizo la llamada (en este caso el carácter se devuelve a main) */

4- int main()

5- { 6- int numero;

7- char tipo; 8- cout << "ingrese un numero entero: ";

9- cin >> numero;

10- tipo = primera(numero); /* en esta instrucción se realizan dos acciones: 1- Se “llama” a la función primera y se le pasa el argumento numero. 2- Se recibe el valor de retorno y se lo asigna a la variable tipo. */ 11- if (tipo=='P')

12- cout << “el numero ingresado es positivo”; 13- else if (tipo=='N')

14- cout << “el numero ingresado es negativo”;

15- else cout << “error”; 16- return(0);

17- }

154

/*nótese que el argumento pasado “numero”, es una variable local de la función main, y se recibe en la

función factorial como una variable local llamada “N”, esto se denomina pasaje por posición o referencia*/

18- char primera (int N) /*definición de la función primera*/

19- { 20- char tipo; /* se pueden definir variables adicionales (en este caso solo una -> “tipo”) ademas

de las que ya se definen en el pasaje de parametros de la función (“N” en esta función)*/

21- if(N>= 0) 22- tipo = 'P'; 23- else 24- tipo = 'N';

25- return(tipo); // la instrucción return es la que permite definir el valor de retorno de la función, y 26- } // además podemos tener varios “return” definiendo mas de una salida de la función.

Véase que la función primera posee dos variables “locales”, N y tipo.

Ejercicio Nº 1:

Escribir el código fuente de un programa que desde main se llame a una función que recibe como

argumento dos números reales, y retorna el menor que es mostrado desde main.

Ejemplo Nº 2:

Escribir un programa que tenga una función denominada “factorial”, que recibe un numero N ingresado

por teclado y calcula el factorial de N, mostrando el resultado en pantalla. La función “main” debe verificar que el numero N ingresado sea mayor o igual a cero.

Observación: la función “factorial” no devuelve ningún valor.

El factorial de un número se define como:

Ejemplo: 5! = 5 * 4 * 3 * 2 * 1 = 120


2- using namespace std; 3- void factorial (int N); /*prototipo de la función factorial, la palabra void delante de la función indica

que esta no devuelve ningún valor*/ 4- int main()

5- { 6- int numero;

8- do{

9- cout << "ingrese un numero para obtener su factorial: "<< endl; 10- cin >> numero;

11- } while(numero<0); 12- factorial(numero); /*llamado a la función factorial pasando el argumento numero*/

13- return(0);

14- } 15- void factorial (int N) /*definición de la función factorial*/

16- { 17- long int resul=1;

18- int i;

18- if(N==0)

19- cout <<"el factorial de 0 es: 1"; 20- else if(N==1)

21- cout <<"el factorial de 1 es: 1";

155

22- else{

23- for(i=1;i<=N;i++) 24- resul=resul*i;

25- cout <<"el factorial de " << N << " es: "<< resul;

26- } 27- } /*ver que la función factorial no devuelve ningún valor, (no se utiliza el “return”)*/

Observación: nótese que se usan enteros largos, debido a los resultados que arroja un cálculo del factorial.

Ejercicio Nº 2:

Crear un código fuente que permita al usuario ingresar un numero del 1 al 10 inclusive, y una vez ingresado el numero se llame a una función denominada “tabla” que recibe el numero desde main y calcula-

muestra la tabla de multiplicar del numero ingresado.

Observaciones: cuando el usuario ingresa el numero se debe verificar que se encuentre dentro del intervalo [1,10]; sino se debe pedir que se ingrese un nuevo valor.

Ejemplo Nº 3:

Escribir un programa que mediante una función “menu” permita seleccionar si desea calcular una serie o salir del programa, cualquier otra tecla debe ser ignorada, y una vez mostrado el calculo de la serie se

vuelve a presentar el menú al usuario.

La función “serie” toma como argumento dos enteros a y b, y un flotante base, de modo que permita calcular el resultado de:

El cálculo es devuelto a main para su impresión en pantalla. (Para a=0, b=5 y base=1,23 la serie arroja un resultado= )

1- #include<iostream> 2- #include<cmath>


4- float serie(int a, float base, int b); //prototipos de las funciones

5- char menu (void);

6- int main() 7- {

8- float resultado, base1;

9- int inferior, b; 10- char opcion;

11- opcion = menu();

12- while(opcion != 's') 13- {

14- cout << "ingrese el limite inferior de la sumatoria: ";

15- cin >> inferior; 16- cout << "ingrese el limite superior de la sumatoria: ";

17- cin >> b; 18- cout << "ingrese la base: ";

19- cin >> base1;

20- resultado = serie(inferior, base1, b); 21- cout << "el calculo de la serie es: " << resultado << endl << endl;

22- opcion = menu();

∑k = a

k= b

base− k

156

23- }

24- cout << “el programa ha finalizado”; 25- return(0);

26- }

27- char menu (void) //definición de la función menu.

28- { 29- char seleccion;

30- do{ 31- cout << "Elija una opcion del menu:" << endl << “c - Calcula la serie” << endl << “s –

Salir;

32- cin >> seleccion; 33- }

while(seleccion != 's' && seleccion != 'c');

34- return (seleccion);

35- } 36- float serie(int a, float base, int b) //definición de la función serie.

37- { 38- float sumatoria = 0;

39- int i;

40- for(i=a; i<=b; i++)

41- sumatoria = sumatoria + pow (base, -i)

42- return (sumatoria); 43- }

Ejercicio Nº 3:

Modificar el programa del ejemplo 3 para que la potencia se calcule utilizando multiplicaciones sucesivas y NO utilizando la función pow().

Para ello dentro de la función serie() se deberá llamar a una función adicional llamada potencia() que se tiene que definir adecuadamente, calcule la potencia por multiplicaciones sucesivas y retorne el resultado

a serie() para computar la sumatoria.

Ejercicio Nº 4:

Realizar un programa que permita el ingreso de un número entero positivo N y pase como argumento

ese número a una función denominada “serie”. La función serie calcula el resultado de: N+(N-

1)+………+2+1. El resultado de la serie debe ser devuelto a “main” para su impresión en pantalla.

Ejercicio Nº 5:

Escribir un programa que posibilite el ingreso de dos números enteros, X e Y, y calcule mediante una

función “potencia”, X elevado al numero Y. La función potencia realiza el calculo por multiplicaciones

sucesivas y retorna el valor del resultado.

Ejercicio Nº 6:

Realizar un programa que mediante un menú permita llamar a dos funciones distintas, una llamada

“potencia” y otra denominada “multiplicación”.

La función potencia no recibe ningún argumento y devuelve el valor de la potencia de dos números (el ingreso de los dos números se hace dentro de la función potencia.)

La función multiplicación recibe dos argumentos y no devuelve nada, mostrando el resultado antes de

salir de la función.

El menú es otra función que no recibe nada y entrega el valor del menú.


157

Ejercicio Nº 7:

Escribir el código fuente de un programa que desde main se llame a una función pasando un

argumento, esta función calcula la serie de Fibonacci y retorna la suma de los términos que son mostrado desde main.

Ejercicio Nº 8:

Escribir el código fuente de un programa que desde main se llame a una función menú que no reciba

ningún argumento y que retorne la opción de menú elegida , esa se mostrará desde main. Los items del menú deberían ser por EJ. 1,2,3,4 para salir, o A,B, y F para Finalizar.-Controlar que solo se salga con la

opción indicada.-

Ejercicio Nº 9:

Realizar un programa que mediante una función menú permita llamar a 6 funciones distintas, una llamada suma, resta, multiplicación, división, potencia y raíz cuadrada.

Al principio se ingresan por teclado 2 números, en las variables A y B, luego se presenta un menú y se realizan la operación elegida.

La función suma recibe como argumentos los 2 números y devuelve el valor de la suma de los A+B.

La función resta recibe como argumentos los 2 números y devuelve el valor de la suma de los A-

B.

La función producto recibe como argumentos los 2 números y devuelve el valor de la suma de

los A x B.

La función división recibe como argumentos los 2 números y devuelve el valor del cociente de A

y B. Se debe chequear dentro de la función cuando B=0, en caso de serlo, se deberá mostrar un

mensaje de error y abortar la operación.

La función potencia recibe como argumentos los 2 números y devuelve el valor de la potencia .

La función raíz cuadrada recibe como argumentos un números y devuelve el valor de . Se debe

chequear que B sea positivo para poder realizar la raíz.

Observación: tener en cuenta el tipo de variable que retornan las funciones, y en que casos no pueden

tomar valores nulos o negativos, por ejemplo: raíz de un numero negativo, o una división por cero. Para la raíz se puede utilizar la función sqrt(), que se encuentra en la librería “cmath”.

4.11.6. GUÍA PRÁCTICA Nº 6 DE C++

Ejercicios Combinados usando Vectores, Matrices y Funciones

Antes de comenzar:

Los ejercicios se deben realizar en forma secuencial, de esta manera se adquiere la destreza

necesaria para realizar ejercicios que integran el manejo simultaneo de arreglos y funciones.

Ejercicio Nº 1:

Efectuar un algoritmo que permita el ingreso por teclado de los 30 elementos de un vector numérico y

luego imprimirlos en el orden inverso al ingresado.


158

Ejercicio Nº 2:

Efectuar un algoritmo que permita el ingreso por teclado de los 30 elementos de un vector numérico,

duplicar sus valores y luego imprimirlos en el orden ingresado.

Ejercicio Nº 3:

Cargar un vector con las alturas de los N alumnos de un curso. Determinar la media y luego informar cuantos alumnos son mas altos que la media y cuantos mas bajos.

Ejercicio Nº 4:

Efectuar un algoritmo que permita el ingreso por teclado de los 30 elementos de un vector numérico y

luego imprimir:

La suma del contenido de los elementos.

La cantidad de elementos que sean mayores que 15.

Ejercicio Nº 5:

Realizar un algoritmo que vaya solicitando al usuario la posición dentro del vector que desea cargar y

luego el valor a cargar. Deberá indicar con un mensaje cuando ese elemento ya haya sido cargado y cuando

el vector esté completamente cargado.

Ejercicio Nº 6:

Diseñar un algoritmo que cargue un vector A con 10 elementos numéricos reales y con funciones

implementar las siguientes modificaciones:

Asignar el valor 11,2 a la tercer posición del vector A.

Asignar el valor del elemento de la octava posición del vector A en la segunda posición.

Intercambiar el elemento de la cuarta posición, con el de la novena posición del vector A.

Ejercicio Nº 7:

Hacer un programa que permita realizar la suma y el producto (elemento a elemento) de dos vectores de 10 elementos. El usuario elige la operación a realizar y cada operación se realiza mediante una Función.

Ejercicio Nº 8:

Dado un vector de N elementos mediante una función cargar y con otras dos realizar cada operación las

siguientes búsquedas:

La cantidad de veces que se encuentra cada número dentro del Vector.

La cantidad de números distintos.

Ejercicio Nº 9:

Dado dos vectores A y B de N y M componentes, llamar a una función que permita ingresar datos a

través del teclado en dichos vectores, luego llamar una tercer función para que genere un nuevo vector que

contenga los componentes comunes de los dos anteriores e imprimirlo.

Ejercicio Nº 10:

En un colegio secundario, se maneja la información de las notas de un curso, con tres vectores de

longitud n, llamados trim1, trim2 y trim3. Los componentes de los vectores, son las notas del primero,

segundo y tercer trimestre respectivamente, para cada alumno. Generar un cuarto vector de nombre prom, donde cada componente sea el promedio de los elementos homólogos de los tres vectores. Con una Función

llamada Mejor imprimir los tres mejores promedios del curso.


159

Ejercicio Nº 11:

Elaborar un programa en C que cargue números enteros en dos matrices de 5 x 5. Llamar a una función

que calcule en una tercera matriz la suma de los elementos de las dos anteriores. Al final imprimir las tres matrices.

Ejercicio Nº 12:

Escribir un programa que permita la carga de una matriz de orden NxM ( usar define), luego presenta un

menú que llama a tres funciones:

Ordenar de menor a mayor la matriz por filas.

Ordenar de Mayor a menor la matriz por columnas.

Mostrar la matriz.

Ejercicio Nº 13:

Elaborar un algoritmo que lea números enteros en una matriz cuadrada de 10 x 10 elementos. Implementar las siguientes funciones:

Una que calcule la suma de los elementos de la diagonal Principal.

Una que cargue los elementos mayores de cada columna en un Vector.

Una que cargue los elementos menores de cada fila en un vector.

Una que almacene los promedios de cada fila en un vector.

Cada una de estas funciones debe ser llamadas mediante un menú en el cual se selecciona la operación

a realizar.

Ejercicio Nº 14:

En una matriz se tienen las 7 notas correspondientes a cada una de las asignaturas de los 30 alumnos

de un curso. Elaborar un algoritmo que calcule e imprima las notas y el promedio de cada alumno. Cada

alumno cursa como mínimo 3 materias y como máximo las 7.

Ejercicio Nº 15:

En una agencia de quiniela se tienen los valores de los números ganadores y los premios de los mismos.

Escribir el Programa que determine cuales fueron las ocurrencias de cada número y que monto de dinero le

correspondió. Los datos están cargados en una matriz de 365 filas y dos columnas, una fila para cada día y en cada columna el número ganador y en la siguiente el monto del premio.

Ejercicio Nº 16:

Hacer un programa que permita mostrar por pantalla el siguiente menú:

1. Factorial de un Nº F.

2. División de dos números A y B.

3. Salir.

El usuario debe poder ingresar la opción que quiere realizar.

- SOLO podrá Salir del programa si ingresa 3.

- Si elije 1 deberá pedir al usuario que ingrese un número luego deberá calcular el factorial y mostrar el resultado. Debe tener en cuenta que: el nro. debe ser positivo (el programa deberá

pedir que ingrese el número hasta que ingrese un nro. Positivo).

- Si elije 2 deberá pedir al usuario que ingrese dos números A y B y calculará A dividido B. Debe

tener en cuenta que: el nro. B debe ser diferente de cero (el programa deberá pedir que ingrese el número hasta que ingrese un nro. distinto de cero).

- Si ingresa cualquier otro nro. Deberá informar “ERROR” y mostrar nuevamente el menú. Cada uno de los puntos 1,2 se deberán realizar llamando a una función y pasándole los argumentos

necesarios, por ejemplo para factorial un entero y para División dos flotantes ambas funciones deberán retornar el valor que resulte de la operación.

160

Ejercicio Nº 17:

Definiendo una matriz Global llamada Mat de 3 x 3 , realizar el código en c++ que permita llamar a la

función menú la cual mostrará:

1. Carga de Matriz. (función carga, void , void).

2. Muestra fila ( función muestra, recibe int, retorna float)

3. Ordena fila ( función ordena , recibe int , retorna void)

4. Mayor que (función mayor que recibe un float y retorna un entero indicando cuantos valores de la matriz son mayores que el flotante pasado.

F. Finaliza el programa.

En caso que se presione una tecla que no sea 1,2,3,4,F ó f se beberá mostrar un cartel "Tecla no válida" y nuevamente volver al menú.

Ejemplos:

Ejemplo Nº 1:

/*Este Ejercicio permite comprender la equivalencia entre los valores decimales de los dígitos en Código ASCII y el valor entero de un dígito*/

/*Utiliza la propiedad de que los dígitos en ASCII están en forma correlativa '0'=48; '1'=49 ;.. '8'=56;'9'=57*/

# include <iostream>


int numero(char); //Prototipo

int main()

{ char ingreso;

cin >> ingreso; //ingreso el carácter

switch(numero(ingreso)) //llamo a la función

{

case 0: cout<< " Ud ingreso el dígito CERO"; break;

case 1: cout<< " Ud ingreso el dígito UNO"; break;

case 2: cout<< " Ud ingreso el dígito DOS"; break;

case 3: cout<< " Ud ingreso el dígito TRES"; break;

case 4 : cout<< " Ud ingreso el dígito CUATRO"; break;

case 5: cout<< " Ud ingreso el dígito CINCO"; break;

case 6: cout<< " Ud ingreso el dígito SEIS"; break;

case 7: cout<< " Ud ingreso el dígito SIETE"; break;

case 8: cout<< " Ud ingreso el dígito OCHO"; break;

case 9: cout<< " Ud ingreso el dígito NUEVE"; break;

default : cout<<"Ud. no ingreso un dígito";

}

}

int numero(char N) //Definición, recibo un char

{

int i;

for (i=0;i<=9;i++)

{

if(N==(i+48))return i; //retorno un entero

}}

161

Ejemplo Nº 2:

Arreglo Multidimensional

/*Este ejercicio de c++, carga y muestra una matriz de 3 dimensiones por ejemplo ancho alto, profundidad. Esto se podría extender a mas dimensiones */

#include<iostream>

#define X 3

#define Y 2

#define Z 2


int main()

{

int i,j,k;

float matriz[X][Y][Z]; //Matriz de 3 Dimensiones

for(i=0;i<X;i++)

{

for(j=0;j<Y;j++)

{

for(k=0;k<Z;k++)

{

cout<< " Ingrese el elemento"<<endl;

cout<<i<<"-"<<j<<"-"<<k<<" :";

cin>>matriz[i][j][k];

}

}

}

for(i=0;i<X;i++)

{

for(j=0;j<Y;j++)

{

for(k=0;k<Z;k++)

{

cout<<"el elemento :";

cout<<i<<"-"<<j<<"-"<<k<<" vale :"<< matriz[i][j][k]<<endl;

}

}

}

}

Ejemplo Nº 3:

Escribir el código en C++ de una función main que llame a factorial pasando un entero como argumento o parámetro y desde factorial se use la recursividad para calcular el factorial.

#include<iostream>


int factorial(int); //PROTOTIPO

int main()

{

int num;

162

cout<<"Ingrese nro para calcular el factorial: "<<endl;

cin>> num;

cout << factorial(num);

}

int factorial(int n) //DEFINICION

{

if (n==1)return 1;

else return ( n * factorial (n-1));

}

Ejemplo Nº 4: Ejemplo con funciones combinadas

#include <iostream>


#define N 3 //cantidad de filas

#define M 2 //cantidad de columnas

#define C 4 //cantidad de matrices

int Matriz[C][N][M]; //definicion de las matrices

///////prototipos de las funciones//////

void Carga(int);

void Muestra(int);

long long unsigned int Factorial(int m, int f, int c);

// long unsigned se utilizan para numeros grandes y sin

// signo, todos positivos!

void Suma(int, int );

char Menu();

////////////////////////////////////////

int main()

{

bool s=true; // variale que permite la salida del while

bool esta_cargada[C]; // vector "BANDERA"

int c, y, z; // variables que se usan

// ponemos el vector bandera en falso, es decir, ninguna matriz cargada!

for(int i=0;i<C;i++)

esta_cargada[i]=false;

///////////////////////////////////////////////////////////////////////

do{

switch(Menu()) //llamada a la funcion Menu. retorna un "char"

{

case 'a':

cout<<endl<<"Ingrese la matriz a cargar "<<endl;

cin>>c;

if(c<=C-1 && c>0)

// para saber si el valor ingresado es

// correcto y no cargar en un lugar no declarado

{ if(!esta_cargada[c-1])

{ // cargamos la matriz mediante funcion Carga

// si esta no fue cargada aún

163

// y ponemos su correspondiente bandera en

// verdadero, asi no la volvemos a cargar.

Carga(c-1);

esta_cargada[c-1]=true;

}

else cout<<"Ya se cargo esta matriz";

}

else cout<<endl<<"No esta declarada esta Matriz";

break;

case 'f':

cout<<endl<<"Ingrese la matriz, fila y columna: "<<endl;

cin>>c>>y>>z;

if(esta_cargada[c-1] && y>0 && z>0 && c>0 && y<=N && z<=M && c<=C)

if (Factorial(c-1,y-1,z-1)>0)

{ // si factorial es mayor que 0 muestro el resultado:

// (ver función Factorial)

cout<<endl<<"El resultado de: "<<Matriz[c-1][y-1][z-1]

<<"! = "<<Factorial(c-1,y-1,z-1)<<endl;}

else cout<<endl<<"Error, numero negativo!";

else cout<<endl<<"Error, no se cargo dicho elemento";

break;

case 'm':

cout<<endl<<"Que matriz desea mostrar"<<endl;

cin>>c;

if(esta_cargada[c-1] && c>0 && c<=C) // si fue cargada y si

// esta definida esta matriz

Muestra(c-1); // llamada a la funcion Muestra

else cout<<endl<<"No se cargo esta matriz";

break;

case '+': /* Una vez qu*/

cout<<endl<<"Que matrices desea sumar"<<endl;

cin>>z>>y;

if(z>0 && y>0 && z<=N && y<=M && esta_cargada[z-1] && esta_cargada[y-1])

{ // En el if anterior se tiene en cuenta si estan declarada

// las matrices y si se cargaron.

Suma(z-1, y-1);

// llama la función suma la cual guardda el resultado en Matriz[C-1]

// (ver funcion Suma)

esta_cargada[C-1]=true; // pone bandera en verdadero

}

else cout<<endl<<"Al menos una de las matices no se cargó";

break;

case 'S': // Salir es con S y no con s !!!

s=false;

cin.get(); // toma el Enter anterior

cout<<endl<<"Saliendo..."<<endl<<"presione Enter";

cin.get(); // pide un Enter para salir

164

break;

default :

// uso el default para las opciones incorrectas

cout<<endl<<"Error, Opcion Incorrecta";

}

}while(s);// sale si s=falso

return 0;

}

///////// Cuerpos de las Funciones//////////////

char Menu() // No recibe argumento pero si retorna, del tipo char

{

char seleccion; //debe ser del mismo tipo que la función

cout<<endl<<endl<<" - * - * - Menu - * - * -";

cout<<endl<<"a- Cargar una Matriz";

cout<<endl<<"f- Sacar el factorial de un elemento";

cout<<endl<<"m- Mostrar una Matriz";

cout<<endl<<"+- Sumar las matrices";

cout<<endl<<"S- Salir";

cout<<endl;

cin>>seleccion;

return seleccion; //retorna dicho valor

}

void Carga(int a) // recibe "a" como argumento pero no retorna valores

{

cout<<endl<<"Cargue la Matriz: "<<a+1<<endl<<"Cargue la componente: "<<endl;

for(int i=0;i<N;i++)

for(int j=0;j<M;j++)

{

cout<<endl<<i+1<<j+1<<" "; // muestro la componente a cargar;

cin>>Matriz[a][i][j]; // Cargo...

}

}

void Muestra(int a) // No retorna y si recibe. Quiere saber que matriz tiene que mostrar

{

cout<<endl<<"La Matriz: "<<a+1<<" es: "<<endl;


{


{

cout<<"\t"/* hace un tab */<<Matriz[a][i][j];

}

cout<<endl; // salto de linea para cada fila

}

}

long long unsigned int Factorial(int m, int f, int c)

{ // Recibe como argumento, la Matiz, la fila y la columna.

// devuelve el factorial si calcula o cero si no puede calcular

if(Matriz[m][f][c]>=0)

165

{long long unsigned int r=1;// es del "tipo" de la función

for(int i=1;i<=Matriz[m][f][c];i++)

r=r*i;

return r;

}

else return 0;

}

void Suma(int a, int b)

{



Matriz[C-1][i][j]=Matriz[a][i][j]+Matriz [b][i][j];

Muestra(C-1); // Llamada a la función Muestra dentro de otra función

}

/* Una vez que haya probado con los valores definidos N M y C, intente

modificarlos y ver como responde el programa */

4.11.7. Ejercicios Integradores

Ejercicio 1:

Se ingresarán 20 valores por teclado, se deberán guardar de esos 20 solo aquellos valores que no se encuentren entre 10 y 20 incluidos. Luego el programa deberá presentar un menú llamando a la función

"menu" que mostrará:

a- Calcular y mostrar el Mayor.

b- Calcular y mostrar el Menor.

c- Mostrar el valor de una posición.

d- Mostrar los valores cargados.

F- Finalizar.

Cada uno de los puntos a, b, c, d, se deberán realizar llamando a un función (mayor, menor, posición y mostrar). Solo se deberá finalizar el programa si se presiona la Letra o F ó f. En caso que se presione una

tecla que no sea a, b, c, d, F ó f se beberá mostrar un cartel "Tecla no válida" y nuevamente volver al menú.

Ejercicio 2:

Modificar el programa anterior de manera que la función invocada en el punto ”c” reciba como argumento un entero indicando el numero de posición o indice y dentro de esta función se muestra el valor

de la posición y se retorna true, en caso de que el indice o posición no corresponde (el valor es mayor que la dimensión o negativo) con los del vector deberá retornar false y mostrar el cartel desde main. Es decir que

la función posición retorne una variable booleana”bool”.

Ejercicio 3:

Escribir un código que permita el ingreso de 2 valores flotantes, luego desde main se llame a una función llamada enteros pasando como argumento estos flotantes y en ella se deberá mostrar todos los

enteros comprendidos entre los dos flotantes pasados como parámetros. La función enteros no retorna nada.

Ejercicio 4:

Escribir el código en C++ de un programa que desde main llame a una función promedio, la cual recibe

cinco escalares y retorna el promedio que es mostrado desde main.


166

Ejercicio 5:

Realizar una función que reciba como parámetro dos números enteros X e Y, la función retornara si el

numero X es múltiplo de Y. Para ello utilizar la función modulo (operador % ). También debe incluir una segunda función en la cual se ingrese un numero entero N, y calcule todos los múltiplos de N en el intervalo

[1 100]. La selección se debe realizar por medio de un menú.

Ejercicio 6:

Escribir un código en C++ de desde main se pase a una función llamada tecla la cual recibe el valor de una tecla presionada, esta función tecla deberá mostrar ”letra”, ”numero” o ”símbolo” según corresponda a

la tecla presionada, y retornar true si es letra o numero y false si es símbolo.

Ejercicio 7:

Definir un ”string” como variable global y desde main llamar a la función contar, la cual recibe como argumento un carácter que contará cuantas veces se repite en el string global, desde esta función se

muestra la cantidad y se retorna a main la dimensión del string, la cual es mostrada en main.

Ejercicio 8:

Para que un tren complete el recorrido entre dos localidades, la locomotora debe ejercer una fuerza variable con la posición, que responde a la siguiente función:

F = - 0,0035 x2 + 18 x + 10000

En un gráfico Fuerza en función de la posición, el trabajo es el área bajo la curva.

Se puede aproximar dicha área dividiendo el espacio de interés en intervalos iguales y suponiendo que cada uno es un rectángulo de altura igual al valor de la función al comienzo del segmento y de ancho igual a

la longitud del intervalo (aproximación de orden 0). Cuanto menor sea la longitud del intervalo, mayor sera la exactitud de la aproximación.

Realizar un programa en C++ para determinar el trabajo realizado por la locomotora, para ir desde la localidad 1 hasta la localidad 2 a 5000m de distancia, utilizando una aproximación de orden 0. Analizar la

influencia de la longitud del intervalo. Probar con intervalos de 500m y de 100m.

167

Implementar una función que evalúe el valor de la fuerza para una posición dada y otra función que

vaya sumando las sucesivas áreas.

Comparar los resultados.

Ejercicio Resuelto

//Programa que calcula el trabajo realizado por una fuerza, de función conocida,

//aproximando el área bajo la curva mediante interpolación de orden 0.

#include <iostream>


float aproximacion_orden_0 (float inicio, float fin, float incremento); //función que calcula el área bajo la curva

float fuerza_en_posicion (float posicion); // función que evalúa la función en la posición dada.

int main()

{

float trabajo;

trabajo= aproximacion_orden_0(0,5000,10);

cout<<"El trabajo realizado por la Fuerza desde los 0m hasta los 5000m es de "<<trabajo<<" Joules";

return(0);

}

float aproximacion_orden_0 (float inicio, float fin, float incremento)

{ float area_orden_0 = 0;

for (float posicion=inicio; posicion< fin; posicion=posicion + incremento)

{

area_orden_0 = area_orden_0 + fuerza_en_posicion(posicion)*incremento;

}

return (area_orden_0);

}

float fuerza_en_posicion (float posicion)

{

float fuerza;

fuerza=-0.0035*posicion*posicion+18*posicion+10000;

//Fuerza en función de la posición F= -0,0035x^2 + 18x + 10000

return(fuerza);

}

Ejercicio 9:

Realizar un programa que permita mostrar por pantalla el siguiente menú HASTA que el usuario ingrese “S” para salir del programa. Si el usuario ingresa una opción diferente a las que aparecen en el menú deberá

mostrar “ERROR. Opción Incorrecta”. El menú es el siguiente:

MENU DE OPCIONES

A – Cargar una tabla de multiplicar

B – Buscar un número en el vector

C- Sumar números

S – SALIR


168

El usuario deberá ingresar por teclado la opción (OPC) a ejecutar y luego llamar a la función

correspondiente. Hay como variable global V1 un vector de 10 elementos.

a) Si el usuario elige la opción A – Mostrar una tabla de multiplicar deberá pedir que se ingrese un número (N1) del que quiere calcular la tabla. N1 debe estar entre 1 y 10. Luego llamará a la función TABLA que deberá cargar la tabla del número N1 en el vector V1

O sea que, la función TABLA recibe como argumento N1 y no devuelve nada a main().

b) Si el usuario elige la opción B - Buscar un número en el vector deberá pedir que se ingrese un numero N2 y se llamará a la función BUSCA deberá buscar el número en el vector V1. Si existe deberá retornar 1 a main() o 0 si no existe. Cuando devuelve a main deberá mostrar allí el resultado.

c) Si el usuario elige la opción D – Sumar números deberá llamar a la función SUMA que calculará la suma de los números del vector, por último devolverá a main el acumulado (S2) y desde allí se mostrará por

pantalla.

O sea que, la función SUMA no recibe argumentos y devuelve S2 a main().

Ejercicio 10:

Realizar un programa que permita mostrar por pantalla el siguiente menú HASTA que el usuario ingrese “S” para salir del programa. Si el usuario ingresa una opción diferente a las que aparecen en el menú deberá

mostrar “ERROR. Opción Incorrecta”. El menú es el siguiente:

MENU DE OPCIONES

A – Mostrar una tabla de multiplicar

B – Generar una serie de números

C – Calcular el Factorial de un número

D – Sumar números

E - Calcular la potencia

S – SALIR

El usuario deberá ingresar por teclado la opción (OPC) a ejecutar y luego llamar a la función correspondiente.

a) Si el usuario elige la opción A – Mostrar una tabla de multiplicar deberá pedir que se ingrese un número (N1) del que quiere calcular la tabla. N1 debe estar entre 1 y 10. Luego llamará a la función TABLA

que deberá mostrar la tabla del número N1.

O sea que, la función TABLA recibe como argumento N1 y no devuelve nada a main().

b) Si el usuario elige la opción B – Generar una serie de números deberá llamar a la función SERIE, ésta pedirá que se ingrese un número N2. N2 deberá estar entre 1 y 30. N2 indicará la cantidad de términos a

calcular y sumar de la siguiente serie:

S = 1 - 1/3 + 1/9 - 1/27 + 1/81 - ….

La función SERIE no recibe nada de main pero deberá devolver a main el valor de S y main mostrará el resultado por pantalla.

O sea que, la función SERIE no recibe argumentos y devuelve S a main().

c) Si el usuario elige la opción C – Calcular el Factorial de un número deberá llamar a la función FACTORIAL. La función pedirá que se ingrese un número (N3), deberá calcular el factorial de N3 y mostrar

el resultado por pantalla. Tener en cuenta los casos particulares.

O sea que, la función FACTORIAL no recibe argumentos ni devuelve nada a main().


169

d) Si el usuario elige la opción D – Sumar números deberá ingresar un número positivo (N4) y llamará a

la función SUMA que calculará la suma de los números ingresados mientras que el acumulado no supere N4; por último devolverá a main el acumulado (S2) y desde allí se mostrará por pantalla.

O sea que, la función SUMA recibe como argumento a N4 y devuelve S2 a main().

e) Si el usuario elige la opción E – Calcular la potencia deberá ingresar dos valores X e Y, con estos

datos llamará a la función POTENCIA que calculará XY utilizando la función pow() y devolverá el resultado (P) a main donde se mostrará por pantalla.

O sea que, la función POTENCIA recibe como argumentos a X y a Y, y devuelve P a main().

Ejercicio 11:

Realizar un programa que permita llamar a una función MENU que deberá mostrar por pantalla el siguiente menú. El menú es el siguiente:

MENU DE OPCIONES

1 – Cargar un vector

2 – Cargar una matriz

3 – Buscar un número en la matriz

4 – Ordenar la matriz

5 – Buscar el mayor en el vector.

6 – SALIR

El usuario deberá ingresar por teclado la opción (OPC) a ejecutar y devolverá el valor de OPC a main.

O sea que, la función MENU no recibe argumento pero devuelve a main OPC.

El programa se ejecutará HASTA que el usuario ingrese 6 para salir del programa. Si el usuario ingresa una opción diferente a las que aparecen en el menú deberá mostrar “ERROR. Opción Incorrecta”

Luego main llamar a la función correspondiente.

a) Si el usuario elige la opción 1 – Cargar un vector deberá llamar a la función CARGAV que deberá permitir cargar el vector V.

O sea que, la función CARGAV no recibe argumentos y no devuelve nada a main().

b) Si el usuario elige la opción 2 – Cargar una matriz deberá preguntar al usuario cómo quiere cargar la

matriz (CA). El usuario podrá ingresar “F” si quiere cargar la matriz por filas o “C” si quiere cargar la matriz por columnas. Luego deberá llamar a la función CARGAM que deberá permitir cargar la matriz M por filas o

columnas según haya pedido el usuario.

O sea que, la función CARGAM recibe como argumento CA y no devuelve nada a main().

c) Si el usuario elige la opción 3 – Buscar un número en la matriz deberá permitir al usuario ingresar un número N1 y luego llamará a la función BUSCA que deberá buscar si el número N1 se encuentra en la matriz

M. Si lo encuentra deberá informarlo, además de mostrar en qué fila y columna se encuentra. Si no lo encuentra deberá mostrar un mensaje “NO Encontrado”.

O sea que, la función BUSCA recibe como argumento N1 y no devuelve nada a main().

DEBE CONTROLAR QUE para poder realizar la opción 3, la matriz deberá estar cargada.

d) Si el usuario elige la opción 4 –Ordenar la matriz deberá llamar a la función ORDEN que ordenará la matriz por columnas, luego retornará a main y desde allí se llamará a la función MUESTRAM que mostrará la

matriz ordenada.

O sea que, la función ORDEN no recibe argumentos y no devuelve nada a main().

DEBE CONTROLAR QUE para poder realizar la opción 4, la matriz deberá estar cargada.


170

e) Si el usuario elige la opción 5 – Buscar el mayor en el vector deberá llamar a la función MAYOR que

deberá buscar el mayor número ingresado (MAX) en el vector, pero no deberá modificarlo. Retornará a main el valor de MAX.

O sea que, la función MAYOR no recibe argumentos y devuelve MAX a main().

DEBE CONTROLAR QUE para poder realizar la opción 5, el vector deberá estar cargado.

NOTA:

la matriz y el vector deben declararse como variables globales. La matriz deberá ser de 4 x 5 y el vector de 8 elementos.

Ejercicio 12:

Función main

Main mostrará un menu como el siguiente:

1- Contar la cantidad de veces que un caracter aparece en un string.

2- Calcular la Serie.

S – Salir.

El usuario podrá ingresar solamente las opciones indicadas (1,2,S). En caso de presionar cualquier otra tecla deberá mostrar el error por pantalla: "Opción NO VALIDA", y volverá a mostrar el menú.

Según la tecla presionada, se deberá llamar a la función correspondiente o finalizar el programa.

Si el usuario elige 1, en Main se deberán pedir el carácter que pasará como parámetro a Mensaje.

Si el usuario elige 2, en Main se deberán pedir los parámetros necesarios para llamar a la función serie (X y n), y deberá verificar que los argumentos pasados sean válidos ( n > 0 ).

Main llamará a mensaje pasando el argumento necesario (carácter) y mostrará "ENCONTRO" si la función devolvió VERDADERO o "NO ENCONTRO" si la función devolvió FALSO.

Función mensaje

Se define en esta función un string llamado mensa que contiene el siguiente texto: "Si pensas que tu

profesor es jodido, espera a que tengas un jefe!!".

Esta función recibe un carácter como argumento. El código deberá contar la cantidad de ocurrencias de este carácter en el string (mensa). Si el caracter no existe en el string deberá retornar FALSE, en caso

contrario muestra la cantidad de veces que se encuentra y retorna a main con TRUE. Este valor booleano

retornado se usará para mostrar desde main ENCONTRÓ o NO ENCONTRO.

Función Serie

Esta función recibe como argumento dos valores, un entero positivo n mayor que cero y un número X, luego calcula y muestra:

S = -X+ (X2 )/2 - (X3 )/3+(X4 )/4- ......... (- X)n/n

Para el cálculo de las potencias de X dentro de esta función, se deberá llamar a otra función llamada Potencia. Esta función Potencia solo deberá calcular la potencia de X para cada valor de n, o sea que

Potencia recibirá dos argumentos (n y X) y devolverá el resultado a la función Serie.

Por ejemplo:

si Potencia recibe (1, -7) , calcula -71




....

Y así sucesivamente hasta n

171

Ejercicio 13:

Realizar un programa que permita llamar a una función MENU que deberá mostrar por pantalla el

siguiente menú.

MENU DE OPCIONES

1 – Cargar una matriz

2 – Buscar un número en la matriz

3 –Intercambiar dos columnas de la matriz.

4–SALIR

El usuario deberá ingresar por teclado la opción (OPC) a ejecutar y devolverá el valor de OPC a main. O sea que, la función MENU no recibe argumento pero devuelve a main OPC.

El programa se ejecutará HASTA que el usuario ingrese 4 para salir del programa. Si el usuario ingresa una opción diferente a las que aparecen en el menú deberá mostrar “ERROR. Opción Incorrecta”

Luego main llamar a la función correspondiente.

Si el usuario elige la opción 1 – Cargar una matriz deberá preguntar al usuario cómo quiere cargar la

matriz (CA). El usuario podrá ingresar “F” si quiere cargar la matriz por filas o “C” si quiere cargar la matriz por columnas. Luego deberá llamar a la función CARGAM que deberá permitir cargar la matriz M por filas o

columnas según haya pedido el usuario. O sea que, la función CARGAM recibe como argumento CA y no devuelve nada a main().

2 – Buscar un número en la matriz deberá permitir al usuario ingresar un número N1 y luego llamará a la función BUSCA que deberá buscar si el número N1 se encuentra en la

matriz M. Si lo encuentra deberá retornar „E‟ a main. Si no lo encuentra deberá retornar „N‟ y desde main se deberá imprimir “Encontrado” o “No encontrado” según corresponda. O sea que, la función BUSCA recibe

como argumento N1 y devuelve un carácter a main(). DEBE CONTROLAR QUE para poder realizar la opción 2, la matriz deberá estar cargada.

3 – Intercambiar dos columnas de la matriz deberá permitir al usuario ingresar los números C1 y C2 los cuales se deberán validar y luego llamará a la función CAMBIO que deberá

intercambiar las columnas especificadas y luego imprimir la matriz. O sea que, la función CAMBIO recibe como argumento C1 y C2 y no devuelve nada a main(). DEBE CONTROLAR QUE para poder realizar la

opción 3, la matriz deberá estar cargada.

1. #include <iostream>

2. #define M 3

3. #define N 4

4. using namespace std;

5. int mat [M] [N];

6. int menu();

7. void cargam(char ca);

8. char busca(int n1);

9. void cambio(int c1, int c2);

10. int main()

11. {

12. int opc, n1, c1, c2, band=0;

13. char ca, res;

14. do{

15. opc=menu();

16. switch (opc){

17. case 1: do{

18. cout <<endl<<“Elija como desea cargar la matriz: F o C”;

19. cin >> ca;

20. }while(ca!= „F‟ && ca!=„C‟);

172

21. cargam(ca);

22. band=1;

23. break;

24. case 2: if (band == 1){

25. cout<< endl<<“ingrese el numero a buscar en la matriz “;

26. cin>> n1;

27. res=busca(n1);

28. if(res==„E‟) cout<<endl<<“Encontrado”;

29. else cout<<endl<<“No encontrado”;}

30. else cout<<endl<<“La matriz no esta cargada”;

31. break;

32. case 3: if (band == 1){

33. do{

34. cout<<endl<<“Ingrese un nro entre 0 y 3 para c1 “;

35. cin >> c1;

36. cout<<endl<<“Ingrese un nro entre 0 y 3 para c2 “;

37. cin >> c2;

38. }while((c1 <0 || c1>3) || (c2<0 || c2>3));

39. cambio(c1, c2);

40. }

41. else cout<<endl<<“la matriz no esta cargada”;

42. break;

43. case 4: cout<< “Saliendo…presione una tecla para continuar”;

44. break;

45. default: cout<<endl<<“ERROR. Opción incorrecta”

46. }

47. }while (opc != 4);

48. return 0;

49. }

50. int menu()

51. {

52. int opc;

53. cout<< endl<<“MENU DE OPCIONES”<<endl <<“1 – Cargar una matriz”<<endl<<“2 – Buscar un número en la matriz”<<endl<<“3 –Intercambiar dos columnas de la matriz.” <<endl <<“4– SALIR”;

54. cin>>opc ;

55. return opc;

56. }

57. void cargam(char ca)

58. {

59. int i, j;

60. if (ca == „F‟) {

61. for(i=0; i<M; i++)

62. {

63. for(j=0; j<N; j++) {

64. cout<<endl<<“Ingrese el elemento “ <>mat[i][j]; }

66. }

67. }

68. else { for(j=0; j<N; j++)

173

69. {

70. for(i=0; i<M; i++) {

71. cout<<endl<<“Ingrese el elemento “ <>mat[i][j]; }

73. }

74. }

75. }

76. char busca(int n1)

77. {

78. int i,j;

79. char enc =„N‟;

80. for(i=0; i<M; i++)

81. {

82. for(j=0; j<N; j++) {

83. If(mat[i][j] == n1)

84. enc = „E‟; }

85. }

86. return enc;

87. }

88. void cambio(int c1, int c2)

89. {

90. int aux, i, j;

91. for(i=0; i<M; i++)

92. {

93. aux= mat[i][c1];

94. mat[i][c1]= mat[i][c2];

95. mat[i][c2]= aux;

96. }

93. for(i=0; i<M; i++)

94. {

95. for(j=0; j<N; j++) {

96. cout<<mat[i][j]<<“\t”; }

97. cout<<endl;

98. }

84. }

TALLER DE INFORMÁTICA CAPITULO 5. Sistemas Operativos

174

CAPITULO 5.

SISTEMAS OPERATIVOS

En el Capítulo 1, cuando se presenta la definición y clasificación de Software se sostenía que: Software

es el conjunto de instrucciones detalladas que controlan la operación de un sistema de cómputos y existen tres tipos principales de software:

Software de Sistema: es un conjunto de programas generalizados que administran los recursos de la computadora, como la CPU, los dispositivos de comunicaciones y los periféricos.

Software de Aplicaciones: programas escritos para una aplicación específica de negocios con el objeto de realizar funciones específicas por los usuarios finales.

Software de Usuario Final: Es un tipo especial de aplicación que consiste en herramientas de

software que permiten el desarrollo de aplicaciones por los usuarios finales con muy poca o nula intervención de programadores profesionales.

Dentro del Software de Sistema estarían los Sistemas Operativos SO, estos programas realizan tareas básicas, tales como reconocimiento de la conexión del teclado, enviar la información a la pantalla, no perder

de vista archivos y directorios en el disco, y controlar los dispositivos periféricos tales como impresoras, escáner, etc.

5.1. DEFINICIONES

5.1.1. Software de sistemas Coordina las diferentes partes del sistema de cómputos y sirve como mediación entre el software de

aplicación y el hardware.

Consta de:

* Sistema operativo

Programa sucesos de cómputo

Asigna recursos de cómputo

Hace seguimientos de eventos

* Traductores de Lenguaje

Intérpretes

Compiladores

* Programas de Utilería

Operaciones rutinarias (sort, print, etc)

Administración de datos (crea, fusiona archivos)

5.1.2. Sistema Operativo Es el software del sistema que administra y controla las actividades y recursos de la computadora. Es el

administrador del sistema. Decide qué recursos de la computadora habrán de ser usados, qué programas se

ejecutarán y el orden en que ocurrirán las actividades.

5.1.2.1. Funciones del Sistema Operativo

a- Define y asigna los recursos del sistema

b- Programa el uso de los recursos y trabajos de cómputos

c- Realiza el seguimiento de las actividades del sistema de cómputos


175

a) Definición y asignación de los recursos del sistema

El SO asigna recursos a los trabajos que se encuentran en la cola de ejecución.

Proporciona ubicaciones en la memoria primaria para los datos y los programas y controla los

dispositivos de entrada y salida.

b) Programación del uso de los recursos y trabajos

El SO decide cuándo programar los trabajos que se presentan y cuándo coordinar la

programación de las distintas áreas de la computadora, de manera que partes diferentes de los trabajos puedan ser procesadas al mismo tiempo.

No todos los trabajos son realizados en el orden en que se presentan. El SO debe programarlos de acuerdo al orden de prioridades.

c) Seguimiento de las actividades del sist. de cómputos

El SO debe realizar un seguimiento de las actividades realizadas, de quién usa el sistema, qué programas se han ejecutado, y dar cuenta de cualquier intento no autorizado de utilizar el

sistema.

5.1.2.2. Capacidades especiales del SO

a) Multiprogramación

Es la capacidad más importante del SO para compartir recursos de la computadora.

Es un método para ejecutar dos o más programas empleando la misma computadora. El CPU

solo ejecuta un programa, pero puede dar servicio a las necesidades de entrada y salida de otros al mismo tiempo.

Dos o más programas están activos al mismo tiempo, pero no usan los mismos recursos de la computadora simultáneamente.

Varios programas se cargan en memoria principal, este aspecto mejora la administración de la memoria y de los dispositivos de E/S.

b) Multitarea

Es la multiprogramación en los sistemas operativos individuales, para microcomputadoras.

Una persona puede ejecutar más de un programa de manera concurrente en una computadora.

Por ejemplo, imprimir y escribir un texto en el procesador.

c) Almacenamiento Virtual

Maneja los programas de manera más eficiente al dividirlos en pequeñas porciones de longitud fija o variable, almacenando solo una pequeña parte del programa en la memoria principal a la

vez. El resto se almacena en disco hasta que se necesita.

Solo unas cuantas instrucciones se ejecutan en realidad en cualquier momento dado.

El almacenamiento virtual divide el programa en un número de porciones de longitud fija llamadas

páginas, o porciones de longitud variable llamadas segmentos.

Cada una de estas porciones es pequeño (2 a 4 Kb), esto permite que un gran nro. de programas

residan en memoria principal.

d) Tiempo compartido

Permite compartir simultáneamente los recursos de la computadora entre muchos usuarios al asignar un periodo de tiempo muy pequeño (2 miliseg.) a cada usuario. En este lapso el usuario puede utilizar libremente para realizar cualquier operación.

En la Multiprogramación era hacer que la CPU emplee una cantidad fija de tiempo para cada programa, acá es para cada usuario.

e) Multiproceso

El SO es capaz de unir dos o más CPU para que trabajen en paralelo en un solo sistema de

cómputos, el cual puede asignar múltiples CPU para múltiples instrucciones de un mismo programa o de diferentes programas en forma simultánea.


176

5.1.3. Traducción de lenguajes

El Software de Sistema incluye programas especiales de traducción de lenguajes que traducen programas escritos en un Lenguaje de programación de alto nivel (BASIC, C) a un lenguaje de máquina que

ésta pueda ejecutar. Estos programas se llaman compilador o intérpretes

Proceso:

a) El programa escrito en el lenguaje de alto nivel se llama código fuente

b) El compilador traduce el código fuente a código de máquina llamado código objeto

c) Los diferentes módulos de código objetos se juntan en un proceso llamado edición de liga (linkage editing). El módulo de carga resultante es el código a ejecutar por la computadora.

Algunos lenguajes de programación (BASIC) no usan un compilador sino un intérprete que traduce cada

instrucción en código fuente, en código de máquina y la ejecuta. Es más lento porque traduce de a una instrucción por vez.

5.1.4. Programas de Utilería

En el software de sistema se incluyen programas de utilería para rutinas, tareas repetitivas como copiar, limpiar la memoria, formatear un disco, eliminar archivos, crear un texto.

Son programas escritos previamente que se almacenan para que puedan ser compartidos por todos los usuarios de un sistema de cómputos.

5.1.5. Sistemas Operativos para Microcomputadoras

En el software de sistema se incluyen programas de utilería para rutinas, tareas repetitivas como copiar,

limpiar la memoria, formatear un disco, eliminar archivos, crear un texto.

Son programas escritos previamente que se almacenan para que puedan ser compartidos por todos los

usuarios de un sistema de cómputos.

5.1.6. Historia de los Sistemas Operativos

Los Sistemas Operativos han sufrido una serie de cambios revolucionarios llamados generaciones.

Generación Cero (década de 1940)

Los primeros sistemas computacionales no poseían sistemas operativos. Los usuarios tenían completo acceso al lenguaje de la maquina. Todas las instrucciones eran codificadas a mano.

Primera Generación (década de 1950)

Los sistemas operativos de los años cincuenta fueron diseñados para hacer mas fluida la transición entre

trabajos.

Este fue el comienzo de los sistemas de procesamiento por lotes, donde los trabajos se reunían por

grupos o lotes.

El laboratorio de investigación General Motors implementó el primer sistema operativo para la IBM 701.

Los sistemas de los 50's generalmente ejecutaban una sola tarea.

Segunda Generación (a mitad de la década de 1960)


177

La característica de los SO fue el desarrollo de los sistemas compartidos con multiprogramación, y los

principios del multiprocesamiento.

Se desarrollaron sistemas compartidos, en la que los usuarios podían acoplarse directamente con el

computador a través de terminales. Surgieron sistemas de tiempo real, en que los computadores fueron utilizados en el control de procesos industriales.

Tercera Generación (mitad de década 60 a mitad década de 70)

Los computadores de esta generación fueron diseñados como sistemas para usos generales. Casi

siempre eran sistemas grandes, voluminosos, con el propósito de serlo todo para toda la gente. Eran sistemas de modos múltiples, algunos de ellos soportaban simultáneamente procesos por lotes, tiempo

compartido, procesamiento de tiempo real y multiprocesamiento. Eran grandes y costosos.

Introdujeron mayor complejidad a los ambientes computacionales.

Cuarta Generación (mitad de década de 1970 en adelante)

Con la ampliación del uso de redes de computadores los usuarios obtienen acceso a computadores alejados geográficamente a través de terminales

Los sistemas de seguridad se ha incrementado mucho ahora que la información pasa a través de varios tipos vulnerables de líneas de comunicación. La clave de cifrado esta recibiendo mucha atención.

El porcentaje de la población que tiene acceso a un computador en la década de los ochenta es mucho mayor y aumenta rápidamente.

El concepto de maquinas virtuales es utilizado. El usuario ya no se encuentra interesado en los detalles físicos del sistema de computación que esta siendo accedida. En su lugar, el usuario ve un panorama llamado maquina virtual creado por el sistema operativo.

Los sistemas de bases de datos han adquirido gran importancia. Nuestro mundo es una sociedad orientada hacia la información, y el trabajo de las bases de datos es hacer que esta información sea

conveniente accesible de una manera controlada para aquellos que tienen derechos de acceso.

5.1.7. Tipos de Interfaz con el usuario

5.1.7.1. Interfaz de Línea de Comandos

La forma de interfaz entre el sistema operativo y el usuario en la que el usuario escribe los comandos

utilizando un lenguaje de comandos especial.

Los sistemas con interfaces de líneas de comandos se consideran más difíciles de aprender y utilizar que

los de las interfaces gráficas. Sin embargo, los sistemas basados en comandos son por lo general programables, lo que les otorga una flexibilidad que no tienen los sistemas basados en gráficos carentes de

una interfaz de programación.

5.1.7.2. Interfaz Gráfica del Usuario

Es el tipo de visualización que permite al usuario elegir comandos, iniciar programas y ver listas de archivos y otras opciones utilizando las representaciones visuales (iconos) y las listas de elementos del

menú. Las selecciones pueden activarse bien a través del teclado o con el mouse.

Permite a los programadores crear programas que realicen de la misma forma las tareas más frecuentes,

como guardar un archivo, porque la interfaz proporciona mecanismos estándar de control como ventanas y cuadros de diálogo.

Las aplicaciones escritas para una interfaz gráfica de usuario son independientes de los dispositivos

5.1.8. Sistemas operativos actuales En la actualidad existen varios sistemas operativos para diferentes necesidades y tipos de computadoras:


178

MS-DOS (Disk Operating System) Sistema operativo para microcomputadoras de 16 bits. So

monotareas, entorno de texto. Limita el tamaño de programas en memoria a 640 K.

OS/2 WARP Diseñado por IBM es el competidor más cercano de MS-DOS sobre todo por sus grandes capacidades de interconexión de equipos y facilidad de uso bajo ambiente gráfico.

Netware diseñado por Novell, líder mundial en SO para redes de computadoras por el poder y versatilidad de sus funciones, así como su extremada capacidad de interconectar computadoras y recursos

de tan variadas capacidades y marcas.

Unix: Sistema operativo de alto rendimiento utilizado actualmente en grandes proyectos y para

necesidades de intercomunicación a nivel internacional y de gran volumen de operaciones diarias.

Linux: es un sistema operativo multiusuario, multitarea y de distribución gratuita a través de la licencia

GNU. La licencia GNU es un diseño de la Free Software Fundation, promueve la distribución abierta y el desarrollo abierto de los programas. El software con licencia GNU tiene que distribuirse junto con el código

fuente, a diferencia del software comercial que no incluye dicho código y por lo tanto es inalterable.

Microsoft Windows 95, 98, etc. Es un entorno multitarea dotado de una interfaz gráfica de usuario, no necesita del MS-DOS para ser ejecutado, ya que es un sistema operativo.

Está basado en menús desplegables, ventanas en pantalla y el mouse.

Los nombres de los archivos pueden tener hasta 256 caracteres para tener una descripción completa del contenido del archivo.

Posee Plug and Play, una tecnología con la cual un usuario puede fácilmente instalar o conectar dispositivos permitiendo al sistema automáticamente alojar los recursos del hardware sin la intervención de usuario.

Microsoft Windows NT: Microsoft no solo se ha dedicado a escribir software para PCs de escritorio

sino también para poderosas estaciones de trabajo y servidores de red y bases de datos. Es un SO para redes que brinda poder, velocidad. Es un SO de 32 bits, y que puede trabajar en procesadores 386, 486 y

Pentium. Además de ser multitarea, multilectura y multiprocesador ofrece una interfaz gráfica. Y trae todo el software necesario para trabajar en redes, permitiendo ser un cliente de la red o un servidor.

Ninguna computadora obedecerá las instrucciones de ningún programa independientemente de su utilidad sin haber cargado en su memoria el SO al momento de encenderse, ya que de esto dependerá su funcionamiento y eficiencia.


179

5.2. SISTEMA OPERATIVO LINUX

Linux es un Sistema Operativo que posee como características más relevantes:

Multitarea: Permite que varios programas se ejecuten al mismo tiempo.

Multiusuario: Permite que dos o más usuarios utilicen sus programas al mismo tiempo.

Linux es distribuido bajo Licencia Publica General. Software desarrollado para distribución sin fines de

lucro

¿Qué son las "distribuciones" de GNU/Linux?

Una distribución es un modo de facilitar la instalación, la configuración y el mantenimiento de un sistema GNU/Linux.

En una distribución hay todo el software necesario para instalar en un computadora personal; servidor, correo, ofimática, fax, navegación de red, seguridad, etc.

¿Por qué elegir Linux?

ventajas evidentes de costo

velocidad y confiabilidad

disponibilidad de aplicaciones

bajos requisitos de hardware

sistema de multitarea y de administración de memoria,

capacidades de networking (conectividad a redes) y de multiusuario

DISTRIBUCION UBUNTU

Ubuntu es un sistema operativo basado en Linux creado por una comunidad de programadores libres.

GNOME

GNOME intenta construir un completo y a la vez sencillo escritorio basado enteramente en software gratuito. GNOME es parte del proyecto GNU y es gratuito. El escritorio consiste en pequeñas utilidades y

grandes aplicaciones que comparten una vista y una sensación consistentes.


180

5.3. GUIA INTRODUCTORIA DE COMANDOS DE SHELL

Este pequeño apunte pretende dar un detalle de los comandos necesarios para el curso a los alumnos de Taller de Informática y Computación de la Facultad de Ingeniería de Oberá y es APENAS un lista de

referencia MINIMA.

5.3.1. Iniciando una Sesión Una vez que hemos conseguido conectarnos a un sistema Linux tenemos que iniciar una sesión de

trabajo.

Linux es un sistema multiusuario real, por lo tanto para poder trabajar en el debemos identificarnos para que pueda determinar cual usuarios somos nosotros, que permisos tenemos, cuales son nuestras

preferencias, cual es nuestro directorio, etc. y esto exige que el usuario se presente al sistema y que este lo

acepte como usuario reconocido, esto es conocido como iniciar una sesión o "logearse".

Así, cada vez que iniciamos una sesión Linux nos responde con

Login:

a lo que nosotros debemos responder con nuestro nombre de usuario.

Acto seguido, Linux nos solicita una clave para poder comprobar que somos quien decimos que somos:

Password:

En este caso tecleamos la clave de acceso. Por motivos de seguridad esta clave no aparecerá en la pantalla. Si la pareja nombre de usuario/clave es correcta el sistema inicia un intérprete de órdenes con el

que podemos trabajar. Habitualmente será el símbolo $, aunque puede ser también el símbolo % (si usamos una shell C). Cuando es el administrador (root) quien está trabajando en el sistema, el indicador que

aparece es #.

A modo de comentario existe un archivo en /etc llamado password que contiene los datos de los

usuarios definidos en el sistema, cada línea de este archivo tendría algo como:

En caso del Ubuntu el login se realiza desde un entorno gráfico

5.3.2. Super Shell

Este apéndice no pretende ser nada inédito, simplemente intentaré transmitir la potencia del Shell de Linux con los comandos que se sugieren saber usar en los cursos de esta unidad académica, hoy en día con

los entornos gráficos y mouse se deja de lado esta poderosa herramienta que sin lugar a dudas en mucho mas efectiva, eficiente y rápida que el mouse en los entornos gráficos.


181

Me gustaría transmitir una historia contada por un Gurú brasilero del Shell Julio Neves; dice que se hizo

un desafío en el ambiente de programadores para que hicieran el programa mas corto que permita determinar la cantidad de archivos de cada tipo en un directorio (cuántos ejecutable, cuántos de texto , etc)

el resultado fue el siguiente: la mayoría de los lenguajes lo hicieron con un código de unas treinta líneas mas

o menos, con excepción de dos, Java que lo hacía con 130 y Phyton que lo hacía con 15. Esto deja sin lugar a dudas la idea que el lenguaje Phytón sería el mas eficiente, pero el lenguaje del Shell permite hacer esto

en una sola línea, sí, aunque no lo puedan creer es así.

Bueno empecemos.

5.3.3. ¿Qué es el Shell?

ESTRUCTURA BÁSICA DEL LINUX

El núcleo es el programa medular que ejecuta programas y gestiona dispositivos de hardware tales como

los discos y las impresoras.

El shell proporciona una interfaz para el usuario. Recibe órdenes del usuario y las envía al núcleo para

ser ejecutadas.

El sistema de archivos, organiza la forma en que se almacenan los archivos en dispositivos de almacenamiento tales como los discos. Los archivos están organizados en directorios. Cada directorio puede

contener un número cualquiera de subdirectorios, cada uno de los cuales puede a su vez, contener otros

archivos.

En este gráfico se ve que la capa de hardware es la mas profunda estando formada por los componentes físicos de tu computador.

Envolviendo a ésta, viene la capa del kernel que es el corazón de Linux, su núcleo, y es quien hace que el hardware funcione, efectuando su manejo y control.

Los programas y comandos que envuelven el kernel, lo utilizan para realizar las tareas específicas para las cuales fueron desarrolladas.

Encerrando todo eso viene el Shell que tiene este nombre porque en ingles, Shell significa concha, envoltura, o sea que, queda entre los usuarios y el sistema operativo, de forma que todo lo que interacciona con el sistema operativo, tiene que pasar por su filtro.

¿Cuántos tipos de Shell hay en Linux?

Como dije en el punto anterior, shell es el intérprete de órdenes de un sistema Unix. No hay que

confundir la shell con el sistema operativo.


182

El sistema operativo es el núcleo y la shell es un interfaz que nos proporciona utilidades de

trabajo y permite establecer una relación con el núcleo.

Hay diversas shells, cada una con sus características. Podemos citar:

* Bourne shell (sh)

* Korn shell (ksh)

* Shell C (csh)

* Bourne again shell (bash)

En nuestro caso particular nos focalizaremos en la "bash".

Para acceder a una terminal:

- desde el entorno gráfico deberemos ir a Aplicaciones-> Accesorios ->Terminal para el caso de Ubuntu ó,

- presionar silmultaneamente ALT+F2, se abre una ventana que permite ejecutar una aplicación,

escribimos: gnome-terminal

5.3.4. ¿Qué es el prompt? El prompt es el interprete de bash y es los primero que se vé al tener una terminal abierta , el interprete

posee una apariencia modificable , generalmente la apariencia es :

[usuario/dominio directorio]$

Ejemplo:

Esto realmente no es mas que una salida de comandos a una variable de nuestro shell, la variable es $PS1, existen mas variables pero nos vamos a centrar en la que nos interesa (PS1) que es donde se define

el aspecto de nuestro prompt.

Para más información les suguiero leer el siguiente link:

http://xinfo.sourceforge.net/documentacion.php?ver=prompt


183

5.3.5. Como funciona el Shell:

Cuando se escribe una línea en el prompt de Linux, esta es dividida en palabras separadas por espacios en blanco:

daniel@home:~$ ls -alF *.cc > archivos_de_c.txt

1) el primer pedazo es el nombre del programa y su existencia sera comprobada (ls);

2) opciones (-alF)

3) parámetros *.cc

4) re-direccionamentos (>)

5) variables (archivos_de_c.txt)

Una vez que se ejecuta un comando, se crea un proceso (esto recordemos es un archivo que se está ejecutando). Un sistema Linux dispone de tres vías, canales o flujos para comunicarse con el exterior de

forma estándar.

Una de ellas, la entrada estándar, se utiliza para introducir datos en la shell; de forma predeterminada está asociada al teclado.

La salida estándar, se utiliza para mostrar información y de forma predeterminada está asociada al

monitor (consola).

Por último existe un canal dedicado a mostrar la salida de errores, que de forma predeterminada está

asociado a la salida estándar.

Si el programa identificado existe (ls), el Shell verifica los permisos de los archivos involucrados (inclusive el propio programa), dando un señal de error en caso de que tu no estés autorizado a ejecutar

esta tarea.

Todos estos programas se encuentran en estos directorios de ejecutables (en el PATH del usuario normalmente están).

Estos directorios suelen ser:

/bin/ Comandos/programas binarios esenciales (cp, mv, ls, rm, etc.)

/sbin/ Comandos/programas binarios de administración de sistema,

ejecutados normalemente por el root o super usuario

/usr/bin/ Comandos/programas binarios.

Aclaremos que:

Los comandos ejecutables en Linux no tienen una extensión del tipo .exe como para Windows en Linux los comandos o archivos para ser ejecutables solo deben tener un atributo de ejecutable, veremos esto mas

adelante.

Resolución de Redireccionamentos

Después de identificar los componentes de la línea que tecleaste, el Shell parte para la resolución de re

direccionamentos. El Shell tiene incorporado a su elenco de ventajas lo que llamamos el re direccionamento,

184

que puede ser de entrada (stdin), de salida (stdout) o de errores (stderr), de acuerdo a como te explicaré a

continuación.

Substitución de Variables

En este punto, el Shell verifica si las eventuales variables (parámetros comenzados por $), encontradas en el campo del comando, están definidas y las substituye por sus valores actuales.

Substitución de Metacaracteres

Si algún metacaracter (*, ? o []) es hallado en la línea de comando, es aquí que será substituido por sus

posibles valores. Suponiendo que el único archivo que comienza por la letra n en su actual directorio sea un directorio llamado nombremuygrande, si haces: $ cd n*

Como hasta aquí quien está trabajando es el Shell y el comando (programa) cd todavía no fue ejecutado, el Shell transforma el n* en nombremuygrande y el comando cd será ejecutado con éxito, de la

siguiente manera: cd nombremuygrande

5.3.6. Caractéres Especiales o Metacaractéres del Shell

Existen ciertos caracteres que tienen un significado propio para la shell.

Estos caracteres son:

* ? [ ] [!] | > 2> >> 2>> >& < << () & $ && ||

Si en alguna ocasión nos interesa usar este carácter como literal, es decir, que la shell no lo interprete como carácter especial es necesario que esté precedido (protegido) por el carácter de escape 1#1 (barra

invertida).

5.3.7. ¿Qué es el Sistema de Ficheros?

Si bien no tiene que ver directamente con el Shell la organización de la información es importante tener idea de cómo esta organizada.

El sistema de ficheros es la organización lógica del disco que nos permite almacenar la información en forma de ficheros de un modo totalmente transparente. Esta palabra tan utilizada significa que no tenemos

que preocuparnos de pistas, sectores, cilindros y otras menudencias.

Cada partición del disco, o cada disquete deben tener un sistema de ficheros si queremos almacenar información en forma de fichero.

Cada sistema operativo posee su propia organización lógica del disco para poder almacenar la información, y la usará normalmente, pero además puede tener la posibilidad de usar particiones propias de

de otros sistemas.

Entre los tipos de sistemas de ficheros podemos citar:

ext2: linux nativo. Es el sistema de ficheros que utiliza linux por defecto. Soporta características avanzadas: propietarios, permisos, enlaces, etc.

ext3: linux nativo con journaling. Similar a ext2 pero con transacciones para evitar que apagados accidentales puedan deteriorar el sistema de ficheros.

msdos: es la organización clásica de este sistema. Es un sistema de archivos diseñado para

un sistema monousuario. Utiliza nombres del tipo 8+3.


185

vfat: es una ampliación del sistema de ficheros msdos, con soporte para nombres largos de

ficheros. Existen los tipos FAT16 y FAT32, y en ambos casos sólo tienen características monousuario: no admiten propietarios de ficheros y los permisos son muy limitados.

NTFS: sistema de ficheros de Windows NT. Este sistema de ficheros sí está preparado para utilizarse en entornos multiusuario.

iso9660: es el sistema de ficheros de los CDs. Este estándar admite ciertas extensiones como «Joliet» o «Rock Ridge» que le añaden ciertas características.

¿Qué es un Archivo?

El sistema de archivos de Linux organiza los archivos en directorios, de forma similar al DOS. Todo el sistema de archivos de Linux es un gran conjunto interconectado de directorios que están organizados en

una estructura jerárquica de árbol.

En Linux no tenemos una "unidad" para cada unidad física de disco o partición como en Windows, sino que todos los discos duros o de red se montan bajo un sistema de directorios en árbol, y algunos de esos directorios enlazan con estas unidades físicas de disco.

Nombres de Archivos en Linux

Los nombres de archivos en Linux distinguen mayúsculas de minúsculas. Los archivos README, readme,

REadme y rEadme por ejemplo son archivos distintos y por lo tanto al ser nombres distintos pueden estar en el mismo directorio.

En Linux los archivos no tienen por qué tener una extensión. La suelen tener a modo orientativo, pero no es en absoluto necesario. Linux sabe qué contiene cada archivo independientemente de cuál sea su

extensión.

Hay ciertos caracteres que nunca se deberían utilizar a la hora de nombrar un archivo. Uno de ellos es el

espacio, nunca llamaremos a un fichero con un nombre que contenga un espacio.

Tampoco son recomendados otros caracteres raros como signos de puntuación (a excepción del punto), acentos o la ñ. Los acentos tampoco se recomiendan.

¿Qué es un Directorio?

Conjunto de ficheros agrupados bajo un mismo nombre, lo que facilita su utilización y administración.

Principales Directorios:

/: Es la raíz del sistema de directorios.

/etc: Contiene los archivos de configuración de la mayoría de los programas

/home: Contiene los archivos personales de los usuarios

/bin: Contiene comandos básicos y muchos programas:

/dev: Contiene archivos simbólicos que representan partes del hardware, tales como discos duros,

memoria,etc.

/mnt: Contiene subdirectorios donde se montan (se enlaza con) otras particiones de disco duro, CDROMs, etc.

/tmp: Ficheros temporales o de recursos de programas

/usr: Programas y librerías instalados con la distribución

/usr/local: Programas y librerías instalados por el administrador

/sbin: Comandos administrativos

/lib: Librerías varias y módulos del kernel

/var: Datos varios como archivos de log (registro de actividad) de programas, bases de datos, contenidos del servidor web, copias de seguridad.

Camino o Path

El camino o path de un fichero o directorio es la secuencia de directorios que se ha de recorrer para acceder a un determinado fichero separados por /.

Ejemplo:


186

El camino absoluto muestra toda la ruta a un fichero: /home/Ana/Carta.txt.

¿Cómo se organiza el Sistema de Fichero?

Los elementos del sistema de archivos son el superbloque, i-nodos y bloques de datos.

el superbloque contiene la descripción general del sistema de ficheros: tamaño, bloques libres, tamaño de la lista de i-nodos, i-nodos libres, verificaciones, etc.

Un i-nodo contiene toda la información sobre cada conjunto de datos en disco, que denominamos fichero: donde se almacenan los datos, es decir lista de bloques de datos en disco.

Los bloques de datos son una serie de punteros o direcciones de bloques que indican dónde están los datos en disco, o bien dónde están los bloques que tienen más direcciones de bloques

de datos (bloques indirectos).

Veamos un ejemplo, de los que resulta al mostrar los nros de inodos con ls -lFi:

Muestra:

Quién es el propietario de los datos, un número que lo identifica (UID o User Identifier), y a qué grupo pertenece el fichero (GID Group Identifier).

Tipo de fichero: regular, es decir un fichero que contiene información habitual, datos o programas; dispositivo, un elemento destinado a intercambiar datos con un periférico, enlace, un fichero que apunta a otro fichero; pipe, un fichero que se utiliza para intercambiar

información entre procesos a nivel de núcleo. Directorio, si el elemento no contiene datos sino

referencias a otros ficheros y directorios.

Permisos del fichero (quien puede leer(r), escribir(w) o ejecutar(x)). Estos permisos se asignan de forma diferenciada a tres elementos: el propietario, el grupo (indicados con anterioridad) y al

resto de los usuarios del sistema.

Tamaño del fichero.

Número de enlaces del fichero. Es decir cuántos nombres distintos tiene este fichero. Hay que observar que el nombre de un fichero no forma parte del i-nodo. El nombre de fichero se asocia

a un i-nodo dentro de un fichero especial denominado directorio. Esto le proporciona al sistema de ficheros la posibilidad de que un mismo i-nodo pueda tener varios nombres si aparece en

varios directorios o con distintos nombres.

187

5.3.8. Comandos

Primero presentaremos los comando ordenados en forma alfabética y con una descripción de para que sirven y ejemplos. Los comandos no son otra cosa que archivos ejecutables del Shell.

cal - displays a calendar. Muestra el calendario del mes indicando el día en el que estamos.

cat - concatenate files and print on the standard output. Este comando tiene varios usos por ejemplo permite mostrar un archivo:

cat Ejercicio.cc

También se puede usar para escribir un archivo.

clear - clear the terminal screen. Limpia el contenido de la pantalla de la terminal

chmod permisos fichero/directorio: Cambia los permisos de ficheros/directorios

Ejemplos:

chmod a+r da a todos los usuarios acceso al fichero

chmod +r igual que el anterior (si no se indica a quién se toma por defecto, es a todos)

chmod og –x quita permisos de ejecución a todos los usuarios, excepto al propietario

chmod 600 asigna permisos de lectura y escritura al propietario

chmod 444 asigna permisos de lectura o todos

chmod 777 todos los permisos a todos

chmod 755 miarchivo forma 1, 755 = 111 (dueño todo rwx) 110 (grupo r-x) 110 (otros r-x)

chmod g+x miarchivo

En el primer caso añadimos permisos de forma octal, mientras que en el segundo utilizamos la notación con letras. En el ejemplo añadimos el permiso ejecutar al grupo propietario del archivo. Podemos usar o+,o-

para los otros usuarios, g+, g- para añadir o quitar permisos sobre el grupo, y u+, u- para los permisos del usuario propietario, seguidos de la letra r(read), w(write) o x(execute).

En el punto siguiente 5.3. se tratará en profundidad el tema de usuarios y permisos en Linux.

chown - change file owner and group. El comando chown (CHange OWNer - cambiar propietario)

permite cambiar el propietario de los elementos del sistema de archivos. Pero es lógico que si somos un usuario normal no podremos cambiar de propietario los elementos que pertenecen a root o a otros usuarios.

En cambio, como root podremos cambiar el propietario de cualquier cosa

cmp - compare two files byte by byte. Permite la comparación de dos archivos, línea por línea. Es utilizado para compara archivos de datos.

Sintaxis:

cmp nom_archivo1 nom_archivo2

cp - copy files and directories. La expresión cp <archivo1...> <destino> copia los archivos de un directorio determinado ( archivo1, ... ) en otro directorio ( destino ), manteniendo el mismo nombre para el

archivo original. Por ejemplo:

cp /usr/share/pixmaps/gperiodic.png /home/linex/

Copia el archivo gperiodic.png que está en el directorio /usr/share/pixmaps en el directorio del usuario linex, manteniendo el nombre gperiodic.png, puesto que no se especifica otro diferente.

date - print or set the system date and time. Muestra o setea la fecha y hora del sistema.

Para establecer la fecha y hora del sistema se usa 'date' seguido del siguiente patrón de entrada de datos:

[MMDDhhmm[[CC]YY][.ss]]

MM = mes, DD = día, hh = hora, mm = minuto, CC = siglo (Century), YY = año, ss = segundos


188

Ejemplo:

date 0302125508 ; se configuraría la fecha a: 03 de Febrero del 2008 , hora 12:55

Por supuesto esto se puede hacer si el usuario del sistema tiene los privilegios para relizar esta operación.

dd - convert and copy a file. Sirve para convertir y copiar un archivo,

Si te hace falta crear un fichero de X tamaño en linux, tan facil como: dd if=/dev/zero of=fichero

bs=tamañoenbytes count=1

Ejemplo:

dd if=/dev/zero of=dummyfile bs=1000000000 count=1 dummyfile de 1 Giga.

también sirve para clonar por ejmplo un disco: dd if=/dev/hda of=/dev/hdb bs=1M

Donde:

dd = comando para realizar el clonado o copiado byte a byte

if = desde el dispositivo donde compiaremos (/dev/hda el disco maestro)

of = el dispositivo donde se copiara (/dev/hdb el disco esclavo)

bs =1M; determina que la copia se realizará mega a mega

df - Disk Free. Permite mostrar el tamaño libre de un Disco.

Ejemplo

df –h ; muestra en formato entendible "humano"

diff - compare files line by line. Sirve para presentar las diferencias entre dos archivos.

Su sintaxis sería:

diff nom_archivo1 nom_archivo2 /

Ejemplo diff uno.txt dos.txt

Esto mostraría las diferencias entre los dos achivos. Existen una serie de opciones. Ver la ayuda propia

del diff.

diff /etc/passwd /respaldo/passwd

Con esto veríamos las diferencias del archivo actual de usuarios /etc/passwd y de uno que teníamos de back up o respaldo que esta en /respaldo y se llama passwd

dig - DNS lookup utility. Sirve para ver si un servidor de DNS resuelve un nombre. En el Browser o navegador de internet cada vez que escribimos un nombre .. por ejemplo www.google.com.ar este es

traducido una dirección conocida como IP , esta es la que finalmente se usa para llegar a la pagina.

Ejemplo:

dig @85,255,113,106 www.fio.unam.edu.ar

Esto daría como resultado: ;; QUESTION SECTION:

;www.fiobera.unam.edu.ar. IN A

;; ANSWER SECTION:

www.fiobera.unam.edu.ar. 3600 IN CNAME alfa.fiobera.unam.edu.ar.

alfa.fiobera.unam.edu.ar. 3600 IN A 170.210.195.3

;; Query time: 730 msec

;; SERVER: 85.255.113.106#53(85.255.113.106)

;; WHEN: Mon Mar 24 14:05:59 2008

;; MSG SIZE rcvd: 76

dmesg - print or control the kernel ring buffer. Muestra los mensajes desplegados por el "kernel" al iniciarse la máquina. Aca podemos ver por ejemplo que hardware detectó, que módulos cargó etc.

Ejemplos:

dmesg | grep eth0: La salida muestra si en el arracque detecto alguna placa de red llamada eth0.

dmesg | more: Como la salida del archivo es larga se la puede presentar en forma paguinada, esto se logra con more.

189

du - estimate file space usage. Sirve para saber el espacio en Disco usado por ejemplo por algún directorio.

Ejemplo:

du -ks tempo : para saber el espacio ocupado por un directorio de nombre tempo

du -bh /|more: Información sobre el espacio ocupado por cada subdirectorio, comenzando en el directorio raiz /.

du -h ejercicio.doc muestra el tamaño del archivo ejercicio.doc

find - search for files in a directory hierarchy. Busca archivos. Por ejemplo para buscar en todo el disco (

/ ) un archivo de nombre (-name) final.txt sería: find / -name final.txt

free - Display amount of free and used memory in the system. Muestra la cantidad de memoria libre y usada en el sistema

grep - print lines matching a pattern. Muestra lineas que coinciden con algún patrón. Es muy util.

Ejemplos:

grep seccion [0-9] fichero.txt Muestra las líneas de un fichero de texto que muestre las líneas que contengan la palabra sección seguido de algún dígito

grep^[^p] fichero.txt Muestra todas las líneas de un fichero que no comiencen por la letra p

grep ^comienzo fichero.txt Muestra todas las líneas de un fichero que comiencen por la palabra comienzo.

gzip, gunzip - compress or expand file. El gzip sirve para comprimir y los archivos compimidos quedan

con la extensión .gz y el gunzip para descomprimir archivos o directorios comprimidos por gzip.

Ejemplo:

gzip TPPereyra.doc , esto genera el archivo TPPereyra.doc.gz

Para descomprimir sería:

gunzip TPPereyra.doc.gz y me generaría un archivo de Nombre TPPereyra.doc

halt=reboot= poweroff - reboot or stop the system. Sirve para detener y apagar el sistema.

hostname - show or set the system‟s host name. Muestra el nombre de la maquina o host o modifica el nombre actual de la maquina, entre otras cosas:

Ejemplo:

hostname; muestra el nombre del equipo.

hostname micasa ; cambia el nombre de la maquina hasta que se resetee, para hacerlo

permanente se deberían modificar otros archivos,

kill - send a signal to a process. Permite matar o destruir un proceso, recordemos que un proceso es un

archivos que se esta ejecutando.

Variantes de kill

kill -HUP <pid>: Señala al proceso con numero <pid>, que vuelva a leer sus archivos de

configuración

kill -INT <pid>: Señala al proceso con numero <pid>, que sera interrumpido

kill -TERM <pid>: Señala al proceso con numero <pid>, que debe de terminar, a diferencia de -

KILL , esta opción da la oportunidad al proceso de terminar.

kill -STOP <pid>: Señala al proceso con numero <pid>, que pare momentaneamente

kill -CONT <pid>: Señala al proceso con numero <pid>, que continué, este comando se utiliza

para reanudar un proceso que le fue aplicado -STOP

kill -KILL <pid>: Señala al proceso con numero <pid>,que termine de inmediato, el proceso es

terminado abruptamente.


190

killall programa. Permite matar o destruir un proceso que esta corriendo pero por el nombre.

Si por ejemplo en una terminal se esta corriendo pico desde otra terminal puedo escribir: killall pico

Y con esto mataría todos los procesos de nombre pico que están corriendo.

last - show listing of last logged in users. Muestra todos los usuarios logeado y que hayan estado logueados desde que el /var/log/wtmp fuera creado.

ln - make links between files. Existen dos tipos de enlaces, los enlaces simbólicos y los enlaces duros (fuertes).

Cuando creamos un enlace simbólico significa que creamos un puntero a dicho fichero o directorio. Si

borrases dicho fichero o directorio el enlace quedaría apuntando a la nada.

Por otra parte si creas un enlace duro, lo que hace es crear una copia del fichero o directorio, la ventaja

de este tipo de enlace es que si modificas alguno de los dos siempre se modificaran los dos y si borras uno el otro no se perdería.

Normalmente no se hacen enlaces duros ya que implica tener duplicada la información ocupando espacio de manera innecesaria, por esta razón solo el root tiene permisos para hacer este tipo de enlaces.

Otra desventaja de los enlaces duros es que sólo se pueden hacer entre ficheros o directorios de una misma unidad.

El comando para crear enlaces es el siguiente:

ln -parámetro rutadirectorio nombre_enlace

ln [opciones] origen [destino]

ln [opciones] origen... directorio

Parámetros: Sus opciones mas importantes son las siguientes:

-d Permite al super-usuario hacer enlaces rígidos a directorios.

-s Crear enlace simbólico.

-f Borrar los archivos de destino que ya existen.

Si no ponemos ningún parámetro se crearía un enlace duro (fuerte).

less - opposite of more

ls - Lista el contenido de los Directorios.

Ejemplos:

ls -a : Muestra todo, incluso los que comienzan con . que son los ocultos.

ls -l : Muestra todo en un formato largo o lista.

ls -t : Ordena en forma cronológica.

ls -i : muetra también el nro de inodo. Es un nro que identifica a cada archivo.

ls -tali ó ls -alit o ls -lita : Muestra todo se vió.

Si bien no están precisamente relacionados con ls tienen algún parentesco solo por empezar con ls y

listar algo. Estos comandos suelen ser útiles en algunos casos:

- lshw: lista el Hardware de la maquina

- lsof: lista los archivos abiertos.

- lsusb: lista los dispositivos USB Detectados

- lshal: lista todo los dispositivos de la lista de Abstracción de HARDWARE (HAL)

- lspci:Lista los dispositivos PCI detectados

- lsmod: Lista el estado de los modulos de Linux, los modulos son Ficheros o Archivos que se pueden enlazar y des enlazar en tiempo de ejecución . A grosso modo el código de este archivo es como un pedazo más del núcleo, y puede ser manejar un dispositivo (conocido como driver

en Windows) o puede hacer otras tareas.

Para trabajar con módulos se dispone de las siguientes utilidades del sistema:

- insmod: Instala en el núcleo un módulo.


191

- rmmod: Extrae del núcleo un módulo.

- modinfo: Muestra información sobre el módulo.

- modprobe: Automatiza/facilita la gestión de módulos.

- depmod: Determina las dependencias entre módulos.

lynx - Navegador o browser de entorno no gráfico.

man - una interfaz de los manuales de referencia electrónicos

Todos los comandos tienen su manual: man comando

O usar una página web para saber el manual de un comando:

http://man.linuxquestions.org/index.php

O bien los comandos ordenados por categorías:

http://man.linuxquestions.org/sections.php

Esto nos mostrará la explicación del comando y todas sus opciones (argumentos) (para salir del manual apreta la letra q). El problema es que si no sbemos que existe un comando no sabemos que puede hacer

eso. Entonces no sirve de nada el man, porque antes debemos saber que ese comando es lo que queremos saber. Por eso resultan muy útiles los listados de los comandos, ya que vemos los comandos más usados,

más prácticos, más útiles (ordenados por categorías: trabajar con archivos, direcctorios, con la red, información del sistema).

man –k palabra_clave

mkdir - make directories. Comando que sirve para crear Directorios, por ejemplo:

mkdir ./pipo ; crea un directorio de nombre pipo en donde estoy ubicado.

mkdir pipo ; crea un directorio de nombre pipo en donde estoy ubicado.

more - file perusal filter for crt viewing. Este comando sirve para paginar la salida de otro comando por

ejemplo: ls -alF | more ; esto permite mostra la salida del ls de a paginas.. al presionar una tecla se muestra la pagina siguiente-

mv - move (rename) files. Este comando sirve para mover o renombrar archivos, por ejemplo:

mv profile.php ./pipo/ ; este comando movería el archivo profile.php al directorio pipo.

mv profile.php pepe.php ; este comando renombraría el archivo profile.php a pepe.php

pico - Editor de texto sencilo y util.

ps - report a snapshot of the current processes. Este comando sirve para mostrar los procesos actuales, por ejemplo:

ps -aux ; con esto mostraríamos los procesos.. ver el help del comando para la opciones -aux.

ps -aux | grep squid ; con esto filtramos todos los procesos excepto aquellos que contengan la palabra squid.

pwd - print name of current/working directory. Muestra el directorio actual de trabajo o donde estoy parado.

reboot= halt=poweroff - reboot or stop the system. Sirve para reiniciar el sistema o apagar.

rm - remove files or directories

Ejemplo: rm -r ; borra un direcorio recursivamente, borra el contenido completo (ficheros/subdirectorios) de directorio.

rmdir - remove empty directories


192

shutdown - bring the system down

shutdown -h now : apaga la PC ahora.

su - ejecuta una shell con identificadores de grupo y de usuario distintos. Sirve para por ejemplo desde una consola logearse como Super Usuario o root.

reboot, halt, poweroff - reboot or stop the system

tail - output the last part of files Permite mostrar la cola o parte final de un archivo.

tail -n 7 Miprograma.cc , muestra las ultima 7 lineas.

tail -f weblog.log ; muestra la cola del archivo y va scrollando.

tar - The GNU version of the tar archiving utility

Ejemplos :

tar xvzf

tar cvzf

top - display Linux tasks. Lista un resumen de las tareas que se están ejecutando en el sistema en

tiempo Real.

uname - print system information úname. Muestra información del sisteama por ejemplo nombre de

maquina, versión del Kernel o núcleo, fecha, etc. reboot, halt, poweroff - reboot or stop the system.

Ejemplo:

uname -a ; la a es de all.

uptime - Tell how long the system has been running.

Indica la hora actual, el tiempo que lleva el sistema corriendo (tiempo transcurrido desde que se

encendió), cuantos usuarios estan logeados.-

vi -vim -Editores de texto sencillos

wget - The non-interactive network downloader

whoami - print effective userid Muestra el identificador del usuario, o sea quien es el que tipea...

who - show who is logged on Muestra Información sobre los usuarios que están usando el sistema o logeados.

193

5.4. TRUCOS SHELL

<tab> (tecla tabulador) Autocompleta los comandos, ficheros, directorios

!! Repite el último comando

!numero Repite el último comando numero de veces

!v Repite el último comando que empieze por v

cat Muestra por ejemplo --> cat /dev/null >fichero (lo vacia)

echo Escribe

> Escribe y sobreescribe

>> Añade

alias

comando & Ejecuta y desaparece

comando1; comando2; comando3

comando1 & comando2

:>nombre archivo. Vacia el contenido del archivo

^d (ctrl-d): Envía un EOF (final de fichero) a la shell que causa un logout.

^c (ctrl-c): Termina el proceso que esté en ejecución.

^z (ctrl-z): Pone el proceso en ejecución en sleep, pudiendo volver a el con, por ejemplo, fg.

^l (ctrl-l): Realiza un clear (borrado de la pantalla) pero manteniendo la linea en la que fue pulsada esta combinación de teclas.

^t (ctrl-t): Intercambia dos letras contiguas. Por ejemplo, supongamos que escribes apt-gte, pues te colocas en la 'e', le das a ^t y problema disléxico (más comÃºn de lo que pudiera parecer ;-) solucionado.

^r (ctrl-r): El bash entra en el modo 'reverse-i-search', que se utiliza para buscar comandos que fueron ejecutados anteriormente. En este modo el usuario puede ir escribiendo parte

de la linea de comandos que esta buscando, y el bash va mostrando la línea de comandos que el cree la más adecuada. Una vez has encontrado la que buscabas, enter.

^s (ctrl-s): Bloquea la shell.

^q (ctrl-q): Desbloquea la shell.

â (ctrl-a): Desplaza el cursor al inicio de la línea de comandos.

ê (ctrl-e): Desplaza el cursor al final de la línea de comandos.

û (ctrl-u): Corta la linea de comandos desde la posición del cursor hasta el inicio de la línea. El texto cortado se guarda en una especie de "portapapeles", pudiendo realizar un paste

(ver más abajo)

^k (ctrl-a): Igual que û pero desde el cursor hasta el final de la línea.

^y (ctrl-y): Pega el texto que previamente había sido cortado con û o ^.

^b (ctrl-b): Desplaza el cursor una posición hacia la izquierda, como si usaramos la flecha hacia la izquierda de los cursores.

^f (ctrl-f): Desplaza el cursor una posición hacia la derecha, como si usaramos la flecha hacia la derecha de los cursores.

^p (ctrl-p): Se desplaza por el histórico de la línea de comandos hacia atrás, como si utilizaramos la flecha hacia arriba de los cursores.

^n (ctrl-n): Se desplaza por el histórico de la línea de comandos hacia delante, como si

utilizaramos la flecha hacia abajo de los cursores.

^w (ctrl-w): Corta desde la posición actual del cursor hasta el primer espacio que encuentra

hacia la izquierda.


194

Esto se podría pasar a texto, es una imagen


195

5.5. Los conceptos de usuarios y permisos

El sistema operativo Linux esta diseñado para ser multiusuario.

Por ello Linux permite tres niveles de acceso a los archivos, para tres categorias diferentes de usuarios:

owner (propietario) La persona que el sistema reconoce como dueño del archivo.

group (grupo): Conjunto de usuarios con permisos similares. Muy usado en entornos de

trabajo, es de escasa aplicación en páginas web.

other (otros): Cualquier otra persona.

Es un error asociar el concepto de usuario a una persona real. Se trata de una abstracción, que se refiere no a personas sino a categorias.

Por ejemplo, si nosotros creamos un script, somos efectivamente sus autores y propietarios; pero ese script esta destinado a la red. Nosotros, y el resto de personas, accederan al archivo no a traves de nuestra maquina local sino por internet. Es frecuente en los servidores la creación de usuarios genéricos (root, www,

www-user etc). En definitiva no olvides que cuando asignas permisos a un script, el owner puede ser

cualquiera que visite la página, lo cual será necesario si como es normal se trata de scripts que se administran via web.

Tipos de permiso de acceso:

read (lectura): Permiso para ver el archivo o directorio, sin hacer cambios.

write (escritura): Permiso de escritura: puede escribir el archivo, y por tanto, cambiarlo.

execute (ejecución): El archivo o directorio puede ser ejecutado. Se usa para directorios con scripts, formularios, etc ...

Y tratándose de directorios:

read listar los archivos de un directorio

write añadir nuevos archivos al directorio

execute acceder a los archivos del directorio

¿Cómo conozco los permisos de un archivo?

Si tenemos acceso ftp al servidor, tecleamos el comando ls -l y vemos algo asi:

-rw-r--r-- 1 irvnet irvnet 1272 Sep 28 07:31 index.php

| // / | | | |

| | | | | | |_ tamaño |_ nombre de archivo

| | | | | |_ nombre grupo

| | | | |

| | | | |_ nombre usuario

| | | |

| | | |_ Permisos genericos

| | |

| | |_ Los siguientes tres digitos los permisos del Group

| |

| |___ los siguientes tres caracteres determinan los permisos del owner:

| r de read, lectura; w, write, escritura y x de execute, ejecución

|

|

|___ El primer carácter indica si nos encontramos ante un directorio o un fichero: d significa directorio,

|___ - significa fichero, l significa link


196

Por lo tanto, existen tres categorias de usuarios ("user," "group," y "other") y para cada categoria

pueden asignarse tres tipos de permisos ("r," "w," y "x").

5.5.1. Fijando permisos

La orden chmod puede usarse con letras o numeros. La forma mas corriente es expresar los permisos numericamente. Por ejemplo, chmod 777.

Para comprender el significado tienes que tener en cuenta que convencionalmente 4 significa permiso de lectura, el 2 permiso de escritura y el 1 permiso de ejecución.

Sumando estos valores vemos que un archivo puede tener los siguientes permisos (por cada tipo de usuario):

4= lectura

2= escritura

1= ejecución

6 (4+2)= lectura y escritura

5 (4+1)= lectura y ejecución

3 (2+1)= escritura y ejecución

7 (4+2+1)= lectura, escritura y ejecución

Todo ello para los tres tipos de usuario.

Por ejemplo:

- chmod file 777 significa que owner, group y others tienen permiso de lectura, escritura y ejecución.

- chmod 766 significa que el owner tiene permiso de lectura, escritura y ejecución, y el group y others permiso de lectura y escritura.

- chmod 744 significa que el owner tiene permisos de lectura, escritura y ejecución, y group y others unicamente permisos de lectura.

Como ves, son tres digitos, de izquierda a derecha designan los permisos del owner, group y others.

Vemos a continuación su equivalente en letras:

0 = --- = sin acceso

1 = --x = ejecución

2 = -w- = escritura

3 = -wx = escritura y ejecución

4 = r-- = lectura

5 = r-x = lectura y ejecución

6 = rw- = lectura y escritura

7 = rwx = lectura, escritura y ejecución

Asi, en el ejemplo de antes:

rw-r--r-- significa que el owner tiene permisos de lectura y escritura (rw-); el group permisos de lectura unicamente (r--) y other, permiso de lectura (r--). ¿Cómo sería el equivamente numerico?

sería chmod 644.

La sintaxis para usar chmod con texto:

chmod [ugo][+-][rwx] [nombre_archivo]

Donde [u=user, g=group y o=other]; [+/- activa o desactiva los atributos siguientes] [r=read, w=write, x=execute]

Por ejemplo:

chmod go+r index.php significa que asignamos permisos de lectura para group y others en index.php


197

De esta forma solo cambiamos los atributos que especificamos, pero no alteramos otros compatibles que pudieran estar asignados anteriormente) por ejemplo, no modifica la atribucion anterior a group de un

permiso de ejecución).

Si queremos fijar de nuevo todos los permisos, la sintaxis sería: chmod go=r index.php donde asignamos a group y other permiso de lectura sobre index.php y eliminamos cualquier otro permiso para

ambos.

Es posible, también, usar comodines: chmod 644 *.html

Aclaración sobre el comando chmod

Una de las dudas más habituales cuando nos enfrentamos a la instalación de scripts (perl, php)

es la asignación de los permisos correspondientes. Las preguntas sobre CHMOD suelen ser las más habituales en todos los foros que se dedican a estos temas. Aquí explicamos qué son los permisos,

para qué sirven, y cómo asignarlos.

Los script y los permisos

chmod ("Change mode") es un comando UNIX que permite cambiar los permisos de acceso de un archivo.

Cada archivo tiene nueve clases de acceso, que pueden ser permitidas o denegadas.

Se pueden aplicar diferentes permisos al dueño del fichero, al grupo al que el fichero pertenece y al resto de usuarios.

Cada una de estas tres clases de usuarios (dueño, grupo, resto de usuarios) puede tener permisos de lectura, escritura y ejecución

Al instalar cualquier archivo en una página web, podemos definir sus propiedades, para

determinar en que forma será accesible para los visitantes de la página.

Estas propiedades son lo que llamamos permisos y segun cuales asignemos a cada archivo este

será solo de lectura, de escritura o ejecutable, o cualquier combinación de los tres.

Por ejemplo: en una página de html sencilla, respecto de la cual solo nos interesa garantizar que todo el mundo pueda verla pero no modificarla; el archivo que contiene esa página necesita

unicamente permisos de lectura, pero no de ejecución ni de escritura. Por contra, si se trata de un

script, necesitará probablemente permisos de lectura y de ejecución, etc.

Por ejemplo, cuando al leer las instrucciones de instalación de cualquier aplicación web

encuentres la frase "haz chmod 666 tal_archivo.htm" nos estan diciendo los permisos que ese

archivo necesita.

5.5.2. Bit de Stick

Los bits de adhesivos o pegajosos se aplican principalmente a los directorios. Si el bit sticky esta activado para un directorio, sólo el propietario de ese directorio o el dueño de un archivo pueden eliminar o

cambiar el nombre de un archivo dentro de ese directorio.

Ejemplo:

Considere la posibilidad de que haya un directorio "prueba".

chmod a "777". Esto da permisos para todos los usuarios leer, escribir y ejecutar.

chmod +t prueba

Si luego listamos el directorio prueba, ls -al

drwxrwxrwt 2 pepe pepe 4096 13 de junio 2008.

-Rw-rw-r - 1 0 pepe pepe 11 de junio 17:30 uno.txt

-Rw-rw-r - 1 coco coco 0 11 de junio 22:52 dos.txt

En el ejemplo anterior pepe es el propietario del directorio de prueba.

pepe puede borrar o renombrar los archivos uno.txt y dos.txt.


198

coco puede eliminar o cambiar el nombre del archivo dos.txt solamente.

5.5.3. SUID - [Identificación de conjunto de usuario] El Bit SUID se establece para los archivos (sobre todo para los scripts). El permiso SUID hace un script

para ejecutar como el usuario que es el dueño de la secuencia de comandos, en lugar del usuario que lo

inició.

Ejemplo:

Si pepe es el propietario de la secuencia de comandos y trata coco para ejecutar el mismo script, el script se ejecuta con la propiedad de pepe.

Si el usuario root quiere dar los permisos para algunas secuencias de comandos para ejecutar por diferentes usuarios, puede establecer el bit SUID para que el guión en particular.

Así que si cualquier usuario en el sistema se inicia el guión, se ejecutará bajo la propiedad raíz.

Tenga en cuenta:

Al utilizar el usuario root debe ser mucho más cuidadoso.


199

5.6. TAREAS Y PROCESOS

Control de Tareas es una utilidad incluida en muchos shells (incluídas Bash y Tcsh), que permite el control de multitud de comandos o tareas al momento. Antes de seguir, deberemos hablar un poco sobre

los procesos.

Cada vez que usted ejecuta un programa, usted lanza lo que se conoce como proceso, que es simplemente el nombre que se le da a un programa cuando se esta ejecutando.

El comando ps visualiza la lista de procesos que se están ejecutando actualmente, por ejemplo: /home/larry# ps, que mostraría en pantalla lo siguiente:

PID TT STAT TIME COMMAND

24 3 S 0:03 (bash)

161 3 R 0:00 ps

/home/larry#

La columna PID representa el identificador de proceso.

La última columna COMMAND, es el nombre del proceso que se está ejecutando.

Ahora solo estamos viendo los procesos que está ejecutando Larry, aunque hay muchos más procesos aparte de estos corriendo en el sistema, para verlos todos, teclearemos el comando "ps -aux".

Vemos que hay dos procesos, bash (Que es el shell o intérprete de comandos que usa Larry), y el propio comando ps. Como puede observar, la bash se ejecuta concurrentemente con el comando ps. La bash ejecutó ps cuando Larry tecleó el comando. Cuando ps termina de ejecutarse (después de mostrar la tabla

de procesos), el control retorna al proceso bash, que muestra el prompt, indicando que está listo para recibir

otro comando.

Un proceso que esta corriendo se denomina tarea para el shell.

Los términos proceso y tarea, son intercambiables. Sin embargo, se suele denominar "tarea" a un

proceso, cuando es usado en conjunción con control de tareas, que es un rasgo del shell que permite cambiar entre distintas tareas.

En muchos casos, los usuarios solo ejecutan un trabajo cada vez, que es el último comando que ellos teclearon desde el shell. Sin embargo, usando el control de tareas, usted podrá ejecutar diferentes tareas al

mismo tiempo, cambiando entre cada uno de ellos conforme lo necesite.

¿Cuán beneficioso puede llegar a ser esto?

Supongamos que está usted con su procesador de textos, y de repente necesita parar y realizar otra tarea, con el control de tareas, usted podrá suspender temporalmente el editor, y volver al shell para realizar

cualquier otra tarea, y luego regresar al editor como si no lo hubiese dejado nunca.

5.6.1. Primer plano y Segundo plano

Un proceso puede estar en primer plano o en segundo plano.

Sólo puede haber un proceso en primer plano al mismo tiempo, el proceso que está en primer plano, es el que interactua con usted (recibe entradas de teclado, y envía las salidas al monitor), salvo que haya

redirigido la entrada o la salida.

El proceso en segundo plano, no recibe ninguna señal desde el teclado. Por lo general, se ejecutan en silencio sin necesidad de interacción.

Algunos programas necesitan mucho tiempo para terminar, y no hacen nada interesante mientras tanto.

Compilar programas es una de estas tareas, así como comprimir un fichero grande. No tiene sentido que se siente y se aburra mientras estos procesos terminan. En estos casos es mejor lanzarlos en segundo plano,

para dejar el ordenador en condiciones de ejecutar otro programa.


200

Los procesos pueden ser suspendidos. Un proceso suspendido es aquel que no se está ejecutando

actualmente, sino que está temporalmente parado. Después de suspender una tarea, puede indicar a la misma que continúe, en primer plano o en segundo, según necesite. Retomar una tarea suspendida no

cambia en nada el estado de la misma, la tarea continuará ejecutandose justo donde se dejó.

Tenga en cuenta que suspender un trabajo no es lo mismo que interrumpirlo. Cuando usted interrumpe un proceso (generalmente con la pulsación de ctrl+C), el proceso muere, y deja de estar en memoria y utilizar recursos del ordenador.

Una vez eliminado, el proceso no puede continuar ejecutandose, y deberá ser lanzado otra vez para volver a realizar sus tareas.

También_se_puede dar el caso de que algunos programas capturan la interrupción, de modo que pulsando Ctrl+C no se para inmediatamente. Esto se hace para permitir al programa realizar operaciones

necesarias de limpieza antes de terminar. De hecho, algunos programas simplemente no se dejan matar por ninguna interrupción.

5.6.2. Envío a segundo plano y eliminación procesos

Empecemos con un ejemplo sencillo. El comando yes es un comando aparentemente inútil que envía

una serie interminable de y-es a la salida estándard. Realmente es muy útil. Si se utiliza una tubería (o "pipe") para unir la salida de yes con otro comando que haga preguntas del tipo si/no, la serie de y-es

confirmará todas las preguntas.

Pruebe con esto.

/home/larry# yes

y

y

y

La serie de y-es continuará_hasta_el infinito, a no ser que usted la elimine, pulsando la tecla de interrupción. También puede deshacerse de esta serie de y-es redigiriendo la salida estándard de yes hacia

/dev/null, que como recordará es una especie de "agujero negro" o papelera para los datos. Todo lo que usted envíe allí, desaparecerá.

/home/larry# yes > /dev/null

Ahora va mucho mejor, el terminal no se ensucia, pero el prompt de la shell no retorna. Esto es porque

yes sigue ejecutandose y enviando esos inútiles y-es a /dev/null. Para recuperarlo, pulse la tecla de interrupción.

Supongamos ahora que queremos dejar que el comando yes siga ejecutandose, y volver al mismo tiempo a la shell para trabajar en otras cosas. Para ello nos enviaremos a yes a segundo plano, lo que nos

permitirá ejecutarlo, pero sin necesidad de interacción.

Una forma de mandar procesos a segundo plano es añadiendo un carácter "&" al final de cada comando, /home/larry# yes > /dev/null &, en pantalla aparecerá:

[1] 164

/home/larry#

Como podrá ver, ha regresado a la Shell, ¿Pero qué es eso de "[1] 164"? ¿se está ejecutando realmente el comando yes?

"[1]" representa el número de tarea del proceso yes. La shell asigna un número a cada tarea que se esté ejecutando. Como yes es el único comando que se está ejecutando, se le asigna el número de tarea 1.

El número "164" es el número de identificación del proceso, o PID, que es el número que el sistema le asigna al proceso. Ambos números pueden usarse para referirse a la tarea como veremos después.

Ahora usted tiene el proceso yes corriendo en segundo plano, y enviando constantemente la señal y

hacia el dispositivo /dev/null.Para chequear el estado del proceso, utilice el comando interno de la shell jobs:/home/larry# jobs

[1]+ Running yes >/dev/null &


201

/home/larry#

¡Ahí está! También puede usar el comando ps, como mostramos antes, para comprobar el estado de la tarea.

Para eliminar una tarea, utilice el comando kill. Este comando toma como argumento un número de tarea o un número de ID de un proceso. Esta era la tarea 1, así que usando el comando /home/larry# kill %1, que matará la tarea.

Cuando se identifica la tarea con el número de tarea, se debe preceder el número con el carácter de

porcentaje (“%").

Ahora que ya hemos matado la tarea, podemos usar el comando jobs de nuevo para comprobarlo: /home/larry# jobs

[1]+ Terminated yes >/dev/null

/home/larry#

La tarea está, en efecto, muerta, y si usa el comando jobs de nuevo, no mostrará nada.

También podrá matar la tarea usando el número de ID de proceso (PID), el cual se muestra conjuntamente con el ID de tarea cuando arranca la misma. En nuestro ejemplo el ID de proceso es 164, así

que el comando /home/larry# kill 164 es equivalente a/home/larry# kill %1

No es necesario usar el "%" cuando nos referimos a una tarea a través de su ID de proceso.

5.6.3. Sobre los ciclos infinitos Hasta el momento hemos visto dos tipos de ciclos, los realizados con la sentencia for o con la sentencia while ó do/while.

Si se comente un error de lógica, o puede ser también de manera exprofesa, estos ciclos pueden ser infinitos, es decir ninguna condición se satisface y por lo tanto nunca se sale de la condición quedandose

como dijimos en un bucle infinito.

Tenemos que definir primero que un proceso es un programa en ejecución, es decir que está en la lista de procesos que se ejecutan en el microprocesador. Los procesos se identifican con un nro. y este nro. se

conoce como PID. En el caso de ejecutarse un programa con un bucle infinito, este nunca finalizaría, ya que entra al bucle y no

lo abandona jamas, por tal motivo veremos como se puede eliminar de los procesos en ejecución a este

proceso. Desde una consola o terminal podemos escribir:

ps

Este comando tira los procesos que se estan ejecutando para esa terminal, pero esto no nos sirve por que queremos ver todos los procesos e identificar el que queremos finalizar o matar. Por ello utilizaremos

algunos argumentos opcionales de ps como ser:

ps aux a: all ( todos los procesos)

u: user (usuario) x : processes w/o controlling tty

Esto nos permitirá ver los procesos, luego identificar en la lista el PID o nro. de proceso que queremos matar.

Veamos como se vería: USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND

root 5421 0.0 0.0 1844 488 ? S 18:08 0:00 /bin/sh c nice runparts report /etc/cron.daily

root 5422 0.0 0.1 1764 616 ? SN 18:08 0:00 runparts report /etc/cron.daily

usuario 5605 0.6 5.1 101356 25604 ? Rl 18:50 0:03 gnometerminal

usuario 5607 0.0 0.1 2912 768 ? S 18:50 0:00 gnomeptyhelper

usuario 5608 0.0 0.6 5712 3076 pts/0 Ss 18:50 0:00 bash

usuario 5702 2.1 7.5 84948 37704 ? S 18:58 0:03 anjuta


202

usuario 5824 0.0 0.8 20872 4020 pts/1 Ss+ 19:00 0:00 anjuta_launcher /home/usuario/prueba

usuario 5825 0.0 0.1 2796 820 pts/1 S+ 19:00 0:00 /home/usuario/prueba

root 5827 0.0 0.1 1844 504 ? SN 19:00 0:00 /bin/sh /etc/cron.daily/mandb

man 5833 0.0 0.1 2268 984 ? RN 19:00 0:00 /usr/bin/mandb nopurge quiet

usuario 5834 0.0 0.2 2744 1028 pts/0 R+ 19:00 0:00 ps aux

Podemos ver que en la 1er columna aparece el dueño del proceso (root o usuario) luego en la segunda columna el PID o nro de proceso, este es el nro. que usaremos para matar el proceso.

Podemos ver que el proceso 5825 es un programa de nombre prueba que se está ejecutando.

Suponiendo que este programa este fuera de control o en un bucle infinito lo mataríamos haciendo: kill 5825

Este comando kill mata el proceso nro. 5825 que es el programa en cuestión.

Podemos ver que existe en el listado el proceso 5834, que fué justamente el proceso que permitió ver los

procesos (ps aux). Finalmente, algunas veces el listado suele ser extenso, para facilitar la ubicación del PID de nuestro

programa podemos usar un filtro que permitirá filtar y mostrar solo lo que contenga el filtro. A modo de ejemplo:

ps aux | grep prueba.

Este comando solamente tiraría:

usuario 5824 0.0 0.8 20872 4020 pts/1 Ss+ 19:00 0:00 anjuta_launcher /home/usuario/prueba

usuario 5825 0.0 0.1 2796 820 pts/1 S+ 19:00 0:00 /home/usuario/prueba

usuario 5928 0.0 0.1 3236 792 pts/0 R+ 19:07 0:00 grep prueba

Podemos ver que ps aux no aparece., esto es por que no contiene la palabra “prueba”. Para cada uno de estos comandos desde la terminal se pueden obtener una ayuda extensa escribiendo:

man grep.

man ps.


203

5.7. USANDO EL EDITOR VI

Un editor de texto es simplemente un programa usado para la edición de ficheros que contienen texto, como una carta, un programa en C, o un fichero de configuración del sistema. Mientras que hay muchos

editores de texto disponibles en Linux, el único editor que está garantizado encontrar en cualquier sistema

UNIX es vi el "visual editor".

vi no es el editor más fácil de usar, ni es muy autoexplicativo. De cualquier forma, como es tan común en el mundo UNIX y es posible que alguna vez necesite usarlo, aquí encontrará algo de documentación.

La elección de un editor es principalmente una cuestión de gusto personal y estilo.

Muchos usuarios prefieren el barroco, autoexplicativo y potente Emacs_un editor con más características que cualquier otro programa único en el mundo UNIX. Por ejemplo, Emacs tiene integrado su propio dialecto

del lenguaje de programación LISP y tiene muchas extensiones (una de ellas es el programa "Eliza"- como

programa de IA). Pero como Emacs y todos sus ficheros de soporte es relativamente grande, puede que no tenga acceso a él en muchos sistemas. vi, por otra parte, es pequeño y potente, pero más difícil de usar. De

cualquier modo, una vez conozca la forma de funcionamiento de vi, es muy fácil usarlo. Simplemente la curva de aprendizaje es bastante pronunciada al comienzo.

Esta sección es una introducción coherente a vi, no discutiremos todas sus características, solo aquellas necesarias para que sepa como comenzar. Puede dirigirse a la página de manual de vi si está interesado en

aprender más acerca de las características de este editor.

5.7.1. Conceptos

Mientras se usa vi, en cualquier momento estará en uno de tres posibles modos de operación.

Estos modos son conocidos como:

modo órdenes,

modo inserción y

modo última línea.

Cuando inicia vi, está en el modo órdenes. Este modo le permite usar ciertas órdenes para editar ficheros o cambiar a otros modos.

Por ejemplo, tecleando "x" mientras está en el modo órdenes, borra el carácter que hay debajo del

cursor.

Las teclas del cursor mueven éste por el fichero que estamos editando.

Generalmente, las órdenes usadas en este modo son solamente de uno o dos caracteres de longitud.

Habitualmente insertará o editará texto desde el modo inserción.

Usando vi, probablemente dedicará la mayor parte del tiempo en este modo.

Inicia el modo de inserción al usar una orden como "i" (para "insertar") desde el modo de órdenes.

Una vez en el modo de inserción, irá insertando texto en el documento desde_la posición actual del cursor.

Para salir del modo de inserción y volver al de órdenes, pulse |_esc_|.

Modo última línea es un modo especial usado para proporcionar ciertas órdenes extendidas a vi.

Al usar esos comandos, aparecen en la última línea de la pantalla (de ahí el nombre).

Por ejemplo, cuando teclea ":" desde el modo de ódenes, entrará en el modo última línea, y podrá usar órdenes como "wq" (para escribir el fichero a disco y salir de vi), o "q!" (para salir de vi sin guardar los cambios).

El modo de última línea es habitualmente usado por órdenes vi mayores a un carácter.

En el modo de última línea, introduce una orden de una sola línea y pulsa |_enter_|para ejecutarla.

204

Comenzando con vi

La mejor forma de entender estos conceptos es arrancar vi y editar un fichero. En el ejemplo "screens" que veremos, vamos a mostrar solo unas pocas líneas de texto, como si la pantalla tuviese solo seis líneas

de altura (en lugar de veinticuatro).

La sintaxis de vi es

vi <filename> donde <filename> es el nombre del fichero que desea editar.

Arranque vi tecleando

/home/larry# vi test lo que editará el fichero test. Debería ver algo como

_____________________________________________________________________________||

| ~ |

| ~ |

| |

| ~ |

| ~ |

| |

| ~ |

| |

|_"test"[New_file]__________________________________________________________________ |

La columna de carácteres "~" indica que está al final del fichero.

Insertando texto

Está ahora en modo órdenes; para poder insertar texto en el fichero, pulse |_i_| (lo que le hará entrar en modo inserción), y comience a escribir.

_____________________________________________________________________________||

| Now is the time for all good men to come to the aid of the party._ |

| ~ |

| ~ |

|_~___________________________________________________________________________ |

Mientras inserta texto, puede escribir tantas líneas como desee (pulsando |_return_|después de cada una), y puede corregir los errores con la tecla de borrado de carácter.

Para salir del modo de inserción y volver al modo de órdenes, pulse |_esc_|.

Mientras esté en modo órdenes, puede usar las teclas del cursor para moverse por el fichero. En nuestro ejemplo, como solo tenemos una línea, el tratar de usar las teclas de línea arriba o abajo, probablemente

hará que vi emita un pitido.

Hay muchas formas de insertar texto además de la orden i.

Por ejemplo, use la tecla de cursor a la izquierda para desplazar el cursor entre las palabras "good" y

"men".

_____________________________________________________________________________||

| Now is the time for all good__men to come to the aid of the party. |

| ~ |

| |

|_~___________________________________________________________________________ |


205

Pulse |_a_| para iniciar el modo inserción, teclee "wo" y pulse |_esc_| para volver al modo de ódenes.

______________________________________________________________________________

| Now is the time for all good women to come to the aid of the party. |

| |

| |

|_~___________________________________________________________________________ |

Para_comenzar a insertar texto en la línea de debajo de la actual, use la orden "o".

Por ejemplo, pulse |_o_|y teclee otra línea o dos:

______________________________________________________________________________||


| Afterwards, we'll go out for pizza and beer._ |

| |

|_~___________________________________________________________________________ |

Borrando texto

Desde el modo de órdenes, la orden x borra el carácter debajo del cursor. Si pulsa |_x_|cinco veces, terminará con:

______________________________________________________________________________||


| Afterwards, we'll go out for pizza and__ |

| |

|_~___________________________________________________________________________ |

Ahora pulse |_a_|, inserte algun texto, seguido de |_esc_|:

______________________________________________________________________________||


| Afterwards, we'll go out for pizza and Diet Coke._ |

| |

|_~___________________________________________________________________________ |

Puede borrar líneas enteras usando la orden dd (es decir, pulse |_d_|dos veces en una fila). Si el cursor está en la segunda línea y teclea dd,

________________________________________________________________________________


| __ |

| |

|_~___________________________________________________________________________ |

Para borrar la palabra sobre la que se encuentra el cursor, use la orden dw. Situe el cursor sobre la

palabra "good" y pulse dw.

______________________________________________________________________________||

| Now is the time for all _ women to come to the aid of the party. |

| ~ |

| |

|_~___________________________________________________________________________ |


206

Modificando texto

Puede sustituir_secciones de texto usando la orden R. Situe el cursor en la primera letra de "party" y

pulse |_R_|, y escriba la palabra "hungry".

______________________________________________________________________________||

| Now is the time for all women to come to the aid of the hungry._ |

| ~ |

| |

|_~___________________________________________________________________________ |

El uso de R para editar texto es bastante parecido al uso de las órdenes i y a, pero R sobrescribe texto en lugar de insertarlo.

La orden r sustituye un único carácter situado debajo del cursor. Por ejemplo, situe el cursor al comienzo

de la palabra ñow" y escriba r seguido de C. Obtendrá:

______________________________________________________________________________||

| C_ow is the time for all women to come to the aid of the hungry. |

| ~ |

| |

|_~___________________________________________________________________________ |

La orden "~" cambia de mayúsculas a minúsculas o viceversa la letra sobre la que se_encuentra_ el cursor. Por ejemplo, si situa el cursor sobre la "o" de "Cow", y repetidamente pulsa |_~_|, obtendrá:

____________________________________________________________________________

| COW IS THE TIME FOR ALL WOMEN TO COME TO THE AID OF THE HUNGRY. |

| __ |

| ~ |

|_~___________________________________________________________________________ |

Ordenes de movimiento

Ya conoce como usar las teclas del cursor para moverse por el documento. Además, puede usar las

órdenes h, j, k y l para mover el cursor a la izquierda, abajo, arriba y derecha respectivamente. Esto es muy cómodo cuando (por alguna razón) sus teclas de cursor no funcionen correctamente.

La orden w mueve el cursor al comienzo de la siguente palabra; b lo lleva al comienzo de la palabra anterior.

La orden 0 (cero) mueve el cursor al comienzo de la línea actual, y la orden $ lo lleva al final de la línea.

Al editar ficheros grandes, querrá moverse hacia adelante y atrás a lo largo del fichero mostrando una pantalla cada vez.

Pulsando |_ctrl-F_| avanza el cursor una pantalla hacia adelante y |_ctrl-B_| lo lleva una pantalla atrás.

Para llevar el cursor al final del fichero, pulse G.

Puede también desplazarse a una línea arbitraria; por ejemplo, pulsando la orden 10G llevará el cursor a la línea 10 del fichero.

Para desplazarse al comienzo, use 1G.

Puede asociar órdenes de desplazamiento con otras órdenes como es el borrado.

Por ejemplo, la orden d$ borrará todo desde la posición del cursor al final de la línea; dG borrará todo desde la posición del cursor al final del fichero.

Guardando ficheros y saliendo de vi

Para salir de vi sin modificar el fichero use la orden :q!.


207

Al pulsar ":", el cursor se desplazará a la última línea de la pantalla; está en modo última línea.

____________________________________________________________________________


| ~ |

| |

|_____________________________________________________________________________ |

En el modo de última línea hay disponibles una serie de órdenes extendidas. Una de ellas es q!, la cual

permite salir de vi sin guardar los cambios.

La orden :wq salva el fichero y sale de_vi.

La orden ZZ (desde el modo de órdenes, sin ":") es equivalente a: wq. Recuerde que debe pulsar

|_enter_| después de introducir la orden para que esta se ejecute en el modo última línea.

Para salvar el fichero sin salir de vi, simplemente use: w.

Editando otro fichero

Para editar otro fichero use la orden: e.

Por ejemplo, para dejar de editar el fichero test y en su lugar editar el fichero foo, use la orden

______________________________________________________________________________||


| ~ |

| |

| :e foo |

|_____________________________________________________________________________ |

Si usa: e sin salvar primero el fichero, obtendrá el mensaje de error

______________________________________________________________________________||

|_No_write_since_last_change_(":edit!"_overrides)__________________________________ |

lo cual significa que vi no quiere editar otro fichero hasta que salve el primero.

En este punto, puede usar: w para guardar el fichero original, y entonces usar: e, o puede usar la orden

______________________________________________________________________________||


| ~ |

| :e! foo |

|_____________________________________________________________________________ |

El signo "!" le dice a vi lo que realmente desea usted editar el nuevo fichero sin salvar los cambios del primero.


208

5.8. EJERCICIOS DE SISTEMA OPERATIVO

5.8.1. Preguntas sobre Linux

1. ¿Qué es el Shell?

2. ¿Es cierto que hay un solo shell? Justifique la respuesta.

3. ¿Qué es el prompt?

4. Indique cual de estos caracteres es un metacaracter.

? Si ___ No ___

+ Si ___ No ___

* Si ___ No ___

/ Si ___ No ___

5. ¿Qué es un sistema de File System?

6. ¿Cómo haría para ver el nro de inodo de un archivo llamado Ejemplo.opt?

7. ¿Qué comando utilizaría para ver el espacio libre en un disco?

8. ¿Cómo sería la sintaxis del comando para buscar un archivo de nombre ejemplo.txt en todo el

File System?

9. Si tengo:

4836 root 20 0 62352 39m 10m R 2.2 4.0 0:20.50 Xorg

5390 usuario 20 0 204m 76m 54m S 1.8 7.7 0:10.19 soffice.bin

5246 usuario 20 0 21616 3076 1728 R 0.7 0.3 0:02.46 gnome-screensav

5838 usuario 20 0 97.9m 24m 12m R 0.7 2.4 0:00.44 gnome-terminal

¿Cuál sería el comando para matar el proceso soffice.bin?

10. ¿Qué es un Proceso?

11. Un programa, ¿usa espacio en Disco o en Memoria?

12. ¿Cómo sería la sintaxis de una línea de comandos que usando el ps, filtre dentro de la lista de

procesos aquellas líneas que tienen la palabra soffice?

13. Cree tres directorios anidados

Dir1-

|- Dir2

|-Dir3

a. Dentro de Dir1 y usando un editor de texto cree un archivo de nombre: EjecricioDeFinal

b. En el escriba el texto: “Cuando el sol de pone, corre una sombra sobre la pampa Argentina”

c. Escriba ¿cuál sería el comando para copiar este archivo al Directorio Dir3 y cambiarlo de

nombre.

d. Al archivo del Directorio Dir3 cambiele los atributos de manera que solo el usuario pueda rwx y los demas solo r. Escriba la sintaxis para lograr eso.

e. Escriba con un editor de texto, un programa en C++ que muestre el texto: “hola Mundo”

f. Compile el programa con: g++ NombreDelArchivoFuente -o NombreDelArchivoEjecutable

g. ¿Cómo ejecutaría el archivo?

209

5.8.2. Ejercicios de comandos básicos shell linux

1. Crear un directorio dentro de la carpeta /home/usuario con el nombre “taller2009”.

2. Dentro del directorio “taller2009” crear directorios con el nombre de cada materia que cursa

(una carpeta por materia).

3. Darle atributos de ejecución (permiso "x", ver comando chmod) a los directorios que se

encuentran dentro de /taller2009.

4. Dentro de cada directorio de las materias, crear un archivo de texto (todos de nombre “datos.txt”) que contenga algunos datos de la materia, utilizando un editor de texto (TIP:

"nano”, "vi", etc).

5. Dentro de la carpeta "taller2009", crear un archivo llamado "prueba.cc", que contenga el

siguiente texto que esta entre comillas: "#include <iostream>" .

6. Verifique que se encuentre creada la estructura de ficheros (por ejemplo usando el comando “ls

-R” sobre el directorio “taller2009”).

7. Cambiar las propiedades de los archivos de texto para que sean de solo lectura, excepto para el usuario propietario. Para el propietario los permisos deben ser de lectura, escritura y ejecución.

(TIP: "chmod ").

8. Crear otro directorio dentro de /taller2009 llamado “backup”, dentro del mismo copiar los

archivos de texto de cada materia, renombrándolos como “datos_nombremateria.txt”, donde

"nombremateria" es el nombre del archivo que debe remplazarse por el nombre de la materia correspondiente.

9. Borrar uno de los directorios de materia creados, y también borrar el archivo de texto dentro del directorio backup que corresponde a esa misma materia. Verificar que se hayan borrado los

mismos.

10. Con el comando “find”, encuentre los directorios y archivos creados, haciendo una búsqueda

dentro de toda la estructura de ficheros. Por ejemplo buscar los archivos con el nombre

“datos.txt” ("find -name datos.txt") y búsquedas para encontrar los directorios con los nombres de las materias.

11. Crear otro directorio dentro /home/usuario con el nombre “taller_2”.

12. Dentro del directorio “taller_2” crear accesos directos a los archivos de texto de las materias que

se encuentran dentro de “taller2009”.

13. Mover el directorio “taller2009” con todos sus subdirectorios dentro de “taller_2”.

14. Renombrar el directorio “taller2009” con el nombre “backuptaller2009”.

15. Editar alguno de los archivos de texto creados, con la combinación de teclas CTRL+Z detener el proceso, ahora con el comando “ps” visualizar el proceso correspondiente al editor de texto y su

correspondiente PID, y con el comando “kill -9 <nro PID>” matar al proceso del editor, donde "<nro PID>" se debe remplazar por el numero que se visualizó con el comando “ps”.

16. Abrir con el editor de texto (nano, pico o gedit) el archivo "prueba.cc" (ahora debería estar en la

carpeta "/backuptaller2009"). Completar el código de forma que el programa muestre un cartel que diga "Hola Mundo" y luego finalice:

#include <iostream>


int main()

{

cout<<"Hola Mundo"<<endl;

return (0);

}

210

17. Guarde el archivo. Compile usando la siguiente línea de comandos: "g++ -c prueba.cc". Y luego

genere un ejecutable con: "g++ -o prueba prueba.cc". Usando el manual, o el help averigüe que significa el parámetro "-o" y "-c" . Observe la diferencia entre el manual del comando y la ayuda.

18. Pruebe el programa usando el comando: "./prueba". Debiera ver el cartel "Hola Mundo" en pantalla y luego el prompt del sistema.

19. Utilice el comando "ls" para ver los permisos del programa "prueba".Utilice el manual del comando para ver que parámetro utilizar.

20. Quite los permisos de ejecución al programa "prueba".

21. Intente ejecutar nuevamente el programa "prueba". Analice que sucede.

22. Presione flecha arriba tantas veces hasta llegar al primer comando que ejecuto: "mkdir taller2009", luego borre 2009. Observe que ocurre con la tecla tabular, borre todo y escriba

"mk" y nuevamente presione la tecla tabular.

23. Dentro del directorio /backuptaller2009 cree un archivo de texto donde explique brevemente que hacen las teclas tabular, flecha arriba y flecha abajo. Ejecute el comando "cd ~" y luego intente ejecutar el programa prueba; ¿Como debe ser el comando para poder ejecutarlo?.

Para recordar:

CTRL+C y CTRL+V, copia y pega en ventana gráfica.

CTRL+SHIFT+C y CTRL+SHIFT+V, copia y pega en la consola de comandos.

El comando "ls" se usa para listar el contenido de la carpeta.

"man <nombre de comando>" abre el manual del comando especificado, se sale presionando la letra "q".

" <nombre de comando> --help" muestra una ayuda de como se usa el comando.

Al escribir las rutas a los archivos, presionando la tecla "TABULADOR", se autocompleta el

nombre que se está escribiendo, esto agiliza mucho la tarea.

TALLER DE INFORMÁTICA CAPITULO 6. Aplicaciones

211

CAPITULO 6.

SOFTWARE DE APLICACIONES

El software de aplicación es el conjunto de programas que han sido diseñados para que la computadora pueda desarrollar un trabajo.

Sirven como herramienta para elevar la productividad de los usuarios en la resolución de problemas.

Está diseñado y escrito para realizar tareas específicas personales, empresariales o científicas. El software de este tipo procesa datos y genera información.

Consta de:

* Lenguajes de programación

Fortran

Cobol

Basic

Pascal

C

* Lenguaje ensamblador

Lenguajes de Programación

Los lenguajes naturales son aquellos con los cuales hablamos y escribimos en nuestras actividades

cotidianas. Los lenguajes de programación ocupan una posición intermedia entre los lenguajes naturales humanos y los precisos lenguajes de máquina.

El lenguaje de programación consiste en un conjunto de órdenes o comandos que describen el proceso deseado. Cada lenguaje tiene sus instrucciones y enunciados verbales propios, que se combinan

para formar los programas de cómputo.

Los lenguajes de programación son herramientas que permiten construir y adecuar aplicaciones.

Son cualquier lenguaje artificial que puede utilizarse para definir una secuencia de instrucciones para su procesamiento por un ordenador

Generaciones de Lenguajes de Programación

Los lenguajes de programación se dividen en 2 categorías fundamentales:

BAJO NIVEL: Son dependientes de la máquina, están diseñados para ejecutarse en una

determinada computadora. A esta categoría pertenecen las 2 primeras generaciones.

ALTO NIVEL: Son independientes de la máquina y se pueden utilizar en una variedad de computadoras. Pertenecen a esta categoría la tercera y la cuarta generación. Los lenguajes de

más alto nivel no ofrecen necesariamente mayores capacidades de programación, pero si

ofrecen una interacción programador/computadora más avanzada. Cuanto más alto es el nivel del lenguaje, más sencillo es comprenderlo y utilizarlo.

Cada generación de lenguajes es más fácil de usar y más parecida a un lenguaje natural que su predecesores.

Los lenguajes posteriores a la cuarta generación se conocen como lenguajes de muy alto nivel. Son lenguajes de muy alto nivel los generadores de aplicaciones y los naturales.

En cada nuevo nivel se requieren menos instrucciones para indicar a la computadora que efectúe una tarea particular.


212

Un mayor nivel significa que son necesarios menos comandos, debido a que cada comando o mandato

de alto nivel reemplaza muchas instrucciones de nivel inferior.

Primera Generación- Lenguaje de máquina: (1940-1950) Consistía en sucesiones de dígitos binarios. Todas las instrucciones y mandatos se escribían valiéndose de cadenas de estos dígitos. Es el único lenguaje interno que entiende la computadora; los programas se escriben en lenguajes de mayor nivel y se

traducen a lenguaje de máquina.

Segunda Generación – Lenguajes ensambladores: (Fines de los ‟50) En lugar de usar códigos binarios, las instrucciones se representan con símbolos fáciles de reconocer, conocidos como

mnemotécnicos. Aún se utilizan estos lenguajes cuando interesa un nivel máximo de eficiencia en la ejecución o cuando se requieren manipulaciones intrincadas. Son únicos para una computadora particular.

Esta dependencia de la computadora los hace ser lenguajes de bajo nivel.

Tercera Generación: años ‟60. Los lenguajes de esta generación se dividen en tres categorías, según se orienten a:

* Procedimientos: Requieren que la codificación de las instrucciones se haga en la secuencia en que se deben ejecutar para solucionar el problema.

A su vez se clasifican en científicos (p.ej.: FORTRAN), empresariales (v.g.: COBOL), y de uso general o

múltiple (p.ej.: BASIC).

Permiten señalar cómo se debe efectuar una tarea a un nivel mayor que en los lenguajes ensambladores. Hacen énfasis en los procedimientos o las matemáticas implícitas, es decir en lo que se hace

(la acción).

* Problemas: Están diseñados para resolver un conjunto particular de problemas y no requieren el detalle de la programación que los lenguajes orientados a procedimientos.

Hacen hincapié en la entrada y la salida deseadas.

* Objetos: El énfasis se hace en el objeto de la acción. Los beneficios que aportan estos lenguajes incluyen una mayor productividad del programador y claridad de la lógica, además de ofrecer la flexibilidad

necesaria para manejar problemas abstractos de programación.

Cuarta Generación: su característica distintiva es el énfasis en especificar qué es lo que se debe hacer, en vez de cómo ejecutar una tarea.

Las especificaciones de los programas se desarrollan a un más alto nivel que en los lenguajes de la generación anterior. La característica distintiva es ajena a los procedimientos, el programador no tiene que

especificar cada paso para terminar una tarea o procesamiento.

Características de los lenguajes de cuarta generación son:

Uso de frases y oraciones parecidas al inglés para emitir instrucciones

No operan por procedimientos, por lo que permiten a los usuarios centrarse en lo que hay que hacer no en cómo hacerlo

Al hacerse cargo de muchos de los detalles de cómo hacer las cosas, incrementan la productividad.

Hay dos tipos de lenguajes de cuarta generación, según se orienten:

a la producción: Diseñados sobre todo para profesionales en la computación.

al usuario: Diseñados sobre todo para los usuarios finales, que pueden escribir programas para hacer consultas en una base de datos y para crear sistemas de información. También se llama

lenguaje de consultas (SQL, Structured Query Language: lenguaje estructurado para consultas).

Software de usuario final

Procesador de Textos


213

Sustituyen el trabajo de una tradicional maquina de escribir. Podemos encontrar las siguientes

funciones:

Escribir de corrido y una sola vez todo nuestro documento

Permiten con suma rapidez y flexibilidad hacer modificaciones al contenido, como: mover párrafos o bloques de texto completo de una hoja a otra, entre documentos e incluso entre programas.

Cambiar en un instante palabras o frases repetidas por sinónimos.

Permiten modificar en la marcha el escrito sin desperdiciar papel, ni tiempo.

Se puede cambiar completamente el estilo, diseño, formato e incluso el tipo y tamaño de la letra deseada.

Podemos verificar la ortográfica del documento.

Se pueden crear cartas o documentos de tipo constante, ya sea para circulares o formatos específicos incluso de facturación y manipularlos rápidamente.

Crear Documentos estilo periodístico a base de columnas, con gráficos, imágenes o fotografías e

incluso en formato cuadricular.

Cuentan palabras, deshacen los cambios, imprimen partes, etc.

Planilla de Cálculo

También denominadas Hojas de cálculo. Es una de las herramientas imprescindibles en cualquier

empresa, ya que permite realizar tareas que involucran complejas fórmulas y procesos basados en análisis, proyecciones, presupuestos, amortizaciones, cálculos básicos pero repetidos en cantidades, etc.

Entre las capacidades de las modernas hojas de cálculo, encontramos las siguientes:

Rápida escritura de fórmulas autocalculables

Inmensa cantidad de funciones financieras, científicas, matemáticas, lógicas, etc.

Implementación avanzada de varios gráficos estadísticos

Incrustación de texto e imágenes de diseño gráfico

Poder en la manipulación de grandes cantidades de registros de información

Diseño, Generación e Impresión rápida de reportes y listados.

Herramientas flexibles de proyección y análisis para la planeación y la oportuna toma de

decisiones

Graficación

a) Software de pintura: con él es posible “pintar” pixels en la pantalla usando un dispositivo apuntador, traduciendo los movimientos a líneas y patrones en la pantalla. Un programa de pintura ofrece

herramientas, de las cuales algunas imitan instrumentos de dibujo del mundo real.

b) Software de procesamiento digital de imágenes: permite al usuario manipular fotografías y

otras imágenes de alta definición con herramientas similares a las que proporcionan los programas de pintura. Es posible distorsionar y combinar fotografía, creando imágenes fabricadas que no muestran indicios

de manipulación.

c) Software de dibujo: almacena una imagen, no como una colección de puntos, sino como una colección de líneas y formas. Calcula y recuerda una fórmula matemática para la línea. El programa de

dibujo almacena las formas como formas y el texto como texto; es lo que se conoce como graficación orientada a objetos.

Tendencias en las capacidades del Software

Incrementar la facilidad con que el usuario puede interactuar con el hardware y el software.


214

Software cada vez más interactivo, mediante el uso de dispositivos apuntadores, programas de

reconocimiento de voz.

Incremento en la velocidad de acceso a los datos para los usuarios finales.

Comercialización de software directamente a usuarios finales.

Desarrollo de software integrado que tienen capacidades de comunicación y control. Integran partes de una institución y permiten el control y coordinación de la toma de decisiones en la

institución.

¿Cómo seleccionar Software y Lenguajes de programación?

Los criterios más importantes a tener en cuenta son:

Adaptabilidad: Al seleccionar un lenguaje es importante identificar el uso que se le quiere dar y quienes serán los usuarios.

Sofisticación: Los lenguajes deberán soportar muchos tipos de estructuras de datos.

Consideraciones de tipo organizacional: Fáciles de aprender, de mantener, de cambiar, flexibles, que puedan crecer con la institución.

Soporte: de otras empresas, y desde el proveedor. Que permita ediciones, asistencia para el desarrollo.

Eficiencia: en relación al tiempo de máquina, recursos de hardware y de personal especializado que necesitan para operarse o desarrollarse.


215

A partir de acá hay que organizar títulos y estilos como corresponda. Solo está el contenido, que también se debe revisar o completar según lo planificado

En todo este capitulo faltan lso ejercicios

6.1. Procesador de Textos Writer En el transcurso de esta guía se expondrán características y configuraciones disponibles, así como

modos de utilizaciones básicas y avanzadas de ciertos aspectos incluidos en Writer. Estos serán

encabezados, tratamientos con imágenes, formulas, tablas, objetos OLE, insertar numeración de

páginas y otros.

El objetivo NO es exponer todas las definiciones, sino solamente nombrar las características mas usadas y una pantallazo de sus utilidades. Así el usuario sabrá como y donde buscar lo que necesite. También se

expondrán algunas relaciones que tiene Writer y Microsoft Word.

6.1.1. Configuraciones de OpenOffices Aquí se trataran configuraciones básicas y modos de uso de distintas utilidades. Estas configuraciones

abarcan desde configuraciones de páginas hasta configuraciones del propio procesador de texto:

6.1.1.1. Configuraciones de Páginas

Para configurar los aspectos de la hoja que se usa, como margen, horizontal y vertical,

encabezados, etc., lo hacemos desde:

Click derecho1 → Página.

Formato → Página:

Se configurarán principalmente:

Estilos de pagina (Se verá mas adelante).

Tamaño y formato del papel, diseño, tipo de numeración2 de página.

Fondo de la página.

Columnas

Encabezado y Pie de Página (solamente configuraciones).

Nota al pie (solamente configuraciones).

Hay que tener en cuenta que la edición de página y párrafo siempre están asociado a un

determinado Estilos de página (predeterminado, primera página, índices, sobre, Página

derecha, etc.). Este estilo de página es usado a la hora de configurar de forma diferente una

página con otra; así por ejemplo se podrá insertar una página horizontal en el medio de

verticales.

Tamaño y Formato del Papel

En la pestaña correspondiente a configuración de página se pueden configurar fácilmente

el papel que se usara a la hora de imprimir, el formato, los márgenes, bordes y otros.


216

Encabezados y Pie de Página

Encabezado y pie de página son en realidad dos cuadros de texto que se ubican al

principio y al final de la página respectivamente.

Las configuraciones disponibles son semejantes para ambos. En los Encabezados y Pie

de Página se insertaran textos3 que serán iguales para toda una sección del documento, (por

ejemplo: año, número de página, nombre del documento, logo, etc.). En esta pestaña de

configuración de páginas están características como: tamaño, bordes, etc.

Para Insertar un Encabezados o Pie de Página:

Tildar en la casilla Activar [Pie de Página, Encabezado].

Insertar → [Pie de Página, Encabezado] → Estilo de Página.

Como ya se ha mencionado: “van las configuraciones de página asociada a un estilo de

página en particular4”, (por defecto se usa el estilo de página predeterminado).

Insertar Numeración de Página

Para esto se necesita insertar un pie de página, luego, en este cuadro de texto, insertar los

campos5 correspondientes. Así por ejemplo se puede escribir “Página X de Y” donde X e Y

serán campos distintos, uno sera el número de página y otro la cantidad de página.

Nota al Pie

Ésta va en otro lugar de la página, mas arriba del pie de página; su configuración es mas

limitada y su utilización es distinta.

En la pestaña correspondiente en la ventana de configuraciones de página se podrán

configurar:

Área de la nota al pie.

Linea de separación.

Las Notas al pie se usan para hacer aclaraciones de ciertos temas, insertando

automáticamente una referencia al final de la hoja o del documento.

Para Insertar una nota al pie, se debe tener el cursor al final de la palabra o texto al cual

se quiere referenciar, luego:

Insertar → Nota al Pie/Nota al Final.

CONFIGURACIONES DE PÁRRAFOS

Para configurar los Párrafos, basta con:

Click derecho6 → Párrafo.

Formato → Párrafo.

Aquí se configuran Principalmente:

Sangría y Espacios (importante en todo documento).

Alineación: Justificado, Centrado, etc. (CTR + [J L R T]).

Flujo del texto7.


217

PERSONALIZAR

Se puede personalizar principalmente el uso de las teclas y las barras de herramientas.

Uso de las Teclas Rápidas

Herramientas → Personalizar → Teclado.

En esta sección se podrán configurar las teclas rápidas, esto facilitara a la hora de editar

documentos, por ejemplo CTR + K, CTR + N, etc., son usadas para agilizar la edición del

texto, en este caso, poniendo en negrita y/o cursiva el texto seleccionado. Así el uso de teclas

rápidas configuradas en esta pestaña, facilitan o agilizan bastante el uso del procesador de

texto8.

Barras de Herramientas

Las barras de herramientas (por defecto, están visibles las barras: Estándar y Formato)

se pueden activar o colocar en el panel desde el menú: Ver → Barras de Herramientas →

[...]. Las cuales son configurables desde:

Ver → Barra de Herramientas → Personalizar.

Click derecho9 → Personalizar Barra de Herramienta.

Herramientas → Personalizar.

En el asistente de configuración se debe seleccionar la barra a editar, luego:

Si el elemento esta en la lista, solo hay que asegurarse que este tildado.

Si no lo esta, hay que Agregar...

OPCIONES

Herramientas → Opciones.

Aquí, las configuraciones son muchas y complejas, abarca desde el tiempo que tarda en

guardar el archivo (copia de seguridad), hasta formato por defecto que se usará para guardar

el documento10.

Básicamente todo tipo de configuración que se quiera realizar sobre el procesador de

texto (no sobre el documento) se realizarán aquí (Opciones) y en Personalizar.

Formateo de texto

Para este tema, en OpenOffice, la palabra clave es Carácter. Para editar el formato del

texto:

Click derecho11 → Carácter.

Formato → Carácter.

En esta ventana las configuraciones principales son:

Fuente: tipografía, tamaño.

Efectos: subrayado, relieve, mayúsculas.

Fondos.


218

Pero es importante recalcar que en la barra de herramientas es común tener estas

opciones además de otras, como por ejemplo superíndices o subíndices.

Corrector Ortográfico

Se usa para estar seguro de que el texto escrito este correcto. Generalmente se desea:

Cambiar idioma de un texto o una palabra:

Efectuar una corrección asistida:

Para esto primero hay que configurar el corrector (por defecto se encontrará en el idioma

del sistema operativo):

Herramientas → Idioma → […] → Idioma a usar.

En la barra de estado

El corrector ortográfico generalmente esta activo, en tal caso habrá un icono en la barra

de herramientas que permitirá desactivarlo, o en caso contrario activarlo, indicando la

activación o no del corrector ortográfico. Si no está el icono es porque alguien ha modificado

la barra de herramientas o no está la barra de herramienta estándar.

Cabe destacar que éste corrector es de ortografía nada mas. Existen extensiones para

OpenOffice Writer, como LanguageTool, que es una herramienta de corrección gramatical.

Estilos y Formatos de Textos

GENERALIDADES

Porque es útil usar “Estilos y Formatos”: Porque una vez configurado, con simples

combinaciones de teclas o simples click, se podrá cambiar la configuración de los textos y/o

páginas seleccionadas, cuyos cambios abarcan muchos aspectos (como estilos de párrafo,

página, formatos, carácter, etc.).

Existen distinto tipos de estilos ya configurados, como ser: encabezado1, encabezado2,

cuerpo de textos, predeterminados, contenido de tabla, etc., que están listos para ser usados.

Estos estilos serán usado automáticamente en ciertas acciones, como por ejemplo: cuerpo

de texto será usado en documentos, Ilustraciones en gráficas o figuras, Pie de página en notas

al pie, texto de tablas en tablas, etc. Entonces, si se modifican los estilos, automáticamente

se estarán usando configuraciones a gusto de cada uno, en todo el documento.

Muchas características que posee OpenOffice en general, requieren que el usuario sepa

usar esos estilos, ya sean de páginas, de párrafos, de carácter, etc. Por ejemplo, si se quiere

que la carátula de un documento no este usando el pie de página pero si el resto del

documento, es necesario usar estilos diferentes.

COMO USAR LOS ENCABEZADOS

Método clásico usando el mousse y la barra de herramientas en el cuadro de

Aplicar estilos.

Usando F11 para abrir el gestor de estilos y formatos.

Usando las teclas rápidas CTR + [1 2 3 4] para los distintos estilos de

encabezados. El texto normal (Cuerpo de texto) siempre con CTR + 0.


219

Cuando estemos usando numeración de capítulos (se verá mas adelante):

ubicando el cursor al principio del encabezado y presiono TAB o SHIFT + TAB

provoca el cambio de estilos.

EDITAR “ESTILOS Y FORMATOS”

Para editar los Estilos y Formatos se tendrá que estar usando un estilo determinado,

luego, hacer click derecho sobre el párrafo → Editar estilo de párrafo. Este método tiene

muchas opciones reagrupadas12 y a veces suelen prestar a confusión.

Otra forma de editar es: Editar un texto cualquiera, configurar de la forma ya vista su

preferencia de párrafo, de carácter, etc., luego presionando F11 o yendo a Formato →

Estilos y Formatos se selecciona el nombre del estilo que se quiere editar (ejemplo:

Encabezado 1) y luego “Actualizar estilos”.

Entonces: Para Editar los Estilos de Párrafo hay que “Actualizar Estilos de Párrafos”.

CONSEJOS

Para Encabezados

Configuraciones de Párrafo:

Espacio entre párrafo.

Que este tildada la casilla mantener párrafos juntos13.

Para Cuerpo de Textos

Configuraciones de Párrafo:

Espacio entre párrafo.

Que NO este tildada la casilla mantener párrafos juntos14.

Configuración de interlineado que sea mayor que simples y

Separación entre párrafos (facilita la lectura)

Configurar el flujo del texto en modo justificado (para informes).

NUMERACIÓN EN LOS ENCABEZADOS

Esto hace referencia a enumerar capítulos, títulos subtítulos, figuras, etc. Como se puede

ver en este documento, en los encabezado se ha usado una numeración. Para editarla hay que

ir a:

Herramienta → Numeración de Capítulos.

Ya en la ventana, en la primer pestaña, se configura la forma de la numeración, el nivel

usado, el texto que ira antes y después, etc., para los distintos estilos que se requiera. En la

segunda pestaña se configura la posición y el espaciado (en muchos casos, es útil cambiar

Tabulación por Espacio).

También se podrá insertar la numeración en los capítulos de la misma forma que se inserta

una numeración en un texto cualquiera, como se explica mas adelante (sección 7 ). Este

puede ser un método mas fácil pero a la vez NO tan configurable.


220

Formatos de Páginas

En esta sección se tratará de explicar sobre un tema que ya fue mencionado, se ah

insinuado que cada pagina puede estar configurada de forma diferente, esto se logra con los

estilos y formatos distintos para cada página. La edición de la los distintos estilos, es similar a

la edición de estilos para párrafos:

En complemento a las configuraciones dichas anteriormente (sección 1.1 ). Lo

que se necesita es guardar las configuraciones hechas en un estilo. Si se esta

trabajando con un estilo, ya sea predeterminado o seleccionado manualmente, al

editarlo se irá guardando, pero si se quiere editar además otro estilo, se tendrá que

cambiar.

Para usar un determinado estilo, es conveniente usar la barra de estado (ver ).

Con F11 o Estilos y Formatos. Se abre el gestor de formatos, en la cuarta

pestaña (estilos de páginas), se podrá elegir el estilo deseado. También, una vez

configurada la pagina a gusto, se usa para actualizar algún estilo, en este caso de

página.

Uso de Plantillas

La configuración de distintos estilos que se usarán en todo el documento puede ser

laboriosa, si a esto se le agrega encabezados y/o notas al pie, además de una carátula

predeterminada, es efectivamente trabajoso. Es útil en esos casos, y que el documento tiene

un formato único, usar distintas plantillas, para crear dichos documentos de textos.

Una plantilla es un documento que contiene estilos de formato específicos, imágenes,

tablas, objetos y cualquier otra información. Una plantilla “se usa como base para crear otros

documentos”. Por ejemplo, puede definir estilos de párrafo y de carácter en un documento,

guardarlo como plantilla y usarlo para crear un nuevo documento con los mismos estilos.

GUARDAR UNA PLANTILLA

Crear un documento y añadir los estilos de contenido y de formato que se desee.

Archivo → Plantillas → Guardar.

CARGAR UNA PLANTILLA

Archivo → Nuevo → Plantillas y documentos.

Después de seleccionar la plantilla deseada, se abrirá un nuevo documento que será igual

al archivo que se ha guardado. Por lo tanto cabe preguntarse que conviene guardar:

Principalmente los formatos de estilos y páginas

Carátulas que se usaran en los informes

Otras: como encabezados o pie de página, etc. “En general es mas fácil borrar

algo que crearlo”.


221

USAR UNA PLANTILLA COMO PREDETERMINADA

Para predeterminar una plantilla, se debe:

Tener la plantilla ya guardada

Ir al administrador de plantillas: Archivo → Plantillas → Administrar.

Seleccionar la plantilla deseada, luego: Comandos → Definir como plantilla

predeterminada.

Entonces de esta forma cada vez que se cree un documento nuevo se estará usando una

plantilla, que es la que se ha creado y puesto como predeterminada.

Esta plantilla es nada mas que para el documento, para aspectos del procesador de texto

ver las secciones “1.3 ” y “1.4 ”.

Numeración y Viñetas

Método clásico:

Click derecho → Numeración y viñetas.

Agregamos un icono en la barra de herramienta.

En esta ventana de configuración, se pueden configurar varios aspectos entre ellos:

Tipo de numeración

Esquema

Imagen

Niveles

Opciones, etc.

Otros métodos de insertar o modificar viñetas son:

Es útil, en los casos que se usen muy a menudo, configurar teclas rápidas. La

forma es: Herramientas → Personalizar... → Teclado, usando CTR + [5 6 7 8] por

ejemplo.

Una vez que estas usando viñetas, podes usar TAB o SHIFT + TAB para

cambiar de niveles. Esto es: Con el cursor al inicio del párrafo presionas TAB para

subir de nivel o SHIFT + TAB para bajar.

Insertar Imagen

Insertar → Imagen → a partir de archivos. También es una buena forma de insertar las

imágenes arrastrándolas desde un navegador de archivos o copiándolas desde portapapeles.

CONFIGURAR LAS IMÁGENES

Una vez insertada, es importante configurar (Doble click o Click derecho → Imagen).

Entre las preferencias y características se pueden encontrar:

Opción de redimensionamiento (importante es mantener proporciones)

Recortar


222

Modo en que se integrará la imagen con el texto y el resto de los objetos. En la

pestaña Ajustes → predeterminaciones (Ninguno, Dinámico, Detrás, etc.)

Teniendo seleccionada la imagen, aparece una nueva barra de preferencia, esta

tiene cosas simples pero muy útiles, como ser:

Filtro: invertir, suavizar, aumentar nitidez, etc.

Modo de gráfico: escalas de grises, etc.

Color: ajusta el color, contraste, brillo, etc.

Transparencia.

Reflejar horizontalmente y verticalmente

Estas opciones no son muy avanzadas como un editor de imagen, pero podrán de manera

simples convertir una imagen oscura en una que pueda ser imprimible sin problemas.

Titulo de Imagen

Click derecho sobre la imagen → Titulo entonces se abre un asistente.

Figura 8.1: Esta imagen es de un software

En la casilla Categorías (del asistente) se podrá crear un nuevo tema, en este caso se

creó Figura.

Características del Titulo: Si se creó una nueva categoría, llamada Figura, una vez

insertado el titulo de la imagen, se creará un nuevo estilo llamado Figura, el cual se podrá

editar al igual que se editan los demás estilos.

Insertar Tablas

Para insertar una tabla:

Insertar → Tabla. Entonces se abrirá un asistente que permitirá seleccionar las

columnas y filas, también se tendrá una opción de auto formateo (tablas

preformateada).

Las tablas son como un párrafo especial, de forma que cuando seleccionamos texto

utilizando el teclado (SHIFT + Flecha) desde encima de la tabla, la tabla entera es

seleccionada junto con la línea por debajo de ella.

Al insertar una tabla, el contenido de ésta respeta un estilo y formato predeterminado,

en este caso el se llama contenido de la tabla.

El uso es intuitivo. Haciendo click derecho sobre ella aparecerá un menú contextual que

tendrá opciones distintas y algunas conocidas.

Entre las opciones principales se encuentran:

Celda: En está se puede cambiar las características de la/s celda/s

seleccionada/s:

Unir, dividir vertical, dividir horizontal, etc.

Ubicar el contenido arriba, abajo, etc.


223

Filas y columnas: En estos submenues se configurarán aspectos que

relacionan toda la fila o toda la columna.

Tabla: este abrirá una ventana que contendrá opciones conocidas y usadas (por

ejemplo el uso de bordes).

Objetos OLE

Son básicamente cualquier archivo hecho en OpenOffice que pueden ser insertados en un

documento. Para insertar un objeto OLE: Insertar → Objeto → Objeto OLE → […]. En esta

ventana se observaran distintas categorías, de las que veremos:

Formulas.

Hoja de Cálculo.

Dibujos.

Los Objetos OLE tendrán en el documento en el cual fueron insertados un aspecto

semejante a una imagen o gráfico (la configuración principal estará en vez de click derecho →

Imagen en Click derecho → Objeto) pero su contenido podrá ser editado y tendrá las mismas

herramientas que en CALC, DRAW o MATH. Por tal caso siempre podremos editar el Objeto

OLE en el mismo documento (editor empotrado) o abriéndolo externamente (Objeto OLE

externamente).

También, y respaldando lo que se ha dicho, se podrá insertar un título en un Objeto OLE,

al igual que en las Imágenes, esto será útil para el caso de tablas de cálculos, diagramas y

dibujos.

INSERTAR FORMULA

Para insertar la formula (con un número y que éste pueda ser usado para referencia) como

a continuación:

(1)

Usando auto-texto, hay que escribir “núm” y presionar F3. En éste método lo que se esta

haciendo es uso de un auto-texto, éste a su vez inserta una tabla de dos columnas por una fila

(con una distribución predeterminada) en la cual contiene un objeto (formula) y otro un texto

(ver ) que se ira actualizando para cada fórmula.

Otra forma de insertar una formulas es:

Insertar → Objeto → Formula. Pero este método no tendrá todas las características que

posee el anterior.

Editar formulas

Para esto se puede hacer con Doble click, en este caso se usará el editor de formula

empotrado. También se puede usar el editor externo (click derecho → Activar objeto OLE

externamente). El uso del editor es tanto gráfico (no tan intuitivo) como por comandos (muy

útil y el más usado)15.


224

INSERTAR HOJAS DE CÁLCULO

Una tabla hecha en CALC remplaza en cualquier aspecto a la vista anteriormente (9 ).

Para insertar una tabla hecha en calc o crear una nueva tabla se usan básicamente dos

métodos:

Hacer la tabla en la hoja de cálculo calc y luego copiarla desde allí.

Insertar → Objeto → Objeto OLE → Hoja de cálculo.

Cualquiera de estos métodos, insertarán un objeto OLE, que es tratado como todos en

OpenOffice.

Editar las Hojas

Para editar las hojas, el proceso es tal cual el de “10.1.1 ”.

Las características que posee CALC son muchas y será necesario otra guía para cubrir ese

aspecto.

INSERTAR DIBUJOS

El proceso de insertar un dibujo es repetido al de Hoja de calculo. No remplaza Insertar

una Imagen ya que es otro tema.

Lo importante es saber que la edición del dibujo se hará desde la edición externa (activar

Objeto OLE externamente) que sería Dibujo (DRAW) o desde su correspondiente editor

empotrado. Pero la forma en que se integrará este en el documento es semejante a la de una

imagen16.

Relaciones de Writer con Word

Uso de Teclas

Se tratarán uso de las teclas direccionales, combinaciones de teclas que agilizan la edición

de los documentos.

MOVIMIENTO Y SELECCIONES

Estas teclas o combinaciones de ellas, son útiles para los procesadores de textos (Writer),

tanto como para editores de textos (mousepad, leafpad, kwriter, kate, etc.) o IDEs de

programación (anjuta, geany, glade, gambas, etc.).

Up, down, left y rigth: Permite movimientos hacia arriba, abajo,

izquierda y derecha (un carácter).

Page Up y page down: Permite movimientos por paginas hacia

arriba y abajo respectivamente.

Home o Inicio y End o Fin: Movimiento al Principio y al final del

renglón.


225

Efecto de la tecla SHIFT: Se usa para seleccionar el texto desde donde estaba

el cursor anteriormente a donde esta después del movimiento.

Efecto de la tecla CTR: Usada como multiplicador de efecto, es decir:

CTR + [Up, down, left y rigth]: Los movimientos hacia arriba y

abajo se realizan por párrafos; de izquierda y derecha por palabras.

CTR + [Home y End]: Movimiento al Principio y al final del

documento.

Si se combinan los efectos de CTR y SHIFT, funcionaria como seleccionador y a

la vez multiplicador de efectos. A modo de ejemplo:

CTR + Home y después CTR + SHIFT + End: Seleccionaría todo el documento.

COMBINACIONES DE TECLAS

Estas configuraciones están por defecto configurada según el idioma que se usa en el

sistema, a veces por motivos desconocidos las combinaciones de teclas son en ingles aunque

el sistema operativo este en español, algunos ejemplos son:

Inglés Español Que hace?

CTR + A CTR + E Selecciona todo el texto

CTR + B CTR + N Pone en Negrita

CTR + I CTR + K Pone en cursiva

CTR + S CTR + G Guarda el documento

CTR + SHIFT + P CTR + SHIFT + P Superíndices

CTR + SHIFT + B CTR + SHIFT + B Subíndices

CTR + F CTR + F Buscar/Remplazar

Además es posible modificarlas, como se ha tratado en la sección “1.3.1 ”.

CREAR ÍNDICES

Un aspecto a tener en cuenta es que cuando queramos crear un índice, Los niveles de

configurados en Numeración de Capítulos serán los niveles del índice.

Para crear un índice basta con:

Usar los estilos y formatos

Configurar los niveles (en caso de que se haya usado encabezado [1 2 3 …] no

es necesario).

Insertar → Índices y seguir el asistente.

Editar el contenido del índice

Podemos después de insertar un índice, editarlo, para esto en el momento de insertar,

deberíamos haber desmarcado la opción “Protegido contra modificaciones manuales”.


226

Editar el estilo del índice

Después de insertar el índice podemos editar los estilos de los distintos niveles, para ello

la forma mas fácil es haciendo click derecho sobre la linea que tiene el estilo que se quiere

modificar, luego editar estilo de párrafo (ver 4.3 ).

Actualizar

Herramientas → Actualizar → [Campos, Todos los índices...]

Si se realiza una edición manual del índice, ésta es sobre-escrita al actualizar el índice o al

actualizar todo.

SOBRE LA NUMERACIÓN DE LAS FIGURAS Y LAS GRÁFICAS

Si se desea que los objetos tengan una numeración que siga al capítulo (por ejemplo

Figura 3.1.1)se tendrá que modificar la forma de insertar el título de la figura:

Click derecho → Título → Opciones. Y aquí hay que configurar el nivel (nivel uno: sigue

al titulo, nivel dos: sigue al subtitulo...).

Para configurar la numeración de las formulas (por ejemplo 3.1.1), hay que poner el cursor

en frente del número y:

Click derecho → Campos → Opciones. Y aquí se configura el nivel.

USO DE REFERENCIAS

Insertar → Referencia.

Esta es útil para documentos largos. Por ejemplo: se inserta una nueva sección en medio

del documento, por lo tanto cambiara la numeración y la referencia, entonces, se debe

cambiar manualmente la referencia (si es que esta no se esta usando) y muchas veces recién

después de imprimir el trabajo nos damos cuenta que se esta haciendo mal la referencia.

INSERTAR SALTO DE PÁGINA

Como es obvio: Insertar → salto de página. Es muy simples, pero hay aclaraciones que

son validas en ciertos casos:

Si se quiere insertar una carátula o índices se puede insertar la página con un

estilo distinto (generalmente primera página o índices).

Insertar la página pero que la numeración de pagina empiece en un valor

determinado.

Insertar página de forma Horizontal (es un estilo de página).

BARRA DE ESTADO

La barra de estado puede estar de modo visible o no (menú → ver → barra de estado). En

ella se encuentran:

Número de página: Ver la cantidad de páginas y en que página se está situado.

Estilo de la página: Ver el estilo usado y con click derecho permite cambiar el

estilo.


227

Idioma: Ver el idioma usado y con click derecho permite cambiar el Idioma ya

sea para una selección, una palabra o el texto completo.

Modo de inserción (tecla insert), sobrescribe el carácter que sucede al cursor.

Nivel de numeración o viñeta.

Escala o Ampliación: permite ajustar la escala del documento.

GUARDAR COMO PDF

En OpenOffice es fácil exportar cualquier archivo como pdf, para ello:

Icono en la barra de herramientas estándar.

Archivo → exportar.

Archivo → Imprimir → imprimir en archivo (esta opción exporta todo el

contenido como imagen).

1Sobre la página que se quiera editar.

2Puede ser para numerar las páginas con letras, con números romanos, etc.

3No solamente textos, pueden ser gráficos, formulas, etc.

4No todos los encabezados o pie de página son los mismos en el documento. Se podrán tener por ejemplo páginas con encabezados y paginas sin.

5Para esto: Insertar → Campos → [Fecha, Hora Número de Página, Total de Página, etc.]

6Sobre la página que queremos editar, (la edición de Párrafo siempre esta asociada a un determinado Estilo de Página,

al igual que la edición de Página).

7Se verá en la sección 10 consejos que hacen uso de esta característica.

8Se puede usar las combinaciones de teclas disponibles para una acción determinada. Por ejemplo “CTR + SHIFT +

N” para insertar Notas.

9Sobre la barra que se quiera editar.

10Herramientas → Opciones → Cargar/Guardar → General. Aquí se puede configurar para que automáticamente

guarde en un formato compatible con Word “.doc”.

11Después de seleccionar el texto a formatear.

12 Por ejemplo en sus opciones están las configuraciones de carácter, de página y de párrafo juntas.

13De esta manera el Titulo o subtítulo siempre tendrá un texto debajo (no quedará solo y el texto en la página

siguiente).

14Esta opción trabaja en conjunto con la del encabezado, si esta no se respeta, no funciona la otra.

15Es útil porque conociendo palabras claves y usando las llaves y comandos se puede escribir mas rápido que

seleccionando con el mousse los distintos signos y/o símbolos.

16Se vuelve a repetir para que quede en claro, ya que es una de las confusiones principales a la hora de insertar un

dibujo hecho en DRAW.

…………………………………………….


228

6.2. Hoja de Cálculo Calc

Planilla de Cálculo

En una planilla de cálculo se pueden ingresar valores, rótulos, fórmulas matemáticas, estadísticas,

financieras, cálculos de ingeniería, etc.

Se pueden aplicar las fórmulas sobre los datos de entrada nos devolverá los resultados.

La principal ventaja de una planilla de cálculo es que, una vez establecidas las fórmulas, al cambiar

los datos de entrada podremos ver inmediatamente las consecuencias del cambio en los resultados.

De esta forma podremos analizar inversiones, esquemas de tiempo, organizaciones de producción y

en base a esto tomar las decisiones correspondientes.

Partes de una planilla de Cálculo:

Hoja: Está formada por filas y columnas.

Celda: Intersección de una fila con una columna.

Celda Activa: Donde está posicionado el cursor.

Rango: conjuntos de Celdas.

Libro: conjunto de hojas

Funciones/Formulas: expresiones que vinculan Celdas y otros elementos

Una archivo de planilla de Cálculo esta formado por varias hojas. Cada hoja tiene columnas y filas.

La intersección de una fila y una columna es una Celda.

Cada Celda puede contener: Texto, Valores Numéricos, Funciones , Fórmulas.

Cada Fila de una hoja suele tener como nombre un número.. (1,2,3....) y cada columna de esa hoja

una letra ( A,B,C...) así que cada celda al ser la intersección de una fila con una columna recibe el

nombre de ambas, por ejemplo para referirnos a la celda que resulta de la intersección de la fila 2

con la columna B lo haremos con B2.

Como una hoja de Cálculo puede contener varias hojas..estas tendrán nombres.. de esta manera se

puede indentificar a cada celda de cada hoja. Estos nombres se pueden personalizar, los nombres de

las hojas de cálculo se pueden ver en la parte inferior de cada hoja.

Una formula es una expresión que escribimos en una celda , por ejemplo en la Celda B3 ,

escribimos

B2+B1, esto quiere decir que el contenido o lo que vemos en la celda B· será la suma de el

contenido de B2 mas el contenido de B1 , ya veremos mas al respecto mas adelante.


229

Una función es una fórmula que utiliza un lenguaje propio de la planilla de cálculo, que permite

hacer operaciones mas compleja. (promedios, máximos, mínimos, etc). Mas adelante veremos mas

en detalle el uso de funciones.

La cantidad de Filas y Columnas para cada hoja dependen de la aplicación, por ejemplo:

Open Office Excel

cantidad de filas

cantidad de

columnas

Partes de la Interfase de la Planilla de Cálculo:

Veremos a continuación las partes de la interfase de una planilla de cáculo del Open Office.

Podemo

s ver

también

las

barras

de

desplaz

amiento

horizont

al y

vertical

de la

Ventana

. Sobre

la parte

inferior

izquierd

a

podemo

s ver:

Estas flechas nos permiten avanzar a la siguiente , ultima o anterior y primer hoja de cálculo.

A continuación describiremos el uso de cada una de las partes vistas:

Barra de Fórmula:

Barra de

Formulas

Celda Activa

Hoja Activa Barra de Estado

Barra de

herramientas

Menú

Cuadro de Nombre


230

Es la Barra situada en la parte superior de la ventana o area de trabajo, que se utiliza para introducir

o modificar los valores o las fórmulas de las celdas o los gráficos. Muestra el valor constante o la

fórmula utilizada en la celda activa.

Se puede mostrar u ocultar la barra de fórmulas, en Open Office Ver->Barra de Herramientas-

>Formula.

Cuadro de Nombre:

Es el nombre que tiene la celda. Este nombre se puede personalizar, por ejemplo se podría llamar

una celda: temp_amb, para que en ella escribamos el valor de la temperatura ambiente. Esto sirve

por que luego en una formula o función se podría usar el nombre personalizado lo que mejoraría la

compresión de la formula.

Celda Activa:

Celda donde esta el cursor. Lo que escribamos se ubicaría en esta celda.

Barra de Herramientas: Esta barra sirve para agilizar el acceso a comando usados con mayor frecuencia. Se puede

personalizar el contenido de la misma.

Barra de Estado:

Se puede visualizar distintas opciones. Cantidad de hojas ( ej: 2/13) , Escala de Visualización,

Promedio , Suma , Cantidad de un rango celdas Seleccionados.

Menú:

Debajo de la barra de títulos de la Ventana , encontramos la Barra de Menú, similar al de cualquier

otra aplicación, pulsando con el puntero del Mouse sobre cualquiera de sus opciones se descolgara

hacia abajo un menú de tipo persiana con una serie de comandos y funciones relacionadas con dicha

opción. Estando el menú desplegado con las teclas Flecha abajo/arriba nos movemos entre las

opciones, con las teclas Flecha derecha/izquierda nos movemos entre los menúes, con la tecla

ENTER se elige una opción y con la tecla ESC se sale del menú.

También podemos acceder al menú presionando ALT + Primer letra del menú deseado.

Referencias relativas y absolutas

En una hoja se usan habitualmente formulas para realizar operaciones, suele se de mucha utilidad

transportar copiar esta formula a otras celda pero se quiere que los valores de la fórmula se vayan

modificando , veamos un ejemplo:

Podemos ver que en la celda D7 contiene la suma

de B7+C7 , y en la otra imagen la Celda D8 contiene la suma de B8+C8. En las planillas de Cálculo

esto se logra haciendo un click & drag sobre

el vértice inferior derecho de la celda que tiene la fórmula.

Veamos como sería:


231

Podemos ver que en la celda E1 esta la Fórmula D1*C1

Solo para resaltar vemos que el cursor en la esquina inferior de la

celda cambia la forma , en realidad en de color negro pero para

resaltar en el dibujo lo hemos dejado de color rojo. Si

presionamos

el botón izquierdo del mouse y arrastramos.

Veremos que se completando la formula, pero se va rellenando de

manera que la celda E2 = D2*C2 ,

la celda E3 =D3*C3

Entonces se puede ver que las referencias a las celdas se ajustaban al copiar las fórmulas: este tipo

de referencias se llaman referencias relativas, y son las más corrientes. Sin embargo, en ocasiones

nos interesa usar referencias absolutas, es decir, referencias que no se ajustan al copiar una fórmula

de una celda a otra: para ello, ponemos el carácter $ delante de la referencia a la columna, a la fila, o

a ambas, según nos interese mantener fija la referencia a la columna, a la fila, o tanto a la columna

como a la fila. Por ejemplo:

Referencia relativa B2

Referencia absoluta a la columna $B2

Referencia absoluta a la fila B$2

Referencia absoluta (a la columna y la fila) $B$2

Funciones y Fórmulas

En realidad hacemos una diferencia respecto de formula y función , una formula es una expresión

que escribimos en una celda , por ejemplo en la Celda B3 , escribimos B2+B1, esto quiere decir que

el contenido o lo que vemos en la celda B· será la suma de el contenido de B2 mas el contenido de

B1 , y consideramos función una expresión que es propia de la planilla de calculo , como ser la

función suma. Veamos un ejemplo de esto:

Fórmula Función

En general todas las planillas de cálculo poseen muchas funciones que están agrupadas por

"categorías" , es decir las lógicas, trigonométricas, matemáticas, estadísticas, etc.


232

Para cada una de estas suele existir una pequeña ayuda sobre su utilización , suele ser algo así como

la imagen que se muestra a continuación:

Esto permite entender la Sintaxis de la fórmula, la cual hay que respetar para poder usarla.

A modo de ejemplo vamos a comentar sobre algunas de las planillas de cálculo que existen hoy en

día como ser el Excel de Microsoft y la que usaremos en este curso de Calc Open Office.

No intentaremos comparar o calificar a cada uno de ellos , no viene al caso , simplemente

mencionaremos características de Open Office Calc y algunas parecidas o distintas del Excel ya que

este esta muy difundido.

Este programa de hoja de cálculo ; Calc viene incluido en la suite completa de Open Office desde

el nacimiento de esta y al igual que los otros programas de la suite como ser :

Write - Procesador de Texto

Impress - Presentaciones

Base - Base de Datos

Las extensiones de estas

aplicaiones de la Suite

Ofimática de

OpenOffice.org son:

Esta suite de programas está disponible para un número de plataformas más amplio y lo mas

importante tiene una licencia libre.

Veamos una comparativa de las características del Software propietario contra el Software libre:


233

En particular ahora nos referiremos a Calc que nos presenta una interfaz similar a la vista en

anteriores de la planilla de Microsoft Excel , decimos esto por que la última versión del Excel (

2007) se modificó bastante , las diferentes funciones del programa son accesibles desde la barra de

menús despegables de la parte superior de la pantalla , como cualquier sistema de ventanas.

Algunas de las características de Calc frente a Excel son, por ejemplo, la gran cantidad de formatos

que el programa es capaz de abrir (incluyendo el formato .xls de Excel y los propios formatos de

Calc, entre otros), esto no es así con el Excel que no permite guardar en un formato por ejemplo

como el del Calc (ods).

Además, podemos realizar también todo tipo de cálculos a través de su editor de fórmulas, que nos

permitirá tratar incluso con números complejos (imaginarios) o con funciones estadísticas

financieras. Posee además un editor de gráficas, que al igual que en Excel nos permitirá generar

gráficas a partir de los datos introducidos previamente y representarlos del modo que queramos.

Al igual que pasaba con Writer (Procesador de Texto del Open Office) , Calc puede salvar nuestro

trabajo directamente en formato PDF, esto no es así en su competidor , ajustando las hojas de

cálculo al formato que le indiquemos.

A modo de ejemplo vamos a comentar las Equivalencias de los Términos usados en cada una de las

suites Ofimática ( OpenOffice.org , Microsoft)


234

)

TALLER DE INFORMÁTICA CAPITULO 7. Conceptos de Redes e Internet

235

CAPITULO 7

CONCEPTOS DE REDES E INTERNET

FALTARIA UNA INTRODUCCION

A partir de acá hay que organizar títulos y estilos como corresponda. Solo está el contenido, que también se debe revisar o completar según lo planificado

En este capitulo faltan los ejercicios

7.1. DEFINICIONES

7.1.1. Telecomunicaciones

Las telecomunicaciones pueden definirse como comunicación de información por medios electrónicos, normalmente a cierta distancia.

Anteriormente, las telecomunicaciones significaban transmisión de voz mediante líneas telefónicas. En la actualidad, muchas de las transmisiones de telecomunicaciones son de información digital, usando las

computadoras para la transmisión de datos.

Un sistema de telecomunicaciones es un conjunto de software y hardware compatibles ordenados

para comunicar información de un lugar a otro.

Estos sistemas pueden transmitir textos, gráfico, imágenes, voz o video.

Componentes de un sistema de telecomunicaciones

Computadoras: para procesar la información.

Dispositivos de E/S: para enviar o recibir datos.

Canales de comunicación: son los enlaces mediante los que se transmiten los datos entre los dispositivos de emisión y recepción en una red.

Procesadores de comunicación: como módems que proporcionan las funciones de soporte para la transmisión y recepción de los datos.

Software de comunicaciones: controla las actividades de E/S y maneja otras funciones

de la red de comunicaciones.

Funciones de los sistemas de telecomunicaciones

Transmitir información

Establecer la interfase entre emisor y el receptor

Enviar mensajes a través de los caminos más eficaces


236

Realizar el procesamiento preliminar de la información para asegurar que el mensaje

correcto llegue al receptor adecuado Editar los datos, verificar errores, reordenar el formato

Convertir las velocidades de una a otra, ejemplo de la línea a la de la computadora

Controlar el flujo de información

7.1.2. Protocolos

Una red típica de telecomunicaciones contiene diferentes componentes de hardware y software que

deben trabajar en conjunto para transmitir información; estos componentes deben adherirse a un conjunto

común de reglas que permiten que se comuniquen entre ellos.

Protocolo es el conjunto de reglas y procedimientos que gobiernan la transmisión entre dos puntos de

una red.

Funciones principales:

Identificar cada dispositivo de la ruta de comunicaciones para asegurar la atención del otro

dispositivo Verificar la correcta recepción del mensaje transmitido

Verificar que el mensaje requiere retransmisión porque no puede ser correctamente

interpretado Realizar la recuperación cuando tenga errores.

7.1.3. Tipos de Señales

La información viaja en un sistema de telecomunicaciones en forma de señales electromagnéticas.

Hay dos tipos de señales: Analógica: se representa por una onda continua que pasa por un medio de comunicación.

Para comunicaciones de voz.

Digital: es una forma de onda, mas bien discreta que continua, que transmite datos codificados en dos estados discretos (1 bit y 0 bit) que se representan por dos pulsos

eléctricos de encendido y apagado. Las usan las computadoras.

Las señales digitales deben ser traducidas a analógicas antes de ser transmitidas en un sistema analógico.

El módem es el dispositivo utilizado para traducir las señales digitales de la computadora a las señales analógicas de la línea telefónica y viceversa.

7.1.4. Canales de comunicación

Los canales de comunicación son los medios mediante los cuales los datos se transmiten de un dispositivo de red a otros.

Un canal puede utilizar diferentes medios de transmisión de telecomunicaciones: par trenzado, cable coaxial, fibra óptica, microondas terrestres, satélite.


237

a) Par trenzado

Es un medio de transmisión que consiste en pares de alambre de cobre torcidos. Se emplea para la

transmisión analógica de conversaciones telefónicas pero puede ser usado para transmisión de datos.

Ventajas / Desventajas: bajo costo, relativamente lento, tiene interferencia. Velocidad hasta los 10

megabits por seg.

b) Cable coaxial

Es un medio de transmisión que consiste en un alambre de cobre con un gran espesor de aislamiento.

Puede transmitir rápidamente grandes volúmenes de datos.

Ventajas / Desventajas: es más rápido, menos interferencia, velocidad de hasta 200 Megabits por

seg. Es grueso, difícil de instalar, no soporta conversaciones analógicas de teléfonos, se debe mover al mover las computadoras.

c) Fibra óptica

Consiste en haces de fibra de vidrio transparente, delgados que se unen en cables. Los datos se

transmiten en pulsos de luz que se llevan a través del cable por un dispositivo láser.

Ventajas / Desventajas: velocidad de 500 kilobits por seg. hasta millones de bits por seg. Es más

rápido, más ligero, mas durable. Es apropiado para los sistemas donde se transmiten grandes volúmenes de información. Es más cara, más difícil de trabajar e instalar.

d) Transmisión inalámbrica

Envía señales a través del aire sin ninguna conexión física. Puede ser de microondas terrestres, satélites, telefonía celular.

* Sistemas de microondas terrestres

Transmiten señales de radio de alta frecuencia a través de la atmósfera. No requiere de cableado, pero

necesita estaciones entre 40 y 50 Km de distancia. Se utiliza para comunicaciones con alto volumen de datos, larga distancia y de punto a punto.

* Satélites

Transmisión de datos usando satélites orbitales para servir como estaciones de enlace para la transmisión de señales de microondas a muy largas distancias.

7.1.5. Características de los Canales de Comunicación

Ayudan a determinar la eficiencia de y capacidades de un sistema de transmisión de datos.

Entre las características tenemos:

a) Velocidad de transmisión

Es la cantidad total de información que puede ser transmitida a través de cualquier canal de

comunicación. Se mide en BPS: bits por seg. Algunas veces esto se conoce como tasa en bauds. Baud representa un cambio de señal de positivo a negativo o viceversa.

La tasa depende de la frecuencia: el número de ciclos por seg. que pueden ser enviados a través de

ese medio. Se mide en hertz.

La amplitud de banda es otra medida de la capacidad de un canal de comunicaciones medida por la

diferencia entre la más alta y más baja frecuencia que puede ser transmitida por un canal.

b) Modos de transmisión

Son convenciones para determinar cuando comienza y cuando termina un carácter.

* Transmisión asíncrona: es la transmisión a baja velocidad de datos, de a un carácter por vez. Cada

carácter limitado por el bit de control, un bit de arranque, uno o dos bits de alto y un bit de paridad.


238

* Transmisión síncrona: es la transmisión simultánea de alta velocidad de grandes bloques de datos.

Transmite simultáneamente grupos de caracteres, con el principio y fin de bloque de caracteres.

c) Dirección de transmisión

Es la dirección del flujo de información a través de la red.

* Dirección simplex: los datos pueden viajar en una sola dirección todo el tiempo.

* Dirección half-duplex: los datos pueden fluir en los dos sentidos, pero solo en una dirección a la vez.

* Dirección full-duplex: los datos pueden enviarse en las dos direcciones simultáneamente.

7.1.6. Funciones del software de telecomunicaciones

Es software especial para controlar y sustentar las actividades de una red de telecomunicaciones.

Las funciones son: Control de la red: direcciona los mensajes, encabeza las terminales de la red, determina

las prioridades de transmisión, mantiene el registro de actividades y verifica errores. Control de acceso: establece las conexiones entre las terminales y las computadoras,

establece la velocidad, el modo y la dirección de transmisión. Control de transmisión: permite enviar y recibir datos, programas, comandos y mensajes.

Control de errores: detecta y corrige los errores, retransmite los datos corregidos.

Seguridad y Control: realiza el seguimiento del uso, los registros, los procedimientos de autorización para evitar el acceso no autorizado de la red.

7.2. REDES DE COMUNICACIONES

7.2.1. Clasificación

Las redes se pueden clasificar de acuerdo a:

Estrella

Su forma o topología: Bus

Anillo

Su ámbito geográfico: Redes de área local Redes de área amplia

7.2.2. Topologías de las redes

Las tres topologías de redes más comunes son:


239

II.X.2.1. Estrella

Se trata de un nodo central del cuál salen los cableados para cada estación. Las estaciones se comunican unas con otras a través del nodo central. Es sencilla de controlar: el software no es complicado y el flujo de tráfico es simple.

Conectar un conjunto de computadoras en estrella es uno de los sistemas mas antiguos, equivale a tener una computadora central (el Server), encargada de controlar la información de toda la red. Dicha información abarca desde los mensajes entre usuarios, datos almacenados en un archivo en particular, manipulación de archivos, etc. Para poder instalar este tipo de red, cada una de las computadoras utilizadas como estaciones de trabajo necesitan de una tarjeta de conexión para lograr la interfase con la computadora central.

II.X.2.2. Bus

Permite conectar a todas las computadoras de la red en una sola línea compartiendo el mismo canal de datos (bus), de ahí su nombre.

A fin de poder identificar hacia cual de las computadoras de toda la red se está dirigiendo, se añade un sufijo al paquete de información, este contiene la dirección de la computadora que debe recibir la información en particular. Cada una de las computadoras revisa el mensaje y comparar la dirección de la terminal de recepción, en caso de no ser igual a la propia, se rechaza y en caso de ser igual la dirección, se acepta el mensaje.


240

II.X.2.3. Anillo

Recibe su nombre del aspecto circular del flujo de datos.

En muchos casos, el flujo de datos va en una sola dirección. Es decir, una estación recibe la señal y la envía a la siguiente estación del anillo. La topología en anillo es muy atractiva debido a que los cuellos de botella son raros.

Además, la lógica necesaria en una red de este tipo es relativamente simple. Consiste en unir una serie de computadoras en un circuito cerrado formando un anillo por donde circula la información en una sola dirección, factor que permite tener un control de recepción de mensajes.


241

7.2.3. Ámbito Geográfico

7.2.3.1. Redes de área local - LAN

Las redes de área local abarcan una distancia limitada, en general un edificio. La mayoría de las LAN conectan dispositivos localizados dentro de un radio de los 670 m

Requieren de sus propios canales de comunicación. En general transmiten a razón de 256 Kilobits a 100 Megabits por seg.

Permiten compartir hardware y software.

El servidor de archivos es una computadora en una red que almacena diversos programas de la red. Determina el acceso u disponibilidad en la red. Contiene el SO de la red.

Sistema Operativo de la red: software que administra el servidor de archivos en una LAN y direcciona y administra las comunicaciones en la red.

La tecnología LAN consiste en: Cableado (par trenzado, coaxial, fibra óptica) o tecnología inalámbrica que enlaza los

dispositivos individuales de cómputos.

Tarjetas de interfase de redes (adaptadores de la computadora al cable). Especifican la

tasa de transmisión de datos, el tamaño de unidades de mensaje, la información direccionada asociada a cada mensaje y la topología de red.

Software para controlar las actividades de la LAN.

Existen cuatro tecnologías principales de LAN para conectar físicamente los dispositivos: Ethernet

Appletalk Token Ring

ARCnet

Estas tecnologías utilizan una tecnología de canal de banda base o banda amplia. Banda base (baseband): es una tecnología de canales LAN que proporciona una ruta

única para la transmisión de texto, gráficas, voz o video al mismo tiempo.

Banda amplia (broadband): es una tecnología de canales LAN que proporciona diversas

rutas para la transmisión de texto, gráficas, voz o video de manera que distintos tipos de datos puedan ser transmitidos simultáneamente.

Sistema operativo

El SO puede residir en cada una de las computadoras o en un servidor único de archivos designado para todas las aplicaciones de la red.

Ejemplo: son el Netware de Novell, PCLan de IBM.

7.2.3.2. Red de área amplia - WAN

Es una red de gran cobertura en la cual pueden transmitirse datos a larga distancia. Interconecta facilidades de comunicación entre diferentes localidades de un país.

Son generalmente una serie de dispositivos de conmutación interconectados. Se desarrollan o bien utilizando tecnología de conmutación de circuitos o conmutación de paquetes.


242

Tipos de redes WAN

a) Conmutadas por Circuitos:

Para establecer la comunicación se debe efectuar una llamada y cuando se establece la conexión, los usuarios disponen de un enlace directo a través de los distintos segmentos de la red. Se establece un camino a través de los nodos de la red dedicado a la interconexión de dos estaciones. En cada enlace, se dedica un canal lógico a cada conexión. Los datos se transmiten tan rápido como se pueda.

b) Conmutadas por Mensaje:

El conmutador suele ser una computadora que se encarga de aceptar tráfico de los computadoras y terminales conectados a él. La computadora examina la dirección que aparece en la cabecera del mensaje hacia el que debe recibirlo. Esta tecnología permite grabar la información para atenderla después. El usuario puede borrar, almacenar, redirigir o contestar el mensaje de forma automática.

c) Conmutadas por Paquetes:

Los datos de los usuarios se descomponen en trozos más pequeños. Estos fragmentos o paquetes, están insertados dentro de informaciones del protocolo y recorren la red como entidades independientes. No es necesario reservar canal lógico. En cada nodo, el paquete se recibe totalmente, se almacena y seguidamente se transmite al siguiente nodo.

d) Redes Orientadas a Conexión:

En estas redes existe el concepto de multiplexión de canales y puertos conocido como circuito o canal virtual, debido a que el usuario aparenta disponer de un recurso dedicado, cuando en realidad lo comparte con otros pues lo que ocurre es que atienden a ráfagas de tráfico de distintos usuarios.

e) Redes no orientadas a conexión:

Pasan directamente del estado libre al modo de transferencia de datos. Estas redes no ofrecen confirmaciones, control de flujo ni recuperación de errores aplicables a toda la red, aunque estas funciones si existen para cada enlace particular. Un ejemplo de este tipo de red es INTERNET.

7.2.4. Implementación de una red

Factores a tener en cuenta al momento de decidir qué tecnología de telecomunicaciones debe adoptarse:

Distancia entre máquinas.

Margen de servicios que se necesitan Seguridad

Acceso múltiple (la cantidad de máquinas) Utilización. Frecuencia y volumen de las telecomunicaciones.

Costo

Instalación Conectividad


243

7.3. Conectividad

Nueva arquitectura de la información

Es el ordenamiento de los recursos de software, hardware, telecomunicaciones y datos para dar más poder de cómputo sobre el escritorio y crear una red que enlace muchas redes pequeñas.

Es la forma particular que toma la tecnología de información para alcanzar las metas seleccionadas.

Existen diferentes maneras de entregar poder de cómputo al escritorio.

a) Modelo cliente / servidor

En este modelo el procesamiento de la computadora se divide entre los “clientes” en una red y los “servidores”. Donde cada función se asigna a la máquina más capacitada.

La parte del cliente en una aplicación, corre en el sistema de cliente y la parte de la aplicación del servidor corre en el servidor de archivos.

El usuario interactúa con la parte del cliente en la aplicación:

interfase de usuario

proceso de captura de datos

consulta a bases de datos

obtención de informes

El servidor realiza funciones no visibles para el usuario

administración de los periféricos

control de acceso a las bases de datos compartidas.

La división de las tareas depende de:

requerimientos de las aplicaciones

requerimientos del procesamiento

cantidad de usuarios

recursos disponibles

Tareas del cliente:

obtención de las entradas del usuario

solicitudes al servidor de programas y datos

cálculos en datos locales

muestra de resultados.

Tareas del servidor:

capturar y/o procesar los datos

Requerimientos:

Los programas deben ser escritos como dos componentes separados de software que corren en distintas máquinas pero aparecen operando una sola aplicación.

Características:

Es difícil escribir software que divida el procesamiento entre clientes y servidores.

Se puede saturar el servidor

Es difícil administrar una red.


244

b) Modelo de terminal X

Es una terminal de escritorio controlada centralmente que se usa en una red y que puede acceder a las operaciones de diversas computadoras remotas de manera simultánea. No son computadoras con capacidades individuales de procesamiento.

Características:

Es una solución más barata

Requiere de un sistema operativo como UNIX para poder funcionar

Baja el rendimiento cuando se incrementa el número de terminales.

7.3.1. Definición de Conectividad La meta última de la nueva arquitectura de la información son las redes a nivel de toda la

empresa, donde toda la información digitalizada puede circular a lo largo de una trama continua de redes electrónicas, que enlazan diferentes tipos de máquinas, personas, sensores, bases de datos, departamentos, etc.

La meta es difícil porque deben poder trabajar juntos diferentes tipos de hardware, software y sistemas de comunicaciones.

La conectividad es la capacidad de las computadoras para comunicarse entre sí y “compartir” información de una manera significativa sin la intervención del hombre.

7.3.1.1. Aspectos de la Conectividad

Lo que sigue es un listado de términos utilizados para explicar diferentes aspectos de la conectividad.

Portabilidad de las aplicaciones (transportabilidad): es la capacidad de operar el mismo elemento de software en diferentes tipos de hardware.

Migración: es la capacidad de mover el software de una generación de hardware a otra generación más poderosa.

Procesamiento cooperativo: es la división de tareas entre macrocomputadoras, minicomputadoras, microcomputadoras o estaciones de trabajo para resolver un problema

único.

Portabilidad de la información: es la capacidad de compartir archivos de computadora entre distintas plataformas de hardware y aplicaciones de software.

Interoperabilidad: es la capacidad de que un elemento único de software opere en dos clases distintas de hardware, y muestre a los usuarios una interfase idéntica y realice las

mismas tareas.

Sistemas abiertos: Sistemas de software que pueden operar en distintas plataformas de

hardware porque se construyen sobre sistemas operativos, interfases de usuario, normas de aplicación y protocolos de redes públicas no propietarias.

La conectividad implica sistemas operativos comunes, normas comunes de telecomunicaciones (y aún normas comunes para interfases de usuario), que la pantalla se vea semejante y poder atravesar las diferentes

aplicaciones de software.


245

7.3.2. Normas para la Conectividad

Alcanzar la conectividad implica establecer normas para las redes, sistemas operativos e interfases de usuario.

¿Quién establece las normas?

El proceso de establecimiento de normas es en gran medida política e involucra a muchos poderosos grupos de interés.

El NIST (National Institute for Standars and Technology) del gobierno federal de los Estados Unidos, las asociaciones de ingeniería como la IEEE (Institute of Electrical and Electronic Engineers) y la ANSI (American National Standars Institute) han estabecido las normas para la definición del lenguaje de software, desempeño del hardware y protocolos de comunicación.

Con la globalización de los negocios, las normas internacionales son críticas.

La ISO (Internacional Organization for Standarisation) y la CCITT (International Telephone and Telegraph Consultative Commitee) han ayudado a legitimar uno de los más poderosos modelos conectivos.

El OSI (Open System Inteconnect Reference Model)

7.3.2.1. Modelos de conectividad para redes

Existen diferentes modelos para alcanzar la conectividad en las redes de telecomunicaciones.

Modelo de referencia: es un marco genérico para pensar sobre un problema. Es una

partición lógica de alguna actividad en pasos o partes.

Protocolo: es un enunciado que establece cómo una tarea específica debe realizarse.

Los modelos de referencia y los protocolos se transforman en normas o estándares cuando son aprobados por grupos importantes.

7.3.2.1.1. El modelo de referencia OSI

Es un modelo de referencia internacional para enlazar diferentes tipos de computadoras y de redes. Fue diseñado para permitir redes globales con grandes volúmenes de procesamiento de operaciones.

Permite que una computadora conectada en una red se comunique con otra en la misma red o en otra diferente, independientemente de quien sea el fabricante. Cada computadora que participa en una red OSI se considera como un dispositivo inteligente no una terminal.

El modelo OSI divide el proceso de telecomunicaciones en siete niveles.


246

Datos y paquetes de datos:

La información que viaja a través de una red se conoce como paquete, datos o paquete de datos.

Un paquete de datos es una unidad de información, lógicamente agrupada, que se desplaza entre los sistemas de computación. Incluye la información origen junto con otros elementos necesarios para hacer que la comunicación sea factible y confiable en relación con los dispositivos destino.

La dirección origen de un paquete especifica la identidad de la computadora que envía el paquete.

La dirección destino especifica la identidad de la computadora que finalmente recibe el paquete.

Protocolos

Para que los paquetes de datos puedan viajar desde el origen hasta su destino a través de una red, es importante que todos los dispositivos de la red hablen el mismo lenguaje o protocolo.

Un protocolo es un conjunto de reglas que hacen que la comunicación en una red sea más eficiente.

Una definición técnica de un protocolo de comunicaciones de datos es: un conjunto de normas, o un acuerdo, que determina el formato y la transmisión de datos.

La capa n de una computadora se comunica con la capa n de otra computadora.

Las normas y convenciones que se utilizan en esta comunicación se denominan colectivamente protocolo de la capa n.

El modelo de referencia OSI

Al principio de su desarrollo, las LAN y WAN eran en cierto modo caótico. A principios de la década de los 80 se produjeron tremendos aumentos en la cantidad y el tamaño de las redes.

A mediados de los 80, las empresas debieron enfrentar problemas cada vez más serios debido a su expansión caótica. Resultaba cada vez más difícil que las redes que usaban diferentes especificaciones pudieran comunicarse entre sí.

Se dieron cuenta que necesitaban salir de los sistemas de networking propietarios.

Los sistemas propietarios se desarrollan, pertenecen y son controlados por organizaciones privadas. Significa que una empresa o un pequeño grupo de empresas controla el uso de la tecnología.

Abierto: significa que el uso libre de la tecnología está disponible para todos.

Para enfrentar el problema de incompatibilidad de las redes y su imposibilidad de comunicarse entre sí, la Organización Internacional para la Normalización (ISO) estudió esquemas de red a fin de encontrar un conjunto de reglas.

Como resultado de esta investigación, la ISO desarrolló un modelo de red que ayudaría a los fabricantes a crear redes que fueran compatibles y que pudieran operar con otras redes.

El modelo de referencia OSI (Nota: No debe confundirse con ISO), lanzado en 1984, fue el esquema descriptivo que crearon.


247

Este modelo proporcionó a los fabricantes un conjunto de estándares que aseguraron una mayor compatibilidad e interoperabilidad entre los distintos tipos de tecnología de red utilizados por las empresas a nivel mundial.

El modelo de referencia OSI es el modelo principal para las comunicaciones por red.

El modelo de referencia OSI permite que los usuarios vean las funciones de red que se producen en cada capa.

El modelo de referencia OSI es un marco que se puede utilizar para comprender cómo viaja la información a través de una red.

Se puede usar el modelo de referencia OSI para visualizar cómo la información o los paquetes de datos viajan desde los programas de aplicación (por ej., hojas de cálculo, documentos, etc.), a través de un entorno de red (por ej., cables, etc.), hasta otro programa de aplicación ubicado en otro computador de la red, aún cuando el remitente y el receptor tengan distintos tipos de red.

En el modelo de referencia OSI, hay siete capas numeradas, cada una de las cuales ilustra una función de red particular.

La división de la red en siete capas presenta las siguientes ventajas:

Divide la comunicación de red en partes más pequeñas y sencillas.

Normaliza los componentes de red para permitir el desarrollo y el soporte de los productos

de diferentes fabricantes.

Permite a los distintos tipos de hardware y software de red comunicarse entre sí.

Impide que los cambios en una capa puedan afectar las demás capas, de manera que se

puedan desarrollar con más rapidez.

Divide la comunicación de red en partes más pequeñas para simplificar el aprendizaje.

Las capas del modelo OSI

El problema de trasladar información entre computadoras se divide en siete problemas más pequeños y de tratamiento más simple en el modelo de referencia OSI.

Cada uno de los siete problemas más pequeños está representado por su propia capa en el modelo.

Las siete capas del modelo de referencia OSI son:

Capa 7: La capa de aplicación

Capa 6: La capa de presentación

Capa 5: La capa de sesión

Capa 4: La capa de transporte

Capa 3: La capa de red

Capa 2: La capa de enlace de datos

Capa 1: La capa física

Si dos computadoras diferentes usan normas OSI, ambas tendrían software y hardware correspondiente a cada uno de los niveles del modelo OSI.

APLICACIÓN

PRESENTACIÓN

SESION


248

TRANSPORTE

RED

ENLACE DE DATOS

FISICO

Funciones de cada capa

Cada capa individual del modelo OSI tiene un conjunto de funciones que debe realizar para que los paquetes de datos puedan viajar en la red desde el origen hasta el destino.

Capa 7: La capa de aplicación

La capa de aplicación es la más cercana al usuario; suministra servicios de red a las aplicaciones del usuario.

Difiere de las demás capas debido a que no proporciona servicios a ninguna otra capa OSI, sino solamente a aplicaciones que se encuentran fuera del modelo OSI.

Ejemplos: son los programas de hojas de cálculo, de procesamiento de texto. Establece la disponibilidad de los potenciales socios de comunicación, sincroniza y establece acuerdos sobre los procedimientos de recuperación de errores y control de la integridad de los datos.

Capa 6: La capa de presentación

Traduce el mensaje al formato que se usa en la red en forma comprensible para los programas de emisión y recepción en la capa 7.

Este nivel permite negociar, seleccionar y mantener la sintaxis de la información que está siendo transferida entre los procesos de aplicación.

Capa 5: La capa de sesión

En la capa de sesión se establece y controla el diálogo entre las dos aplicaciones que se comunican.

Ayuda a seleccionar el turno para enviar y recibir información, recuperación de la sincronización y una terminación ordenada de la comunicación.

Es el moderador del diálogo que tiene lugar en la red, prohibiendo y permitiendo interrupciones cuando sea necesario.

Capa 4: La capa de transporte

La capa de transporte controla la calidad de la transmisión y se asegura que las redes se usen adecuadamente.

Este nivel asegura la integridad de todo el mensaje desde su origen hasta su destino. Puede establecer prioridades para el control del flujo de datos.

La capa de transporte intenta suministrar un servicio de transporte de datos que aísla las capas superiores de los detalles de implementación del transporte.

Al proporcionar un servicio de comunicaciones, la capa de transporte establece, mantiene y termina adecuadamente los circuitos virtuales.


249

Capa 3: La capa de red

Esta capa determina la ruta adecuada para los datos a través de la red. Proporciona funciones de direccionamiento e intercambio que seleccionan los caminos por la red y por los circuitos, intercambio de paquetes.

Capa 2: La capa de enlace de datos

En la capa de enlace se “empacan” los datos para su transmisión, se “desempacan” al recibirlos y se efectúa la detección de errores durante la transmisión.

Su función principal es la corrección de errores.

La capa de enlace de datos se ocupa del direccionamiento físico (comparado con el lógico) , la topología de red, el acceso a la red, la notificación de errores, entrega ordenada de tramas y control de flujo.

Capa 1: La capa física

Establece la conexión física entre los equipos de cómputo y la red.

Por ejemplo el tamaño y forma del conector, el numero de pines en el conector, etc.

La capa física define las especificaciones eléctricas, mecánicas, de procedimiento y funcionales para activar, mantener y desactivar el enlace físico entre sistemas finales.

Las características tales como niveles de voltaje, temporización de cambios de voltaje, velocidad de datos físicos, distancias de transmisión máximas, conectores físicos y otros atributos similares se definen a través de las especificaciones de la capa física.

Nombres de los datos en cada capa Para que los paquetes de datos puedan viajar desde el origen hasta su destino, cada capa del

modelo OSI en el origen debe comunicarse con su capa igual en el lugar destino.

Esta forma de comunicación se conoce como comunicaciones de par-a-par.

Durante este proceso, cada protocolo de capa intercambia información, que se conoce como unidades de datos de protocolo (PDU), entre capas iguales. Cada capa de comunicación, en la computadora origen, se comunica con un PDU específico de capa y con su capa igual en la computadora destino.

7.3.2.1.2. El modelo de referencia TCP/IP

Es el Protocolo de Control de Transmisión/Protocolo Internet (TCP/IP). Es el estándar abierto de Internet. El modelo de referencia TCP/IP y la pila de protocolo TCP/IP hacen que sea posible la comunicación entre dos computadoras, desde cualquier parte del mundo, a casi la velocidad de la luz.

Las capas del modelo de referencia TCP / IP

El Departamento de Defensa de EE.UU. (DoD) creó el modelo TCP/IP porque necesitaba una red que pudiera sobrevivir ante cualquier circunstancia. Se necesita que fluya la información o los datos (organizados en forma de paquetes), independientemente de la condición de cualquier nodo


250

o red en particular. El DoD desea que sus paquetes lleguen a destino siempre, bajo cualquier condición, desde un punto determinado a cualquier otro punto determinado.

El modelo TCP/IP tiene cuatro capas:

La capa de aplicación

La capa de transporte

La capa de Internet

La capa de red.

Es importante observar que algunas de las capas del modelo TCP/IP poseen el mismo nombre que las capas del modelo OSI. No confunda las capas de los dos modelos, porque la capa de aplicación tiene diferentes funciones en cada modelo.

Capa de aplicación

Los diseñadores de TCP/IP sintieron que los protocolos de nivel superior deberían incluir los detalles de las capas de sesión y presentación.

Simplemente crearon una capa de aplicación que maneja protocolos de alto nivel, aspectos de representación, codificación y control de diálogo.

El modelo TCP/IP combina todos los aspectos relacionados con las aplicaciones en una sola capa y da por sentado que estos datos están correctamente empaquetados para la siguiente capa.

Capa de transporte

La capa de transporte se refiere a los aspectos de calidad del servicio con respecto a la confiabilidad, el control de flujo y la corrección de errores.

El protocolo para el control de la transmisión (TCP), ofrece maneras flexibles y de alta calidad para crear comunicaciones de red confiables, sin problemas de flujo y con un nivel de error bajo.

TCP es un protocolo orientado a la conexión. Mantiene un diálogo entre el origen y el destino mientras empaqueta la información de la capa de aplicación en unidades denominadas segmentos. Orientado a la conexión significa que los segmentos de la Capa 4 viajan de un lado a otro entre dos hosts para comprobar que la conexión exista lógicamente para un determinado período. Esto se conoce como conmutación de paquetes.

Capa de Internet

El propósito de la capa de Internet es enviar paquetes origen desde cualquier red y que estos paquetes lleguen a su destino independientemente de la ruta y de las redes que se utilizaron para llegar hasta allí.

El protocolo específico que rige esta capa se denomina Protocolo Internet (IP).

En esta capa se produce la determinación de la mejor ruta y la conmutación de paquetes. Esto se puede comparar con el sistema postal. Cuando envía una carta por correo, usted no sabe cómo llega a destino (existen varias rutas posibles); lo que le interesa es que la carta llegue.

Capa de red

Es la capa que se ocupa de todos los aspectos que requiere un paquete IP para realizar realmente un enlace físico y luego realizar otro enlace físico. Esta capa incluye los detalles de tecnología de LAN y WAN y todos los detalles de las capas física y de enlace de datos del modelo OSI.


251

Gráfico de protocolo TCP/IP

Algunos de los protocolos comunes especificados por el modelo de referencia TCP/IP en la capa de aplicación incluyen las siguientes:

FTP : File Transfer Protocol (Protocolo de transporte de archivos)

HTTP: Hypertext Transfer protocol (Protocolo de transferencia de hipertexto)

SMTP: Simple Mail transport protocol (Protocolo de transporte de correo simple)

DNS: Domain Name Service (Servicio de nombre de dominio)

TFTP: Trival File transport protocol(Protocolo de transporte de archivo trivial)

La capa de transporte involucra dos protocolos:

el protocolo de control de transmisión (TCP)

el protocolo de datagrama (UDP).

En el modelo TCP/IP existe solamente un protocolo de red:

El protocolo Internet, o IP. IP sirve como protocolo universal que permite que cualquier

computadora en cualquier parte del mundo pueda comunicarse en cualquier momento.

Comparación modelos: OSI - TCP/IP

Similitudes Ambos se dividen en capas

Ambos tienen capas de aplicación, aunque incluyen servicios muy distintos

Ambos tienen capas de transporte y de red similares

Se supone que la tecnología es de conmutación de paquetes (no de conmutación de circuitos

Los profesionales de networking deben conocer ambos

Diferencias TCP/IP combina las funciones de la capa de presentación y de sesión en la capa de

aplicación.

TCP/IP combina la capas de enlace de datos y la capa física del modelo OSI en una sola capa.

TCP/IP parece ser más simple porque tiene menos capas

Los protocolos TCP/IP son los estándares en torno a los cuales se desarrolló Internet.

En comparación, no se crean redes a partir de protocolos específicos relacionados con OSI,

aunque todo el mundo utiliza el modelo OSI como guía.


252

TALLER DE INFORMÁTICA BIBLIOGRAFIA

253

BIBLIOGRAFIA

LIBROS RELACIONADOS CON ALGORITMOS E INTRODUCCIÓN A LA PROGRAMACIÓN

“INTRODUCCIÓN A LA PROGRAMACIÓN. ALGORITMOS Y SU IMPLEMENTACIÓN EN VB, C#, JAVA Y C++” de RAMIREZ, F. Ed. ALFAOMEGA, México, 2007.

“FUNDAMENTOS DE PROGRAMACION” de JOYANES AGUILAR, L., Ed. McGRAW-HILL.,

Madrid, 2003.

“ALGORITMOS + ESTRUCTURAS DE DATOS = PROGRAMAS” de WIRTH, N. Ed. DEL CASTILLO

“FUNDAMENTOS DE PROGRAMACION. PIENSA EN C” de CAIRO BATTISTUTTI O., Ed. PEARSON ADDISON-WESLEY, México, 2006

PÁGINAS CON MATERIAL INTERESANTE RELACIONADO CON ALGORITMOS E INTRODUCCIÓN A LA PROGRAMACIÓN

Tutorial de diseño estructurado de algoritmos de Departamento de Sistemas y Computación Instituto Tecnológico de La Paz, México

http://sistemas.itlp.edu.mx/tutoriales/algoritmos/index.htm

Curso de Diseño de Algoritmos de Carlos Javier Pes Rivas

http://www.carlospes.com/curso_de_algoritmos/

Guía de Programación. Material de Eduteka para leer desde Internet o descargar.

http://es.calameo.com/read/000170621716489806b76 ó http://www.eduteka.org/pdfdir/AlgoritmosProgramacion.pdf

PÁGINAS CON MATERIAL INTERESANTE RELACIONADO CON SISTEMA OPERATIVO LINUX:

Guía de referencia de comandos Unix/Linux en castellano: http://www.scribd.com/doc/563515/Guia-de-referencia-de-comandos-UnixLinux-en-castellano

http://www.julioneves.com

http://dns.bdat.net/shell/

Curso sobre Gnome: http://lliurex.net/home/files/documentacion/es/html509/index.html

PÁGINAS CON INFORMACIÓN SOBRE SOFTWARE PARA LA ELABORACIÓN DE DIAGRAMAS DE FLUJO

DFD 1.0 http://www.softonic.com/ie/16035/DFD

Scratch http://scratch.mit.edu/

SmartDraw http://www.smartdraw.com

Inspiration http://www.inspiration.com

WinEsquema http://www.softonic.com/ie/27771/WinEsquema

Dia Win32 Installer http://www.softonic.com/ie/33781/dia

Paraben's Flow Charter http://www.paraben.com/html/flow.html

Novagraph Chartist http://www.tucows.com/preview/289535.html

Flow Charting 5 http://www.patton-patton.com

OrgPlus http://www.tucows.com/preview/281861.html

Antechinus Draw Magic http://www.tucows.com/preview/254904.html

http://sistemas.itlp.edu.mx/tutoriales/algoritmos/index.htm

http://www.carlospes.com/curso_de_algoritmos/

http://es.calameo.com/read/000170621716489806b76

http://www.eduteka.org/pdfdir/AlgoritmosProgramacion.pdf

http://www.scribd.com/doc/563515/Guia-de-referencia-de-comandos-UnixLinux-en-castellano

http://www.julioneves.com/

http://dns.bdat.net/shell/

http://lliurex.net/home/files/documentacion/es/html509/index.html

http://www.softonic.com/ie/16035/DFD

http://scratch.mit.edu/

http://www.smartdraw.com/

http://www.inspiration.com/

http://www.softonic.com/ie/27771/WinEsquema

http://www.softonic.com/ie/33781/dia

http://www.paraben.com/html/flow.html

http://www.tucows.com/preview/289535.html

http://www.patton-patton.com/



TALLER DE INFORMÁTICA BIBLIOGRAFIA

254

PÁGINAS CON INFORMACIÓN SOBRE LENGUAJE C

Cursos de C++ http://www.conclase.net/c/curso/index.php

Cursos de C++ http://c.conclase.net/index.php

Free C++ (and C), Programming Tools: http://www.freebyte.com/programming/cpp/

PÁGINAS CON INFORMACIÓN SOBRE ENTORNO ANJUTA

Página del proyecto Anjuta: http://anjuta.org/

Proyecto en freshmeat: http://freshmeat.net/projects/anjuta/

Tutorial de glade y Anjuta (en inglés) http://writelinux.com/glade/index.php

http://www.conclase.net/c/curso/index.php

http://c.conclase.net/index.php

http://www.freebyte.com/programming/cpp/

http://anjuta.org/

http://freshmeat.net/projects/anjuta/

http://writelinux.com/glade/index.php

TALLER DE INFORMÁTICA ANEXOS

- 255 -

ANEXOS

ANEXO 1.

ESTANDARES PARA DIAGRAMAS DE FLUJO – PSEUDOCÓDIGO

SIGNIFICADO

DIAGRAMA DE FLUJO

PSEUDOCÓDIGO

Proceso

X a + b

Decisión

Si <condición>

<acciones> sino

<acciones>

Conectores

Inicio / Fin

Inicio / Fin

Entrada de Datos

Leer ...

Salida de Datos

Escribir ...

Dirección del flujo

Comentarios

// Comentarios.....

SI NO

- 256 -

ANEXO 2. OPERADORES

2.1. OPERADORES MATEMÁTICOS

OPERADOR SIGNIFICADO OPERANDOS RESULTADO

^ Exponenciación Entero ó Real Entero ó Real

+ Suma Entero ó Real Entero ó Real

- Resta Entero ó Real Entero ó Real

* Multiplicación Entero ó Real Entero ó Real

/ División Real Real

div División enteros Entero Entero

mod Módulo - Resto Entero Entero

2.2. OPERADORES DE RELACIÓN ó COMPARACIÓN

<expresión1> OPERADOR <expresión2>

OPERADORES SIGNIFICADO

== Igual

> Mayor

< Menor

>= Mayor o igual que

<= Menor o igual que

<> ó != Distinto

2.3. OPERADORES LÓGICOS – TABLAS DE VERDAD

NO - NOT Y - AND O - OR

A NO A A B A y B A B A ó B

V F V V V V V V

F V V F F V F V

F V F F V V

F F F F F F

- 257 -

2.4. OPERADORES – ORDEN DE PRECEDENCIA

Normalmente, las expresiones con operadores se evalúan de izquierda a derecha, aunque no todos, ciertos operadores que se evalúan y se asocian de derecha a izquierda.

Además, no todos los operadores tienen la misma prioridad, algunos se evalúan antes que otros, de hecho, existe un orden muy concreto en los operadores en la evaluación de expresiones.

Esta propiedad de los operadores se conoce como precedencia o prioridad.

Veremos ahora las prioridades de todos los operadores incluidos los que aún conocemos.

Considera esta tabla como una referencia, no es necesario aprenderla de memoria, en caso de duda siempre se puede consultar, incluso puede que cambie ligeramente según el compilador, y en último caso

veremos sistemas para eludir la precedencia.

ORDEN (SE EVALÚA...) OPERADORES

1ero. (prioridad más alta) no – not

2do. / , * , div , mod , y – and

3ero. + , - , o – or

4to. (prioridad más baja) < , > , = , >= , <= , <>

La precedencia es el orden en el cual serán realizadas las evaluaciones; por ejemplo: la multiplicación se realiza antes que la suma.

Las reglas de precedencia, en forma completa, de los operadores se muestran en la siguiente tabla:

ORDEN (SE EVALÚA...) OPERADORES

Prioridad más alta (1era operación ejecutada) O – OR

Y – AND

NO – NOT

< , > , = , >= , <= , <>

+ , -

MOD

DIV

* , /

Prioridad más baja (última operación ejecutada) ^

- 258 -

2.5. ASOCIATIVIDAD DE OPERADORES

Operadores Asociatividad

() [] -> :: . Izquierda a derecha

Operadores unitarios: ! ~ + - ++ -- & (dirección de) *

(puntero a) sizeof new delete

Derecha a izquierda

.* ->* Izquierda a derecha

* (multiplicación) / % Izquierda a derecha

+ - (operadores binarios) Izquierda a derecha

<< >> Izquierda a derecha

< <= > >= Izquierda a derecha

== != Izquierda a derecha

& (bitwise AND) Izquierda a derecha

^ (bitwise XOR) Izquierda a derecha

| (bitwise OR) Izquierda a derecha

&& Izquierda a derecha

|| Izquierda a derecha

?: Derecha a izquierda

= *= /= %= += -= &= ^= |= <<= >>= Derecha a izquierda

, Izquierda a derecha


- 259 -

ANEXO 3.- TIPOS DE DATOS EN C++

TIPO TAMAÑO

(EN BITS)

RANGO DE VALORES APLICACIÓN

unsigned char 8 0 a 255 Números pequeños y el conjunto de

caracteres de la PC

char 8 -128 a 127 Números muy pequeños y caracteres ASCII

enum 16 -32.768 a 32.767 Conjunto ordenado de valores.

unsigned int 16 0 a 65.535 Números grandes, bucles.

short int 16 -32.768 a 32.767 Contadores, números pequeños, control de bucles.

int 16 -32.768 a 32.767 Contadores, números pequeños,

control de bucles.

unsigned long 32 0 a 4.294.967.295 Distancias astronómicas

long 32 - 2.147.483.648 a 2.147.483.647 Números grandes (poblaciones)

float 32 3.4 x 10-38 a 3.4 x 1038 Científica

double 64 1.7 x 10-308 a 1.7 x 10308 Científica

long double 80 3.4 x 10-4932 a 3.4 x 104932 Financiera

near pointer 16 No se aplica Manipulación de direcciones de

memoria

far pointer 32 No se aplica Manipulación de direcciones fuera del

segmento actual

3.1. Conversión de tipos de datos Quizás te hayas preguntado qué pasa cuando escribimos expresiones numéricas en las que todos los

operandos no son del mismo tipo.

Por ejemplo:

char n;

int a, b, c, d;

float r, s, t;

...

a = 10;

b = 100;

r = 1000;

c = a + b;

s = r + a;

d = r + b;


- 260 -

d = n + a + r;

t = r + a - s + c;

...

En estos casos, cuando los operandos de cada operación binaria asociados a un operador son de distinto tipo, se convierten a un tipo común.

Existen reglas que rigen estas conversiones, y aunque pueden cambiar ligeramente de un compilador a otro, en general serán más o menos así:

1. Cualquier tipo entero pequeño como char o short es convertido a int o unsigned int. En este punto cualquier pareja de operandos será int (con o sin signo), long, long long, double, float o

long double.

2. Si algún operando es de tipo long double, el otro se convertirá a long double.

3. Si algún operando es de tipo double, el otro se convertirá a double.

4. Si algún operando es de tipo float, el otro se convertirá a float.

5. Si algún operando es de tipo unsigned long long, el otro se convertirá a unsigned long long.

6. Si algún operando es de tipo long long, el otro se convertirá a long long.

7. Si algún operando es de tipo unsigned long, el otro se convertirá a unsigned long.

8. Si algún operando es de tipo long, el otro se convertirá a long.

9. Si algún operando es de tipo unsigned int, el otro se convertirá a unsigned int.

10. En este caso ambos operandos son int.

En el ejemplo:

c = a + b; caso 8, ambas son int.

s = r + a; caso 4, "a" se convierte a float.

d = r + b; caso 4, "b" se convierte a float.

d = n + a + r; caso 1, "n" se convierte a int, caso 4 el resultado (n+a) se convierte a float.

t = r + a - s + c; caso 4, "a" se convierte a float, caso 4 (r+a) y "s" son float, caso 4, "c" se convierte a float.

También se aplica conversión de tipos en las asignaciones, cuando la variable receptora es de distinto tipo que el resultado de la expresión de la derecha.

Cuando esta conversión no implica pérdida de precisión, se aplican las mismas reglas que para los operandos, estas conversiones se conocen también como promoción de tipos.

Cuando hay pérdida de precisión, las conversiones se conocen como democión de tipos.

El compilador normalmente emite un aviso o "warning", cuando se hace una democión implícita, es decir cuando hay una democión automática.

En el caso de los ejemplos 3 y 4, es eso precisamente lo que ocurre, ya que estamos asignando expresiones de tipo float a variables de tipo int.

3.2. Conversión explícita de tipo: Para eludir estos avisos del compilador se usa el "casting", o conversión explícita.

En general, el uso de "casting" es obligatorio cuando se hacen asignaciones, o cuando se pasan

argumentos a funciones con pérdida de precisión.

En el caso de los argumentos pasados a funciones es también muy recomendable aunque no haya pérdida de precisión. Eliminar los avisos del compilador demostrará que sabemos lo que hacemos con

nuestras variables, aún cuando estemos haciendo conversiones de tipo extrañas.

En C++ hay varios tipos diferentes de "casting", pero de momento veremos sólo el que existe también en C.

- 261 -

Sintaxis de "casting":

(<nombre de tipo>)<expresión>

ó

<nombre de tipo>(<expresión>)

Esta última es conocida como notación funcional.

En el ejemplo anterior, las líneas 3 y 4 quedarían:

d = (int)(r + b);

d = (int)(n + a + r);

ó:

d = int(r + b);

d = int(n + a + r);

Hacer un "casting" indica que sabemos que el resultado de estas operaciones no es un int, que la variable receptora sí lo es, y que lo que hacemos lo hacemos a propósito.

Veremos más adelante, cuando hablemos de punteros, más situaciones donde también es obligatorio el uso de "casting".


- 262 -

ANEXO 4.- SISTEMAS NUMÉRICOS

¿Que es un sistema Numérico?

Un sistema de numeración es un conjuntode símbolos y reglas de generación de números que permiten construir TODOS los números válidos en el sistema.

Por ejemplo tenemos en el sistema Decimal definidos los números desde el 0 al 9, éste es el conjunto de símbolos y pero podemos formar otros números usando estos números o el 12 anteponiendo dos de ellos

esto sería una regla.

Sería algo parecido al sistema de numeración romana, por elemplo X (en decimal el 10) sería un símbolo y una regla nos permitiría hacer el XXI (en decimal el 21).

A lo largo de la historia se crearon varios sistemas Numéricos, nombraremos algunos de ellos:

- Decimal

- Romano

- Binario

- Octal

- Hexadecimal

Cada uno de estos sistemas Numéricos tiene su conjunto de símbolos y reglas de generación que permiten construir todos los números válidos en el sistema, en algunos casos son mas fáciles unos que

otros.

Los sistemas Numéricos se suelen clasificar en dos grandes grupos, posicionales y no posicionales.

En los sistemas modernos de numeración básicamente se usa el sistema posicional o ponderado (dependiendo de la ubicación u orden tiene un peso, para el caso del 12, el 1 tiene un peso de 10), en estos

sistemas de numeración ponderados o posicionales el valor de un dígito depende tanto del símbolo utilizado, como de la posición que ése símbolo ocupa en el número (unidad, decena, centena). Esto tiene como efecto

facilitar operaciones como suma, resta, etc.

Cómo encontrar las equivalencias entre algunos sistema de numeración?

Nos concentraremos en los sistemas: Hexadecimal, Binario. Utilizaremos como punto de comparación o conversión el Sistema más usado el Decimal.

Sistema Hexadecimal:

El sistema de numeración hexadecimal, de base 16, utiliza 16 símbolos.

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.

Es común abreviar hexadecimal como hex aunque hex significa base seis. Como dijimos dado que el sistema usual de numeración es de base decimal y, por ello, sólo se dispone de diez dígitos, se adoptó la

convención de usar las seis primeras letras del alfabeto latino para suplir los dígitos que nos faltan: A = 10, B = 11, C = 12, D = 13, E = 14 y F = 15.

Si intentamos hacer una conversión al sistema decimal quedaría:

0 ≡ 0

1 ≡ 1 6 ≡ 6 11 ≡ B

2 ≡ 2 7 ≡ 7 12 ≡ C

3 ≡ 3 8 ≡ 8 13 ≡ D

4 ≡ 4 9 ≡ 9 14 ≡ E

5 ≡ 5 10≡ A 15 ≡ F

Con esto tenemos algunos números del espacio de números Hexadecimal pero como encontramos las equivalencias para convertir cualquier número Hexadecimal a Decimal.


- 263 -

Por ejemplo:

1A → el 1 indica que supero una vez a la base que es 16, y la letra A que son 10 unidades. Entonces 1A

sería equivalente a 16+10 total 26

3F → el 3 indica que supero tres veces a la base 3*16, y la letra F que son 15 unidades. Entonces 3F

sería equivalente a 3*16+15 total 63.

En forma genérica se puede expresar:

VXYZHexadecimal = V*163 + X*162 + Y*161 + Z*160

V, X, Y, Z serían el equivalente decimal de cualquier símbolo Hexadecimal.

El Resultado de esto daría un número en formato Decimal.

Ejemplo:

1A3F = 1*163+ A*162 + 3*161 + F*160 = 1*163+ 10 *162 + 3*161 +15*160 = 6719

Observación:

-Ver que exponente de la base (16) está relacionado con la posición del símbolo. Se empieza a contar la posición desde la derecha y la primera es la posición cero.

Para el caso de:

- A se encuentra en la posición 2, 0(F), 1(3), 2(A), por lo que A (10) quedará multiplicado por 16 elevado al Cuadrado.

- F se encuentra en la posición cero, por lo que F (15) quedará multiplicado por 16 elevado a la cero.

- 3 se encuentra en la posición 1, por lo que 3 (3) quedará multiplicado por 16 elevado a la uno.

Sistema Binario:

El sistema binario, es usado en matemáticas e informática, es un sistema de numeración en el que los números se representan utilizando solamente las cifras cero y uno (0 y 1).

Es el que se utiliza en los ordenadores, pues trabajan internamente con dos niveles de voltaje o tensión, por lo que su sistema de numeración natural es el sistema binario (encendido 1, apagado 0). Cada posición

puede tener = o 1 y se denominaremos Bit.

Para este tipo de Sistema numérico los símbolos son 0 y/ó 1 y se forman los números combinando ceros

y unos.

Veamos que si tengo 2 símbolos y tengo que representar el equivalente a 7 (en decimal) voy a necesitar 3 bits, ya que 2 (base) elevado a la cantidad de bits (3) me dá 8, que sería la cantidad de combinaciones

posibles logradas con 3 bits en un sistema binario.

Veamos como queda:

000 0 100 4

001 1 101 5

010 2 110 6

011 3 111 7

Vemos entonces que el sistema de números se logra poniendo Bits o Ceros y unos.

De lo expuesto para el sistema binario y pensando en lo que hicimos para el sistema Hexadecimal podemos hacer un expresión similar con la base que tenemos, que para nuestro caso es 2.

101 = 1 * 22 + 0 * 21 + 1 * 20 = 1*4+0+1= 5 (decimal)

En forma genérica se puede expresar:

VXYZBinario = V*23 + X*22 + Y*21 + Z*20

V, X, Y, Z serían el equivalente binario de cualquier símbolo binario (0 o 1). El Resultado de esto daría un

número en formato Decimal.


- 264 -

Ejemplo:

1011 = 1*23+ 0*22 + 1*21 + 1*20 = 1*8+ 0 + 1*2 +1*1 =11 (once en sistema decimal)

Observación:

- Ver que exponente de la base (2) está relacionado con la posición del símbolo. Para el caso de 1011 se encuentra en la posición tres, por lo que este 1 quedará multiplicado por 2 elevado a la tres.-


- 265 -

ANEXO 5.- CÓDIGOS ASCII

ASCII: Acrónimo inglés de American Standard Code for Information Interchange. Son códigos estandar para que los equipos intercambien información, es decir la N en Europa es la N en Latinoamerica pero como a los equipos les es más facil manejar Números que caracteres, internamente, estos caracteres son

representados por números.

El código ASCII utiliza 7 bits para representar los caracteres.

Esta es la Tabla:

Como podemos ver, existen relaciones importantes que se puelen usar.

Por ejemplo:

0 1 2.... 9 => 48 49 50, … , 59 siempre hablando de decimales.

Lo mismo podemos plantear para a, b, c, e..... y para A, B, C.....etc.

¿Cómo se puede utilizar?

Si el carácter ingresado tiene un valor decimal mayor o igual que 65 y menor o igual que 90 es una letra Mayúscula.

Si el carácter ingresado tiene un valor decimal mayor o igual que 97 y menor o igual que 122 es una letra Minúscula.

Si el carácter ingresado tiene un valor decimal mayor o igual que 48 y menor o igual que 57 es un Número.


- 266 -

Símbolos y nombre ASCII usados corrientemente

Nombres Comunes

Nombres Raros

!

Signo de Explamación

exclamation mark bang

pling excl

not

shriek

factorial

exclam smash

cuss boing

yell

wow hey

wham eureka

spark-spot

soldier control

"

Comilla doble quotation marks

quote

double quote

literal mark double-glitch

dieresis

dirk rabbit-ears

double prime

#

Numeral

hash pound sign

number

sign pound

sharp crunch

hex

mesh

grid

crosshatch octothorpe

flash

square pig-pen

tictactoe scratchmark

thud

thump splat

$

Signo pesos dollar sign

dollar

currency symbol buck

cash string

escape

ding cache

big money

%

Porciento

percent sign

mod grapes

double-oh-seven

&

ampersand

amp

amper and

and sign

address

reference

andpersand bitand

background pretzel

'

apostrofe apostrophe

single quote

quote

prime glitch

tick

irk pop

- 267 -

spark

closing single quotation mark

acute accent

( )

opening / closing parentesis

left / right paren left / right parenthesis

left / right open / close

open / close paren

paren / thesis

so/already lparen/rparen

opening/closing parenthesis opening/closing round bracket

left/right round bracket wax/wane

parenthisey/unparenthisey

left/right ear

[ ]

Corchetes

opening / closing bracket left / right bracket

left / right square bracket

bracket / unbracket

square / unsquare

u turn / u turn back

{ }

Llaves

opening / closing brace open / close brace

left / right brace left / right squiggly

left / right squiggly

bracket/brace left / right curly bracket/brace

brace / unbrace

curly / uncurly leftit / rytit

left / right squirrelly embrace / bracelet

< >

Menor , Mayor less / greater than

bra / ket

left / right angle left / right angle bracket

left / right broket

from / into (or towards) read from / write to

suck / blow

comes-from / gozinta in / out

crunch / zap tic / tac

angle / right angle

*

asterisco star

splat

wildcard gear

dingle mult

spider aster

times

twinkle glob

Nathan Hale

+ mas

plus

add

cross

intersection

, coma

comma

cedilla

tail

-

menos, guión medio

dash hyphen

minus

worm

option dak

bithorpe

.

punto period

dot point

decimal point

radix point full stop

spot

/ barra slash

diagonal solidus


- 268 -

stroke

slant forward slash

over

slak virgule

slat

\

backslash hack

whack escape

reverse slash

slosh

backslant backwhack

bash reverse slant

reversed virgule backslat

: colon dots

two-spot

; Punto y coma

semicolon semi

weenie

hybrid pit-thwong

=

igual equals

gets takes

quadrathorpe half-mesh

?

signo de pregunta

question mark query

ques

quiz

whatmark what

wildchar huh

hook

buttonhook hunchback

@

arroba at sign

at

strudel

each vortex

whorl

whirlpool cyclone

snail ape

cat rose

cabbage

commercial at

^

acento circunflexo

circumflex caret

hat

control uparrow

xor sign

chevron shark (or shark-fin)

to the

fang pointer

_

Guión bajo underline

underscore underbar

under

score backarrow

skid flatworm

`

Acento grave grave accent

backquote left quote

left single quote

open quote grave

backprime backspark

unapostrophe birk

blugle

back tick back glitch


- 269 -

push

opening single quote quasiquote

|

barra

bar or

or-bar v-bar

pipe vertical bar

vertical line

gozinta thru

pipesinta spike

~

tilde

squiggle twiddle

not

approx

wiggle swung dash

enyay sqiggle (sic)


- 270 -

ANEXO 6.- PALABRAS RESERVADAS EN C

C ++ C

1 asm auto

2 auto break

3 bool case

4 break char

5 case const

6 catch continue

7 char default

8 class do

9 const double

10 const_cast else

11 continue enum

12 default extern

13 delete float

14 do for

15 double goto

16 dynamic_cast if

17 else int

18 enum long

19 explicit register

20 extern return

21 false short

22 float signed

23 for sizeof

24 friend static

25 goto struct

26 if switch

27 inline typedef

28 int union

29 long unsigned


- 271 -

30 mutable void

31 namespace volatile

32 new while

33 operator

34 private

35 protected

36 public

37 register

38 reinterpret_cast

39 return

40 short

41 signed

42 sizeof

43 static

44 static_cast

45 struct

46 switch

47 template

48 this

49 throw

50 true

51 try

52 typedef

53 typeid

54 typename

55 union

56 unsigned

57 using

58 virtual

59 void

60 volatile

61 while

- 272 -

ANEXO 7.- ESTILOS DE NOTACIÓN

En la medida en que el lenguaje C y C++ se empieza a conocer y el código fuente empieza a ser mas

complejo conviene tratar de ser lo mas claro posible en el código, de manera de que sea facil la interpretacion del código fuente.

Recordemos que hoy, tal vez entendamos bien qué hace el código, pero que sucedería si lo miramos dentro de 5 años?

Para lograr una convención en la escritura de código fuente presentamos algunas sugerencias:

7.1. Comentarios Se deben escribir comentarios!!

Recodermos que con // o /* .... */ se pueden introducir comentarios en el código.

7.2. Nombres de variables Los nombres de las variables se tienen que seleccionar de acuerdo al uso o al contenido que

almacenaran.

Por ejemplo, llamaríamos tempambiente o temp_ambiente a una variable que represente la temperatuta ambiente y no solamente t.

En este punto se puede incluir la Notación tipo Camello que sería:

TempAmbiente que también es muy usada.

5.3. Notación tipo Húngara Para utilizar una notación común, hemos seleccionado la notación tipo Húngara, ya que esta facilita la

interpretación en cuanto al tipo de variable y uso.

La notación Húngara esta conformada por dos partes, además del nombre de la variable:

<Prefijo> <Tipo Base>_<Nombre de la Variable>

<Tipo Base> sería el tipo de la variable

Los tipos de variables más comunes son:

Notación Tipo de variable Ejemplo

s varibles del tipo short

i variables del tipo int int b; => int ib;

l variables del tipo long long dni => long l_dni;

c variables del tipo char char opcion => char c_opcion;

sz variables del tipo string ( array de caracteres terminados en /0)

char texto[20] => char sz_texto[20];

d variables del tipo double

f variables del tipo float float f_promedio;

e variables del tipo enum enum habiles {lunes=1 , martes, miercoles,

jueves, viernes}; =>enum e_dias{lunes=1 , martes, miercoles, jueves, viernes}

b variables del tipo bool bool bandera => bool b_bandera;

- 273 -

<Prefijo> va antes del tipo base e indican el uso.

Los prefijos más comunes son:

Notación Uso Ejemplo

a_ array int x[10] , notas [3][3]=> int ai_x[10] ,

ai_notas[3][3]

c_ contador int j => int ci_j;

e_ elemento de un array int x0 => int ei_x0 ;//primer elemento del array;

g_ variable global. bool cargado /*fuera de main()*/ =>

bool gb_cargado;

m_ variable miembro o propiedad ( usado en estructuras o clases)

p_ puntero int *k => int * pi_k; /* puntero a entero */

- 274 -

ANEXO 8. SUMARIO DE ÓRDENES BÁSICAS LINUX

Esta sección introduce algunos de las órdenes básicas más útiles de un sistema UNIX, incluidas las ya cubiertas en las secciones anteriores.

Nótese que las opciones usualmente comienzan con "-" y en la mayoría de los casos se pueden añadir múltiples opciones de una letra con un único "-". Por ejemplo, en lugar de usar ls -l -F es posible usar ls -lF.

En lugar de listar todas las opciones disponibles para cada uno de los comandos solo hablaremos de aquellas más útiles o importantes. De hecho, la mayoría de las órdenes tienen un gran número de opciones

(muchas de las cuales nunca usará). Puede usar man para ver las páginas de manual de cada orden, la cual mostrará la lista completa de opciones disponibles.

Nótese también, que la mayoría de las órdenes toman una lista de ficheros o directorios como argumentos, denotados como "<fichero1> . .<.ficheroN>". Por ejemplo, la orden cp toma como argumentos

la lista de ficheros a copiar, seguidos del fichero o directorio destino. Cuando se copia más de un fichero, el destino debe de ser un directorio.

cd Cambia el directorio de trabajo actual.

Sintaxis: cd <directorio>

<directorio> es el directorio al que cambiamos. ("." se refiere al directorio actual,".." al directorio padre.)

Ejemplo: cd ../foo pone ../foo como directorio actual.

ls Muestra información sobre los ficheros o directorios indicados.

Sintaxis: ls <fichero1> <fichero2> . . .<ficheroN>

Donde <fichero1> a <ficheroN> son los ficheros o directorios a listar.

Opciones: Hay más opciones de las que podría suponer. Las más usadas comúnmente son: -F (usada para mostrar información sobre el tipo de fichero), y -l (da un listado "largo" incluyendo tamaño, propietario, permisos..etc. Trataremos esto en detalle más adelante.)

Ejemplo: ls -lF /home/larry mostrará el contenido del directorio /home/larry.

cp Copia fichero(s) en otro fichero o directorio.

Sintaxis: cp <fichero1> <fichero2> . . .<ficheroN> <destino>

Donde <fichero1> a <ficheroN> son los ficheros a copiar, y <destino> es el fichero odirectorio

destino.

Ejemplo: cp ../frog joe copia el fichero ../frog al fichero o directorio joe.

mv Mueve fichero(s) a otro fichero o directorio. Es equivalente a una copia seguida del borrado del original. Puede ser usado para renombrar ficheros, como el comando MS-DOS RENAME.

Sintaxis: mv <fichero1> <fichero2> . . .<ficheroN> <destino>

Donde <fichero1> a <ficheroN> son los ficheros a "mover" y <destination> es el fichero o directorio destino.

Ejemplo: mv ../frog joe mueve el fichero ../frog al fichero o directorio joe.

rm Borra ficheros. Nótese que cuando los ficheros son borrados en UNIX, son irrecuperables (a diferencia de MS-DOS, donde usualmente se puede recuperar un fichero borrado).

Sintaxis: rm <fichero1> <fichero2> . . .<ficheroN>

Donde <fichero1> a <ficheroN> son los nombres de los ficheros a borrar.

Opciones: -i pedirá confirmación antes de borrar un fichero.

Ejemplo: rm -i /home/larry/joe /home/larry/frog borra los ficheros joe y frog en /home/larry.

- 275 -

mkdir Crea directorios nuevos.

Sintaxis: mkdir <dir1> <dir2> . . .<dirN>

Donde <dir1> a <dirN> son los directorios a crear.

Ejemplo: mkdir /home/larry/test crea el directorio test colgando de /home/larry.

rmdir Esta orden borra directorios vacios. Al susar rmdir, el directorio de trabajo actual no debe de

estar dentro del directorio a borrar.

Sintaxis: rmdir <dir1> <dir2> . . .<dirN>

Donde <dir1> a <dirN> son los directorios a borrar.

Ejemplo: rmdir /home/larry/papers borra el directorio /home/larry/papers si está vacio.

man Muestra la página de manual del comando o recurso (cualquier utilidad del sistema que no

es un comando, como funciones de librería) dado.

Sintaxis: man <command> Donde <command> es el nombre del comando o recurso sobre el que queremos obtener la ayuda.

Ejemplo: man ls muestra ayuda sobre la orden ls.

more Muesta el contenido de los ficheros indicados, una pantalla cada vez.

Sintaxis: more <fichero1> <fichero2> . . .<ficheroN>

Donde <fichero1> a <ficheroN> son los ficheros a mostrar.

Ejemplo: more papers/history-final muestra por el terminal el contenido del fichero papers/history-final.

cat Oficialmente usado para concatenar ficheros, cat también es usado para mostrar el contenido completo de un fichero de una vez.

Sintaxis: cat <fichero1> <fichero2> . . .<ficheroN>

Donde <fichero1> a <ficheroN> son los ficheros a mostrar.

Ejemplo: cat letters/from-mdw muestra por el terminal el contenido del fichero letters/from-

mdw.

echo Simplemente envía al terminal los argumentos pasados.

Sintaxis: echo <arg1> <arg2> . . .<argN>

Donde <arg1> a <argN> son los argumentos a mostrar.

Ejemplo: echo ``Hola mundo'' muestra la cadena "Hola mundo".

grep Muestra todas las líneas de un fichero dado que coinciden con un cierto patrón.

Sintaxis: grep <patrón> <fichero1> <fichero2> . . .<ficheroN>

Donde <patrón> es una expresión regular y <fichero1> a <ficheroN> son los ficheros donde buscar. Ejemplo: grep loomer /etc/hosts mostrará todas las líneas en el fichero /etc/hosts que contienen la cadena "loomer".


- 276 -

ANEXO 9. ENTORNO ANJUTA

Este apéndice explica como utilizar el Anjunta para realizar tareas sencillas como compilar, depurar, etc., para obtener un manual detallado (en inglés) se puede descargar la página desde el link:

http://anjuta.org/documentations/subpage/documents/C/anjuta-manual/anjuta-manual.html

9.1. Introducción

Anjuta es un Entorno Integrado de desarrollo (IDE) para C y C++ que proporciona gran cantidad de facilidades para la programación. Posee una interfaz gráfica para acceder a múltiples herramientas de programación disponibles para sistemas Linux que se ejecutan en línea de ordenes.

Anjuta intenta ser amigable al usuario. Está escrito para GTK+/GNOME y pretende combinar la flexibilidad y la potencia de las herramientas en línea de ordenes con la interfaz gráfica fácil-de-usar de

GNOME.

Este apéndicel se refiere a la versión 1.2.2 de la aplicación.

La primera vez que se inicia Anjuta, se muestra al usuario un mensaje de bienvenida.

Al iniciar la aplicación se mostrará la ventana principal en la que se distingue diversas zonas:

Ventana principal de Anjuta

http://anjuta.org/documentations/subpage/documents/C/anjuta-manual/anjuta-manual.html


- 277 -

9.2. Barra de menú

Prácticamente todas las opciones de Anjuta están disponibles desde alguna opción de este menú. Estas opciones están agrupadas en diversos submenús:

Archivo: incluye las opciones típicas de gestión de archivos (Nuevo, Abrir, Guardar, Guardar

Como, Cerrar), así como opciones de gestión de proyectos (Proyecto Nuevo, Abrir proyecto, Cerrar proyecto, Guardar proyecto, Importar proyecto). Un proyecto permite organizar los

diversos archivos de una aplicación en una sola entidad, para una mejor gestión de la misma. En este menú también están las opciones de impresión (Imprimir, Vista previa de impresión).

Editar: con las opciones de Cortar, Copiar, Pegar y Borrar, así como las de Deshacer y Rehacer. También incluye varios submenús para facilitar la edición de texto al programar. Desde opciones

de búsqueda y reemplazo (opción Buscar), opciones de conversión de caracteres (opción Transformar), opciones de selección de texto (opción Seleccionar), múltiples opciones de

inserción de texto orientadas a la programación en lenguaje C (opción Insertar texto), opciones

de comentar bloques de código fuente (opción Comentar código), así como opciones para ir rápidamente a diversos sitios del documento (opción Ir a).

Sugerencia: La opción Editar -> Buscar -> Buscar en archivos permite realizar búsquedas de un texto en múltiples archivos, mediante una caja de diálogo con múltiples y potentes opciones.

Ver: permite mostrar y ocultar las diversas barras de herramientas y ventanas de la aplicación, así como algunas características del editor (números de línea, márgenes, etc.)

Proyecto: opciones para gestionar los proyectos, tales como añadir y quitar archivos del

proyecto, o editar la configuración del proyecto. Desde aquí también se invoca al editor GUI para crear la interfaz gráfica de la aplicación(opción Editar GUI de la aplicación, necesita tener Glade

instalado).

Formato: opciones de formateo del texto, permitiendo el resaltado sintáctico, así como desplegar

y replegar trozos de código.

Construir: opciones de compilación y de construcción del código de la aplicación.

Marcador: permite insertar marcadores en el código y desplazarse por ellos.

Depurador: opciones de depuración del código. Permite insertar puntos de ruptura y una ejecución controlada, así como evaluar e inspeccionar variables.

CVS: opciones para trabajar sobre un repositorio CVS (Sistema de Control de Versiones), lo que permite controlar los cambios que se realicen sobre el código.

Opciones: opciones para establecer las preferencias de un montón de características de la

aplicación, desde opciones del compilador y enlazador hasta las opciones del editor y las preferencias generales de la aplicación.

Ayuda: permite acceder a la ayuda en línea (Manual de Anjuta), a un tutorial (Cursillo de Anjuta), a la página web del proyecto, así como a fuentes relacionadas, tales como páginas del

API de Gnome, páginas de Man y páginas de Info.

9.3. Barra de herramientas

En ellas se incluyen las opciones más habituales. Por defecto Anjuta muestra dos barras, la Barra Principal y la Barra de Navegación.

Estas barras pueden desplazarse de su ubicación y colocarse en otra posición o ser incluso flotantes. Para ello, hacer clic en el extremo izquierdo de la barra y arrastrar con el ratón a la ubicación deseada.

Las barras disponibles son:

Barra principal: funciones de archivos y de edición de textos.

Barra de Navegación: navegación por los marcadores y etiquetas de función.

Barra extendida: funciones del proyecto y de compilación, construcción y ejecución.

Barra de depuración: controles para el Depurador de código.

Barra de formato: funciones para dar formato al texto y al código.


- 278 -

9.4. Ventana principal

Es la zona de trabajo y en ella se pueden observar diversos paneles, que pueden ocultarse y mostrarse (menú Ver -> Ventana de mensajes y Ver -> Ventana del proyecto), así como cambiar su tamaño, haciendo clic sobre los bordes de separación y arrastrando con el ratón.

Estos paneles son:

Ventana de edición: Esta ventana es la ubicada en la zona derecha y en ella están los documentos abiertos con los que se trabaja. Puede haber muchos documentos abiertos, pero únicamente hay uno activo en un momento dado. Todos los órdenes y acciones se aplicarán

sobre dicho documento. Se puede cambiar de documento haciendo clic en la pestaña de la

página. También se puede seleccionar un documento haciendo clic derecho sobre cualquier pestaña y seleccionando el documento de la lista que aparece.

Ventana de proyecto: Esta ventana es la ubicada en la zona izquierda. Muestra un árbol con los archivos de código fuente que contiene el proyecto. Posee en la parte inferior varias pestañas

para ver diversas vistas del proyecto (Proyecto: muestra el código fuente, Archivos: Muestra todos los archivos de la carpeta, y Símbolos)

Ventana de mensajes: Ubicada en la zona inferior de la ventana. Muestra todos los mensajes tanto de la salida estándar (stdout) como de la salida estándar de error (stderr) cuando se

ejecuta una orden externa. La Ventana de mensajes está habitualmente oculta y se muestra cuando se ejecuta una orden externa.

Los colores con que se muestran los mensajes son relevantes. Los de color negro son mensajes normales informativos. Los de color azul son mensajes importantes como avisos (Warnings) y mensajes de

error. Los mensajes de color rojo indican que están enlazados, es decir, haciendo doble-clic sobre un mensaje de color rojo llevará el cursor al archivo y la línea que se especifica en el mensaje.

Además, la ventana de mensajes tiene múltiples pestañas donde se va mostrando información según las acciones que se estén llevando a cabo, incluyendo las salidas estándar y ventanas de depuración.

9.4.1. Hacer las ventanas flotantes

Haciendo clic en la esquina superior izquierda de las ventanas, éstas se vuelven flotantes. Para ponerlas otra vez en su sitio, hacer clic derecho sobre la ventana y seleccionar la opción Empotrado.

9.4.2. Ventana de Inicio de Anjuta

Al iniciar Anjuta se verá una imagen como la siguiente:


- 279 -

Deberemos elegir para la mayoría de los caso la Opción “Archivo Nuevo”, luego aparecerá la siguiente

partalla:

Le damos un nombre al Archivo, recordemos que es aconsejable que el mismo refleje la tarea del código. Como tipo de Archivo, debemos indicar que es C++ Source File.

9.5. Teclas Rápidas

Abrir Archivo Nuevo Ctrl + N

Abrir Ctrl + O

Copiar Ctrl + C

Pegar Ctrl + V

Cortar Ctrl + X

Compilar F9

Construir ejecutable F11

Deshacer Ctrl + Z

Buscar Ctrl + F

9.6. Compilar y construir una aplicación

9.6.1. Compilar el programa fuente

Para compilar el archivo actual (si es un archivo fuente en C o C++), seleccionar la opción de menú

Construir -> Compilar o hacer clic en el botón Compilar de la barra extendida.

Otra opción es pulsar la tecla de función F9.

A continuación, aparecerá la ventana de mensajes que mostrará todos los mensajes que produzca el proceso de compilación, incluidos los errores.

Haciendo doble clic sobre las líneas de color rojo, se sitúa el cursor en la línea que ha generado el error.

Pueden establecerse las opciones de compilación seleccionando la opción de menú Opciones -> Opciones de compilador y enlazador. Al compilar un archivo, Anjuta lo guardará antes en disco y luego lo

compilará.


- 280 -

El proceso de compilación genera un archivo de código objeto (*.o) que será luego enlazado para

construir el ejecutable.

9.6.2. Construir el archivo ejecutable

Para construir un ejecutable, seleccionar la opción de menú Construir -> Construir o hacer clic en el botón Construir de la barra extendida.

Otra opción es pulsar la tecla de función F11.

Esto mostrará la ventana de mensajes con todos los mensajes que produzca la construcción del ejecutable.

El proceso de construcción enlazará el archivo objeto con las bibliotecas indicadas y generará el ejecutable.

Las bibliotecas a enlazar se pueden indicar en Opciones -> Opciones de compilador y enlazador, pestaña Bibliotecas.

9.6.3. Dependencias de construcción

El proceso de construcción, puede detectar si el archivo objeto no está actualizado o aún no ha sido generado; en ese caso intentará compilar el archivo antes de enlazarlo. Esto implica que puede construirse

directamente un archivo sin necesidad de compilarlo.

Sin embargo, cuando se está trabajando en un proyecto con múltiples archivos que se enlazan, la compilación y la construcción son conceptos claramente distintos.

9.7. Ejecutar un programa

Una vez que se ha construido con éxito el ejecutable, para probarlo seleccionar la opción de menú Construir -> Ejecutar o hacer clic en el botón Ejecutar de la barra extendida.

También se puede pulsar la tecla de función F3.

9.7.1. Dependencias

Al contrario que en la fase de construcción, la ejecución no comprueba las dependencias, es decir, no

comprueba si el ejecutable está en la última versión, así que es tarea del usuario, realizar la comprobación.

Para pasar argumentos al programa, seleccionar la opción Construir -> Configurar los parámetros del programa. Se mostrará una caja de diálogo donde poder introducir los parámetros. Para ejecutar, seleccionar el botón Ejecutar.

También puede especificarse si el programa debe ejecutarse en un terminal o no.

Cuadro de diálogo: Establecer los parámetros del programa

9.8. Preferencias

Anjuta permite la personalización de muchas de sus características para que el usuario trabaje más

cómodamente.

Para mostrar la ventana de preferencias, seleccionar la opción de menú Opciones -> Preferencias.


- 281 -

Para volver a las preferencias que trae Anjuta por defecto, seleccionar la opción de menú Opciones -> Preferencias predeterminadas.

Ventana: Establecer las preferencias

La ventana de preferencias que se muestra posee diversas secciones:

Editor: En esta sección se pueden establecer algunos valores como el tiempo de autoguardado, el tipo de autocompletado, el plegado de código, la posición y orden de las solapas del editor,

etc.

Print: Opciones de impresión de los documentos.

CVS: Opciones para la utilización del Sistema de Control de Versiones (CVS).

Build: Opciones de construcción. Según haya un proyecto abierto o no, las preferencias que se establezcan serán a nivel de proyecto o serán globales.

Messages: Se pueden cambiar algunas características de la Ventana de mensajes, como el color de los mismos, el estilo de los indicadores.

Indentation: Opciones de sangría y autoformato como el tamaño de la tabulación y de la

sangría, el estilo del formato.

General: Opciones como el directorio en que se guardarán los directorios de proyectos, el tamaño del histórico, información del usuario y otras opciones generales.

Encodings: En qué codificación de caracteres se almacenan los documentos del proyecto. Puede utilizarse la codificación original, la codificación definida en el sistema o utilizar siempre UTF-8.

Terminal: Permite indicar un perfil para el terminal de la solapa Terminal en la Ventana de mensajes.

apuntetallerinformatica_v2.pdf

Documents