Apunte Taller Informatica

Taller de Informática
Apunte de cátedra
UNaM
Facultad de Ingeniería
UNIVERSIDAD NACIONAL DE MISIONES
FACULTAD DE INGENIERÍA
TALLER DE INFORMÁTICA
Apuntes de Cátedra
INDICE
INDICE ............................................................................................................................................ 3
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. ........................................................................... 9
CAPITULO 1. ................................................................................................................. 10
INTRODUCCION A LA INFORMÁTICA ........................................................................... 10
1.1. OBJETIVOS. .......................................................................................................................... 10
1.2. TIPOS DE CONOCIMIENTOS. ............................................................................................ 10
1.3. SISTEMAS NUMÉRICOS ..................................................................................................... 11
1.4. OPERACIONES LÓGICAS BINARIAS ............................................................................... 13
1.5. EL SISTEMA BINARIO Y LA RELACIÓN CON LA ELECTRÓNICA. ........................... 15
1.6. UNIDADES DE INFORMACIÓN ......................................................................................... 16
1.7. CODIFICACIÓN DE CARACTERES ................................................................................... 16
1.8. MAQUINA DE VON NEUMANN VS. ARQUITECTURA HARWARD ........................... 18
1.9 LENGUAJES DE PROGRAMACIÓN ................................................................................... 19
1.10 LENGUAJES INTERPRETADOS VS LENGUAJES COMPILADOS ............................... 20
1.11. TIPOS DE ERRORES .......................................................................................................... 21
CAPITULO 2. ................................................................................................................. 22
INTRODUCCION A LA PROGRAMACION ....................................................................... 22
2.1. ANÁLISIS Y RESOLUCIÓN DE PROBLEMAS. ................................................................ 22
2.1.1. Análisis del Problema ...................................................................................................... 22
2.1.2. Diseño del Algoritmo ....................................................................................................... 22
2.1.3. Implementación del Algoritmo en la Computadora. ........................................................ 23
2.2. ETAPAS EN LA CREACIÓN DE PROGRAMAS. .............................................................. 25
2.2.1. Análisis del Problema. ..................................................................................................... 25
2.2.2. Diseño. ............................................................................................................................. 25
2.2.3. Implementación del Algoritmo en la Computadora ......................................................... 25
2.2.4. Documentación y Mantenimiento. ................................................................................... 26
2.3. PROGRAMAS: CONCEPTO, CARACTERÍSTICAS. ......................................................... 27
2.3.1. Partes de un programa. ..................................................................................................... 27
2.4. TÉCNICAS DE PROGRAMACIÓN. .................................................................................... 28
2.4.1 Programación no Estructurada. ......................................................................................... 28
2.4.2 Programación Procedimental ............................................................................................ 28
2.4.3 Programación Modular ..................................................................................................... 29
2.5. EJERCICIO PARA ILUSTRAR LA METODOLOGÍA ....................................................... 30
 PREGUNTAS DE REPASO .................................................................................................... 31
CAPITULO 3. ................................................................................................................. 32
ALGORITMOS ............................................................................................................... 32
3.1. CONCEPTO. CARACTERÍSTICAS. DISEÑO. ................................................................... 32
3.1.1. Concepto .......................................................................................................................... 32
3.1.2. Características .................................................................................................................. 32
3.1.3. Diseño .............................................................................................................................. 32
3.2. APLICACIÓN DE ESTRATEGIAS DE RESOLUCIÓN DE PROBLEMAS. ..................... 35
3.3. ESTRUCTURAS BÁSICAS: LINEALES, SELECTIVAS Y REPETITIVAS ..................... 37
3.3.1. Estructuras básicas lineales .............................................................................................. 37
3.3.2. Estructuras básicas selectivas........................................................................................... 40
3.3.3. Estructuras de Control Repetitivas ................................................................................... 46
3.4. CONTADORES, INTERRUPTORES Y ACUMULADORES. ............................................ 53
3.4.1. Contador ........................................................................................................................... 53
3.4.2. Acumulador ...................................................................................................................... 53
3.5. ARREGLOS DE DATOS ....................................................................................................... 54
3.5.1. Arreglos Unidimensionales o Vectores............................................................................ 54
3.5.2. Operaciones con Vectores ................................................................................................ 55
3.5.3. Arreglos Bidimensionales o Matrices .............................................................................. 56
3.5.4. Operaciones con Matrices ................................................................................................ 57
 Preguntas de Repaso ............................................................................................................. 58
