fundamentos de la programacion u1

Capítulo 1

Sistemas de Procesamiento

de Datos 1.1 Conceptos de la programación

1.1.1 Programa

1.1.2 Programación

1.1.3 Programador/Desarrollador

1.1.4 Sistema

1.1.5 Sistema de Información

1.1.6 Dato

1.1.7 Información

1.1.8 Software

1.1.9 Hardware

1.2 Ejecución de un programa

1.2.1 Representación sencilla de la ejecución de un programa

1.3 Lenguajes de Programación

1.4 Evolución los lenguajes de Programación

1.4.1 Lenguajes de Alto nivel

1.4.2 Lenguajes de bajo nivel

1.5 Tipos de lenguajes de programación

1.5.1 En función de la forma de programar

1.5.2 Orientados al problema

1.5.3 Según su campo de aplicación

Sistemas de Procesamiento de Datos

Introducción

Es el conjunto de métodos y procedimientos que permiten obtener información.

A continuación se mencionan conceptos que será fundamental que el lector conozca:

1.1 Conceptos de los sistemas de computación

1.1.1 Programa

Es el conjunto de instrucciones que una computadora ha de seguir. Estas instrucciones son escritas en

un lenguaje de programación que la computadora es capaz de interpretar.

1.1.2 Programación

Es aquella actividad por la cual se crean programas para computadoras.

1.1.3 Programador/Desarrollador

Individuo que ejerce la programación, es decir escribe programas para computadoras.

1.1.4 Sistema

Es un conjunto de elementos interrelacionados entre sí, interactuando con un objetivo en común.

1.1.5 Sistema de Información

Es el conjunto de procedimientos ordenados que al ser ejecutados proporcionan información para

apoyar la Toma de Decisiones y el control de una organización.

1

Entrada (INPUT) Proceso Salida (OUTPUT)

1.1.6 Dato

Representa observaciones o hechos fuera de contexto y sin significado inmediato (Es materia prima de

la información).

1.1.7 Información

Es el significado que una persona asigna a un dato (conjunto de datos).En otras palabras es el

resultado o salida que emite un programa o sistema de información.

1.1.8 Software

Serie de programas que la computadora utiliza con un fin en especial.

1.1.9 Hardware

Son las maquinas físicas reales que constituyen una instalación de cómputo.

1.2 Ejecución de un programa

En la ejecución de un programa intervienen elementos de entrada y de salida que interactúan en la

computadora. Se necesita de datos de entrada ingresados desde teclado usualmente, un programa

escrito en un lenguaje de programación, una computadora que mostrara los resultados y/o salida

usualmente por pantalla.

1.2.1 Representación sencilla de la ejecución de un programa

Programa

-------------

-------------

-------------

----

Datos

-------------

-------------

-------------

Computadora

Salida

--------------

--------------

--------------

1.3 Lenguajes de Programación

Definición

Es un conjunto de reglas semánticas así como sintácticas que los programadores usan para la

codificación de instrucciones de un programa o algoritmo de programación.

1.4 Evolución los lenguajes de Programación

Es el desarrollo y mejoramiento de los lenguajes de programación a través de la historia, se

categorizan en:

1.4.1 Lenguajes de Alto nivel

4to nivel: Llamados también generador de aplicaciones Son en esencia programas para crear

programas, por ejemplo herramientas CASE, GENEXUS Tool, PowerDesigner, etc.

3er nivel: Es el nivel de lenguaje más parecido al lenguaje del ser humano, con más signos y reglas

para expresar con facilidad las cosas más complicadas, entre ellos existen C++, BASIC, PASCAL, C#,

JAVA, Php, ETC

Ejm: Z=X+Y

1.4.2 Lenguajes de Bajo Nivel

2do nivel: Es el tipo de lenguaje que cualquier computadora puede entender, por ejemplo

Ensamblador.

Ejm: ADD X Y Z

1er nivel: Llamado también Lenguaje de Maquina. Son los programas escritos en forma de ceros y

unos.

Ejm

0110 1001 1010 1011

1.5 Tipos de lenguajes de programación

Son las distintas formas y categorías de los lenguajes de programación, se categorizan en:

1.5.1 En función a la forma de programar

Lenguajes procedurales: FORTRAN, BASIC, PASCAL, ADA, MODULA-2

Lenguajes declarativos: LIPS, PROLOG

Orientados a objetos: C++, Java, C#

1.5.2 Orientados al problema:

Generadores de aplicaciones: GENEXUS Tool, PowerDesigner, etc.

1.5.3 Según su campo de aplicación.

Aplicaciones científicas: FORTRAN y PASCAL

Aplicaciones en procesamiento de datos: COBOL y SQL.

Aplicaciones de tratamiento de textos: C

Aplicaciones en inteligencia artificial: LISP y PROLOG

Aplicaciones de programación de sistemas: ADA, MODULA-2 y C.

Lenguajes de Internet: HTML, JAVA, Perl, PHP, ASP.NET

Capítulo 2

Metodología para solución

de problemas

computacionales 2.1 Pasos para la solución de problemas computacionales

2.1.1 Definición del problema

2.1.2 Análisis de la solución

2.1.3 Diseño de la solución

2.1.4 Codificación

2.1.5 Prueba y Depuración

2.1.6 Documentación

2.1.7 Mantenimiento

2.2 Tipos de errores

2.2.1 Error sintáctico de software

2.2.2 Error de lógica de programador

2.2.3 Error fatal en tiempo de ejecución

2.2.4 Error interno de software

2 Metodología para solución de problemas computacionales

Introducción

Es la serie de pasos adecuados que se ha de seguir para obtener una solución completa de un

problema computacional.

2.1 Pasos para la solución de problemas computacionales

A continuación se mencionan los puntos a seguir:

2.1.1 Definición del problema

Conocer y delimitar por completo el problema, saber que es lo se desea realice la computadora.

2.1.2 Análisis de la solución

Establecer una serie de preguntas acerca de lo que establece el problema:

¿Con qué cuento? , ¿Qué hago con esos datos? , ¿Qué se espera obtener?

2.1.3 Diseño de la solución

Es la creación del algoritmo (Diagrama de flujo y/o pseudocódigo),

2.1.4 Codificación

Escribir la solución del problema (de acuerdo al pseudocódigo), en una serie de instrucciones

detalladas en un código reconocible por la computadora (PROGRAMA).

En la actualidad y con algo de práctica se es posible pasar del análisis de la solución a la codificación,

en muchos casos es más rápido y permite detectar errores mediante la depuración o debug, asunto

que se haría manualmente en el pseudocódigo y/o diagrama de flujo.

2.1.5 Prueba y Depuración

La Prueba es el proceso de identificar los errores que se presenten durante la ejecución del programa.

La Depuración consiste en eliminar los errores que se hayan detectado durante la prueba.

2.1.6 Documentación

Es la guía o comunicación escrita que sirve como ayuda para usar un programa, o facilitar futuras

modificaciones.

La documentación que va a sustentar en términos legales la creación y/o modificación del programa.

Existen 3 tipos:

Documentación Interna

Consiste en los comentarios o mensajes que se agregan en el código del programa (Es la más usada),

mientras más detallado se encuentre el programa será más fácil la modificación en el futuro, además

es utilizado para controles internos dentro del área de TI.

Consta de: Nombre de modulo, Descripción del módulo, Nombre del Autor, fecha creación, fecha

modificación

Documentación Externa

Es el Manual Técnico (A menudo obviada), está integrada por los siguientes elementos: Descripción

del Problema, Nombre del Autor, Diagrama del Flujo, Pseudocódigo, Lista de variables y constantes, y

Codificación del Programa.

Manual del Usuario

Es la documentación (Generalmente diapositivas) que se le proporciona al usuario final, presentando

todas las pantallas y menús que se va a encontrar y una explicación de los mismos.

Es de uso indispensable cuando se va a entregar el programa al usuario final puesto que facilitara el

manejo en gran medida del programa.

2.1.7 Mantenimiento

Se realiza después de determinado el programa cuando se detecta que es necesario hacer un cambio,

ajuste y/o complementación al programa para que siga trabajando de manera correcta.

Nota: En la actualidad para un performance adecuado en el desarrollo de sistemas algunas empresas

disponen de usar un software manejador de versiones de fuentes esto favorece en gran medida el

control y feedback de los desarrollos.

2.2 Tipos de Errores