3.6. GUÍA DE EJERCICIOS ......................................................................................................... 59
3.6.1. Ejercicios Algoritmo ........................................................................................................ 59
3.6.2. Ejercicios Expresiones ..................................................................................................... 59
3.6.3. Instrucciones Secuenciales ............................................................................................... 59
3.6.4. Instrucciones de Decisión ................................................................................................ 60
INSTRUCCIONES REPETITIVAS .......................................................................................... 62
3.6.5. Estructura FOR (Controladas por un Contador) .............................................................. 62
3.6.6. Estructuras WHILE y DO WHILE (Controladas por una condición) ............................. 63
ESTRUCTURAS DE DATOS................................................................................................... 64
3.6.7. Vectores ........................................................................................................................... 64
3.6.8. Matrices ............................................................................................................................ 65
3.6.9. Ejercicios Integradores ..................................................................................................... 67
CAPITULO 4. ................................................................................................................. 70
LENGUAJES DE PROGRAMACION ................................................................................. 70
4.1. INTRODUCCIÓN .................................................................................................................. 71
4.1.1. ¿Por qué usar C? .............................................................................................................. 71
4.2. LENGUAJE C......................................................................................................................... 73
4.2.1. Operaciones básicas de programación. ............................................................................ 73
4.2.2. Manejo de Errores. ........................................................................................................... 74
4.3. ESTRUCTURA DE UN PROGRAMA .................................................................................. 76
4.3.1. Directivas del preprocesador ............................................................................................ 76
4.3.2. Declaración de variables globales .................................................................................... 77
4.3.3. Prototipos de funciones .................................................................................................... 77
4.3.4. Declaración de clases ....................................................................................................... 77
4.3.5. Función main() ................................................................................................................. 77
4.3.6. Definición de funciones ................................................................................................... 78
4.3.7. Definición de clases ......................................................................................................... 78
4.4. DATOS, VARIABLES Y CONSTANTES ............................................................................ 79
4.4.1 Datos ................................................................................................................................. 79
4.4.2. Variables .......................................................................................................................... 79
4.4.3 Ejercicios sobre Variables ................................................................................................. 82
4.5. CONSTANTES ....................................................................................................................... 83
4.5.1. Normas para la notación .................................................................................................. 83
4.5.2. Recomendaciones en el uso de la notación. ..................................................................... 86
4.5.3 Constantes carácter. Comentario adicional. ...................................................................... 87
4.5.4. Ejercicios .......................................................................................................................... 89
4.6. OPERADORES ...................................................................................................................... 91
4.6.1. Operadores aritméticos. ................................................................................................... 91
4.6.2. Operadores relacionales ................................................................................................... 93
4.6.3. Operadores lógicos. .......................................................................................................... 93
4.6.4. Operadores de asignación ................................................................................................ 95
4.6.5. Operador "sizeof" ............................................................................................................. 95
4.6.6. Operador condicional (?) ................................................................................................. 95
4.6.7. Operador coma (,) ............................................................................................................ 96
4.7. EXPRESIONES ...................................................................................................................... 97
4.7.1. EXPRESIONES ARITMÉTICAS. ...................................................................................... 97
4.7.2. Expresiones lógicas .......................................................................................................... 98
4.7.3. Ejercicios con operadores y expresiones ....................................................................... 100
4.8. INSTRUCCIONES ............................................................................................................... 102
4.8.1. Bloques........................................................................................................................... 102
4.8.2. Expresiones. ................................................................................................................... 103
4.8.3. Bucles. ............................................................................................................................ 103
4.8.4. Etiquetas. ........................................................................................................................ 105
4.8.5. Sentencias de Selección. ................................................................................................ 106
4.8.6. Sentencias de salto ......................................................................................................... 108
4.8.7. Comentarios. .................................................................................................................. 109
4.8.8. Ejercicios con sentencias. .............................................................................................. 109
4.9. FUNCIONES ........................................................................................................................ 111
4.9.1. Declaración de función. El Prototipo. ............................................................................ 111
4.9.2. Definición de función..................................................................................................... 112
4.9.3. Función main() ............................................................................................................... 113
4.9.4. Ámbito de variables ....................................................................................................... 114
4.9.5. Ejercicios ........................................................................................................................ 115
4.10. ARREGLOS........................................................................................................................ 118
4.10.1. Cadena de caracteres. ................................................................................................... 118
4.10.2. Arreglos ........................................................................................................................ 119
4.10.3. Algoritmos de ordenación: método de la burbuja ........................................................ 121
4.10.4. Ejercicios: cadenas de caracteres. ................................................................................ 121
4.10.5. Ejercicios: arreglos ....................................................................................................... 122
4.11. GUÍA DE EJERCICIOS ..................................................................................................... 125
4.11.1. Guía Practica 1 de C++. Instrucciones secuenciales .................................................... 125
4.11.2. Guía Práctica 2 de C++. Estructuras de Decisión ........................................................ 127
4.11.3. Guía Práctica N° 3 de C++. Estructuras Repetitivas.................................................... 133
4.11.4. Guía Práctica Nº 4 de C++. Arreglos ........................................................................... 137
4.11.5. GUÍA PRÁCTICA Nº 5 DE C++. Funciones .............................................................. 151
4.11.6. GUÍA PRÁCTICA Nº 6 DE C++ ................................................................................ 155
Ejercicios Combinados usando Vectores, Matrices y Funciones ............................................ 155
Ejemplos: ................................................................................................................................. 158
4.11.7. Ejercicios Integradores ................................................................................................. 163
CAPITULO 5. ............................................................................................................... 172
SISTEMAS OPERATIVOS ............................................................................................. 172
5.1. DEFINICIONES ................................................................................................................... 172
5.1.1. Software de sistemas ...................................................................................................... 172
5.1.2. Sistema Operativo .......................................................................................................... 172
5.1.3. Traducción de lenguajes................................................................................................. 174
5.1.4. Programas de Utilería..................................................................................................... 174
5.1.5. Sistemas Operativos para Microcomputadoras .............................................................. 174
5.1.6. Historia de los Sistemas Operativos............................................................................... 174
5.1.7. Tipos de Interfaz con el usuario ..................................................................................... 175
5.1.8. Sistemas operativos actuales .......................................................................................... 175
5.2. SISTEMA OPERATIVO LINUX ........................................................................................ 177
5.3. GUIA INTRODUCTORIA DE COMANDOS DE SHELL ................................................. 178
5.3.1. Iniciando una Sesión ...................................................................................................... 178
5.3.2. Super Shell ..................................................................................................................... 178
5.3.3. ¿Qué es el Shell? ............................................................................................................ 179
5.3.4. ¿Qué es el prompt? ......................................................................................................... 180
5.3.5. Como funciona el Shell:................................................................................................. 181
5.3.6. Caractéres Especiales o Metacaractéres del Shell.......................................................... 182
5.3.7. ¿Qué es el Sistema de Ficheros? .................................................................................... 182
5.3.8. Comandos....................................................................................................................... 185
5.4. TRUCOS SHELL ................................................................................................................. 191
5.5. Los conceptos de usuarios y permisos .................................................................................. 193
5.5.1. Fijando permisos ............................................................................................................ 194
5.5.2. Bit de Stick ..................................................................................................................... 195
5.5.3. SUID - [Identificación de conjunto de usuario] ............................................................. 196
5.6. TAREAS Y PROCESOS ...................................................................................................... 197
5.6.1. Primer plano y Segundo plano ....................................................................................... 197
5.6.2. Envío a segundo plano y eliminación procesos ............................................................. 198
5.6.3. Sobre los ciclos infinitos ................................................................................................ 199
5.7. USANDO EL EDITOR VI ................................................................................................... 201
5.7.1. Conceptos ....................................................................................................................... 201
5.8. EJERCICIOS DE SISTEMA OPERATIVO ........................................................................ 206
5.8.1. Preguntas sobre Linux .................................................................................................... 206
5.8.2. Ejercicios de comandos básicos shell linux ................................................................... 207
CAPITULO 6. ............................................................................................................... 209
Software de aplicaciones ............................................................................................ 209
6.1. Procesador de Textos Writer ................................................................................................. 213
6.1.1. Configuraciones de OpenOffices ................................................................................... 213
Tamaño y Formato del Papel...................................................................................................... 213
Encabezados y Pie de Página ...................................................................................................... 213
Insertar Numeración de Página ............................................................................................ 214
Nota al Pie ................................................................................................................................... 214
Configuraciones de Párrafos .......................................................................................... 214
Personalizar ................................................................................................................. 214
Uso de las Teclas Rápidas ........................................................................................................... 214
Barras de Herramientas ............................................................................................................. 215
Opciones ...................................................................................................................... 215
Generalidades .............................................................................................................. 216
Como Usar los Encabezados ........................................................................................... 216
Editar “Estilos y Formatos” ............................................................................................ 217
Consejos ...................................................................................................................... 217
Para Encabezados ....................................................................................................................... 217
Para Cuerpo de Textos ................................................................................................................ 217
Numeración en los Encabezados ..................................................................................... 217
Guardar una Plantilla .................................................................................................... 218
Cargar una Plantilla ...................................................................................................... 218
Usar una Plantilla como Predeterminada ........................................................................ 218
Configurar las Imágenes ................................................................................................ 219
Titulo de Imagen ......................................................................................................................... 220
Insertar Formula .......................................................................................................... 221
Editar formulas ........................................................................................................................... 221
Insertar Hojas de cálculo ............................................................................................... 221
Editar las Hojas ........................................................................................................................... 222
Insertar Dibujos ........................................................................................................... 222
Movimiento y selecciones .............................................................................................. 222
Combinaciones de Teclas ............................................................................................... 223
Crear Índices ................................................................................................................ 223
Editar el contenido del índice ..................................................................................................... 223
Editar el estilo del índice ............................................................................................................. 223
Actualizar .................................................................................................................................... 223
Sobre la numeración de las figuras y las gráficas .............................................................. 224
Uso de Referencias ........................................................................................................ 224
Insertar salto de Página ................................................................................................. 224
Barra de estado ............................................................................................................ 224
Guardar como PDF ........................................................................................................ 224
6.2. Hoja de Cálculo Calc ............................................................................................................ 226
Capitulo 7 ................................................................................................................... 233
conceptos de redes e internet .................................................................................... 233
7.1. DEFINICIONES ................................................................................................................... 233
7.1.1. Telecomunicaciones ....................................................................................................... 233
7.1.2. Protocolos....................................................................................................................... 234
7.1.3. Tipos de Señales............................................................................................................. 234
7.1.4. Canales de comunicación ............................................................................................... 234
7.1.5. Características de los Canales de Comunicación ........................................................... 235
7.1.6. Funciones del software de telecomunicaciones ............................................................. 236
7.2. REDES DE COMUNICACIONES ...................................................................................... 236
7.2.1. Clasificación................................................................................................................... 236
7.2.2. Topologías de las redes .................................................................................................. 236
7.2.3. Ámbito Geográfico ........................................................................................................ 239
7.2.4. Implementación de una red ............................................................................................ 240
7.3. Conectividad ......................................................................................................................... 241
7.3.1. Definición de Conectividad ........................................................................................... 242
7.3.2. Normas para la Conectividad ......................................................................................... 243
Funciones de cada capa ............................................................................................................ 246
Nombres de los datos en cada capa .......................................................................................... 247
Las capas del modelo de referencia TCP / IP .......................................................................... 247
Gráfico de protocolo TCP/IP ................................................................................................... 249
Comparación modelos: OSI - TCP/IP ......................................................................................... 249
Similitudes ............................................................................................................................... 249
Diferencias ............................................................................................................................... 249
BIBLIOGRAFIA ........................................................................................................... 251
ANEXOS ...................................................................................................................... 253
ANEXO 1. .................................................................................................................................... 253
ESTANDARES PARA DIAGRAMAS DE FLUJO – PSEUDOCÓDIGO ................................ 253
ANEXO 2. OPERADORES ........................................................................................................ 254
2.1. OPERADORES MATEMÁTICOS .................................................................................. 254
2.2. OPERADORES DE RELACIÓN ó COMPARACIÓN ................................................... 254
2.3. OPERADORES LÓGICOS – TABLAS DE VERDAD................................................... 254
2.4. OPERADORES – ORDEN DE PRECEDENCIA ............................................................ 255
2.5. ASOCIATIVIDAD DE OPERADORES.......................................................................... 256
ANEXO 3.- TIPOS DE DATOS EN C++ ................................................................................... 257
3.1. Conversión de tipos de datos ............................................................................................ 257
3.2. Conversión explícita de tipo: ............................................................................................ 258
ANEXO 4.- SISTEMAS NUMÉRICOS ..................................................................................... 260
¿Que es un sistema Numérico? ................................................................................................ 260
ANEXO 5.- CÓDIGOS ASCII .................................................................................................... 263
Símbolos y nombre ASCII usados corrientemente .................................................................. 264
ANEXO 6.- PALABRAS RESERVADAS EN C ....................................................................... 268
ANEXO 7.- ESTILOS DE NOTACIÓN ..................................................................................... 270
7.1. Comentarios ...................................................................................................................... 270
7.2. Nombres de variables ........................................................................................................ 270
5.3. Notación tipo Húngara ...................................................................................................... 270
ANEXO 8. SUMARIO DE ÓRDENES BÁSICAS LINUX ....................................................... 272
ANEXO 9. ENTORNO ANJUTA ............................................................................................... 274
9.1. Introducción ...................................................................................................................... 274
9.2. Barra de menú ................................................................................................................... 275
9.3. Barra de herramientas ....................................................................................................... 275
9.4. Ventana principal .............................................................................................................. 276
9.5. Teclas Rápidas .................................................................................................................. 277
9.6. Compilar y construir una aplicación ................................................................................. 277
9.7. Ejecutar un programa ........................................................................................................ 278
9.8. Preferencias ....................................................................................................................... 278
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.
- Arreglos. Vectores y Matrices.
- Funciones: Ámbito de las variables: variables locales y variables globales. Pasaje de parámetros.
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
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 más más), 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.
- 10 -
d) Esperar de 1 a 2 minutos según el gusto del comensal.

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 mundial, 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.
- 11 -
Una primera 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 sistemas 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
particular se reutiliza el 1, pero en otra posición, más 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.
- 12 -
En general para cualquier número entero de cualquier sistema numérico se puede de plantear la
siguiente expresión:
Nen base r = dn-1.rn-1+dn-2.rn-2+dn-3.rn-3+....d1.r1+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:

- Decimal: 23710=2.102+3.101+7.100
- 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.
- Octal: 3558=3.82+5.81+5.80=19210+4010+510=23710
- 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.
- 13 -
En 1854, el matemático británico George Boole detalló 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.
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 claramente 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.
1
http://es.wikipedia.org/wiki/%C3%81lgebra_de_Boole
- 14 -
• 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.
Entrada a Entrada b Salida

0 0 0
0 1 1
1 0 1
1 1 1
Por último veamos la 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.
1.5. EL SISTEMA BINARIO Y LA RELACIÓN CON LA

ELECTRÓNICA.
2
El objetivo es tratar de establecer la relación entre el Sistema Numérico Binario y la Electrónica Digital
1. Los sistema electrónicos pueden simular de una manera efectiva y fácil, diríamos que casi natural,
los “0” ceros y “1” unos, con niveles de tensión, por ejemplo 0 V 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 Integrados 3
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.
- 15 -
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.
1.6. UNIDADES DE INFORMACIÓN
Hasta ahora vimos 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 1.3, se necesitan agrupar los “bits” para codificar por ejemplo números en el
sistema binario o letras ¿por qué no?
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 ampliamente 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 byte 4 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.
1.7. CODIFICACIÓN DE CARACTERES
4
http://es.wikipedia.org/wiki/Kilobyte
- 16 -
Esta agrupación 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.
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.
- 17 -
1.8. 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,
la siguiente es una máquina de sumar binaria que suma el bit de la entrada A con el de la entrada B:
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 es un diseño NO flexible y rapidamente los profesionales 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 completamente 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 mundial, el Sr. Alan Turing en 1941, hizo una Computadora de Programa fijo que
decodificaba un código secreto alemán, pero pese a ser una máquina muy importante desde el punto de
vista histórico, 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 (Memoria), por otro lado está la ALU que es donde se realizan
las operaciones, conocida como unidad aritmética 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.
- 18 -
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, combinando 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:
- Escribir.
- Leer.
- Sumar.
- Mover a la derecha.
- Mover a la izquierda.
- 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 combinación de 30 letras permite lograr infinitas combinaciones que
permiten escribir todo, incluso, describir cosas iguales de maneras distintas.
1.9 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.
Con el avance surgieron 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 combinan 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 :-).
- 19 -
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.
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.
1.10 LENGUAJES INTERPRETADOS VS LENGUAJES