A continuación se detallan los distintos tipos y formas en que aparecen los errores, además las

recomendaciones para disminuir su aparición.

2.2.1 Error sintáctico de software

Son los errores conocidos como gramaticales respecto al software de lenguaje de programación que

se utiliza. Estos errores son los que se muestran en la mayoría de los casos en el programa editor de

código en tiempo de codificación.

Pueden aparecer por no teclear correctamente alguna instrucción y/o comando del lenguaje de

programación utilizado, la buena noticia de este tipo de errores son que se pueden detectar y corregir

en tiempo de codificación, El software del lenguaje de programación en muchos casos detecta los

errores automáticamente mientras se digita el código antes de ejecutar el programa.

Por ejemplo en C++ toda instrucción termina en punto y coma < ; > si obvias ponerla seguramente el

compilador te mostrara un mensaje de error al intentar ejecutar el programa.

2.2.2 Error de lógica de programador

Son los errores del desarrollador y son errores de interpretación de los procesos funcionales (A

menudo en expresiones de cálculos).

Por ejemplo le podrían pedir calcular el promedio de 2 números y por distracción suma los dos

números y los divide sobre tres, O quizás en su fórmula emplea lo siguiente: A+B / 2 y no coloca el

paréntesis para que primero sume.

Este tipo de errores no es percibido por el software editor de código ya que estos errores son

sintácticamente correctos, en consecuencia solo pueden ser percibidos en tiempo de ejecución del

programa al intentar ver el resultado o quizás mucho después.

2.2.3 Error fatal en tiempo de ejecución

Estos tipos de errores suelen mostrar el respectivo mensaje de error, y en muchos casos consiguen

hacer terminar forzosamente al programa.

Este tipo de errores son los más comunes aun cuando se alcanza a dominar la programación.

A menudo este tipo de errores son por cálculos numéricos y reglas matemáticas que no pueden ser

pasadas por alto por ejemplo si se intenta dividir un número sobre cero,

Otro caso general es cuando se intenta obtener un valor ya sea por teclado o de otra ubicación, y no

se valida que haya obtenido realmente el valor y se hace una expresión con la variable como si tuviera

el valor y en ese momento seguramente tendrás un error en tiempo de ejecución.

La recomendación para este tercer tipo de error es siempre validar las entradas ya sea teclado, lectura

de archivos de texto, base de datos, etc.

2.2.4 Error interno de software

No solo el desarrollador tiene errores, el software de programación utilizado algunas veces muestra

errores. En algunos casos por modificación de algún componente interno ya sea por la instalación de

algún otro software en la PC (Personal Computer) que consigue modificar el componente.

Otros casos también suceden por no refrescar el proyecto utilizado, actualmente el software de

programación cuenta con herramientas de actualización incluido. Este es nombrado de muchas

formas: refrescar, actualizar, regenerar, etc. En cualquiera de los casos es recomendable actualizar

cada cierto tiempo el proyecto de programación.

Un caso menos usual es la infección de virus que en la actualidad se corrige con un antivirus efectivo.

Capítulo 3

Fases de la Programación

3.1 Elementos de un programa

3.1.1 Tipos de datos en C++

3.1.2 Identificadores

3.1.3 Conceptos básicos al nombrar variables

3.1.4 Asignación de variables

3.1.5 Operadores

3.1.6 Prioridad de Operadores

3.1.7 Entrada y Salida

3.2 Manejo de Expresiones

3.2.1 Transformación de expresiones algebraicas a computacionales

3.2.2 Declaración de Variables

3.2.3 Datos Enteros vs Datos Reales

3.2. 4 Partes de la división

3.2.5 División Entera vs división real

3.2.6 Resultados de la división

3.2.7 Análisis de almacenamiento de la división con resultados numéricos

3.2.8 Residuo (Modulo)

3Fases de la Programación

Introducción

En este capítulo comenzaremos a revisar los elementos de un programa, los conceptos necesarios

para realizar un programa sencillo.

3.1 Elementos de un programa

3.1.1 Tipos de datos en C++

Son clasificadores de variables ya sea en el dato que contendrá u operaciones que se realizara sobre

ellas. A continuación se muestra una tabla con los rangos y algunas otras características de los tipos

de datos:

Tipo de datos

Rango Mínimo (*) Precisión

Descripción C++

Enteros

short 32,767

int 32,767

long 2‟147,483,467

Entero sin signo unsigned long 4‟294,967,295

Reales

float 10^37 6 dígitos

double 10^37 6 dígitos

long double 10^37 6 dígitos

Carácter char 127

Cadena string

Booleano bool

(*) EL limite considera límite inferior el mismo número con signo negativo hasta el límite superior que

es el numero mostrado, con excepción de los que llevan la palabra reservada unsigned(sin signo) en

esos casos el límite inferior es cero y el límite superior es el doble del numero mostrado.

Estos son los mínimos rangos sin embargo esto puede variar de acuerdo a la versión del compilador, a

continuación se muestra los típicos rangos para un ambiente de 32 bits:

Tipo de datos

Bytes utilizados Típico Rango(*)

Descripción C++

Enteros

short 2 bytes 32,767

int 4 bytes 2‟147,483,467

long 4 bytes 2‟147,483,467

Entero sin signo unsigned long 4 bytes 2‟147,483,467

Reales

float 4 bytes 1.8^-38 a 3.4^38

double 4 bytes 2.2^-308 a 1.8^308

long double 8 bytes 2.2^-308 a 1.8^308

Real sin signo

unsigned double

unsigned long double

Carácter char

1 Byte: guarda un carácter

Cadena string

Bytes Dinámicos, su tamaño es ilimitado

Booleano bool 1 bit

Nota: Para los iniciantes los tipos de datos definidos bajo pseudocódigo se puede utilizar la descripción

de la tabla. Sin embargo para este libro se utilizara los términos de C++.

3.1.2 Identificadores

Es el nombre de una variable. Las variables se dividen en 2 tipos:

Variable: Son ubicaciones de memoria en las cuales guarda un valor, además dicho valor puede ser

cambiado a lo largo del programa.

Constante: Son un tipo de variable que mantiene su valor desde el principio hasta el final del

programa.

3.1.3 Conceptos básicos al nombrar variables

Se consideran las siguientes recomendaciones al nombrar variables:

Use un nombre de variable que le dé significado al valor que va a contener.

Es factible usar abreviaturas, parte de la palabra o concepto que va a almacenar, mnemónico

(palabra técnica) o palabra completa separada por guion bajo “_” ya sea por la complejidad de la

rutina o del problema.

Respecto a las terminaciones con numeración pueden usarse en caso de tener variables con el

mismo nombre pero con diferentes valores de una lista.

Se debe tener en cuenta que C++ distingue letras mayúsculas de minúsculas por lo tanto la

variable (A) es distinta de la variable (a).

No se puede nombrar variables que tengan como nombre algún comando, palabra

reservada, tipo de dato, etc. del lenguaje de programación utilizado. Por ejemplo en c++

existe el tipo de dato double si nombramos una variable con el nombre double

seguramente nos dirá que hay un error.

Una forma recomendada de nombrar variables es:

<ámbito (local, global, parámetro, etc.)><Tipo de dato>_<nombre variable>.

Imagine una variable local de tipo entero que va a contener una edad, el nombre de la variable podría

ser: li_edad.

Variable global para guardar el sexo de maría („M‟,‟F‟), podemos declarar: gc_sexo_maria.

A continuación listamos más ejemplos:

CAR

Car

CAR y Car son variables distintas

a_50

b35a

pepito

Promedio_ventasC

31p => no valido

Luis Sánchez => no valido

Usuario-1 => no valido

lc_nombre =>local de tipo carácter (recomendado)

gl_cantidad => global de tipo long (recomendado)

afl_promedio =>argumento de tipo float (recomendado)

En este libro usaremos la forma recomendada de nombrar variables cuando veamos problemas

algorítmicos de sobremanera complejos.

3.1.4 Asignación de variables

Se asigna valores del mismo tipo que el que se declaró previamente a la variable/constante

(aritmética, lógica, textos y caracteres).

Pseudocódigo

C++

Observación

Variable = variable/valor

Variable = variable/valor;

A=10 A=10;

B=20 B=20;

C = A + B C = A + B;

D="Arriba Peru" strcpy(D,"Arriba Peru"); Se utiliza una función predefinida de C++ (Véase capítulo 6)