COMPILADOS
Existen dos grandes divisiones en los lenguajes de programación:

- los interpretados
- 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.
- 20 -
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.
1.11. TIPOS DE ERRORES
En general, los lenguajes se componen de estructuras que se deben respetar, respetando el significado
de sus elementos y expresiones, el no cumplimiento de estas reglas puede ocacionar errores del tipo:
• 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.
- 21 -
TALLER DE INFORMÁTICA CAPITULO 2. Introducción a la Programación
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
Análisis del Diseño del Programa de

Problema Algoritmo 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.
22
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.
23
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
24
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.
25
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:
26
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.
27
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.
Programa
principal
datos
É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.
Programa
principal
Procedimiento
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.
28
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.
Programa
principal
datos
Procedimiento 2 Procedimiento 3
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.
Programa
principal
datos
módulo 1 módulo 2
datos + datos 1 datos + datos 2
procedim. 1 procedim. 2 procedim. 3
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.
29
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
30
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?”
31
TALLER DE INFORMÁTICA CAPITULO 3. Algoritmos
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.
32
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 BEGIN
LEER numero1, numero2, numero3 READ numero1, numero2, numero3
suma = numero1 + numero2 + numero3 suma = numero1 + numero2 + numero3
promedio = suma / 3 promedio = suma / 3
IMPRIMIR suma, promedio WRITE suma, promedio
FIN 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.
33
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.
V El rombo es una caja de decisión que representa respuestas sí/no o diferentes

alternativas.
F
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º.
Inicio
N1  0
N2  0
N3  0
N1  0
Leer N1,
N2, N3
PROM  (N1 + N2 + N3) / 3
N1  0
Imprimir PROM
Fin
34
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?
35
- 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?
36
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) ó

Lista de variables READ (“Mensaje”, lista de variables)
37
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:
IMPRIMIR(“Mensaje”, lista de variables) ó

WRITE (“Mensaje”, lista de variables)
Lista de
variables
Por Ejemplo:
El clásico "Hola Mundo": imprimirá en pantalla la frase 'Hola Mundo'.
INICIO
INICIO
IMPRIMIR(“HOLA MUNDO”)
“HOLA MUNDO” FIN
FIN
Por Ejemplo:
Operaciones de Entrada / Salida: El algoritmo permite sumar dos números ingresados por el usuario
38