E='A' E='A';

F = 10 + 50 F = 10 + 50;

G = 10 + "50" G = 10 + "50"; No valido(10 es un numero entero y “50” es cadena por estar entre comillas)

H = D + B H = D + B; No valido(D es cadena y B es un entero)

3.1.5 Operadores

Tipo Operadores Descripción Pseudocódigo C++

Aritméticos

Suma + +

Resta - -

Multiplicación * *

División real /

/

División entera Div

Residuo(división entera) Mod %

Relacionales

Mayor que > >

Mayor o igual que > >=

Menor < <

Menor o igual que < <=

Igualdad = ==

Diferente <> !=

(*)

(*) Notar que para C++ se colocó el mismo símbolo en división real y entera, para saber en qué

momento funciona como división real y en qué momento como división entera (Véase los apartados

3.2.5, 3.2.6, 3.2.7)

3.1.6 Prioridad de Operadores

A continuación se detalla el orden de prioridad al momento de operar, se respeta de manera similar al

orden que se usa en el álgebra de las matemáticas. Al igual que en el álgebra es posible alterar el

orden de operación haciendo uso de paréntesis. Para agrupaciones más complejas solo está permitido

el uso del paréntesis “()”.

1. () (*)

2. /

3. *

4. +

5. –

(*) Las operaciones que están dentro de paréntesis se evalúan primero. Cuando existe múltiples paréntesis (anidado: internos unos a otros), se evalúan primero las expresiones más internas. Ejemplos

Considere si: A=3, B=4, C=5:

Lógicos

Y And &&

O Or ||

Negación Not !

a)

X = A - B + C

X = 3 - 4 + 5

X = 3 - 9

X = - 6

b)

Y = A*B + C

Y = 3*4 + 5

Y = 12 + 5

Y = 17

3.1.7 Entrada y Salida

Entrada

Es el flujo de datos que el programa utilizará para realizar sus procesos. Vale decir que la entrada

puede originarse de distintas ubicaciones (Teclado, un archivo, etc.).

En c++ utilizaremos el comando:

scanf(<formato>, &<variable>);

Ejemplo:

int nro; scanf("%d”,&nro");

Salida

Es generalmente la información y/o resultado del programa. Además se puede utilizar como mensajes

para solicitud de entradas.

En c++ utilizaremos el comando:

printf(<formato>, <lista de variables>);

Ejemplos:

printf("\n\n\r Ingrese un numero entero: "); printf("\n El Entero ingresado: %d", nro); printf("\nEl real ingresado: %f y la cadena ingresada: %s", nro_float, cadena);

c)

Z = C*B + A / A

Z = 5*4 + 3 / 3

Z = 5*4 + 1

Z = 20 + 1

Z = 21

d)

W = ((A + B) - (C - A)) / C

W = ( (3 + 4) - (5 - 3) ) / 5

W = ( (7) - (2) ) / 5

W = (5) / 5 = 1

(*)

printf("\nEl real ingresado: %8.4lf", nro_double); (**)

(*) Notar el texto en negrita %f y %s, dichos valores serán reemplazados por las variables listadas

después de la coma en orden de ocurrencia.

(**) Notar el número 8.4 del formato %8.4lf, representa el formato de impresión del número en pantalla

en este caso longitud 8 a 2 decimales.

Formatos de entrada y salida

Formato Tipo de dato

%d int

%ld long

%f float

%lf double

%c char

%s char(cadena)

%u Entero sin signo

Notar que %c y %s tienen el mismo tipo de dato, no obstante %c imprime solo un carácter y %s

imprime una cadena de caracteres.

Secuencias de escape

Como señalamos en los ejemplos de Salida en la impresión con printf, mostramos unos ejemplos de

uso de las secuencias de escape, a continuación listamos más secuencias de escape:

Descripción Símbolo

Nueva Línea \n Tabulación Horizontal \t Retorno de carro \r Alerta \a Diagonal invertida \\ Comillas dobles \"

Ejemplos:

printf("\n\t Promedio: %8.2lf \n\n", prom); printf("\n\n la cadena \"%s\" tiene una longitud: %d \n\n", cadena, longitud);

3.2 Manejo de Expresiones

3.2.1 Transformación de expresiones algebraicas a computacionales

Como ya se mencionó en el apartado Prioridad de operadores, solo están permitidos los paréntesis “()”

a continuación veremos cómo transformar las expresiones algebraicas hacia expresiones

computacionales:

Expresión algebraica Expresión computacional

4 + 5 4 + 5

A - 10

2 x 4 2 * 4

1 / 2

1 + 2 / 8 - ( 10 * 2 )

7(a + b) 7*(a+b)

8*x + 9y + 3*z

( )

(p+q) / (x+m/n)

(a / b)*c*d

(a+b)*(c-d)*(e-f)

(a+b)*(c-d) * ((e-f) / (g-h))

(A + 5 – b – 4 + 2) / D

[ ]

(a * b * (-c * d) + 5) / 10

1 / (a * b * c + c * d - 10)

((a-b)/(c-d) / ((e-f)/(g-h))

3.2.2 Declaración de Variables

Es el acto de definir un Tipo de dato válido a una variable que se utilizará en el programa.

Ejemplos:

Pseudocódigo C++

Entero: A,B int A,B; long k,b;

Real: P,Q float P,Q; double R, s;

Carácter: Sexo, Condición char Sexo, Condición;

Constante Entero: P=10 const int P = 10;

3.2.3 Datos Enteros vs Datos Reales

En c++ hay que tener claro la diferencia entre los datos enteros y reales, para eso dividimos el

concepto en 2 partes: números y variables:

Para los números digitados en expresiones, son enteros siempre y cuando no se digita el punto

decimal y números posteriores, en caso contrario son reales.

Números Enteros

Son aquellos números que no cuentan con parte decimal.

Ejemplo: 0, 1, 15, 540, 1500, etc.

Números Reales

Son aquellos números que poseen parte real o decimal.

Ejemplo: 0.00001, 1.633, 20.3598, 1.3333333, 1.0, etc.

No obstante en la programación en C++, las variables que contendrán números son del tipo en el

que son declarados ya sea real (double o float) o entero (int, long).

Variables Enteras

Son aquellas variables que son declaradas como enteras.

Ejemplo: int P; long Q, R;

Variables Reales

Son aquellas variables que son declaradas como tipo de dato reales.

Ejemplo: float A; double B, C;

3.2.4 Partes de la división

3.2.5 División Entera vs división real

En los problemas computacionales no solo es usada la división real sino también es a menudo

necesario el uso del operador de divisiones enteras.

3.2.6 Resultados de la división

Los resultados de la división van a depender del tipo de dato del dividendo y/o divisor. A continuación

mostraremos los resultados teniendo en cuenta el tipo de dato del dividendo y divisor:

División de Números

a) 10 ÷ 5 = 2 (Símbolo de división no utilizado en C++)

b) 12 / 5 = 2

c) 15 / 4.0 = 3.75

d) 15 / 4 = 3

e) 10 / 3 = 3

f) 10.0 / 3 = 3.333333…

La representación c) muestra el resultado real pues la división cuenta con un dividendo entero y un

divisor real (por estar con punto decimal .0) y además tiene residuo inicial 3 (> 0)

Dónde:

15: Dividendo

4.0: Divisor

3.75: Cociente (es el resultado de la operación)

3: Residuo

La representación e) muestra el resultado entero pues se está usando operadores enteros.

Dónde:

10: Dividendo

3: Divisor

3: Cociente (es el resultado de la operación)

1: Residuo

División de Variables

Supongamos que contamos con las siguientes variables:

int P, Q; double R,S;

Ahora supongamos que tienen los siguientes valores:

P=10; Q=20;

R=1.5; S=2.5;

División variables enteras

a) B / A = 2

b) A / B = 0

División variables Reales

c) S / R = 1.66666…

d) R / S = 0.6

División variables Enteros y Reales

e) Q / S = 8.0

f) R / P = 0.15

División de variables y números

Supongamos que contamos con las variables P, Q, R, S mencionados anteriormente:

a) P / 5 = 2

b) Q / 4.0 = 5.0

c) P / 6 = 1

d) Q / 20.0 =1.000000 (*)

e) P / 0 = (Error en tiempo de ejecución)

f) R / 10 = 0.15