INICIO
INICIO
IMPRIMIR('Introduce el primer número:')
“Introduce el primer número:”
LEER (num1)
IMPRIMIR('Introduce el segundo número:')
num1 LEER (num2)
IMPRIMIR ('El total es: ' , num1 + num2)
“Introduce el segundo número:” FIN
Num2
“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:
Nombre_de_variable  expresión
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.
39
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.
40
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.
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.
41
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 ) Esto imprime "Mayor de edad" si la persona tiene 18 años ó
IMPRIMIR "Mayor de edad" más e imprime "Menor de edad" si la persona tiene menos
ELSE de 18 años. En cualquiera de los casos, después de
efectuar la impresión, se ejecutará la primera instrucción
IMPRIMIR "Menor de edad"
que sigue a la estructura IF...ELSE.
Estructura de Selección Doble
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.
42
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
43
Por Ejemplo:
Diseñe un algoritmo que determine si un número es negativo, positivo o cero.
INICIO
Algoritmo (Formato 1)
n
INICIO
REAL n “Ingrese nº: “
LEER n
IF ( n > 0 ) n
IMPRIMIR "Positivo"
ELSE
n>0 “Positivo “
IF ( n < 0 )
IMPRIMIR "Negativo"
ELSE
n<0 “Negativo“
IMPRIMIR "Cero"
END
“Cero“
FIN
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
}
}
44
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.
45
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.
46
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.
47
La representación sería:
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
INICIO
Contador = 0 Cont=0
LEER (numero)
WHILE (numero > 0) “Ingrese nº: “
{
contador = contador + 1 num
LEER (numero)
}
IMPRIMIR ('El número de enteros positivos es: ', contador) num
END
num
>0 Cont=Cont+1
Cont
FIN
48
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>
V
…
}
F
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 INICIO
INT x, n
x=1
x=1
IMPRIMIR (‘Ingrese la letra: ‘) “Ingrese letra y cantidad“
LEER (letra)
IMPRIMIR (‘Cuántas veces quieres repetirlo?: ‘) letra, n
LEER (n)
DO
{ x, “-“, letra
IMPRIMIR (x , ’- ‘, letra)
x=x+1
x=x+1
}
WHILE (x < n)
FIN num > 0
FIN
49
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 Diagrama de Flujo
FOR (V= Vi, V < Vf , V= V +1)

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

{
Sentencia 1;
Sentencia 2;
Sentencia N
}
50
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) INICIO

Sentencia;
V = Vi
Sentencia/s
V=V+1
V ‹ Vf
FIN
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.
51
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).
While, Repeat o For

El primer bucle que se abra
While, Repeat o For debe ser el último en
cerrarse.
Lo que es equivalente a
decir, que el último bucle en
abrirse debe ser el primero
Fin While, Repeat o For en cerrarse y así tantas
veces como sea necesario.
Fin 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:
Primer bucle abierto
INCORRECTO
NO puede ser el primer
bucle en cerrarse.
52
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
53
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.
54
 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.
55
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.
Columnas
0 1 2 3 4 5
F 0 X[0,0] X[0,1] X[0,2]
i 1
l 2
a
3 X[3,0] X[3,5]
s
56
 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.
57
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?
58
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?

 C  A B

C  (B - A) / (A - 3)
 C  A* 5  B
 C  4 / 2* 3 / 6  B / 2 / 1 / 5 ^ 2 - A

C  B  A  25  4 * (A* B) / 2

C  B ^ A  (A / B) - 20 / B
 C  A - B / 2  A* 5

C  A* B * 5  (B - A) ^ 3
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.
59
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: h  a  b , donde a y b son los catetos, h es la hipotenusa.

2 2
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.
60
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 Peso (lb.) Categoría Tarifa de

(modelo) de Peso Registro
1970 o Menos de 2.700 1 $ 11.600
anterior 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 Menos de 3.500 7 $ 12.000
posterior 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.
61
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 x n, 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.
62
 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.
el valor máximo de la lista.
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 Ax 2 + 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,
63
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.
numérico y luego imprimirlos en el orden inverso al ingresado.
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.
64
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.
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.
65
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.
66
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
67
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).
68
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 $
69
TALLER DE INFORMÁTICA CAPITULO 4. Lenguajes de Programación
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
70
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.
71
¿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.
72
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.
73
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.
74
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.
75
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
76
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.
77
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.
78
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.
79
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;
80
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};
81
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
82
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,
83
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.
84
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".
85
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
86
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.
87
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;
88

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
89
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.
90
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.
91
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.
92
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:
93
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.
94
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)
95
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.
96
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.
97
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.
98
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.
99
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
100
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
101
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
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.
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.
102
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.
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.
103
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>);
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.
104
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.
4.8.4.1. Etiquetas "case" y "default".

Estas etiquetas se circunscriben al ámbito de la sentencia "switch", y se verá su uso cuando
estudiemos ese apartado.
105
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".
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á.
106
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)
{
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.
107
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:
switch(letra)
{
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
EsVocal = true;
break;
default:
EsVocal = false;
}
4.8.6.2. 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;
}
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
108
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.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
b) int x=10;
do x++; while(x < 10);
 10
 10,11
 11
c) bool salir = false;

int x = 13;
while(!salir) {
109
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
110
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")
111
 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.
112
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: ";
113
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;}
114
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
115
 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.
116
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.
117
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.
118
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.
119
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;
120
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[])
121
{
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.
122
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.
123
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.
124
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.
INICIO Inicio el programa.
a = 0 ; b =0
Declaro e inicializo las variables a, b y Area.
Area = 0
a Cargo por teclado a.
b Cargo por teclado b.
Area = a*b Calculo el area: Area = a*b.
Muestro el resultado (se muestra en

area pantalla el valor de Area).
Finalizo el programa.
FIN
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.
125
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.
126
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- }
INICIO
El número es
SI
Valor > 0 positivo
Ingrese un número
NO
SI El número es
valor Valor < 0 negativo
NO
El número es
Valor = 0
SI cero
NO
El número
vale cero
FIN
127
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;

7- cin >> valor;
8- if (valor>0) cout << endl << "El numero es positivo";
9- else
10- {
11- if (valor<0)
13- else
15- }
16- return (0);
17- }
INICIO
SI El número es
Ingrese un Valor > positivo
número 0
NO
valor
SI El número es
Valor < negativo
0
NO
El número es
cero
FIN
128
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.
3- int main()
4- {
5- int valor;

7- cin >> valor;
8- if (valor>0) cout << endl << "El numero es positivo";
9- else if (valor<0)
11- else
13- return (0);

14- }
INICIO
SI El número es
Ingrese un Valor >
positivo
número 0
NO
valor
SI El número es
Valor < negativo
0
NO
El número es
cero
FIN
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.
129
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- }
130
INICIO Diagrama de flujo del ejemplo Nº 4
Ingrese el
primer numero
selec
a
?
'a' 'b' 'c' 'd'
Ingrese el segundo
numero
resul = a+b El resultado de El resultado

b la resta es: del producto
“a-b” es: “a*b”
El resultado de
Elija una opción: la suma es:
a -SUMA “resul”
b -RESTA
c -MULTIPLICACION
d -Salir
FIN
selec
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.”
131
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:
Raiz cuadrada sqrt(x)
Operacion Potencia pow(x,y)
Logaritmo Natural log(x)
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.
132
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
INICIO
Ejemplo Nº 1:
Escribir un algoritmo que permita el ingreso de dos números enteros y calcule el

PRO = 0
producto de los mismos (multiplicación) por sumas sucesivas ( Ejemplo: 5x2 =
2+2+2+2+2).
Ingrese un
1- #include <iostream> numero
3- int main()
4- { a
5- int a,b,cont,PRO=0;
7- cin >> a; Ingrese el
8- cout << endl << "Ingrese el segundo numero: "; segundo
9- cin >> b; numero
10- for (cont=1 ; cont<=a ; cont++)

11- PRO = PRO + b;
b
12- cout<<endl<<"El producto de "<<a<<"por"<<b<<" vale "<<PRO;
13- }
cont = 1
cont = cont+1
SI
PRO=PRO+b cont<=a
NO
El producto
de a por b
vale PRO
FIN
133
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.
INICIO
2- using namespace std; i; z; tabla;
3- int main()
4- {
Ingrese la tabla
5- int tabla,i,z;
6- cout << "Ingrese la tabla que desea calcular: "; que desea
7- cin >> tabla; calcular
8- for(i=0;i<=10;i++)
9- {
10- z=tabla*i; tabla
11- cout << endl << z;
12- }
i=0
13- }
i = i+1
SI
z=tabla*i i<=10
NO
FIN
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.
134
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”).
INICIO
suma=0; num;
3- int main()
4- {
Ingrese los
5- float num, suma=0; números a
6- cout << "Ingrese los números a sumar: ";
sumar
7- while (suma <= 1000)
8- {
9- cin >> num;
10- suma=suma+num;
11- } suma=suma+num
12- cout << endl << "La suma es: " << suma;
13- } SI
num suma<=1000
NO
La suma
es “suma”
FIN
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.
135
1- #include <iostream> INICIO

3- int main()
suma=0;
4- {
num;
5- float num, suma=0;
6- cout << "Ingrese los números a sumar: "; Ingrese los
7- do
números a
8- { sumar
9- cin >> num;
10- suma=suma+num;
11- } while (num != 0);
12- cout << endl << "La suma es: " << suma; num
13- } suma=suma+nu
m
SI
num != 0
NO
La suma
es “suma”
FIN
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.
136
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.
1- #include <iostream> INICIO

3- int main()
4- { Vec1[10]
5- int Vec1[10]; // Declaración del arreglo Vec1 de una
// dimensión y diez elementos enteros.
6- int i;
i=0
8- for(i=0;i<10;i++)
9- {
10- cout << "ingrese el elemento " << i << ":";
11- cin >> Vec1[i];
12- }
i = i+1
13- return (0);
14- }
Vec1[i
]
Ingrese el SI
elemento i: i < 10
NO
FIN
137
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- {
12- cin >> 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- }
138
Diagrama de flujo del ejemplo Nº 2, método 1 INICIO
Vec3[N]
i=0
i = i+1
Vect3[i]
Ingrese el elemento SI
i: i<10
NO
bandera=0
i=0
i = i+1 SI
i < N-1
NO
NO Vect3[i]
<
Vect3[i+1]
SI
temp=Vect3[i]
Vect3[i]=Vect3[i+1]
Vect3[i+1]=temp
bandera=1
SI
bandera≠0
NO
FIN
139
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++)
10- {
13- }
14- for(i=0;i<N-1;i++)
15- {
17- {
19- Vect3[i] = Vect3[i+1];
21- i = -1; // se debe reinicializar en -1 el contador debido al
22- } // incremento automático del bucle for.
23- }
24- return(0);
25- }
140
Diagrama de flujo del ejemplo Nº 2, método 2:
INICIO
Vec3[N]
i=0
i = i+1
Vect3[i]
Ingrese el SI
elemento i: i < 10
NO
i=0
i = i+1 SI
i < N-1
NO
NO Vect3[i]
<
Vect3[i+1]
SI
temp=Vect3[i]
Vect3[i]=Vect3[i+1]
Vect3[i+1]=temp
i = -1
FIN
141
Método Nº 3: burbuja con dos for.
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- {
13- }
16- for(j=0;j<N;j++)
{
17- for(i=0;i<N-1;i++)
18- {
20- {
22- Vect3[i] = Vect3[i+1];
25- }
26- }
27- }
28- return(0);
29- }
142

INICIO
Vec3[N]
i=0
i = i+1
Vect3[i]
Ingrese el SI
elemento i: i<10
NO
j=0
i=0
i = i+1 SI
i<N-1
NO
NO
Vect3[i]
<
Vect3[i+1]
SI
temp=Vect3[i]
Vect3[i]=Vect3[i+1]
Vect3[i+1]=temp
SI
j = j+1 j<N
NO
FIN
143
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++)
10- {
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- {
22- Vect3[i] = Vect3[j];
23- Vect3[j]=temp;
25- }
26- }
27- }
28- return(0);
29- }
144