g) 5.0 / S = 2.0

h) 2.5 / R = 1.666666… (**)

(*): El resultado es real, en el ejemplo se muestra 1.000000 como resultado no obstante la cantidad de

dígitos decimales va a depender del tipo de dato definido en C++ ya sea float o double. (Véase el

apartado 3.1.1)

(**): Existen divisiones en las cuales el resultado de la división es un número con parte decimal muy

extenso como .33333..., la longitud de los dígitos va a depender del tamaño del tipo de dato de la

variable en la cual se va a almacenar o el formato redondeando el ultimo digito de ser necesario

(Véase el apartado 3.1.1)

En general para obtener los resultados esperados de acuerdo al dividendo y divisor ya sea variables o

números se puede aplicar la siguiente regla:

Dividendo Divisor Resultado

Entero Entero Entero

Entero Real Real

Real Entero Real

Real Real Real

3.2.7 Análisis de almacenamiento de la división con resultados numéricos

Considere que las variables A, B, C y P son de tipo entero int, variables C, D E y Q de tipo double:

//Declaración de variables enteras int A, B, C, P; //Declaración de variables reales double D, E, F, Q;

//Asignación a variables A=10; B=5; C=0.5; // C almacena 1 ya que la variable C es de tipo int D=0.5; E=1.24; F=1; // F almacena 1.000000, ya que la variable F es de tipo double

A continuación se muestran típicas operaciones en la que se almacena valores erróneos por los tipos

de datos:

P=A / E;

Cuidado con este tipo de operaciones. El resultado de la división es 8.06 pero P=8, por la causa de

que la variable P es de tipo entero.

Q=(A+B) / 2;

El resultado de la división es un entero 7 y como Q es doublé Q=7.000000.

Q=(A+B) / 2.0;

El resultado de la división es real 7.5 por lo tanto Q=7.500000.

3.2.8 Residuo (Modulo)

En C++ el operador modulo es representado por < % >, y se utiliza para obtener el residuo o resto de

una división entera, vale decir que para obtener el resto el dividendo y divisor deben ser

necesariamente enteros.

Ejemplos

Si A=15, B=14, C=3, D=2 entonces:

a) A % 6 = 3

b) B % 2 = 0

c) 19 % C = 1

d) 7 % 9 = 7

e) C % 3 = 0

f) D % 5 = 2

g) B % 0 = 0

Capítulo 4

FLUJOS DE CONTROL

4.1 Estructuras condicionales

4.1.1 Expresiones booleanas

4.1.2 Estructura condicional < if >

4.1.3 Estructura condicional < if - else >

4.1.4 Estructura condicional anidada < if - else - if >

4.1.5 Estructura de selectiva múltiple < switch >

4.1.6 8 Recomendaciones para el uso de estructuras condicionales.

4.2 Estructuras repetitivas

4.2.1 Conceptos acerca de estructuras repetitivas

4.2.2 Operadores de incremento

4.2.3 inicialización de variables

4.2.4 Contadores y Acumuladores y Banderas (flag)

4.2.5 Estructura repetitiva < for >

4.2.6 Estructura repetitiva < while >

4.2.7 Estructura repetitiva < do - while >

4.2.8 Anidamiento de bucles

4.2.9 8 Recomendaciones para el uso de estructuras repetitivas

4.3 Introducción a C++

4.3.1 Reseña histórica

4.3.2 Librerías y palabras reservadas básicas

4.3.3 Estructura de un programa en C++

4.3.4 Creación, ejecución y depuración de un programa mediante Visual Studio .Net

4Flujos de Control

4.1 Estructuras Condicionales

Usualmente en los programas va a ser necesario que se ejecuten ciertas instrucciones bajo ciertas

condiciones, es en estos casos cuando resultan sumamente útiles las estructuras de control, las cuales

mediante expresiones booleanas en una estructura condicional van a determinar que bloque del

código se va a ejecutar.

4.1.1 Expresiones Booleanas

Se denomina expresión booleana a aquella expresión en la cual se va a realizar una evaluación y

como resultado de dicha evaluación solo puede devolver dos posibles valores true (Verdad) o false

(falso). Está compuesta generalmente por variables/valores, operadores de comparación y operadores

lógicos.

Expresiones con operadores de comparación

Son el tipo de expresiones más sencillas en las cuales se van a evaluar dos valores mediante un

operador de comparación.

Ejemplos:

Si A=50, B=70, C=‟A‟, D=1 entonces:

char

A == 50 => true B = 70 => No es una expresión booleana, es una asignación a la variable B con 70

A > B => false

C==”A” => Error en tiempo de codificación, las comillas dobles indica cadena

C==‟A‟ => true

B>C => true, „A‟ representa el número 65 en la tabla de los códigos ASCII Véase capitulo X

A+B < B+D => false

D != D => false

D => true

!D => false (*)

(*) Nótese que < !D > retorna false, puesto que en C++ el numero 1 representa true y 0 false, aunque

esto es posible no se recomienda usar los números para este propósito, en su lugar C++ cuenta con

un tipo de dato especial bool.

Ejemplo:

bool sw;

sw = false;

sw=true;

Expresiones con operadores lógicos

Para este propósito utilizaremos los operadores lógicos, pero antes debemos mostrar las tablas de

verdad de los principales operadores:

Tabla de verdad && (Disyunción lógica “Y”)

Operando 1 Operador Y Operando 2 Resultado

true && true true

true && false false false && true false false && false false

Una receta para recordar la tabla del Y: “Los operadores deben ser todos verdaderos para que el

resultado sea verdadero, caso contrario es falso”

Ejemplos:

Considere que:

A = 10, B = 20, C = 30 entonces:

A > 0 && B > 0 => true && true = true

A < C && B==C => true && false = false

A==10 && B==20 => true && true = true

B==20 && C==40 => true && false = false

A!=15 && B==20 => true && true = true

C==20 && A!=10 => false && false = false

Tabla de verdad || (Conjunción lógica “O”)

Una receta para recordar la tabla del O: “Los operadores deben ser todos falsos para que el resultado

sea falso, caso contrario es verdadero”

Ejemplos:

Considere que:

A = 10, B = 20, C = 30 entonces:

Operando 1 Operador O Operando 2 Resultado

true || true true

true || false true false || true true false || false false

A > 0 || B > 0 => true || true = true A < C || B==C => true || false = true A==10 || B==20 => true || true = true B==20 || C==40 => true || false = true A!=15 || B==20 => true || true = true C==20 || A!=10 => false || false = false

Tabla de verdad ! (Negación lógica “No”)

Ejemplos:

Considere que:

A = 10, B = 20, C = 30 entonces:

A > 0 => true ! (A > 0) => ! true = false A > 0 && ! (B > 0) => true && ! true = true && false = false A < C || ! (B==C) => true || ! false = true || true = true !(A==10 || B==20) => !(true || true) = ! true = false !(!(B==20) || !(C==40))=> !(! true || ! false) = ! (false || true) = ! true = false !!(A!=15) || !(B==20) => !! true || ! true = ! false || false = true || false = true

Operando 1 Operador NO Resultado

true ! false false ! true

4.1.2 Estructura Condicional < if >

Es una estructura que bifurca el flujo de ejecución del código del programa en función del resultado de

una expresión booleana.

Sintaxis

if(<Expresión booleana>)

{<Inicio de bloque>

<Bloque de Código>

}<Fin de bloque>

<Continuación del programa>

dónde:

Expresión booleana: Debe siempre retornar true o false.

Inicio de bloque: La llave abierta que indica el inicio del cuerpo de código a ejecutarse si la expresión

booleana retorna true.

Bloque de Código: El compilador va a ejecutarlo siempre que la expresión booleana retorne true.

Fin de bloque: La llave cerrada indica el fin del cuerpo de código a ejecutarse si la expresión


Continuación del programa: Si la expresión booleana dentro de la instrucción < if > retorna false el

compilador salta hacia continuación del programa.

Ejemplos:

Promedio = 10.5; if( Promedio < 10.5 ){

flag_desaprobado = true; printf("Condicion Alumno: Repitente");

} scanf("Ingrese Nota1: %d", %n1); ….. …..

Salta

Para este ejemplo no se ejecuta las instrucciones:


Cuando el compilador llegue hasta la evaluación dentro de la instrucción < if > como el promedio no es

menor sino igual a 10.5 saltará hasta la instrucción:

scanf("Ingrese Nota1: %d", %n1);

En otro caso si el promedio hubiese sido: Promedio=10 se hubiese ejecutado:


y aun también:

scanf("Ingrese Nota1: %d", %n1);

4.1.3 Estructura Condicional < if – else >

Es la estructura que bifurca el flujo de ejecución del código del programa con una estructura alternativa

en función del resultado de una expresión booleana.

Sintaxis

if(<Expresión booleana>)

{<Inicio de bloque if>

<Bloque de Código if>

}<Fin de bloque if>

else

{<Inicio de bloque else>

<Bloque de Código else>

}<Fin de bloque else>


dónde:

Expresión booleana: Debe siempre retornar true o false.

Inicio de bloque if: La llave abierta que indica el inicio del cuerpo de código a ejecutarse si la

expresión booleana retorna true.

Bloque de Código if: El compilador va a ejecutarlo siempre que la expresión booleana retorne true.

Fin de bloque if: La llave cerrada indica el fin del cuerpo de código a ejecutarse si la expresión


Inicio de bloque else: La llave abierta que indica el inicio del cuerpo de código a ejecutarse si la

expresión booleana retorna false.

Bloque de Código else: El compilador va a ejecutarlo siempre que la expresión booleana retorne

false.

Fin de bloque else: La llave cerrada indica el fin del cuerpo de código a ejecutarse si la expresión

booleana retorna false.

Continuación del programa: En este caso de estructura condicional como tiene parte alternativa

<else> este debe ejecutarse primero antes de la continuación del programa.

En este tipo de estructuras solo un bloque se ejecuta: el bloque de código if o el bloque de código else,

más no los dos bloques.

Ejemplos:

Promedio = 15;

if( Promedio > 10.5 )

{

printf("Alumno Aprobado");

}

else

{

printf("Alumno Desaprobado");

}

….. …..

Para este ejemplo solo se ejecutara el bloque < if >, lo que no ocurriría si el Promedio=10 en ese caso

se ejecutaría el bloque < else >.

La instrucción <if> del ejemplo anterior se puede escribir de la siguiente forma:

if(Promedio > 10.5)

printf("Alumno Aprobado");

else

printf("Alumno Desaprobado");

O también:

if(Promedio > 10.5) printf("Alumno Aprobado");

else printf("Alumno Desaprobado");

La razón es que en C++ son necesarias las llaves solo si un bloque tiene 2 a más instrucciones.

En C++ existe una forma adicional de condicional que simula la instrucción <if>, que no es

recomendada, pero que quizás observen en algunos códigos externos, y aquí se muestra para que sea

de conocimiento:

int A=11; (A==10) ? printf("A es 10") : printf("A No es 10");

Estas sentencias devolverán por pantalla: "A No es 10".

4.1.4 Estructura Condicional anidada < if – else – if >

Es la estructura con n alternativas de bifurcación del flujo de ejecución del código del programa, en

función del resultado de múltiples expresiones booleanas.

Sintaxis

if(<Expresión booleana 1>){

<Bloque de Código 1>

}else

if(<Expresión booleana 2>){

<Bloque de Código 2>

}else

…..

if(<Expresión booleana n>){

<Bloque de Código n>

}


dónde:

Expresión booleana 1,2,…n: Debe siempre retornar true o false en la respectiva expresión booleana.

Bloque de Código 1,2,…n: El compilador va a ejecutarlo siempre que la expresión booleana

respectiva retorne true.

Continuación del programa: Si la estructura anidada tiene al final un bloque <else> en ese caso

debe ejecutarse primero antes de la continuación del programa. Si no tuviese un bloque < else > al

final, el compilador de no encontrar ningún true en las estructuras booleana saltará a la continuación

del programa.

Ejemplos:

Numero = 15; if(Numero < 0 ) { printf("Numero Negativo"); } else if(Numero == 0 ) { printf("Numero Neutro"); }else{ printf("Numero Positivo"); }

Para este ejemplo el resultado será “Numero Positivo”

La instrucción < if > del ejemplo anterior se puede escribir de la siguiente forma:

if( Numero < 0 ) printf("Numero Negativo"); else if( Numero == 0 ) printf("Numero Neutro"); else printf("Numero Positivo");

O también:

if( Numero < 0 ) printf("Numero Negativo"); else if( Numero == 0 ) printf("Numero Neutro"); else printf("Numero Positivo");

Cabe decir que para este ejemplo, la última forma mostrada es la más fácil de entender e interpretar.

Este tipo de estructura es solo una variación ampliada de la estructura <if-else>. Realmente esta

estructura es flexible y se va a acomodar muy bien a cualquier tipo de problemas en las cuales se

evalúe varias condiciones.

4.1.5 Estructura selectiva múltiple < switch >

A diferencia de la instrucción < if - else > en C++ esta estructura puede evaluar solo una variable y solo

puede comparar igualdad además no permite la combinación con operadores lógicos como && (Y

lógico por ejemplo), en su lugar puede combinar el || (O lógico) de forma homologa.

Sintaxis

switch (<variable a comparar>)

{

case <valor a comparar 1> : <Bloque de instrucción 1> break;

case <valor a comparar 2> : <Bloque de instrucción 2> break;

…..

case <valor a comparar i> : <Bloque de instrucción i> break;

…..

case <valor a comparar n> : <Bloque de instrucción n> break;

default: <Bloque de instrucción default> break;

}

Dónde:

<variable a comparar>: Variable a ser evaluada.

<valor a comparar i>: Constante con la cual la <variable a comparar >va a evaluar igualdad, si es

que no coincide pasa al siguiente <valor a comparar i>.

<Bloque de instrucción i>: Conjunto de instrucciones a ejecutarse si es que el <valor a comparar i>

respectivo retorna true.

<Bloque de instrucción default>: Conjunto de instrucciones a ejecutarse si es que la variable a

comparar no coincide con ninguno de los <valor a comparar i>.

break: Instrucción C++ para bifurcar o saltar al final de la estructura switch. De no invocar a la

instrucción break si es que encuentra coincidencia seguirá evaluando los siguientes “case” de la

instrucción.

Ejemplos:

char sexo; printf("Ingrese sexo de persona (M, F):"); sexo=getchar(); switch(sexo){ case 'M': printf("Masculino"); break; case 'F':

printf("Femenino"); break; default: printf("Error: Dato de ingreso No valido"); break; }

La función getchar() permite el ingreso por teclado de un carácter.

Para el ejemplo anterior mostrado supongamos que se ingresó por teclado el carácter M, entonces se

imprime por pantalla: Masculino.

Supongamos que se ha ingresado por teclado la letra m, entonces por pantalla se mostrara: Error:

Dato de ingreso No valido. La siguiente estructura switch muestra el mensaje correcto sin distinguir

mayúsculas o minúsculas.

switch(sexo){ case 'M': case 'm': printf("Masculino"); break; case 'F': case 'f': printf("Femenino"); break; default: printf("Error: Dato de ingreso No valido"); break; }

4.1.6 8 Recomendaciones para el uso de estructuras condicionales.

Sin lugar a dudas es posible usar las estructuras condicionales de muchas formas, a continuación

mencionamos unos consejos para la elección de estructura:

1) Elija < if > cuando va a evaluar varias variables.

2) Elija < switch > cuando va a evaluar una sola variable y en casos de igualdad.

3) Evite en lo posible hacer anidamientos, solo realizarlo si es irremediable.

Ejemplo: Sumar 10 a un número ingresado solo si es mayor a 10 y solo si es par.

a) Solución anidada

if( A <= 10 ) printf("Error número no es mayor a 10.\n\n"); else if( A % 2!=0 ) printf("Error número no es par.\n\n");

else { A = A + 10; printf("A = %d\n\n", A); } system("PAUSE");

Aunque esta solución es válida, dificulta la lectura cuando se cuenta con varios niveles de anidamiento y con más instrucciones.

b) Solución recomendada

if(A <= 10){ printf("Error numero no es mayor a 10.\n\n"); system("PAUSE"); exit(0); //Función para terminar el programa } if(A % 2!=0){ printf("Error numero no es par.\n\n"); system("PAUSE"); exit(0); //Función para terminar el programa } A = A + 10; printf("A = %d\n\n", A); system("PAUSE");

La debilidad de esta forma es que se generan más líneas de código, no obstante en los problemas

computacionales en algún momento va a pesar más el entendimiento que las líneas de código.

4) Para evaluaciones con tipos booleanos, usar los booleanos:

Ejemplo: Decir si un numero pasa la prueba de validación. Debe ser múltiplo de 3 y la vez divisible por

18.

a) Solución pésima

bool pasa_prueba; if( A % 3 == 0 && 18 % A == 0 ) pasa_prueba=true; else pasa_prueba=false; if( pasa_prueba == true ) printf("Si pasa la prueba"); else printf("No pasa la prueba"); system("PAUSE");

No se recomienda este tipo de soluciones se sobrescribe las alternativas de los booleanos, ya que

sabemos que los booleanos solo tienen dos posibles valores (true o false)

b) Solución buena

bool pasa_prueba=false; if( A % 3 == 0 && 18 % A == 0 ) pasa_prueba=true; if( pasa_prueba == true ) printf("Si pasa la prueba"); else printf("No pasa la prueba"); system("PAUSE");

Esta solución es a menudo utilizada, inicializar como false y luego preguntar si pasa la prueba y

asignar a true.

c) Solución recomendada:

bool pasa_prueba; pasa_prueba = ( A % 3 == 0 && 18 % A == 0 ); if( pasa_prueba ) printf("Si pasa la prueba"); else printf("No pasa la prueba"); system("PAUSE");

Con más conocimiento técnico sabemos que una expresión booleana retorna dos valores (true o

false) entonces, no es necesario preguntar con < if > por lo tanto es válido < pasa_prueba = ( A

% 3 == 0 && 18 % A == 0 ); >. Además tampoco es necesario if( pasa_prueba == true )

puesto que el código del < if > se va a ejecutar si la expresión retorna true, pero

la variable pasa_prueba solo tiene (true o false) como valor por lo tanto es válido

if( pasa_prueba )

Como consejo practico use if ( < true >) para booleanos.

5 ) Use switch para estructuras grandes, para demarcar algo importante y diferenciarlo de estructuras

< if >, además de lo explicado anteriormente.

6) Evite en lo posible utilizar switch para comparar muchos valores:

Ejemplo

Mostrar un mensaje si un carácter ingresado por teclado es una vocal minúscula.

a) Solución no recomendada

char op; op=getchar(); switch(op){ case 'a': case 'e':case 'i': case 'o':case 'u': printf("Es vocal minúscula"); break; }

b) Solución recomendada

char op; op=getchar(); if(op=='a' || op=='e' || op=='i' || op=='o' || op=='u') printf("Es vocal minúscula ");

7) Utilice sangrías. Hasta ahora no habíamos resaltado la importancia de estas, sin embargo son

esenciales para la lectura del código.

Tenemos fortuna de utilizar C++, pues antiguamente no contábamos con estas, asi que a sangrar

código.

Para hacer un sangrado es usualmente utilizada la tecla < Tab >.

Ejemplo

a) Sin sangría

if( A > 0 ){ if( A == 5 ) printf("Es cinco positivo"); else printf("No es cinco positivo"); } else if ( A < 0 ){ if( A == -5 ) printf("Es cinco negativo"); else printf("No es cinco negativo"); }

b) Con sangría

if( A > 0 ){ if( A == 5 ) printf("Es cinco positivo"); else printf("No es cinco positivo"); } else if ( A < 0 ){ if( A == -5 ) printf("Es cinco negativo"); else printf("No es cinco negativo"); }

8) Fíjese y utilice las ayudas del editor de código de fuente como el color (azul, rojo, verde, etc.). En

nuestro caso utilizamos Visual Studio .Net el cual tiene varias ayudas.

Al inicio no se tome mucho tiempo pensando con coraje en una solución cuando es difícil el problema y

no muestra los resultados esperados.

Use marcadores y validaciones de usuario, es decir asegúrese de que la variable contiene el deseado

o supuesto valor, imprimiendo la variable por pantalla antes de entrar a una estructura. Este

concepto nos puede ahorrar horas de análisis después de todo “Un vistazo no está de más“.

4.2 Estructuras repetitivas

Son estructuras en las cuales un bloque de código puede ser ejecutado un número de veces, ya sea

por un número que represente la cantidad de veces o por una expresión booleana.

4.2.1 Conceptos acerca de estructuras repetitivas

Bucle: Es el funcionamiento o el proceso de dar vueltas (repetir) de la estructura repetitiva.

INICIO ESTRUCTURA REPETITIVA

FIN ESTRUCTURA REPETITIVA

Iteración: Es cada repetición del bucle. Por ejemplo si una estructura repetitiva

tiene 3 repeticiones, tendrá iteración 1, Iteración 2 e Iteración 3.

4.2.2 Operadores de incremento

A menudo las variables son utilizadas como controladores de bucles, para tal caso mostraremos como

incrementar o decrementar una variable:

Modo ampliado Modo Reducido Explicación

A = A + 1; A++; La variable incrementa su valor en 1

A = A - 1; A--; La variable decrementa su valor en 1

A = A + 3; A+=3; La variable incrementa su valor en 3

A = A - 4; A-=4; La variable decrementa su valor en 4

A = A + n; A+=n; La variable incrementa su valor en n

A = A - n; A-=n; La variable decrementa su valor en n

A = A * 5; A*=5; La variable multiplica su valor en 5

A = A / 6; A/=6; La variable divide su valor en 6

4.2.3 inicialización de variables

Antes de utilizar una variable es necesario que esta tenga un valor contenido, ya sea por teclado o

asignación. En estructuras repetitivas su uso muy amplio, y en aplicaciones reales son utilizadas de

muchas formas. En un sentido es una asignación simple. Para tal caso mostraremos un ejemplo:

Bucle

//Declaracion de variables int A; bool bandera; //inicialización de variables A=0; bandera=false;

Existe un riesgo que ocurre al no inicializar variables, estas variables pueden ser utilizadas y el

compilador no mostrara error sino hasta el tiempo de ejecución y si el programa es complejo puede no

detectarse rápidamente

Para el caso de estructuras repetitivas (Punto a ver a continuación) es general inicializar las variables a

cero.

En términos prácticos una variable que no es ingresada por teclado y que va a usarse en una

estructura repetitiva siempre debe ser inicializada.

4.2.4 Contadores y Acumuladores y Banderas (flag)

Son variables que serán utilizadas en la estructura repetitiva, Algunas de ellas son inicializadas antes

de la estructura repetitiva, otras dentro de ellas.

Contadores

Son variables que controlan mediante conteo un aspecto del bucle, pueden se controlador de

iteraciones del bucle, o contar algunos aspectos del problema a resolver por el programa.

Generalmente el conteo es de a 1.

Ejemplo

Contador = Contador + 1

Acumuladores

Son variables que van a funcionar como recolectoras de resultados individuales, es decir de cada

iteración. Su uso es para obtener un resultado general de todo el bucle y generalmente son

sumatorias.

Ejemplo

Acumulador = Acumulador + promedio

Banderas (Flag)

Son variables que trabajan como indicadores o marcadores. Son para resolver algún aspecto de

identificación dentro del programa. Su uso se extiende en las estructuras repetitivas para determinar la

continuación de iteraciones. Generalmente son de tipo booleano sin embargo su uso se puede ampliar

hasta el grado de usar enteros o caracteres para representar sus múltiples estados.

Ejemplo

bool flag_casado=false; ………. if(estado_civil=='C') flag_casado = true;

4.2.5 Estructura repetitiva < for >

Es la estructura repetitiva de C++ para ejecutar código teniendo como datos el inicio , el fin e

iteraciones a procesar.

Aunque en C++ la estructura < for > es muy flexible, no es muy utilizado en sus formas complejas,

para esos casos veremos más adelante estructuras que nos ayudaran en esos casos.

Sintaxis

for ( <valor inicial> ; <expresión booleana para continuar> ; <incremento / decremento> )

{//opcional, si hay más de 1 instrucción

<bloque de código>

}//opcional, si hay más de 1 instrucción

<valor inicial> :variable con dato o punto de inicio del bucle.

<expresión booleana para continuar>: si retorna true continúa el bucle, caso contrario termina.

<incremento / decremento>: incremento o paso de variable dentro del bucle

<bloque de código>: Instrucciones a repetirse dentro del bucle

Orden de evaluación del compilador a la estructura < for >

La primera vez:

for( 1 ; 2; 4 )

{ 3, solo si la expresión booleana retorna true }

Las veces restantes:

for( <omitido> ; 1; 3 )

{ 2, solo si la expresión booleana retorna true }

Ejemplo:

Mostrar los 7 primeros números naturales positivos:

final=7; for( indice = 1 ; indice <= final ; indice = indice + 1 ) printf("\n Numero: %d", indice);

Explicación del código:

Iteración índice expresión booleana ejecución código estado bucle

1 1 1 <= 7 = true printf("\n Numero: %d", 1); Continua







8 8 <= 7 = true <No ejecuta código> Termina

Notar que al final del bucle la variable índice queda con el valor final del bucle más el incremento, es

decir: índice = final + incremento.

La expresión booleana debe estar bien planteada de lo contrario ocurre 2 posibles eventos:

-El bucle no se ejecuta ni una vez

-El bucle se ejecuta indefinidamente hasta acabar los recursos o “bloquear” la computadora por

completo.

El bloque de código anterior da como resultado:

Forma alternativa de estructura repetitiva < for >

Una forma adicional de la estructura < for > es utilizarla como instrucción en los problemas

algorítmicos y es a menudo para abreviar conteos o para marcar posiciones.

Numero: 1

Numero: 2

Numero: 3

Numero: 4

Numero: 5

Numero: 6

Numero: 7

for (<valor inicial> ; <expresión booleana para continuar> ; <incremento / decremento>) ;

Notar que la instrucción < for > termina en < ; >

Puede ser utilizada para obtener precisamente el valor final del <valor inicial> al finalizar el bucle.

Esta no es la forma más fácil de usar < for > pues puede crear confusiones, sin embargo en

aplicaciones prácticas veremos su uso.

Ejemplo:

final=7; for ( indice = 1; indice <= final ; indice = indice + 1 ); printf("\n Numero: %d", indice);

El bloque de código anterior da como resultado:

Trabajo con múltiples variables en la estructura repetitiva < for >

La estructura < for > puede admitir el trabajo con muchas variables, para separarlas se debe usar

coma < , > diferenciando claramente el < ; > que distingue la parte funcional del < for >.

Ejemplo:

Numero: 8

final =10; for( A = 1, B = - A ; A <= final ; A++, B-- ) { printf("\n Positivo: %d", A); printf("\t Negativo: %d", B); }

Resultado:

Nota: Como último recurso también es posible declarar variables dentro de la estructura < for >.

for ( int indice = 1; indice <= final ; indice = indice + 1 )

Este tipo de declaraciones aunque no es tan usado solo permite usar la variable (en este caso indice)

dentro de la estructura, es decir la variable no será tomada en cuenta como declarada en otros lugares

del código del programa.

Positivo: 1 Negativo: -1







4.2.6 Estructura repetitiva < while >

Es la estructura repetitiva para evaluar una expresión booleana y entonces ejecutar un bloque de

código. A diferencia del < for > no siempre cuenta con los límites de las iteraciones (Valor inicial y valor

final).

Sintaxis

while (<expresión booleana>)

{

<bloque de código>

}

<expresión booleana>: Retorna true o false.

<bloque de código>: Se ejecuta siempre que la expresión booleana retorne true.

Ejemplo:

int C, S, final; C=1; S=0; final=15 while( C <= final ){ S+=C; printf("\n%d",C); C+=2; } printf("\n\nSuma: %d",S);

El ejemplo mostrado anteriormente muestra por pantalla los 15 primeros números impares positivos y

además al final muestra la suma de ellos.

Notar las inicializaciones S=0 porque va a acumular, C=1 porque es el primer número impar, final=15

es el límite superior.

Para este ejemplo S es el acumulador <S+=C> en cada iteración acumula a la variable C.

C trabaja como el número impar de la iteración y el contador. Notar que se incrementa a la variable C

de dos en dos: < C+=2; >.

Notar que dentro del < while > se cuenta con una instrucción printf que imprime por pantalla a la

variable C (número impar de cada iteración) con un salto de línea, y al finalizar el bucle imprime la

suma con dos saltos de línea

< printf("\n\nSuma: %d",S); >.

Detalle Trabajo de la Estructura Repetitiva:

Iteración final S C C <= final Estado Bucle

<Inicialización> 15 0 1

1 15 1 3 3 <= 15 = true Continua

2 15 4 5 5 <= 15 = true Continua

3 15 9 7 7 <= 15 = true Continua

4 15 16 9 9 <= 15 = true Continua

5 15 25 11 11 <= 15 = true Continua

6 15 36 13 13 <= 15 = true Continua

7 15 49 15 15 < = 15 = true Continua

8 15 64 17 17 < = 15 = false Termina

El resultado es:

1

3

5

7

9

11

13

15

Suma: 64

4.2.7 Estructura repetitiva < do - while >

Es la estructura repetitiva para ejecutar un bloque de código por lo menos una vez, y evaluar una

expresión booleana.

Sintaxis

do{

<bloque de código>

} while (<expresión booleana>);

(<expresión booleana>): Retorna true o false.

<bloque de código>: Se ejecuta al menos una vez antes de que se evalué la expresión booleana,

para que se repita dicha expresión debe retornar true.

Ejemplo:

Ingresar una secuencia de números, mostrar por pantalla los números ingresados y su suma, hasta

que el usuario decida no ingresar más números.

char op; int N, S; S=0; do{ printf("\nIngrese numero: "); scanf("%d", &N); fflush(stdin); S+=N; printf("\n\nNumero ingresado: %d", N); printf("\n\n\nDesea seguir ingresando numeros?(S/N): "); op=getchar(); } while( op!='N' && op!='n' ); printf("\n\nSuma: %d",S);

Notar las inicializaciones < S=0; > porque va a acumular, N es el número ingresado en la iteración

respectiva, < op > es la variable con la opción de seguir ingresando más números.

En este ejemplo se ingresa N mediante < scanf("%d", &N); >, se acumula < S+=N; > y se muestra

dicho valor ingresado.

Se imprime por pantalla el mensaje de solicitud para seguir ingresando números.

Luego se ingresa el carácter por teclado mediante getchar() y se guarda en la variable op

Entonces llega a la expresión booleana de la estructura repetitiva, la cual va a repetir siempre que el

usuario no digite la tecla N o n.

Al final se muestra la suma de los números ingresados < printf("\n\nSuma: %d",S);

>.

Detalle Trabajo de la Estructura Repetitiva:

Iteración N S op op!='N' && op!='n' Estado Bucle

<Inicialización> 0

1 5 5 S 'S'!='N' && 'S'!='n' = true Continua




5 50 72 N 'N'!='N' && 'N'!='n' = false Termina

< N > es un valor ingresado por teclado, es decir pueden ser cualquier número.

< op > es un carácter ingresado por teclado, para el ejemplo el usuario afirmo ingresar 4 números

pero, como se usa la estructura < do- while > se ejecuta la primera vez sin evaluar.

El resultado es:

Ingrese numero: 5

Numero ingresado: 5

Desea seguir ingresando numeros?(S/N): S

Ingrese numero: 1

Numero ingresado: 1

Desea seguir ingresando numeros?(S/N): N

Ingrese numero: 9

Numero ingresado: 9


Ingrese numero: 7

Numero ingresado: 7


Ingrese numero: 50

Numero ingresado: 50


Suma: 72

4.2.8 Anidamiento de bucles

Del mismo modo en que se puede anidar las estructuras condicionales, también es posible anidar

estructuras repetitivas, ya que en realidad no hay regla que lo impida. Por tanto veremos el

anidamiento mediante este un ejemplo.

Ejemplo: Se pide generar la tabla de multiplicar de un número ingresado por teclado. Se debe solicitar

la finalización del programa.

char op; int N; do{ printf("\nIngrese numero: "); scanf("%d", &N); fflush(stdin); for(int i=0;i<=12;i++) printf("\n %d * %d = %d", N, i, N * i ); printf("\n\n\nDesea continuar?(S/N): "); op=getchar(); } while( op!='N' && op!='n' ); system("PAUSE");

Como se muestra en este ejemplo existe una estructura repetitiva < do – while > y dentro de ella una

estructura repetitiva < for >. Sin embargo puede haber varios niveles de anidamiento de acuerdo a la

complejidad del problema.

4.2.9 8 Recomendaciones para el uso de estructuras repetitivas

1) Cuando se conozcan los límites a iterar use la estructura < for >.

2) Cuando al menos necesite ejecutar una vez la estructura repetitiva use < do – while>.

3) Cuando necesite salir de un bucle antes de ejecutar todas las iteraciones utilice la instrucción

break.

Ejemplo:

int N=5; for(int i=1;i<=12;i++){ if (i==5)break; printf("\n %d * %d = %d", N, i, N * i ); }

Este ejemplo muestra la tabla de multiplicar del número N desde 1 hasta 4, puesto que cuando llega a

5 está la instrucción break, por lo tanto termina la instrucción < for >.

4) Evite anidamientos de estructuras condicionales. Si necesita validaciones dentro de la estructura utilice la instrucción continue. Ejemplo:

a) No recomendado

int N=5; for(int i=1;i<=12;i++){ if (i==5) printf("\n %d * %d = %d", N, i, N * i ); }

b) Recomendado

int N=5; for(int i=1;i<=12;i++){ if (i!=5)continue;

printf("\n %d * %d = %d", N, i, N * i ); }

Este ejemplo muestra la tabla de multiplicar del número <N>, pero si el indice es distinto a 5 itera

nuevamente por la instrucción continue, solo cuando llega a 5 muestra por pantalla el resultado.

5) Minimice el uso de constantes. En los bucles como en la mayoría de casos es de usarse variables

por más estática que parezca, ya cada vez más nos damos cuenta que no existen las constantes sino

las variables muy variables y las variables que son muy lentamente variables o las variables

lejanamente variables ya que en el futuro seguramente será modificado su valor.

Ejemplo

a) No recomendado

for(i=1;i<=12;i++) S+= precio * 0.18;

b) Recomendado

IGV=0.18; NroMeses=12; for(i=1;i<=NroMeses;i++)

S+= precio * IGV;

La forma no recomendada parece correcta, pero si pensamos bien el porcentaje 0.18 representa el

IGV y aunque por años se mantiene esa tasa, en algún momento de seguro su valor cambiara a 0.19,

0.17 u otro.

Respecto a NroMeses=12, fácilmente se puede pensar que ese valor no va a cambiar, mas la lectura

puede volverse menos tediosa cuando dejamos de ver el código del programa por algún tiempo y

cuando volvamos a ver sabremos rápidamente que ese 12 que hubiesemos dejado representa los

números de meses del año.

Es solo un ejemplo de las variables que parecen constantes.

6) Analice que variables se inicializan fuera y dentro del bucle. Como consejo practico se inicializa

afuera del bucle respectivo (por que puede haber anidamientos) las variables que van a retener un

valor global acumulado respecto al bucle. Las variables que van a retener datos de la iteración se

deben inicializar dentro del bucle respectivo.

7) Use estructuras condicionales para asegurarse que las variables de la iteración son las correctas e

imprímalas.

Ejemplo

Supongamos que se desea sumar todos los múltiplos de 7 entre 7 y 100000.

int S=0; for( int i=7;i<=100000; i+=7 ){ S+=i; }

Ahora supongamos un caso particular, que necesitamos saber si el número 97930 también se está

sumando, entonces podríamos añadir:

int S=0; for( int i=7;i<=100000; i+=7 ){ S+=i; if (i==97930) printf("\n Si esta sumando!"); }

Si se muestra el mensaje en pantalla sabremos que ese número está siendo sumado.

No obstante este ejemplo es solo una suposición, ya que sabemos que 97930 es múltiplo de 7. Pues

también podemos averiguarlo con 97930 % 7, como el resultado del módulo es cero decimos que si

es múltiplo de 7.

8) Cuídese de los bucles sin fin. Cuando en un bucle la expresión booleana que la controla nunca

retorna false entonces habremos caído en un bucle infinito. Un poco de práctica nos será necesario

para no preocuparnos por estas.

Ejemplo

Este es una terrible forma de definir bucles:

int S=0; while(S%2==0){ printf("\n%d", S); S+=2; }

Este ejemplo muestra claramente que no puede ser variado la condición de la variable S dentro del

código como numero par, por lo tanto no tiene un adecuado fin el programa, porque se va a ejecutar

hasta que se acaben los recursos o porque se forzó a cerrarse.

4.3 Introducción a C++

4.3.1 Reseña histórica

C++ tiene sus orígenes en la década de los 70 y en ese entonces fue creado como C y su función fue

para mantener el sistema operativo UNIX y su creador fue Bjarne Stroustrup de la compañía AT&T.

Previamente hubo lenguajes: BCPL -> B -> C -> C++, pero no fue contundente como lo es hoy C++, C

comparte muchas características de C++ pero C++ hoy es más popular por su manejo mejorado de

memoria, funcionalidades además de contar con programación orientada a objetos.

4.3.2 Directivas y palabras reservadas básicas.

El lenguaje C++ utiliza directivas o archivos de cabecera que proporciona información necesaria útil para el programa. Para importar un archivo de cabecera se utiliza #include iostream es el nombre de la biblioteca que contiene las definiciones de las rutinas que manejan las

entradas del teclado y el despliegue en la pantalla. El espacio de nombres std ordena al compilador utilizar el espacio de nombres de std. Un programa básico debe tener escrito al inicio del programa:

#include <iostream> using namespace std;

fflush(stdin)

Es la función de C++ que va a eliminar los caracteres sobrantes en una entrada, el no utilizarla

provocará errores de entrada de múltiples variables. Se suele llamar a esta instrucción inmediatamente

luego de usar una instrucción scanf.

gets(<variable carácter>)

Funcion para ingresar una cadena de caracteres.

system("PAUSE")

Es el comando de C++ para detener la ejecución hasta que se presione la tecla < Enter >.

system("CLS")

Es el comando de C++ para borrar la pantalla de ejecución.

exit(0)

Termina inmediatamente el programa.

getchar()

La función que permite el ingreso por teclado de un carácter.

break Permite salir o terminar a una estructura (Condicional o repetitiva por ejemplo).

continue Permite continuar o iterar a una estructura repetitiva.

goto Permite saltar o bifurcar el flujo del programa hacia una etiqueta.

Comentarios en C++

En C++ existen dos tipos de comentarios:

Para comentar una sola línea de código

//Comentario de una sola línea de código

Para comentar varias líneas de código

/*

Comentario de

varias líneas

de código

*/

4.3.3 Estructura de un programa en C++

Un programa en C++ se compone de directivas con archivos de cabecera, la función principal main,

declaración de variables e instrucciones validas de C++, a continuación se muestra un ejemplo sencillo

completo de un programa que envía por pantalla un mensaje “HOLA MUNDO”.

//Archivos de encabezado

#include <iostream>

using namespace std;

//Inicio de función principal

void main(){

//Instrucciones C++

printf("\nHOLA MUNDO\n");

system("PAUSE");

}

4.3.4 Creación, ejecución y depuración de un programa mediante Visual Studio .Net

Creación

Para crear

un

programa

en C++,

utilizaremos

Visual

Studio .Net

Ingresamos al menú Archivo – Nuevo – Proyecto

En el árbol de la izquierda, seleccionar Visual C++ En el panel central seleccionar Proyecto Vacío. En la parte inferior escribir el nombre del proyecto. Finalmente Click en Aceptar

Click en boton de Nuevo y seleccionar Agregar Nuevo Elemento.

En el panel izquierdo, seleccionar Visual C++. En el panel central seleccionar Archivo C++.cpp). En la parte inferior escribir el nombre del archivo. Click en Agregar.

Finalmente tendremos una pantalla con un editor de código fuente en el cual introduciremos nuestro código C++.

Ejecución

Ahora ejecutaremos el siguiente programa con la tecla < F5 > o en el botón verde con símbolo de play

de la barra de menú:

Se mostrara la ventana de ejecución:

Depuración

Es el seguimiento y visualización del código de un programa mientras se ejecuta.

En el menú depurar se cuenta con algunas opciones de depuración:

Además se puede iniciar la depuración en un punto escogido por el desarrollador haciendo click, y

luego ejecutando:

Al pasar el mouse por encima de alguna instrucción de C++ muestra un pequeño mensaje.

También se puede seleccionar variable para una inspección rápida.

Desplazarse en el código con los botones de depuración.

Detener la ejecución o depuración presionamos el botón stop.

fundamentos de la programacion u1

Documents