INICIO
Vec3[N]
i=0
i = i+1
Vect3[i]
Ingrese el SI
elemento i: i<10
NO
j=0
i = j+1
i = i+1 SI
i<N
NO
NO Vect3[j]
<
Vect3[i]
SI
temp=Vect3[i]
Vect3[i]=Vect3[j]
Vect3[j]=temp
SI
j = j+1 j < N-1
NO
FIN
145
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.
INICIO
matris [filas][columnas]
F =0
NO
F < filas
SI
1
C =0
SI
C < columnas
Ingrese el
NO
elemento (F,C):
matris [F][C]
F = F+1
C = C+1
146
Bandera = 0
F =0
NO
F < filas
SI
C =0
SI
C < columnas-
1
NO
NO matris[F][C] <
matris[F][C+1]
F = F+1
SI
temp = matris[F][C]
matris[F][C] =
matris[F][C+1]
matris[F][C+1] =temp
bandera = 1
C = C+1
SI
Bandera
!= 0
FIN NO
147
Código fuente del programa del ejemplo Nº 3:
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.
148
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- }
149
Diagrama de flujo del ejemplo Nº 4:

1
Observación: se ha omitido la carga del arreglo,
que se puede ver en el ejemplo 3.
Ingrese los extremos de
un intervalo cerrado
a b
SI
a<b
temp = a NO
a=b
b = temp
F =0
NO
F <M
SI
C =0 FIN
SI
C<N
matris[F][C] > a NO
NO
&&
matris[F][C] < b
F = F+1
SI
cantidad = cantidad
+1
C = C+1
150
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.
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- }
151
/*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
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";
152
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:
k= b
∑ base− k
k=a
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= )
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();
153
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ú.
154
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.
155
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.
156
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.
157
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
}}
158
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;
159
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
160
// 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
161
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)
162
{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.
163
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.
164
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
165
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().
166
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.
167
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
168
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’);
169
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 “ <<i <<j <<“: “;
65. cin>>mat[i][j]; }
66. }
67. }
68. else { for(j=0; j<N; j++)
170
69. {
70. for(i=0; i<M; i++) {
71. cout<<endl<<“Ingrese el elemento “ <<i <<j <<“: “;
72. cin>>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. }
171
TALLER DE INFORMÁTICA CAPITULO 5. Sistemas Operativos
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
172
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.
173
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)
174
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:
175
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.
176
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.
177
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.
178
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.
179
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
180
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,
181
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.
182
 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:
183
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.
184
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
185
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.
186
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.
187
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.
188
- 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
189
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.
190
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.
191
192
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
193
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
194
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.
195
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.
196
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.
197
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 &
198
/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
199
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.
200
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.
201
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. |
|~ |
| |
|_~___________________________________________________________________________ |
202
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. |
|~ |
| |
|_~___________________________________________________________________________ |
203
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!.
204
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.
205
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?
206
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);
}
207
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.
208
TALLER DE INFORMÁTICA CAPITULO 6. Aplicaciones
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.
209
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
210
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.
211
 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.
212
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 derecho → Página.
1
 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ón de página. 2
 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.
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 textos que serán iguales para toda una sección del documento, (por
3
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:
213
 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 particular ”, (por defecto se usa el estilo de página predeterminado).
4
Insertar Numeración de Página

Para esto se necesita insertar un pie de página, luego, en este cuadro de texto, insertar los
campos correspondientes. Así por ejemplo se puede escribir “Página X de Y” donde X e Y
5
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 derecho → Párrafo.
6
 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 texto . 7
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
214
rápidas configuradas en esta pestaña, facilitan o agilizan bastante el uso del procesador de
texto .
8
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 derecho → Personalizar Barra de Herramienta.
9
 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 documento .10
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 derecho → Carácter.
11
 Formato → Carácter.
En esta ventana las configuraciones principales son:
 Fuente: tipografía, tamaño.
 Efectos: subrayado, relieve, mayúsculas.
 Fondos.
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:
215
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.
 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.
216
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 reagrupadas y a veces suelen prestar a confusión.
12
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 juntos .
13
Para Cuerpo de Textos

 Configuraciones de Párrafo:
 Espacio entre párrafo.
 Que NO este tildada la casilla mantener párrafos juntos .14
 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.
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
217
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”.
USAR UNA PLANTILLA COMO PREDETERMINADA
Para predeterminar una plantilla, se debe:

 Tener la plantilla ya guardada
 Ir al administrador de plantillas: Archivo → Plantillas → Administrar.
218
 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
 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.
219
 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.
 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).
220
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
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.
221
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
imagen .
16
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.
 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.
222
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”.
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.
223
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.
 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:
224
 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.
…………………………………………….
225
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.
226
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 Barra de
de herramient
desplaz
amiento
horizont
al y
vertical
de la
Ventana
. Sobre Ho
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:
227
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:
228
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.
229
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:
230
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)
231
232
TALLER DE INFORMÁTICA CAPITULO 7. Conceptos de Redes e Internet
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
233
 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.
234
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.
235
* 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:
236
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.
237
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.
238
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.
239
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
240
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.
241
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.
242
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.
243
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.
244
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
245
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.
246
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
247
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.
248
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.
249
250
TALLER DE INFORMÁTICA BIBLIOGRAFIA
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
251
TALLER DE INFORMÁTICA BIBLIOGRAFIA
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
252
TALLER DE INFORMÁTICA ANEXOS
ANEXOS
ANEXO 1.
ESTANDARES PARA DIAGRAMAS DE FLUJO – PSEUDOCÓDIGO
SIGNIFICADO DIAGRAMA DE FLUJO PSEUDOCÓDIGO
Proceso Xa+b
Si <condición>
NO SI
Decisión <acciones>
sino
<acciones>
Conectores
Inicio / Fin Inicio / Fin
Entrada de Datos Leer ...
Salida de Datos Escribir ...
Dirección del flujo
Comentarios // Comentarios.....
- 253 -
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 AyB 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
- 254 -
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) ^
- 255 -
2.5. ASOCIATIVIDAD DE OPERADORES
Operadores Asociatividad
() [] -> :: . Izquierda a derecha
Operadores unitarios: ! ~ + - ++ -- & (dirección de) * Derecha a izquierda

(puntero a) sizeof new delete
.* ->* 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
- 256 -
ANEXO 3.- TIPOS DE DATOS EN C++
TIPO TAMAÑO RANGO DE VALORES APLICACIÓN

(EN BITS)
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;
- 257 -
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.
- 258 -
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".
- 259 -
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.
- 260 -
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.
- 261 -
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.-
- 262 -
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.
una letra Minúscula.
un Número.
- 263 -
Símbolos y nombre ASCII usados corrientemente
Nombres Comunes Nombres Raros
Signo de Explamación factorial

exclamation mark exclam
bang smash
pling cuss
excl boing
not yell
! shriek wow
hey
wham
eureka
spark-spot
soldier
control
Comilla doble literal mark
quotation marks double-glitch
quote dieresis
" double quote dirk
rabbit-ears
double prime
Numeral grid
hash crosshatch
pound sign octothorpe
number flash
sign square
# pound pig-pen
sharp tictactoe
crunch scratchmark
hex thud
mesh thump
splat
Signo pesos currency symbol
dollar sign buck
dollar cash
string
$ escape
ding
cache
big money
Porciento double-oh-seven
percent sign
% mod
grapes
ampersand address
amp reference
amper andpersand
& and bitand
and sign background
pretzel
apostrofe prime
apostrophe glitch
' single quote tick
quote irk
pop
- 264 -
spark
closing single quotation
mark
acute accent
opening / closing so/already
parentesis lparen/rparen
left / right paren opening/closing parenthesis
left / right parenthesis opening/closing round bracket
() left / right left/right round bracket
open / close wax/wane
open / close paren parenthisey/unparenthisey
paren / thesis left/right ear
Corchetes square / unsquare
opening / closing bracket u turn / u turn back
[] left / right bracket
left / right square bracket
bracket / unbracket
Llaves brace / unbrace
opening / closing brace curly / uncurly
open / close brace leftit / rytit
left / right brace left / right squirrelly
{} left / right squiggly embrace / bracelet
left / right squiggly
bracket/brace
left / right curly bracket/brace
Menor , Mayor from / into (or towards)
less / greater than read from / write to
bra / ket suck / blow
< left / right angle comes-from / gozinta
> left / right angle bracket in / out
left / right broket crunch / zap
tic / tac
angle / right angle
asterisco wildcard
star gear
splat dingle
mult
spider
* aster
times
twinkle
glob
Nathan Hale
mas cross
+ plus intersection
add
coma cedilla
, comma tail
menos, guión medio worm
dash option
- hyphen dak
minus bithorpe
punto radix point
period full stop
. dot spot
point
decimal point
barra diagonal
/ slash solidus
- 265 -
stroke over
slant slak
forward slash virgule
slat
backslash bash
hack reverse slant
whack reversed virgule
escape backslat
\ reverse
slash
slosh
backslant
backwhack
colon dots
: two-spot
Punto y coma weenie
; semicolon hybrid
semi pit-thwong
igual quadrathorpe
equals half-mesh
= gets
takes
signo de pregunta quiz
question mark whatmark
query what
ques wildchar
? huh
hook
buttonhook
hunchback
arroba each
at sign vortex
at whorl
strudel whirlpool
cyclone
@ snail
ape
cat
rose
cabbage
commercial at
acento circunflexo xor sign
circumflex chevron
caret shark (or shark-fin)
^ hat to the
control fang
uparrow pointer
Guión bajo score
underline backarrow
_ underscore skid
underbar flatworm
under
Acento grave backprime
grave accent backspark
backquote unapostrophe
` left quote birk
left single quote blugle
open quote back tick
grave back glitch
- 266 -
push
opening single quote
quasiquote
barra vertical line
bar gozinta
or thru
| or-bar pipesinta
v-bar spike
pipe
vertical bar
tilde approx
squiggle wiggle
~ twiddle swung dash
not enyay
sqiggle (sic)
- 267 -
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
- 268 -
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
- 269 -
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 char texto[20] => char sz_texto[20];
caracteres terminados en /0)
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;
- 270 -
<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 */
- 271 -
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.
- 272 -
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".
- 273 -
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
- 274 -
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.
- 275 -
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:
- 276 -
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á.
- 277 -
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.
- 278 -
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.
- 279 -

Apunte Taller Informatica

Cargado por

Copyright:

Formatos disponibles

Apunte Taller Informatica

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Apunte Taller Informatica

Cargado por

Copyright:

Formatos disponibles

Taller de Informática

CAPITULO 1. Introducción a la Informática

CAPITULO 2. Introducción a la Programación

CAPITULO 4. Lenguajes de Programación.

CAPITULO 5. Sistemas Operativos.

CAPITULO 6. Software de Aplicación.

CAPITULO 7. Conceptos de Redes e Internet.

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

1.2. TIPOS DE CONOCIMIENTOS.

En general podemos decir que hay dos Tipos de Conociemientos.

Veamos otro ejemplo en otro ámbito:

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

¿Cuales son conocimientos Declarativos y cuales Imperativos?

Raiz de 25? g = 3, => 3+3= 9, g= (3+25/3)/2= 5.6666 => 5.6666+5.6666=32.11 g=

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

1.3. SISTEMAS NUMÉRICOS

Entonces tenemos dos divisiones.

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

Decimal Hexadecimal Octal Binario

Veamos algunas observaciones respecto de la tabla anterior.

Nen base r = dn-1.rn-1+dn-2.rn-2+dn-3.rn-3+....d1.r1+d0.r0

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

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

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

Paso Resto Nro. Binario

1.4. OPERACIONES LÓGICAS BINARIAS

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

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

Entrada 1 Entrada 2 Salida

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

Veamos algunos ejemplos:

Entrada a Entrada b Salida

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

1.5. EL SISTEMA BINARIO Y LA RELACIÓN CON LA

Un Computador u Ordenador está formado por Circuitos Integrados 3

1.6. UNIDADES DE INFORMACIÓN

1.7. CODIFICACIÓN DE CARACTERES

1.8. MAQUINA DE VON NEUMANN VS. ARQUITECTURA

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

• Software: Sería lo que se almacena en la memoria en un formato binario, no se puede

1.9 LENGUAJES DE PROGRAMACIÓN

a=a+1 move acc, # 0x10A8

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.

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.

1.10 LENGUAJES INTERPRETADOS VS LENGUAJES

Existen dos grandes divisiones en los lenguajes de programación: