Вы находитесь на странице: 1из 378

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

Teodoro Luciano Córdova Neri

en Borland C++ 5.0.2 Teodoro Luciano Córdova Neri Lenguaje de programación estructurada y sus aplicaciones en

Lenguaje de programación estructurada

y sus aplicaciones en Borland C++ 5.02

Universidad Nacional de Ingeniería Editorial Universitaria

Universidad Nacional de Ingeniería

Editorial Universitaria

I

Teodoro Luciano Córdova Neri

Rector Dr. Ing. Aurelio Padilla Ríos Primer Vicerrector Geol. José S. Martínez Talledo Segundo Vicerrector Msc. Ing. Walter Zaldívar Álvarez

Primera edición, mayo de 2012

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2 Impreso en el Perú / Printed in Peru

© Teodoro Luciano Córdova Neri Derechos reservados

© Derechos de edición

Universidad Nacional de Ingeniería Editorial Universitaria

Universidad Nacional de Ingeniería Editorial Universitaria Av. Túpac Amaru 210, Rímac – Lima Pabellón Central /

Av. Túpac Amaru 210, Rímac – Lima Pabellón Central / Sótano Telfs. 4814196 / 4811070 anexo 215 Correo-e: eduni@uni.edu.pe Jefe EDUNI: Prof. Álvaro Montaño Freire Coordinador Editorial: Nilton Zelada Minaya

Impreso en la Imprenta de la Editorial Universitaria de la Universidad Nacional de Ingeniería

ISBN 978-612-4072-23-9

Hecho el Depósito Legal en la Biblioteca Nacional del Perú Nº 2011-13203

Prohibida la reproducción de este libro por cualquier medio, total o parcialmente, sin permiso expreso del autor.

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

Palabras liminares

Me complace felicitar a los docentes de nuestra Universidad ganadores del II Concurso para la Publicación de Libros de Texto convocado por el Rectorado

y realizado en cada una de las Facultades. Una de las políticas medulares del

Rectorado es la permanente mejora en la calidad académica, y en ese sentido nos interesa que cada docente tenga la oportunidad de convertir su labor cotidiana de enseñanza en textos para uso de los estudiantes universitarios de todo el país.

Los autores han hecho un meritorio esfuerzo para organizar los temas de sus exposiciones, realizando investigaciones y consultando fuentes peruanas y extranjeras, así como recogiendo el fruto del diálogo con sus colegas y los propios estudiantes. Asimismo, se han esmerado en presentar sus cursos de manera que facilita el acceso por parte de los interesados.

La publicación de textos académicos es una de las obligaciones de toda universidad y uno de los índices que se toma en cuenta para la evaluación de

la calidad académica. Por ende, seguiremos apoyando la publicación de libros

y revistas a través de nuestra Editorial Universitaria, cuya meta es formar parte

del liderazgo peruano en la industria editorial dedicada a ingeniería, ciencia y arquitectura.

Es responsabilidad de la Universidad Nacional de Ingeniería aportar al Perú un liderazgo de base tecnológica que trabaje en estrecha asociación con las autoridades gubernamentales, los dirigentes empresariales y la sociedad civil en su conjunto, lo cual requiere de una política editorial y de publicaciones que estamos impulsando.

Dr. Ing. Aurelio Padilla Ríos Rector

Teodoro Luciano Córdova Neri

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

A mis padres Luis y Gliceria, gracias

por todo.

A María, mi compañera de siempre.

A mis tres hijos, frutos del amor y

compromiso con la vida

Teodoro Luciano Córdova Neri

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

Reconocimiento y gratitud a todos mis maestros por su importante apoyo Profesional. Y en especial al Decano FIIS Mg. Luis Acuña P. y al Ing. Carlos Chafloque E. por su apoyo

Teodoro Luciano Córdova Neri

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

Índice

Presentación

XIII

Introducción

XV

 

Capítulo I

Generalidades

1

1.1 Introducción

.1

1.2 Introducción a la programación

1

1.3 Características de un algoritmo de computador

2

1.4 Lenguajes de programación

2

1.5 Lenguajes de máquina

3

1.6 Lenguaje de bajo nivel

3

1.7 Lenguaje de alto nivel

3

1.8 Programa ejecutable

3

1.9 Compilador

3

1.10 Palabras reservadas

3

1.11 Identificadores

4

1.12 Comentarios

4

1.13 Tipos de datos

5

1.14 Carácter (char)

5

1.15 Declaración de constantes simbólicas

6

Capítulo II Estructuras de control

11

2.1

Estructuras secuenciales

11

2.2

Estructuras selectivas condicionales

16

2.2.1

Estructura selectiva simple

.16

2.2.2

Estructura selectiva compuesta

18

2.2.3

Estructura condicional con anidamiento

19

2.3

Estructuras múltiples

21

Teodoro Luciano Córdova Neri

2.4

Estructuras repetitivas

29

2.4.1

Estructura repetitiva

con pretest de prueba

29

2.4.2

Estructura repetitiva con postest de prueba

37

2.4.3

Estructura repetitiva cuando se conoce el número de iteraciones

44

2.4.4

Estructuras múltiples – módulo de operaciones aritméticas

85

Capítulo III Estructuras de datos arrays

 

123

3.1 Introducción a las estructuras de datos

124

3.2 Arraysunidimensionales: los vectores

124

3.3 Operaciones con vectores: métodos de ordenación, inserción, eliminación, búsquedas, crear sublistas, etc. Aplicaciones

126

3.4 Arrays bidimensionales

 

149

Capítulo IV Las cadenas de caracteres

199

4.1 Introducción

199

4.2 Punteros a cadenas

200

4.3 Funciones para el tratamiento de cadenas:strlen(), strcat()

202

4.4 Copia de cadenas:stpcpy(), strcpy(), strncpy()

204

4.5 Funciones para buscar un carácter en una cadena:strchr(), strrchr()

206

4.6 Función para reconocimiento de una porción de cadena: strspn(), strcspn(), strpbrk() y strtok()

208

4.7 Funciones para la comparación de cadenas: strcmp(), strnicmp(), stricmp()

210

4.8 Transformación de cadenas: strset(), strnset()

213

4.9 Funciones para invertir cadenas:strxfrm(), strrev()

214

4.10 Conversión a mayúsculas y minúsculas: strupr(),strlwr()

215

4.11 Inclusión de una cadena en otra cadena

215

Capítulo V Programación modular

 

221

5.1 Introducción

221

5.2 Funciones definidas por el usuario

222

5.3 Declaración y definición de funciones

224

5.4 Lista de parámetros y sus tipos de datos

225

5.5 Variables locales y globales

226

5.6 Parámetros por defecto, valor

227

5.7 Funciones que llaman a funciones

246

5.8 Funciones recursivas

 

259

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

Capítulo VI

 

Registros

 

273

6.1 Introducción. Definiciones

273

6.2 Definición y declaración de una estructura

275

6.3 Variables registro (instancias)

275

6.4 Anidamiento de registros

276

6.5 Acceso a los elementos de una estructura

276

6.6 Aplicaciones

277

Capítulo VII Archivos (File)…….………………….……………

……

307

7.1

Introducción

308

7.2

Características de los archivos

308

7.3

Archivos (file)

308

7.4

Apertura de archivos

308

7.5

Clasificación de archivos por tipo de contenido: texto, binarios

309

7.5.1

Archivos de texto

309

7.5.2

Archivos binarios

309

7.6

Clasificación de archivos por tipo de acceso

310

7.6.1

Archivos secuenciales

310

7.6.2

Archivos directos: acceso aleatorio

310

7.7

Direcciones lógicas y direcciones físicas

310

7.8

Cálculo de direcciones físicas

311

7.9

Funciones para el manejo de archivos

311

7.10

Declaración de la variable lógica (“alias”) del archivo

311

7.11

Función para procesar archivos

311

7.12

Validar la apertura de un archivo

312

7.13

Cierre de archivos usando fclose() y fcloseall()

312

7.14

Escritura de registros usando fwrite()

313

7.15

Vaciando los buffers usando fflush ()

313

7.16

Lectura de registros usando fread ()

313

7.17

Función para acceso de archivo

313

7.18

Conocer posición del apuntador del archivo:función ftell()

314

7.19

Posicionando apuntador al inicio del archivo: rewind()

314

7.20

Detectando el final del archivo con feof()

314

7.21

Cambio de nombre de archivo rename()

314

7.22

Eliminando archivos con la función remove()

315

Teodoro Luciano Córdova Neri

Capítulo VIII Programación dinámica

327

8.1 Programación dinámica:punteros

327

8.2 Creación de un puntero

328

8.3 Operadores

328

8.4 Inicialización de un puntero

329

8.5 Lista

332

8.6 Pila

332

8.7 Punteros nivel RAM

336

8.8 Punteros y archivos

346

8.9 Compendio de problemas

349

Bibliografía

357

Índice temático ……………………………………………………

……

359

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

Presentación

En el milenio pasado, como en el actual, se exige constantemente a la universidad elevar su calidad académica, especialmente la formación profesional que está relacionada directamente con la formación del docente universitario.

En general, el paradigma de la docencia universitaria está ligado a dos variables:

el dominio y experiencia de la especialidad profesional y el conocimiento y praxis

del proceso de enseñanza - aprendizaje en sus asignaturas correspondientes. Dentro de este contexto, felicito a las autoridades de la Universidad y al ente normativo de promocionar actividades estratégicas en el sector académico, tales

como la publicación de textos universitarios, actividad estratégica que beneficia a

la

universidad como al docente, debido que en conjunto se está cumpliendo con

el

perfil de la universidad: Ciencia Tecnología y Sociedad (CTS).

Respecto al docente, estamos en la responsabilidad de proporcionar un conjunto de enfoques didácticos relacionados con nuestro rol universitario, donde el

proceso de enseñanza - aprendizaje, métodos, técnicas y evaluación, engloben las TICS buscando mejoras continuas. En este sentido, como docente de la asignatura “Lenguaje de Programación Estructurada”, asignatura obligatoria que forma parte del plan curricular de vuestra Facultad, presento el texto denominado “Aplicaciones en Borland C++ 5.02 – Programacion Estructurada”, organizado

y diseñado con base en la experiencia de más de 20 años comprometido con el concepto de programación en lenguajes estructurados.

Esperando que la lectura, análisis y reflexión de la antología que presento sirva para acrecentar el espíritu de renovación institucional, de innovación profesional continua y que obviamente trascenderá al mejor aprendizaje y alta calidad académica de nuestros alumnos, cuando además de la enseñanza presencial, también se dispongan de herramientas didácticas: libros, clases on line, etc.

El autor

Teodoro Luciano Córdova Neri

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

Introducción

El comité para el estándar ANSI C se formó en el año 1983 con el objetivo de crear un lenguaje uniforme a partir del Lenguaje de Programación C original,

desarrollado por Kernighan y Ritchie en 1972, en la ATT. Respecto a C++ comenzó

a desarrollarse en 1980 por B. Stroustrup. Al comienzo era una extensión del

lenguaje C, que fue denominada C with classes. Este nuevo lenguaje comenzó

a ser utilizado fuera de la AT&T en 1983. Ante la gran difusión y éxito que iba

obteniendo en el mundo de los programadores, la AT&T comenzó a estandarizarlo internamente en 1987. En 1989 se formó un comité ANSI para estandarizarlo a nivel internacional.

En la actualidad, el C++ es un lenguaje versátil, potente y general. Su éxito entre los programadores permite ocupar el primer puesto como herramienta de desarrollo de aplicaciones, pues mantiene las ventajas del C en cuanto a riqueza de operadores y expresiones, flexibilidad, conciso y eficiencia. Además, ha eliminado muchas de las dificultades y limitaciones que tiene C original. La evolución de C++ ha continuado con la aparición de Java, un lenguaje creado simplificando algunas partes de C++ y añadiendo otras, que se utiliza en la presente década para realizar aplicaciones en internet.

El C++ se presenta como:

1. Lenguaje de programación procedural (orientado a algoritmos) y por cumplir con las normas de poseer las tres estructuras de control (secuenciales, condicionales/ múltiples y repetitivas).

2. Lenguaje orientado a objetos (objectoriented programming, OOP). Como lenguaje procesal se asemeja al C y es compatible con él. Este nivel de programación admite una filosofía completamente diferente, que exige del programador un completo cambio de mentalidad. Las características propias de la programación orientada a objetos, este tema es el más fascinante, pues C++ cambia radicalmente su pensamiento de programación.

Cabe notar que un programa fuente diseñado a nivel C++, no compila en C, pero lo contrario sí se cumple. Además de las estructuras del control, también disponen de estructuras de datos en forma legible al usuario, tales como: listas o

Teodoro Luciano Córdova Neri

vectores, tablas o matrices, etc. Asimismo, los registros (struct), uniones, archivos (FILE), programación dinámica (punteros), procesamiento de cadenas basadas fuertemente en funciones (strcmp, struppr, etc.).

El presente texto está basado en experiencias obtenidas por más de década y media, dictando asignaturas en las escuelas de Ingeniería de Sistemas, Computación e Informática de las diferentes universidad del Perú (Universidad Nacional de Ingeniería - Facultad de Ingeniería Industrial y de Sistemas), Universidad de San Martín, Universidad Antúnez de Mayolo, Universidad Tecnológica del Perú, Universidad San Martín de Porres, etc.).

Me es grato agradecer las sugerencias de colegas que, en su debida oportunidad, aportaron con sus opiniones para la mejora del presente libro.

El autor

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

Capítulo 1

generalidades

ObjetIvOs

- Conocer la biblioteca standard de Borland C++ 5.02.

- Dar fundamentos para el estudio de otros lenguajes de programación en general y aplicarlos para java, etc.

- Comprender la programación de ni- vel estructurada.

- Comprender las técnicas básicas para resolver problemas.

- Desarrollar programas usando las técnicas de tipo top-down (de arriba abajo)

- Usar los operadores lógicos, relacio- nales, funciones resto y parte entera.

- Usar los tipos de datos enteros, rea- les, cadenas, booleanos.

los tipos de datos enteros, rea- les, cadenas, booleanos. 1.2 IntrOduccIón a la PrOgramacIón 1.2.1 definiciones

1.2 IntrOduccIón a la PrOgramacIón 1.2.1 definiciones

Computadora. Una computadora (PC) se puede definir como una máquina electrónica digital capaz de procesar información y producir datos de salida, para lo cual requiere de datos de entrada. El término digital se debe al hecho de que la información almacenada y procesada por la computadora está representada mediante códigos numéricos binarios formados por ceros y unos (0 y 1) conocidos como bits , los mismos que con 8 bits, se forma un byte (una palabra).

Debo aclarar, que para los informáticos hay una diferencia entre datos e información.

Teodoro Luciano Córdova Neri

Dato. Es la representación de algún hecho, concepto o entidad real.

Información. Es el resultado del procesamiento de los datos.

Observación. Para este curso no haremos distinción entre dato e información sino que hablaremos de datos de entrada y datos de salida.

Proceso de información en una computadora

Una computadora está compuesta por dos elementos fundamentales: hardware y software.

Hardware. Está constituido por la parte física de la computadora. Es aquello que podemos ver y tocar. Está formado por el monitor, el teclado, el mouse, la unidad del sistema, la impresora, etc.

Software. Es la parte lógica de la computadora y está formado por el conjunto de programas que controlan el funcionamiento de la computadora.

Organización física de una computadora

El software es el conjunto de datos y programas que usa la computadora y se guardan en algún dispositivo del hardware, por ejemplo, un disco duro.

Programa. Es un conjunto detallado de instrucciones que instruyen al procesador para realizar determinados procesos. Los datos pueden ser cualquier información que necesite el programa: caracteres, números, imágenes, etc.

Algoritmo. Es un conjunto de reglas o procedimientos que permiten obtener un resultado determinado a partir de ciertas reglas definidas por el programador.

1.3 características de un algoritmo de computador

Ser algoritmo: tiene que consistir en una secuencia de instrucciones claras y finitas.

Ser correcto: el algoritmo ha de resolver el problema planteado en todas sus facetas.

Ser legible: el usuario o usuarios deben comprender la sintaxis.

Ser eficiente: es relativa, porque depende de la máquinas en la que lo ejecutemos. Existen ejemplos de algoritmos eficientes que ocupan demasiado espacio para ser aplicados sin almacenamiento secundario lento, lo cual puede anular la eficiencia.

1.4 lenguajes de programación

Sirven para editar programas (instrucciones). Las instrucciones escritas en la mayoría de los lenguajes de programación no son entendibles directamente

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

por el procesador, sino que requieren de pasos intermedios de traducción e interpretación para convertir.

Estas instrucciones al lenguaje del procesador, conocido como lenguaje máquina. Podemos citar como lenguajes de programación a Pascal, borlandc++ 5.02, etc.

1.5 lenguajes de máquina

Permiten escribir instrucciones directamente entendibles por el procesador. Una instrucción máquina consiste en una secuencia de dígitos binarios (0 y 1) en la memoria principal, que le indica al procesador qué operación máquina debe realizar. Una colección de instrucciones máquina en la memoria principal se denomina programa en lenguaje máquina.

1.6 lenguajes de bajo nivel

Los lenguajes de bajo nivel representan un paso hacia la humanización de los lenguajes de programación, son más fáciles que los lenguajes máquina pero, al igual que ellos, son dependientes de la máquina. Los lenguajes de bajo nivel son lenguajes simbólicos, siendo el más importante el lenguaje ensamblador.

1.7 lenguajes de alto nivel

Los lenguajes de alto nivel son lenguajes humanizados en los que las instrucciones se escriben utilizando frases del inglés cotidiano (o una mezcla de inglés y otro idioma) y contienen notaciones matemáticas de uso común, facilitando así el aprendizaje del lenguaje y la escritura de programas.

1.8 Programa ejecutable

Un programa ejecutable tiene, normalmente, millones de instrucciones y no necesitan del lenguaje de programación para ejecutarse, pues solo basta ejecutar desde el sistema operativo (DOS).

1.9 compilador

Es una herramienta básica en el mantenimiento y mejora del sistema operativo. Por ello este producto está en constante evolución, ya que de su buen rendimiento depende en parte el del sistema.

1.10 Palabras reservadas

Llamadas también palabras clave, son aquellas que tienen significado especial para el compilador y se utilizan para declarar variables, estructuras, clases, hacer operaciones, definir estructuras de control, etc.

Teodoro Luciano Córdova Neri

Ejemplos:

break

do

enum

int

typedef

bool

double

for

private

while

case

else

if

sizeof

1.11 Identificadores

Son secuencias de caracteres que representan a las variables, constantes, tipos, funciones, clases y etiquetas en un programa. En C++, un identificador válido debe cumplir con lo siguiente:

Reglas

13.1. Debe estar formado solamente por letras mayúsculas (de la “A” a la “Z”), o

letras minúsculas (de la “a” a la “z”) Adicionalmente puede combinarse con el carácter subrayado ( _ ).

Ejemplo : pc, prom_pc, cont, _nombre.

13.2. Usar dígitos del 0 al 9. Debe comenzar con una letra o letras (nunca con

números).

Ejemplo: pc_01, prom_pc, cont, Lab1, etc.

13.3. Puede comenzar con un subrayado, pero las palabras que comienzan con

dos subrayados son reservadas para el uso interno del compilador.

13.4. No debe contener espacios en blanco, use el subrayado ( _ ) en vez de blancos.

13.5. No usar palabras reservadas del compilador.

Ejemplos de identificadores no válidos:

3pc:

nombre apellidos: contiene un espacio en blanco

comienza con un número

_i_y:

comienza con dos subrayados

x*y:

contiene un carácter no válido (*)

do:

es una palabra reservada

Nota: C++ es sensible al uso de las mayúsculas y minúsculas. Así, A es diferente de a.

1.12 comentarios

Son explicaciones literales que sirven para aumentar la legibilidad de los programas. Estas son ignoradas totalmente por el compilador. En C++, se puede colocar comentarios en cualquier parte del programa donde sea posible, de dos maneras:

14.1 Mediante dos barras inclinadas (//), para comentarios de una línea.

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

14.2 Por los delimitadores (/*

Ejemplo:// comenta respecto a una linea:

/* Comenta respecto a una línea o varias líneas:

*/)

para comentarios de una o más líneas.

1.13 tipos de datos

En la siguiente tabla se ilustra los diferentes tipos de datos:

 

Tipo

Tamaño

 

Rango

Lógico

bool

1

bit

true o false

 

Enteros

unsigned char

8

bits

0

255

 

char

8

bits

–128

127

 
 

enum

16

bits

–32 768

32 767

 
 

unsigned int

16

bits

0

65 535

 

short int

16

bits

–32 768

32 767

 
 

int

16

bits

–32 768

32 767

 
 

unsigned long

32

bits

0

4 294 967 295

 

long

32

bits

–2 147 483 648

2 147 483 647

Reales

float

32

bits

±3.4E–38

±3.4E+38

 

double

64

bits

±1.7E–308

±1.7E+308

 

long double

80

bits

±3.4E–4932

±1.1E+4932

1.14 carácter (char)

Las constantes que representan a caracteres o acciones especiales. Ejemplos: ‘s’, ‘A’, ‘-’,‘|’

‘\a’

alerta (bip sonoro) retroceso (backspace) salto de página en la impresora (formfeed) nueva línea (newline) retorno de carro (carriagereturn)

‘\b’

‘\f’

‘\n’

‘\r’

‘\t’

tabulación horizontal tabulación vertical barra invertida (backslash)

‘\v’

‘\\’

Teodoro Luciano Córdova Neri

Constantes cadena (char * o char[])

Son secuencias de caracteres encerrados entre comillas:

“Lenguajes de Programacion”, “Borland C++ 5.0.2”

También se pueden incluir secuencias de escape:

“\tEstudiar, es una etapa de sabidurias \n”

1.15 declaración de constantes simbólicas

Mediante una directiva #define:

Sintaxis:

#define

nombre

valor

Ejemplos:

# define pi 3.141

# define linea “---------------------------------------------------------------“

Puede hacer que una constante tome un valor en función de otras:

# define pi 3.141,

# define doble_pi 2*pi

Mediante tipos enumerados:

El tipo enum es útil cuando se crean constantes simbólicas con valores enteros.

Ejemplo:

enumdias = {lunes=1,martes,miercoles,jueves,viernes,sabado,domingo}

Además, se puede alterar el orden consecutivo, por ejemplo:

enum colores = {blanco,amarillo,rojo,azul,anterior=64 }

Variables.- Una variable es un identificador válido cuyo valor puede cambiar temporalmente durante la ejecución de un programa. Las variables deben ser declaradas antes de ser utilizadas.

Sintaxis:

Tipo_de_dato nombre_de_variable;

en donde tipo_de_dato es cualquier tipo válido en C++.

Ejemplos

float prom;

// prom es un datos de tipo real.

Operadores.- Tienen una gran utilidad durante la programación, considerando su prioridad de evaluación de operadores y su significado. En la siguiente gráfica, se ilustra la sintaxis y el uso respectivo.

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

Categoría

Operador

Significado

 

Ejemplo

Negación

!

Negación lógica

!(n<11)

//si n es menor

(NOT)

que 11,devuelve falso (0)

Contador

 

Preincremento o

n++

usa n y luego incrementa en 1

Incremento

++

posincremento

++n // incrementa n en 1 y luego lo usa n

Contador

 

Predecremento o

 

Disminuir

--

posdecremento

--n//

n disminuye en 1

Multiplicar

*

Multiplicación

a

* b //Multiplica a por b.

Dividir

/

División

a/b // divide a entre b

Resto

%

Módulo (resto)

a%b // devuelve el módulo de la división entera de a y b (que deben ser enteros)

Operadores

 

Menor que

a

< b // devuelve verdadero si a es

relacionales

<

menor que b. los otros son similares

 

<=

Menor o igual que

a

<= b

 

>

Mayor que

c

> d

 

>=

Mayor o igual que

d

>= e

Igualdad

==

Igualdad

5

== 3 // devuelve falso

 

!=

Desigualdad

a!=13

 

y

&&

y Lógico (AND)

((5<13)&&(5>=4)) //Devuelve verdadero

O

||

oLógico (OR)

(mivar==”hola”) || (3<5) //Devuelve verdadero

Condicional

?:

Condicional

(a<b) ? a++:a-- //Si a<b, a se aumenta en

abreviado

1

Sino se disminuye en 1

Asignación

 

Asignación

x

= 5 //A x se le asigna el valor entero 5

=

(x5)

 

Expresiones:

*=

Asignar producto

m*=3 //Equivale a m = m * 3

 

/=

Asignar división

e/=d //Equivale a e = e / d

 

%=

Asignar módulo

t%=2//Equivale a t = t % 2

 

+=

Asignar suma

g+=7 //Equivale a g = g + 7

Estructura básica de un programa

// directivas o librerías # include<iostream.h>

Teodoro Luciano Córdova Neri

# define pi 3.14

// Prototipo de funciones tipo_datonomb_ funcion (lista_argumentos);

// Declaracion de variables globales inta,b,c; // Declaración y definición de funciones: Implementación

tipo_datonomb_funcion(lista de_argumentos)

{ Declaraciones locales <Instrucciones >;

return(expresión_de_tipo_dato);

}

tipo_nfuncion_n(lista_de_argumentos)

{

<ídem caso de la funcion1>;

}

/

/Programa principal voidmain()

{ Declaraciones sobre variables locales al proceso principal <Instrucciones>; Nomb_funcion(lista_de_argumentos);

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

funcion_n(lista_de_argumentos);

return(0);

}

Como se observa el esquema más empleado para un programa en C++ se compone básicamente por:

1. Directivas

2. Declaración y definición de funciones secundarias definidas por el usuario

3. Una función principal main()

Notas:

1. La función principal o main() regresa un valor 0 al sistema operativo para in- dicar que el proceso terminó exitosamente, cuando ocurre algún tipo de error regresará algún otro valor entero. Si no se requiere que main devuelva algún valor, se escribe voidmain() y se omite return0;

2. Si desea retornar un valor entero, entonces defina el tipo de dato delante de la función respectiva. intmain()

{ return 0;

}

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

Las demás funciones, por lo general son llamadas a ejecución dentro del ámbito de nuestra función principal y por consiguiente, ahí pueden regresar valores.

Observación:

Durante el diseño de los programas solo especificaré una librería de entrada y de salida:

# include<iostream.h>

Las demás librerías el usuario definirá según su requerimiento.

Teodoro Luciano Córdova Neri

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

Capítulo II

estructuras de control

ObjetIvOs

C++ 5.0.2 Capítulo II estructuras de control ObjetIvOs - Comprender la selección a través de la

- Comprender la selección a través de la instrucción de condicional if (simple, compuesta y con anidamiento).

- Como definir estructuras múltiples o de selección Switch (selector).

- Utilizar las instrucciones de control con pretest de prueba (while).

- Utilizar las instrucciones de control con posprueba (do, while).

- Utilizar las estructuras de control de programas break y continue.

- Combinar las estructuras selectivas, múltiples y repetitivas.

- Hacer aplicaciones que representen problemas reales, tales como validación de códigos de alumnos, empleados, DNI, código de productos, etc.

2.1 estructuras secuencIales

Son aquellas que se escriben línea a línea y son ejecutadas en el orden en que se encuentran, desde el inicio hasta el final del programa. En C++ estas son solo sentencias simples que terminan en un punto y coma (;):

Sintaxis

<instrucción_1>;

< instrucción _2>;

< instrucción _ n>;

Sentencia nula: En C++ existe, además, la sentencia nula (una instrucción que no

hace nada), está representada por un punto y coma

(“;”).

Teodoro Luciano Córdova Neri

Su aplicación se da a las estructuras repetitivas, cuando se quieren ignorar ciertos valores y procesar otros en función de una condición lógica.

Problema 1. Escribir un programa que calcule el perímetro y el área de un triángulo, dados como datos las longitudes de sus tres lados (suponer que siempre se cumple la desigualdad triangular).

Solución // area.cpp

#include<iostream.h>

#include<iomanip.h>

void main()

//para setiosflags

{ float a,b,c,p,area; clrscr();

gotoxy(8,2);cout<<”Ingrese

los lados del triangulo”; gotoxy(10,4);cout<<”a = “; cin>>a; gotoxy(10,5);cout<<”b = “; cin>>b; gotoxy(10,6);cout<<”c = “; cin>>c;

p=(a+b+c)/2;

= “; cin>>c; p=(a+b+c)/2; gotoxy(10,8);cout<<”El perímetro es

gotoxy(10,8);cout<<”El perímetro es “<<setw(10)<<setprecision(2)<<

2*p;

area=float(sqrt(p*(p-a)*(p-

b)*(p-c)));//moldeo de datos

gotoxy(10,10);

cout<<”El área es “<<setw(15)<<setprecision(4)<<area<<” metros “;

gotoxy(10,14);system(“pause”);

}

Problema 2. Diseñar un programa que permita leer datos de un trabajador consistentes en: nombre, código, sueldo básico y bonificación. Considere también que:

- Los descuentos son: AFP: 8%, invalidez: 1.44%;

- Las aportaciones son: Fonavi: 5%, seguro nacional de pensiones: 11%, Senati: 1%

- Existe un aumento de: 0.125

- El programa debe mostrar el total de su boleta del empleado

Solución: //simula_planilla.cpp #include<iostream.h> void main()

{ float s_basico,bonif,dscto,aumento,s_neto,s_real,fon,afp,snp,

float

inval,senati,aport; char nom[20],cod[5];

clrscr();

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

gotoxy(24,1),cout<<” SISTEMA DE PLANILLAS “; gotoxy(24,3),cout<<” Ingrese datos del trabajador:”; gotoxy(5,5),cout<<”Nombre :”;cin>>nom; gotoxy(5,6),cout<<”Código :”;cin>>cod; gotoxy(5,7),cout<<”Sueldo Básico :”;cin>>s_basico; gotoxy(5,8),cout<<”Bonificación :”;cin>>bonif; //descuentos afp=s_basico*0.08; //8% inval=s_basico*0.0114; //1.44% dscto=(afp+inval); //aportaciones fon=s_basico*0.05; //5% snp=s_basico*0.011; //11% senati=s_basico*0.001; //1% aport=(fon+snp+senati); //Cálculos s_real=(s_basico+bonif)-dscto;

aumento=s_basico*0.125;

s_neto=s_real+aumento;//Reportes clrscr();

gotoxy(2,1),cout<<”-------------------------------------------------------------------”;

gotoxy(38,2),cout<<”Planilla del trabajador “;

gotoxy(2,3),co

ut<<”---------------------------------------------------------------------”; gotoxy(2,4),cout<<”Sr. “<<nom; gotoxy(20,4),cout<<”Cod. “<<cod; gotoxy(44,4),cout<<»Área: SISTEMAS»;

gotoxy(2,5),cout<<»----------------------------------------------------------------------------»;

gotoxy(2,8),cout<<»----------------------------------------------------------------------------»;

gotoxy(3,7),cout<<»BÁSICO»; gotoxy(4,9),cout<<s_basico; gotoxy(11,7),cout<<»BONIF»; gotoxy(11,9),cout<<bonif; gotoxy(19,6),cout<<»DESCUENTOS»; gotoxy(19,7),cout<<»AFP»; gotoxy(19,9),cout<<afp; gotoxy(25,7),cout<<»INVAL»; gotoxy(26,9),cout<<inval; gotoxy(30,6),cout<<» TOTAL»; gotoxy(30,7),cout<<» DSCTOS»; gotoxy(31,9),cout<<dscto; gotoxy(42,6),cout<<»APORTACIONES»; gotoxy(39,7),cout<<»FONAVI»; gotoxy(39,9),cout<<fon; gotoxy(47,7),cout<<»SNP»; gotoxy(48,9),cout<<snp; gotoxy(51,7),cout<<»SENATI»; gotoxy(53,9),cout<<senati; gotoxy(58,6),cout<<»TOTAL»; gotoxy(58,7),cout<<»APORT»; gotoxy(59,9),cout<<aport; gotoxy(65,7),cout<<»BRUTO»; gotoxy(65,9),cout<<s_real; gotoxy(71,7),cout<<»AUMENTO»; gotoxy(73,9),cout<<aumento<<endl;

gotoxy(2,11),cout<<»--------------------------------------------------------------------------»;

gotoxy(65,12),cout<<»TOTAL: S/.»; gotoxy(65,13),cout<<»=====»; gtoxy(72,12),cout<<s_neto; getche(); }

Teodoro Luciano Córdova Neri

Teodoro Luciano Córdova Neri Problema 3. Diseñar un programa que permita leer tres números enteros y

Problema 3. Diseñar un programa que permita leer tres números enteros y luego usando operadores relaciones con operadores lógicos, mostrar resultado booleano de las siguientes expresiones (entrada; 2, 3, 4):

- resp=(a<b)&&(b<c);//

- resp=(a<b)&&(!(b>c));//2<3 y not(3>4) ==>V y V ==>resp= V= 1

- resp=(a==b)|| (!(b>c));//2=3 o not(3>4) ==> F o not(F)==> resp=V=1

- resp=(a==b) &&( b>c);//2=3 y(3>4) ==> F y F = 0

- resp=(a==b) || (b>c);//2=3 o (3>4) F o F = 0

- resp=((a!=b)&&(b<c)); // V y V = 1

- resp=a;”Valida veracidad de entrada de “a”

- letra=letra1<letra2;

2<3 y 3<4 ==> V y V==> resp=V=1

//Solución: Operadores_Relac.cpp #include <iostream.h> #define linea “ void main() { int a,b,c; char letra1,letra2;bool resp, letra; gotoxy(8,1);cout<<” Operadores Relacionales y Lógicos(V=1,F=0)”;

gotoxy(8,2);cout<<linea;

gotoxy(10,3);cout<<” Ingrese a = “;cin>>a; gotoxy(10,4);cout<<” Ingrese b = “;cin>>b; gotoxy(10,5);cout<<” Ingrese c = “;cin>>c; resp=(a<b)&&(b<c);//2 3 4 2<3 y 3<4 ==> V y V==> resp=V=1 gotoxy(10,7);cout<<a<<”<”<<b<<” y “<<b<<”< “<<c <<” ==> resp = “<< resp; getche(); resp=(a<b)&&(!(b>c));//2<3 y not(3>4) ==>V y V ==>resp= V= 1

gotoxy(10,8);cout<<a<<”<”<<b<<”

y not “<<b<< “> “<< c <<” ==> res = “<<resp; getche();

y not “<<b<< “> “<< c <<” ==> res = “<<resp; getche(); ” 14

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

resp=(a==b)|| (!(b>c));//2=3 o not(3>4) ==> F o not(F)==> resp=V=1

gotoxy(10,9);cout<<a<<” = “<<b<<” o not “<<b<< “> “<< c <<” ==> resp = “<<resp;getche(); resp=(a==b) &&( b>c);//2=3 y(3>4) ==> F y F = 0; gotoxy(10,10);

cout<<a<<” = “<<b<<” y “<<b<< “> “<< c <<”

==> resp = “<<resp;

getche();

resp=(a==b) || (b>c);//2=3 o (3>4) F o F = 0

gotoxy(10,11);

cout<<a<<” = “<<b<<” o “<<b<< “ > “<< c <<” ==> resp = “<<resp;getche(); resp=((a!=b)&&(b<c)); gotoxy(10,12); cout<<a<<” diferente de = “<<b<<” y “<<b<< “ < “<< c <<” ==> resp = “<<resp; getch(); resp=a; gotoxy(10,13);cout<<”Valida veracidad de entrada de “<<a<<”=>resp= “<<resp; getche(); gotoxy(10,15);cout<<”Ingrese Primera letra = “; cin>>letra1; gotoxy(10,16);cout<<”Ingrese Segunda letra = “; cin>>letra2; letra=letra1<letra2; gotoxy(10,18); cout<<letra1<<”es<en valor ASCII que “<<letra2<<”resp= “<<resp;getche();

}

Problema 4. Diseñar un programa que permita ingresar un número entero positivo y compuesto por tres dígitos, luego mostrarlo en forma invertida.

Solución //while_prg_03.cpp #include<iostream.h> #define linea” void main()

{ int n,

dig_01,parte_ente_01,dig_02,parte_ente_02;

gotoxy(12,2);cout<<” ESTRUCTURA SECUENCIAL “; gotoxy(12,4);cout<<” ===> INVERTIR UN NÚMERO <===”;

gotoxy(8,5);cout<<linea;

gotoxy(12,6);cout<<” Ingrese número = “;cin>>n; dig_01=n%10; parte_ente_01=n/10; dig_02=parte_ente_01%10;

parte_ente_02=parte_ente_01/10;

gotoxy(8,8);cout<<linea;

gotoxy(12,9);cout<<n<<” invertido= “<< dig_01<< dig_02<<parte_ente_02;

gotoxy(8,10);cout<<linea; getche();

}

invertido= “<< dig_01<< dig_02<<parte_ente_02; gotoxy(8,10);cout<<linea; getche(); } 15

Teodoro Luciano Córdova Neri

2.2 estructuras selectIvas cOndIcIOnales

Permiten evaluar condiciones de proposiciones, comparaciones de tipos de datos que pueden ser números, cadenas, letras, etc. y devuelven resultados tipo booleanos V:1 o F:0 y, dependiendo las instrucciones, a ejecutar cuando es V o cuando es F.

Presentan tres tipos de:

- Estructuras condiciones simples

- Estructuras condiciones compuestas y

- Estructuras condiciones con anidamiento

2.2.1 estructura selectiva simple

Son aquellas que realizan una determinada secuencia de instrucciones, de acuerdo a determinada condición lógica. Si esta es verdadera, la secuencia se ejecuta, si no lo es, continúa el programa con la instrucción siguiente.

Sintaxis:

Cuando se ejecuta una sola sentencia dentro de la estructura

Cuando se ejecuta una sola sentencia dentro de la estructura if (<condición>) { intrucciones; } Cuando

if (<condición>) { intrucciones;

}

Cuando se ejecutan varias sentencias dentro de la estructura If (<condición>) { instrucción_1;

instrucción_2;

………………

Instrucción_n;

}

Observaciones:

a. <condicion> es la condición valor numérico o función que será evaluada como verdadera (distinta de cero) o falsa (cero). Esta puede ser simple (un solo valor o condición) o compuesta, la cual está formada por varias condiciones simples conectadas por los operadores lógicos vistos anteriormente: && (y), || (o) y !

(negación).

b. Siempre se usa paréntesis encerrando a la expresión a evaluarse.

Problema 1. Diseñar un programa que permita leer un número n entero positivo y mayor que 9. Si la lectura es correcta entonces se debe obtener el último dígito. Si la lectura es incorrecta el programa no realiza ninguna tarea.

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

Solución

#include <iostream.h> #include <conio.h> #include <stdlib.h> void main() {int n, ult_dig,dato;

clrscr();gotoxy(10,2);

cout<<”Sr. ingrese número :”;cin>>n; dato=n;

if(n>9)

// if_resto.cpp

:”;cin>>n; dato=n; if(n>9) // if_resto.cpp { ult_dig=dato%10; gotoxy(10,5);cout<<”Último

{ ult_dig=dato%10;

gotoxy(10,5);cout<<”Último dígito de “<< n<<” es = “<<ult_dig;

}

getche();

}

Problema 2. Diseñar un programa que permita leer un número n entero positivo y mayor que 99. Si le lectura es correcta, entonces obtener sus dos últimos dígitos. Si la lectura es incorrecta el programa no realiza ninguna tarea.

Solución void main() {int n, dos_dig,dato; clrscr();

gotoxy(10,2);

cout<<”Sr. ingrese número :”;cin>>n; dato=n; if(n>99) {dos_dig=dato%100; gotoxy(10,5);cout<<” Dos Últimos dígitos de “<< n<<” es = “<<dos_dig;

de “<< n<<” es = “<<dos_dig; if(dos_dig%2==0) { gotoxy(10,7);cout<<” Y además,

if(dos_dig%2==0)

{ gotoxy(10,7);cout<<” Y además, “<< dos_dig<<” es un número PAR “; }} getche();}

Comentario. Los resultados de los problemas 1, 2 y 3 se obtiene toda vez que la condición lógica es verdadera. Si usted ingresa números que no satisfacen la condición, el programa no envía ningún resultado.

es verdadera. Si usted ingresa números que no satisfacen la condición, el programa no envía ningún

Teodoro Luciano Córdova Neri

2.2.2 estructura selectiva compuesta: sentencia if - else

Es aquella que realiza dos acciones distintas, ambas mutuamente excluyentes, de acuerdo al valor lógico de una expresión, es decir, se ejecuta solo una instrucción.

Sintaxis

Cuando las instrucciones a ejecutarse son simples

if (<Condición>)

instrucción_1;

else

instrucción_2;

Si en cada instrucción existe solo una, no se usa {

Problema 1. Diseñar un programa que permita leer datos de usuario por: código = 10 y clave = 12, luego, si los datos son correctos, el programa solicita que ingrese un número entero positivo, inmediatamente el programa debe enviar un reporte si el número ingresado es par, en otro caso es impar. Si los datos del usuario son incorrectos, el programa envia el mensaje “Datos incorrectos ” y finaliza.

Solución: // Sielse.cpp #include <iostream.h>

void main()

cout<<”ingrese código :”; cin>>cod; cout<<”ingrese clave :”; cin>>clave; if((cod==10) && (clave==12))

}, en otro casi si.

{int cod, clave,p;

clrscr();

}, en otro casi si. {int cod, clave,p; clrscr(); { cout<<”Ingrese práctica:”; cin>>p;

{ cout<<”Ingrese práctica:”; cin>>p;

if(p%2==0);

cout<<p<<”es número

}

Par”; else cout<<p<<” es número impar”; else

cout<<” Datos incorrectos “;getche();

}

También se puede usar la expresión condicional abreviada equivalente:

(expresión) instrucción1: instrucción2;

Cuando las instrucciones a ejecutarse son compuestas if (expresión) {instruccion_1; instruccion_2; ……………………… instruccion_n;

}

else {instruccion_1; instruccion_2; ………………………… instruccion_n; }

}

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

Si < expresión > es verdadera, se ejecuta el bloque <instrucciones >, en otro caso se ejecuta las <instrucciones> del bloque else.

Problema 1. Diseñar un programa que permita leer un número y luego averiguar si es capicúa.

Solución // if_capicua.cpp #include<iostream.h> void main() {int num,c,r1,d,u,inv; clrscr();

gotoxy(10,4);

cout<<” Ingrese Número: “;cin>>num; c=num/100; // obtiene primer dígito

r1=num%100; //obtiene dos últimos dígitos

d=r1/10;u=r1%10;

{ clrscr();

//obtiene dos últimos dígitos d=r1/10;u=r1%10; { clrscr(); inv=u*100+d*10+u; if (num==inv)

inv=u*100+d*10+u;

if (num==inv)

gotoxy(10,4);cout<<” El número”<<num << “ Es capicúa”; gotoxy(10,5);cout<<” su primer dígito es=”<<c;

}

else

}

{ clrscr(); gotoxy(10,4);cout<<”El número”<<num <<” No capicúa”; gotoxy(10,5);cout<<”Sus últimos dos dígitos es=”<<r1;

getch();

}

2.2.3. estructura condicional con anidamiento

……………………………. if ( < condicion 1 >)

<instruccion_1;>

else if (< condicion 2 >) < instruccion_1;> …………… else if (< condicion n >) <instruccion_n;> else<instruccion_x;>

Aquí el programa realiza una sola <instruccion_x> para un <valor_x > de una expresión (numérica o lógica). Si el valor que toma la expresión no figura entre los especificados, se ejecutará el bloque de instrucciones_else.(sino

Teodoro Luciano Córdova Neri

Observación. Si el bloque de <instrucciones_x> está formado por varias instrucciones estas deberán agruparse con llaves { }.

Problema 1. Diseñar un programa que permita leer tres números enteros a, b y c

(a, b, c ≠ 0) y que verifique si se cumplen algunas de las siguientes relaciones: a =

b + c; b = a + c; c = a + b; a = b = c

Solución //:

#include <iostream.h> void main()

{ int a,b,c;

gotoxy(10,1);cout<<” VERIFICANDO SUMA DE NÚMEROS”; gotoxy(10,2);cout<<” Ingrese a = “; cin>>a;

clrscr();

gotoxy(10,3);cout<<” Ingrese b = “; cin>>b; gotoxy(10,4);cout<<” Ingrese c = “; cin>>c;

if

(a==b+c)

 

{

gotoxy(10,6); cout<<” Se cumple que “<<a<<” = “<< b<<” + “<< c;

}

else

 

if (b==a+c)

{ gotoxy(10,6);cout<<” Se cumple que “<<b<<” = “<< a<<” + “<< c;

}

= “<< a<<” + “<< c; } } else if (c==a+b) {gotoxy(10,6); cout<<” Se

}

else

if (c==a+b) {gotoxy(10,6); cout<<” Se cumple

que “<<c<<” = “<< a<<” + “<< b

}

else if((a==b)&&(b==c))

{ gotoxy(10,6); cout<<” Se cumple que “<<a<<”=”<<b<<”=”<< c else { gotoxy(10,7);cout<<” No se cumple ninguna relación “; } getche();

}

Problema 2. Diseñar un programa que permita ingresar datos de un usuario por apellidos = “CORDOVA” y clave = “TCN ”, si los datos son correctos el sistema envía un mensaje de saludos y solicita que ingrese tres números enteros y luego devuelve el mayor de ellos. Si el usuario ingreso sus datos con error, el sistema envía el mensaje indicando el error respectivo.

Solución //if_mayor_tres_num.cpp # define linea “----------------------------------------”; void main()

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

{ char apell[10],clave[10],e=0; int a,b,c,mayor, tresd; gotoxy(10,2); cout<<” Ingrese Apellido = “;gets(apell); gotoxy(10,3); cout<<” Ingrese Clave = “;gets(clave); gotoxy(10,4); cout<<linea;

if ((strcmp(strupr(apell),”CORDOVA”)==0) && (strcmp(strupr(clave),”T

CN”)==0))

{ gotoxy(10,6);cout<<” Saludos, Sr

gotoxy(10,7);cout<<” Ingrese 3 números “; gotoxy(10,8);cout<<” a= “;cin>>a; gotoxy(10,9);cout<<” b= “;cin>>b ; gotoxy(10,10);cout<<” c= “;cin>>c;

”<<

apell<< “ y Bienvenido “;

if ((a>b)&&(a>c))

{mayor=a;

gotoxy(10,13);cout<<»El mayor número es = «<<mayor;

}

else

if((b>a)&&(b>c))

{mayor=b;

gotoxy(10,13);

cout<<”El mayor número es = “<<mayor;

}

else if((c>a)&&(c>b)) {mayor=c;

gotoxy(10,13);cout<<”El

mayor

número es = “<<mayor;

}

else

{

gotoxy(10,13);cout<<”

números son iguales

”;

Los

números son iguales ”; Los } else { gotoxy(10,5); cout<<” Sr. sus datos son

} else { gotoxy(10,5); cout<<” Sr. sus datos son incorrectos “; }getche();

}

}

2.3 estructuras múltIPles

Es aquella en la cual el usuario puede realizar una determinada acción para cada tipo de valor que pueda tomar una expresión. Cada acción a realizarse excluye a las demás, de modo que solamente una de ellas es ejecutada.

switch (expresión) {

case

valor1:

<instrucciones_1>;

break;

Teodoro Luciano Córdova Neri

case valor2:

<instrucciones_2>;

break; …….……….……… case valor_n:

<instrucciones_n>; break; default: < instrucciones_X>; break; } //fin de switch()

: < instrucciones_X>; break ; } //fin de switch() Observaciones 1. La etiqueta default indica al

Observaciones

1. La etiqueta default indica al programa lo mismo que el else en la secuencia de if anidado, es decir; se ejecuta cuando el usuario edita un valor que no está en la lista de valores.

2. La sentencia break permite que el programa abandone la estructura switch omitiendo los demás casos.

3. La variable “selector ” no puede ser tipo: real, cadena de dígitos, cadenas.

4. Cuando se quiere realizar una misma acción para distintos valores de la expresión evaluada, se coloca una sentencia case por cada valor, sin ninguna acción y la acción común se pone al final del último valor. Por ejemplo, el segmento de código:

del último valor. Por ejemplo, el segmento de código: switch (a) { case 1: case 2:

switch (a) { case 1:case 2:case 3: cout<<”Acción para 1, 2 y 3”; break; case 4: cout<<”Acción para 4”; break; default: cout<<”Acción para cualquier otro valor”; break;

}

Problema 1. Diseñar un programa que permita disponer de tres alternativas:

- Alternativa 1: permite leer la base y el exponente para calcular la potencia de un número.

- Alternativa 2: permite leer un número n positivo y luego calcula la raíz cuadrada.

- Alternativa 3: permite ingresar un número de tres dígitos y luego este número mostrarlo en forma invertida sin usar estructuras de control repetitivas.

- Alternativa 4: permite salir del modo compilación al programa fuente.

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

Asimismo, el programa debe enviar el mensaje “Fuera de rango”, cuando el usuario digita un número que no está dentro de la lista disponible.

Solución // case1.cpp #include<iostream.h> # define linea “-----------------------------------------------” void main(){int n,raiz,pot,poten,base; int parte_entera2,parte_entera1,ult_dig,pult_dig; gotoxy(15,3);cout<<” Bienvenidos al Menú”;

gotoxy(8,4);cout<<linea;

gotoxy(15,5);cout<<” [P] Potencia”; gotoxy(15,6);cout<<” [R] Raiz cuadrada”; gotoxy(15,7); cout<<” [I] Invertir Número”; gotoxy(15,8);cout<<” [S] Salir”;

gotoxy(8,10);cout<<linea;

gotoxy(15,11);cout<<” Ingrese opción: “;cin>>opc; switch(opc) { case ‘P’:case ‘p’: clrscr();

char opc;

clrscr();

gotoxy(4,2);cout<<linea;

gotoxy(15,4);cout<<” Ingrese la base :”; cin>>base; gotoxy(15,5);cout<<” Ingrese la potencia:”; cin>>pot; poten=pow(base,pot);

gotoxy(15,7);

cout<<” El número “<< base<<” elevado a “ <<pot <<” es

gotoxy(4,10);cout<<linea;

break; case’R’:case ‘r’: clrscr();

=”<<poten;

gotoxy(4,2);cout<<linea;

gotoxy(15,4);cout<<” Ingrese un número :”; cin>>n;

raiz=sqrt(n); gotoxy(15,5);cout<<” La raíz cuadrada de “<< n<<” es =”<<raiz; gotoxy(4,10);cout<<linea; getche(); break; case’I’:case ‘i’: clrscr(); gotoxy(10,2);cout<<”NÚMERO INVERTIDO “;

gotoxy(4,3);cout<<linea;

gotoxy(15,4);cout<<” Ingrese un número = “; cin>>n; if((n>99)&& (n<1000))

{ult_dig=n%10;

parte_entera1=n/10;

pult_dig=parte_entera1%10; parte_entera2=parte_entera1/10;

gotoxy(15,6);

cout<<”

Número

Invertido

=

“<<ult_dig<<pult_dig<<parte_

entera2;

gotoxy(4,8);

Teodoro Luciano Córdova Neri

else

}

cout<<linea;

getche();

{ gotoxy(15,6);

}

break;

cout<<” El número no satisface condición “;

case’S’:case ‘s’:

clrscr();

gotoxy(2,8);cout<<linea;

gotoxy(10,12);cout<<” Ud saldrá del Sistema, hasta luego

getche();

default: gotoxy(10,12);cout<<” Ud NO seleccionó su opción correcta

“;

gotoxy(2,14);cout<<linea;

exit(1);

}

getche();

}

“;

exit(1); } getche(); } “; Problema 2. Diseñar un programa que permita validar datos

Problema 2. Diseñar un programa que permita validar datos de usuario por apellido = “CORDOVA” y clave = “8481100D”, si los datos son correctos el sistema presenta un menú de opciones para:

< O > Ordenadores < I >Impresoras < L > Lectoras y < S > Salir. Si edita O, el sistema presenta un submenú mostrando los tipos de marcas por cada ordenador:

< I >

Ibm,

<C> Compac y

<O> Olivetti.

Por cada opción que usted ingrese, el número de ordenadores a comprar y luego el precio por unidad y calcula el monto a pagar. Análogamente sucede para las demás opciones: para impresoras y lectoras. Si usted ingreso sus datos de validación incorrectos, el sistema envía el mensaje:

“Sr. usuario, sus Datos son incorrectos, hasta pronto”;

Solución // programa case.cpp #include <stdlib.h>

# define linea “----------------------------------------------------” void main() { int nibm,pibm,monto,montoc,ncomp,pcomp,noliv,poliv,montooliv;

int montolasser,nimpl,pimpl, int

int montolcre,nlcre,plcre,

montomat,nimpm,pimpm;

int montolhp,nlhp,plhp;

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

char apell[10],clave[10], char opc,imp;

gotoxy(25,8);cout<<”MÓDULO DE VALIDACIÓN”;

gotoxy(14,9);cout<<linea;

gotoxy(20,12);cout<<” Ingrese apellido :”,gets(apell);

clrscr();

gotoxy(20,13);cout<<” Ingrese clave

:” ,gets(clave);

if (strcmp(apell,”cordova”)==0&& strcmp(clave,”tcn”)==0) {clrscr(); gotoxy(15,12);cout<<” Bienvenidos al sistema de Ventas”;

gotoxy(4,2);cout<<linea;

gotoxy(15,5);cout<<” [O] Ordenadores”; gotoxy(15,6);cout<<” [I] Impresoras”; gotoxy(15,7);cout<<” [L] Lectoras”; gotoxy(15,8);cout<<” [S] Salir”;

gotoxy(4,10);cout<<linea;

gotoxy(16,14);cout<<” Ingrese opción :”; cin>>opc; switch(opc) { case ‘o’:case ‘O’: clrscr();gotoxy(4,2);cout<<linea; gotoxy(15,4);cout<<” <I> IBM :”;

gotoxy(15,5);cout<<” <C> Compact”; gotoxy(15,6);cout<<” <O> Olivetti”;

gotoxy(4,10);cout<<linea;

gotoxy(15,7);cout<<” Edite opción”;cin>>imp; switch(imp)

{ case ‘i’:case ‘I’:

{ clrscr();

cout<<”\nOrdenadores marca IBM”; cout<<”\ningrese número de ordenadores a comprar:”;cin>>nibm;

cout<<”\ningrese precio por unidad:”; cin>>pibm; monto=nibm*pibm;

}

break;

cout<<” \nUd. debe pagar :”<<monto;

getche();

}

{clrscr(); cout<<”\nOrdenadores marca Compac”;

cout<<”\ningrese número de ordenadores a comprar:”;cin>>ncomp; cout<<”\ningrese precio por unidad:”; cin>>pcomp;

montoc=ncomp*pcomp; cout<<” \nUd. debe pagar :”<<montoc;

case ‘c’:case ‘C’:

getche();

break; case ‘o’:case ‘O’:

{clrscr();

cout<<”\nOrdenadores marca OLIVETTI”; cout<<”\ningrese número de ordenadores a comprar:”;cin>>noliv; cout<<”\ningrese precio por unidad:”; cin>>poliv;

montooliv=noliv*poliv;

cout<<” \nUd. debe pagar :”<<montooliv;

}

getche();

break;

Teodoro Luciano Córdova Neri

default:cout<<”No existe Marca de tal Ordenador, hasta luego”; getche();

exit(1);

// fin de alternativas de ordenadores :O : Ordenadores

}

break; case ‘i’:case ‘I’:// Opción de case principal :I : Impresoras clrscr(); gotoxy(15,2); cout<<”Impresoras”; gotoxy(15,4);cout<<”<L> Lasse :”; gotoxy(15,5);cout<<”<M> Matricial”; gotoxy(15,6);cout<<” Edite opción”;cin>>imp; switch(imp) { case ‘l’:case ‘L’:

clrscr();

cout<<”\ningrese número de impresoras Lasser:”;cin>>nimpl; cout<<”\ningrese precio por unidad:”; cin>>pimpl; montolasser=nimpl*pimpl;

cout<<” \nUd. debe pagar :”<<montolasser;

getche();

break; case ‘m’:case ‘M’:

clrscr();

cout<<”\ningrese número de impresoras Matricial:”;cin>>nimpm; cout<<”\ningrese precio por unidad:”; cin>>pimpm; montomat=nimpm*pimpm;

cout<<” \nUd. debe pagar :”<<montomat;

getche();

break; default:cout<<”No existe Impresoras”;

getche();

exit(1);

}// fin de alternativas de Impresoras :I: Impresoras

break;

case ‘l’:case ‘L’:// Opción de case principal :L : Lectoras clrscr(); gotoxy(15,2); cout<<”Lectoras”; gotoxy(15,4);cout<<”<C> Creative :”; gotoxy(15,5);cout<<”<H> HP”; gotoxy(15,6);cout<<” Edite opción”;cin>>imp; switch(imp)

{ case ‘c’:case ‘C’:

clrscr();

cout<<”\ningrese número de Lectoras Creative: “;cin>>nlcre; cout<<”\ningrese precio por unidad:”; cin>>plcre; montolcre=nlcre*plcre;

cout<<” \nUd. debe pagar :”<<montolcre;

case ‘h’:case ‘H’:

clrscr();

getche();

break;

cout<<” \ningrese número de Lectoras HP: “;cin>>nlhp; cout<<” \ningrese precio por unidad:”; cin>>plhp; montolhp=nlhp*plhp;

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

estructurada y sus aplicaciones en Borland C++ 5.0.2 getche(); cout<<” \nUd. debe pagar

getche();

cout<<” \nUd. debe pagar :”<<montolhp; getche(); break; default: cout<<”No existe Marca de lectoras”; getche(); exit(1); } break; case ‘s’:case ‘S’: cout<<” Salida del sistema, presione ENTER”; getche(); exit(1); default:clrscr();gotoxy (20,8);cout<<” No existe Marca de Producto”; } //fin switc(opc)} // alternativa de if else cout<<” Sr. usuario, sus Datos son incorrectos, hasta pronto”;

Si los datos son ingresados correctamente, se muestra las alternativas:

son ingresados correctamente, se muestra las alternativas: Usteddisponedelasalternativas,cadauna dispone de otras
son ingresados correctamente, se muestra las alternativas: Usteddisponedelasalternativas,cadauna dispone de otras

Usteddisponedelasalternativas,cadauna dispone de otras alternativas (submenús), por ejemplo si edita “O”, entonces se obtiene el submenú correspondiente a los tipos de ordenadores:

Ahora, si usted edita la opción C, de Compac, el programa le solicita que ingrese número de ordenadores y precio por unidad, luego calcula el monto a pagar. Así puede continuar con las demás opciones correspondientes a impresoras y lectoras.

Problema 4. Diseñar un programa que permita leer la letra inicial del mes (enero, febrero, marzo o abril) y luego se visualice el mensaje indicando el mes respectivo:

febrero, marzo o abril) y luego se visualice el mensaje indicando el mes respectivo: “Mes de

“Mes de

Observación

Teodoro Luciano Córdova Neri

En el siguiente programa se ilustra que usando la estructura múltiple o la estructura if con anidamiento se puede obtener el mismo resultado

Solución

a) Mediante Case ( )

//case_if_anidados.cpp

void main() {

gotoxy(24,1),cout<<»Meses del Año»;

char mes;

clrscr();

gotoxy(23,2),cout<<»==============»;

gotoxy(5,3),cout<<»Ingrese letra inicial del mes:»;cin>>mes; switch(mes)

{ case ‘E’:case ‘e’: gotoxy(20,5),cout<<” Mes de Enero”;break;

case ‘F’:case ‘f’: gotoxy(20,5),cout<<” Mes de Febrero”;break; case ‘M’:case ‘m’: gotoxy(20,5),cout<<” Mes de Marzo”;break; case ‘A’:case ‘a’: gotoxy(20,5),cout<<” Mes de Abril”;break;

default: gotoxy(20,5),cout<<” Letra fuera de rango

} getche();

}

!”;

b) Mediante If

#include<iostream.h> #include<conio.h> void main() {char mes[10]; clrscr(); gotoxy(20,1),cout<<» Meses del Año»;

gotoxy(21,2),co

ut<<”================”; gotoxy(20,4),cout<<”Ingrese letra inical del mes:”;gets(mes);

if(strcmp(mes,”E”)==0||strcmp(mes

,”e”)==0)

{ gotoxy(20,6);cout<<” Mes de Enero”;

}

else

{ gotoxy(20,6);cout<<” Mes de Enero”; } else if(strcmp(mes,”F”)==0||strcmp(mes, ”f”)==0)

if(strcmp(mes,”F”)==0||strcmp(mes,

”f”)==0)

{gotoxy(20,6);cout<<” Mes de Febrero”;

}

else

if(strcmp(mes,”M”)==0||strcmp(mes,”m”)==0)

{ gotoxy(20,6);cout<<” Mes de Marzo”

}

else

if(strcmp(mes,»A»)==0||strcmp(mes,»a»)==0)

{gotoxy(20,6);cout<<” Mes de Abril”;

}

else

{gotoxy(20,5);

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

cout<<” El valor ingresado esta disponible

}

getche()

}

!”;

2.4 estructuras rePetItIvas

Permiten realizar instrucciones más de una vez, formando bucles. A cada repetición se le llama también iteración, por lo cual las estructuras repetitivas se denominan también iterativas. Para las estructuras repetitivas se suelen utilizar dos tipos de variables especiales:

Contadores: los cuales incrementan o disminuyen su valor en una cantidad constante. Deben inicializarse en un valor constante.

Sintaxis

cont = cont + 1

inicialice : cont =1

Acumuladores: los cuales acumulan o disminuyen su valor en una cantidad variable. También deben inicializarse.

Sintaxis suma = suma + cont

Cabe destacar que todas las estructuras repetitivas se pueden anidar.

inicialice: suma=0

tipos de estructuras repetitivas:

2.4.1 estructura repetitiva con pretest de prueba: while {<instrs > }

Llamado también bucle con entrada controlada, es aquel que repite un grupo de acciones mientras que el resultado de la condición lógica sea verdadera (o distinta de cero). En otros términos, si el resultado de evaluar la condición es verdadera se ejecuta por lo menos UNA instrucción o más. En otro caso NO se ejecuta ninguna instrucción.

Sintaxis:

En otro caso NO se ejecuta ninguna instrucción. Sintaxis: while (< condición >) } { <instrucciones>;

while (< condición >)

}

{

<instrucciones>;

Hay que tener especial cuidado para conseguir, en algún momento, una forma de que la <condición> a evaluar sea falsa. Es muy fácil escribir bucles que se repiten indefinidamente hasta agotar la memoria y hacer colapsar al

sistema.

Problema 1. Escribir un programa

Teodoro Luciano Córdova Neri

que lea una cadena y determine en ella la frecuencia de aparición de cada vocal.

Solución // while_vocal.cpp #include <iostream.h> #define linea “ void main() { int na=0,ne=0,ni=0,no=0,nu=0;

char c=’\0’;

gotoxy(10,2);cout<<”Ingrese texto :”<<endl ; while (c!=’\n’) { c=toupper(getchar()); switch (c) { case ‘A’: na++; break; case ‘E’: ne++; break; case ‘I’: ni++; break; case ‘O’: no++; break; case ‘U’: nu++; break; } // fin de while } gotoxy(10,5);cout<< “ ===>

RESULTADOS <=== “; gotoxy(8,7);cout<<”Cáracter # de repeticiones “;

# de repeticiones “; ” gotoxy(5,8);cout<<linea;

gotoxy(5,8);cout<<linea;

gotoxy(10,9);cout<<” a\t\t”<<na<< “ veces”; gotoxy(10,10);cout<<” e\t\t”<<ne<<” veces”;

gotoxy(10,11);cout<<” i\t\t”<<ni<<” veces”; gotoxy(10,12);cout<<” o\t\t”<<no<<” veces”; gotoxy(10,13);cout<<” u\t\t”<<nu<<” veces”; gotoxy(5,14);cout<<linea; getch();

}

Problema 2. Escribir un programa que permita leer un número compuesto por más de un dígito y luego mostrar:

Total de dígitos, total de dígitos pares e impares, número invertido, total de suma de dígitos pares e impares respectivamente. El programa debe ser interactivo, es decir; después de cada ejecución, el sistema envía el mensaje “Desea continuar ? (S / N)”. Si edita S continúa ejecutando el programa, en otro caso finaliza.

Solución

#include <iostream.h> void main() { int r,d,n,inv=0,par=0,impar=0, nd,sump=0,sumimpar=0; char resp=’s’; while(resp==’s’)

// while_digitos.cpp

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

{ gotoxy(8,3);cout<<”Ingrese un número con mas de 1 dígito : “; cin>>n;

r = n;

nd=0;// inicializó contador de dígitos

while(n>0) // descompongo el número n ingresado { d=n%10; nd=nd+1;

If (d%2==0)

{ par++;

sump+=d;

}

else { impar++; sumimpar+=d; }

inv=inv*10+d;

n=n/10;

}

gotoxy(8,5); cout<<” El número “<<r<<” tiene :”; gotoxy(12,7); cout<<” “<< nd<< “ dígitos “; gotoxy(12,8); cout<<” Invertido es = “<<inv; gotoxy(12,9); cout<<” Tiene “<<par<<” dígitos pares”; gotoxy(12,10); cout<<” La suma de los números pares es = “<<sump; gotoxy(12,11); cout<<” Tiene “<<impar<<” dígitos impares”;

gotoxy(12,12); cout<<” La suma de los números impares es = “<<sumimpar;

gotoxy(20,16); cout<<”Desea continuar getche(); }

(s/n)”;cin>>resp;

}

continuar getche(); } (s/n)”;cin>>resp; } Problema 3. Diseñar un programa que permita leer dos

Problema 3. Diseñar un programa que permita leer dos números comprendidos entre 10 y 99. Luego mostrar el producto respectivo. Si el usuario edita números que no están en el rango especificado, el sistema envía el mensaje: “Sr. sus números

deben estar en el rango <10

? (s /

Asimismo, el programa debe ser interactivo, es

decir; después del error, el sistema envía el mensaje “Desea continuar…… n)”.

Solución // while_producto.cpp #include <iostream.h> void main() { int n,d,p,i=0,a,b;

99>”.

char resp;

resp=’s’;

clrscr();

Teodoro Luciano Córdova Neri

while(resp==’s’){ gotoxy(10,3);cout<<” MULTIPLICACIÓN DE NÚMEROS “; gotoxy(14,6);cout<<”Ingrese multiplicando : “;cin>>a; gotoxy(14,7);cout<<”Ingrese multiplicador :”; cin>>b; if((a>9) &&(a<99)&& (b>9)&&(b<99)) { n=b; while(n>0) //para mensajes de productos parciales

{ d=n%10;

p=d*a;

i++;

cout<<”\nEl “<<i<< “° producto parcial es :”<<p<<endl;

n=n/10;

}

p=a*b;

gotoxy(14,13);cout<<” El producto de “<<a<< “ * “<<b<<” es = “<<p; else {clrscr();

getche();

gotoxy(20,12);

cout<<”Sr. sus números deben estar en el rango <10

gotoxy(20,10);cout<<”Desea continuar

}

99>”;getche(); } clrscr();

?(s/n)”;cin>>resp; clrscr(); } getche();

}

Si el usuario ingresó los dígitos en el rango solicitado, el sistema calcula el producto, tal como se mustra en la siguiente gráfica:

Problema 4. Diseñar un programa que permita validar datos del usuario usando solo un carácter para código y uno para clave (codigo =’a’, clave=’b’).

código y uno para clave (codigo =’a’, clave=’b’). Si los datos son correctos, el sistema solicita

Si los datos son correctos, el sistema solicita que ingrese dos elementos de la

serie 1+2+3+4+

elemento y lado derecho (ladd) indicando segundo elemento; es decir; definimos un rango de elementos a sumar. Luego, generar reportes que permita saber la

Los elementos son lado izquierdo (ladi): indicando primer

+n.

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

suma acumulada y el total de dígitos que tiene este resultado. Si los datos son incorrectos, el sistema envía el mensaje de error.

//while_if.cpp

#include<iostream.h> void main() {int acum=0,ladi,ladd,li;

Solución

char codigo, clave;

gotoxy(12,6);cout<<” Ingrese código : “;cin>>codigo; gotoxy(12,7); cout<<” Ingrese clave : “;cin>>clave;

if((codigo==’a’)&& (clave==’b’))

{clrscr();

gotoxy(12,6); cout<<”Ingrese lado izquierdo :” ;cin>>ladi; gotoxy(12,7); cout<<”Ingrese lado derecho :” ;cin>>ladd; clrscr(); li=ladi; while (ladi<=ladd) { acum+=lad ladi++;

}

gotoxy(6,6);cout<<” La suma desde “<<li<< “ hasta “<<ladd<<” es= “<<acum;

if ((acum>=0)&&(acum<10))

{ gotoxy(6,7);cout<<” La

suma tiene 1 dígito “;

}

else { if ((acum>9)&&(acum<

}

dígito “; } else { if ((acum>9)&&(acum< } 100)) { gotoxy(6,8);cout<<” La suma tiene 2

100))

{ gotoxy(6,8);cout<<” La suma

tiene 2 dígitos”; else { if ((acum>99)&&(acum< 999))

{ gotoxy(6,9);cout<<” La suma tiene 3 dígitos”;

{ gotoxy(6,9);cout<<” La suma tiene 3 dígitos”; } } // fin del if else {clrscr(); }

} } // fin del if

else

{clrscr();

}

}

gotoxy(12,12); cout<<” Sus datos no se registraron, hasta luego :”;

}

getche();

}

Problema 5. Diseñar un programa que permita leer un número n entero positivo, luego calcular su factorial e imprir su resultado.

Solución // while_fact.cpp #include<iostream.h> #include<conio.h> void main()

{ double fact=1.0,n,minumero;

gotoxy(8,4);

cout<<”Ingrese un número : “; cin>>n; minumero=n; while (minumero >0)

{

fact=fact* minumero; minumero--;

}

gotoxy(15,6);cout<<”El factorial

getche();

de “<<n <<” es =”<<fact;

}

Teodoro Luciano Córdova Neri

es =”<<fact; } Teodoro Luciano Córdova Neri Problema 6. Diseñar un programa que permita mostrar la

Problema 6. Diseñar un programa que permita mostrar la tabla de multiplicar de n filas y m columnas, donde el usuario ingresar número de filas y columnas.

Solución //while_mult.cpp #include <iostream.h> void main() { int n,m,i=1,j=1;

gotoxy(12,3);cout<<”TABLA DE MULTIPLICAR”;

gotoxy(4,5);

cout<<”ingrese número de fila

gotoxy(4,6);

:”;cin>>n;

cout<<”ingrese número de columna”;

while(i<=n )

{ cout<<”Para fila :”<<i<<endl; while ( j <= m ) {cout<<”\ti= “<<i<<” y “<<”j=”<<j<<” se tiene “<<i<<”*”<<j<<”=”<<i*j<<endl; j++; } cout<<”\n”;

cin>>m;

i++;

j = 1;

}

system(“pause”);

}

Problema 7. Diseñar un programa que permita calcular la suma acumulada de la

SERIE = 1+x+x*x/2 ! +

+ x^n / n !

Para lo cual se debe ingresar el valor de x y el número de términos a sumar.

Solución //while_sum_fact.cpp #include<iostream.h> void main() { int x,n,i=1;

gotoxy(8,2);cout<<”SUMA DE SERIE = 1+X+X*X/2!+

float r=0.0;

clrscr();

+X^n/n!” ;

gotoxy(8,4);cout<<”Ingrese el valor de

gotoxy(8,5);cout<<”Ingrese el valor de n

x : “;cin>>x; : “;cin>>n;

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

while(i<=n)

{ float fact=1,g=1;int j=1; while(j<=i)

{ g=x*g;

fact=fact*j;

j++;

}

r=r+g/fact;

i++;

}

gotoxy(8,7);

cout<<”La

=

system(“pause”);}

es

“;cout<<(r+1)<<endl<<endl;

suma

Acumulada

suma Acumulada Problema 8. Diseñar un programa que permita leer n

Problema 8. Diseñar un programa que permita leer n números enteros y para finalizar la lectura, edite 0 (cero). Asimismo, el programa debe permitir :

a. La suma de números pares positivos.

b. La suma de números impares positivos.

c. Los resultados de a) y b), mostrarlos en forma concatenada.

d. Al resultado de c) y de derecha a izquierda, es decir; si el dígito es par y la posición que ocupa y si es impar y la posición que ocupa, respectivamente.

e. Según los datos ingresados, genere reportes del: total de dígitos pares e impares positivos, dígitos negativos pares e impares, al mayor dígito par y el mayor dígito impar negativo.

Solución //while_if_uni.cpp #include <iostream.h>

void main (){int

int min=0,ud,o,num,s=0,y,x,p1=0; gotoxy(40,2);cout<<”Edite 0(cero) para finalizar:”;

i=0,n,pp=0,spp=0,mpp=0,ip=0,in=0,sin=0,sip=0;

gotoxy(10,2);cout<<”Ingrese número : “;cin>>num;

while(num!=0)

 

{

if (num!=0)

 

{

if(num>0)

 

{

if (num%2==0)

 

{ pp++;

spp+=num;

}

 

if(num>mpp)

 
 

{mpp=num;

}

}

Else

{ip++; sip+=num;

}

}

else if (num %2!=0)

{in++;

sin+=num;

 

}

 

if (num>>min)

{ min=num;

}

}

i++;

}

Teodoro Luciano Córdova Neri

gotoxy(10,4+i+1); cout<<”ingrese número:”;cin>>num;

}

cout<<” \nSuma de pares positivos :”<<spp<<endl; cout<<” \nSuma de impares positivos:”<<sip<<endl;getche();

y=sip;

while(y>0)

{y=y/10;p1++;

}

x=(spp*pow(10,p1))+ sip; o= x;

while (o>0)

{ o=o/10;

s++;

}

o=x;

cout<<”\n el resultado concatenado es “<<o<<endl;getche();

while (o>0)

{ ud= o%10;

if (ud%2==0) {cout<<”\n “<<ud<<” es par, su posición es “<<s<<endl; s--; } else

{ cout<<”\n “<<ud<<” es impar,su posición es “<<s<<endl; s--;

}

o=o/10;

}

getche(); gotoxy(35,18);cout<<”el total de pares positivos es

:”<<pp;

gotoxy(35,19);cout<<”el total de impares positivos es

:”<<ip;

gotoxy(35,20);cout<<”el total de impares negativos es

:”<<in;

gotoxy(35,21);cout<<”el mayor de los pares positivos es

:”<<mpp;

gotoxy(35,22);cout<<”el mayor de los impares negativos es :” <<min; getche();

}

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

estructurada y sus aplicaciones en Borland C++ 5.0.2 2.4.2 estructura repetitiva con postest de prueba:

2.4.2 estructura repetitiva con postest de prueba:

(<cond>)

Llamado bucle con salida controlada, ejecuta <instrucciones> lo mismo que la estructura while, con la diferencia que primero ejecuta una <instrucción> y luego verifica la <condición>, a partir de esta ejecución, se comporta como la estructura while. Por este motivo la estructura se ejecuta por lo menos una vez.

Sintaxis do {<instrucciones> } while (expresión) ; Este tipo de secuencias es muy utili- zada en procesos de validación de datos (cuando se quiere que el usua- rio del programa introduzca siempre datos correctos). Es decir, se repite un proceso de lectura hasta que la ex- presión (que indica su invalidez) sea falsa.

do { <insts>} while

indica su invalidez) sea falsa. do { <insts>} while Problema 1. Diseñar un programa que permita

Problema 1. Diseñar un programa que permita calcular la suma acumulada de la serie: 1+2+3+4+….+n. El usuario ingresa el número de términos a sumar, validando que el número de términos no sea negativo.

Solución //do_sum.cpp # include <iostream.h> # define linea “---------------------------------------” void main() { int cont=1,suma=0,n,dato; gotoxy(8,2); cout<<” SUMANDO TÉRMINOS DE SERIE “; gotoxy(6,3); cout<<linea;

Obs. La condición de prueba puede ser también

do {

}while(!(cont>n));

Teodoro Luciano Córdova Neri

gotoxy(10,4); cout<<” 1 + 2 + 3 + n”; gotoxy(6,5); cout<<linea;

do{gotoxy(10,6);

clreol();cout<<”Ingrese número de términos = “; cin>>n;

+

número de términos = “; cin>>n; + }while(n<1); gotoxy(10,8); cout<<” Ud sumará

}while(n<1);

gotoxy(10,8);

cout<<” Ud sumará “<< n <<” terminos de la serie”; dato=cont; do { suma+=cont; cont++; } while (cont<=n);

gotoxy(10,10);

cout<<”La suma desde “<< dato <<” hasta “<< n<<” es = “<<suma; getche();

}

Problema 2. Diseñar un programa que permita calcular la suma acumulada de la serie:

1 1 +2 2 +3 3 +4 4 +….+n n

El usuario ingresa el número de

términos a sumar. Después del resultado el sistema envía el mensaje

“Desea continuar

Solución// do_suma_rep.cpp #include<iostream.h> # define linea “----------------------------- ----------”

voidmain(){intcont=1,suma=0,n,dato;

?

----------” voidmain(){intcont=1,suma=0,n,dato; ? (s/n) ”. char resp; clrscr(); do //módulo para repetir el

(s/n) ”.

char resp; clrscr(); do //módulo para repetir el programa {clrscr();

gotoxy(8,2); cout<<” SUMANDO TÉRMINOS DE SERIE “; gotoxy(6,3); cout<<linea;

gotoxy(12,4);

cout<<”1 2 3 n”;

gotoxy(10,5); cout<<” 1 + 2 + 3 +

gotoxy(6,6); cout<<linea; do{ gotoxy(10,8); clreol();cout<<”Ingrese número de términos = “; cin>>n;

}while(n<1);

gotoxy(10,10); cout<<” Ud. sumará “<< n <<” términos de la serie”; dato=cont;

+ n”;

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

do { suma+=pow(cont,cont); cont++;

} while (cont<=n);

gotoxy(10,12);

cout<<”La suma desde “<< dato

<<” hasta “<< n<<” es = “<<suma; gotoxy(14,15); cout<<”Desea continuar ?(s/n)”;cin>>resp; suma=0 ; cont=1;

} while(resp==’s’|| resp==’S’);

}

getche();

}

} while(resp==’s’|| resp==’S’); } getche(); } Problema 3. Diseñar un programa que permita calcular la

Problema 3. Diseñar un programa que permita calcular la suma acumulada de la

SERIE = 1/(1+2^2+3^2 +4^2

+ x^n)

Para un error de e =10 exp(-2) ingresado por el usuario.

Solución //do_whi_serie.cpp #include <iostream.h> # define linea “----------------------------------------------------”

void main () { int n=1;

gotoxy(10,2);cout<<”Ingrese precisión(error) :”;cin>>e; cout<<linea; do { s=s+(1.0/(pow(n,2)));

gotoxy(10,3+n);

cout<<setw(10)<<setprecision(2)<<”valor de s=”<<s<<”en iteración “<<n; n++;

}while(!(1.0/(n*n)<e));

gotoxy(10,n+7);

cout<<”Valor aproximado final: “;cout<<setw(6)<<setprecision(3) <<s<<” en iteración “<<n<<endl; gotoxy(10,n+9);cout<<”Sesatisface que:”;cout<<setw(6)<<setprecision(3)<<p <<”<”<<e<<” en iteración <<n<<endl; getche(); }

float s=0.0,e;

Problema 4. Diseñar un programa que permita validar prácticas calificadas

definidas en el rango:0

informando y, superado este valor, finaliza el programa.

Solución // validar.cpp #include<iostream.h> void main() { int i=0,pc1;

clrscr();

El sistema solo acepta tres intentos, los cuales le van

20.

gotoxy(10,4); cout<<” Sr. usuario, tiene Ud. solo 3 opciones”;

do

{ i++;

Teodoro Luciano Córdova Neri

gotoxy(10,8); cout<<” Le quedan “<<(4-i)<<”

intentos:”;clreol();cin>>pc1;

gotoxy(10,12);cout<<” La práctica pc1= “<< pc1<<” esta fuera de rango “; if(i>=3 ) {clrscr();

gotoxy(12,8);cout<<”Sr. se agotaron sus opciones, hasta luego: “;getche();

exit(1);}

}while ((pc1<0)||(pc1>20));

clrscr();

gotoxy(12,8);cout<<”Sr. Bienvenidos al sistema: “;

getche(); }

Bienvenidos al sistema: “; getche(); } Problema 5. Diseñar un programa que valida, si desea o

Problema 5. Diseñar un programa que valida, si desea o no, finalizar con la ejecución del programa después de mostrar los resultados de calcular el resto de dos números, donde los números son ingresados por el usuario.

Solución //do_while_si.cpp #include<iostream.h> void main() { int a,b; char resp; float k; do{cout<<”ingresar el valor de

a:”;cin>>a; cout<<”ingresar el valor de b:”;cin>>b; k=a%b; cout<<”El resto de ”<<a<<”entre ”<<b <<”es : ”<<k<<endl;

?(s/

n)”;cin>>resp; clrscr();

do{cout<<”Desea terminar

clrscr(); do{cout<<”Desea terminar } while((resp==’s’) && (resp==’n’)); } while

} while((resp==’s’) && (resp==’n’));

} while ( resp ==’n’); getch();

}

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

Problema 6. Diseñar un programa que permita ingresar una cantidad de dinero y luego el programa debe descomponer el billete ingresado en cantidades menores es decir en:

Billetes de 100, de 50, de 20 de 10 de 5 y de 1 sol

Solución // while_Billete.cpp #include<iostream.h> void main()

while_Billete.cpp #include<iostream.h> void main() { int s,b100,b50,b20,b10,b5,b1,r1,r2 ,r3,r4,r5; clrscr();

{ int s,b100,b50,b20,b10,b5,b1,r1,r2

,r3,r4,r5;

clrscr(); char op=’y’; while(op==’y’) { do { cout<<”\nIngrese la Cantidad de

Soles, en el rango 0

}

while (!(s>=1000)); b100=int(s/100);r1=s%100; b50=int(r1/50);r2=r1%50; b20=int(r2/20);r3=r2%20; b10=int(r3/10);r4=r3%10; b5=int(r4/5);r5=r4%5; b1=r5; cout<<”\nHay”<<b100<<”billetes de 100”; cout<<”\nHay “<<b50<<” billetes de 50”; cout<<”\nHay “<<b20<<” billetes de 20”; cout<<”\nHay “<<b10<<” billetes de 10”; cout<<”\nHay “<<b5<<” billetes de 5”; cout<<”\nHay “<<b1<<” billetes de 1”;

cout<<”\n\n\t\tDESEA CONTINUAR (y/n): “;cin>>op; cout<<”\n”; clrscr();

} getch(); }

1000”;cin>>s;

Problema 7. Diseñar un programa que permita leer n números enteros y luego generar reportes para conocer:

Total de números PARES POSITIVOS, suma de números PARES POSITIVOS, total de números PARES NEGATIVOS, suma de números PARES NEGATIVOS, total de números IMPARES POSITIVOS, suma de números IMPARES POSITIVOS, total de números IMPARES NEGATIVOS, suma de números IMPARES NEGATIVOS.

El programa permite leer números hasta que usted presiona 0 (cero).

Solución //do_digitos_p_i.cpp #include<iostream.h>

void main() {int n,i=4,npp=0,npn=0,nip=0,nin=0; int sumanpp=0,sumanpn=0,sumanip=0,sumanin=0;

do { i++;

gotoxy(15,i);cout<<”Ingrese un número: “;cin>>n;

if(n%2==0)

{

gotoxy(42,i);cout<<”número par”;

Teodoro Luciano Córdova Neri

if (n>0) { gotoxy(42,i);cout<<”número par positivo”; sumanpp+=n; npp++;

}

else

{ gotoxy(42,i);cout<<”número par negativo”;

}

else

sumanpn+=n;

}

npn++;

{ gotoxy(42,i);cout<<”número impar”;

if (n>0)

else

{ gotoxy(42,i);cout<<”número impar positivo”;

sumanip+=n;

nip++;

}

{gotoxy(42,i);cout<<”número impar negativo”;

sumanin+=n; } } while(n!=0);

}

clrscr();

gotoxy(20,4);cout<<”

nin++;

RESULTADOS

“;

gotoxy(10,9);cout<<” Total de Números PARES POSITIVOS =”<<npp; gotoxy(10,13);cout<<”Suma de Números PARES POSITIVOS =”<<sumanpp; gotoxy(10,10);cout<<”Total de Números PARES NEGATIVOS =”<<npn-1; gotoxy(10,14);cout<<”Suma de Números PARES NEGATIVOS =”<<sumanpn; gotoxy(10,11);cout<<”Total de Números IMPARES POSITIVOS =”<<nip;

gotoxy(10,15);cout<<”Suma de Números IMPARES POSITIVOS =”<<sumanip; gotoxy(10,12);cout<<”Total de Números IMPARES NEGATIVOS =”<<nin;

gotoxy(10,16);

cout<<”Suma de Números IMPARES NEGATIVOS =”<<sumanin; getche();

}

Problema 8. En la siguiente figura, se ilustra la funcionalidad del módulo de validación y número de intentos por parte del usuario, es decir, debe ingresar la cantidad de dígitos que se desea procesar, que para nuestro caso el rango es como mínimo cinco dígitos (puede ser: 6, 7 ,8, etc.). Por cada error, el sistema envía el mensaje de error (ver figura) y, asimismo, el número de intentos que le quedan. Si el número de intentos supera los tres, entonces el sistema finaliza.

Cuando se ingresó correctamente la cantidad de dígitos en el rango establecido, (en nuestro caso cinco) entra a funcionar el Módulo de Validación de Dígitos definidos como cadenas, el cual solicita que usted ingrese dígito por dígito y si ingresa una letra en forma automática, elimina la letra y presenta los dígitos anteriores para que continúe ingresando más datos hasta cumplir con la condición inicial (cinco dígitos). Ejemplo: edito 43 U, entonces el sistema elimina la letra (carácter U y devuelve solo el número 43, donde usted continúa ingresando nuevos datos (ver figura).

Lenguaje de programación estructurada y sus aplicaciones en Borland C++ 5.0.2

Es un clásico problema en la cual se usa estructuras de control repetitivas, donde la condición de prueba está basada en letras o caracteres y especialmente en caracteres que son los dígitos de 0 a 9, motivo por la cual se debe declarar, en la sesión de variables, el tipo de dato char como un vector de caracteres.

Después de completar de editar los cinco dígitos entra a funcionar el módulo de reportes, para lo cual adicionalmente usted debe contestar lo siguiente:

a. Reporte para conocer la cadena expresada en números enteros. (Usted ingresó la cadena: “43256” entonces cadena en enteros: 43256)

b. Reporte de la cadena numérica en forma invertida: 65234

c. Reporte de los últimos 2 dígitos: 34.

d. Reporte del factorial del último dígito, según c) 4! = 24.

e. Reporte del total de dígitos pares, según c).

f. Reporte del total de dígitos impares, según c).

Solución // for_cadena_digitos1.cpp #define max 100 void main()

{ char cad[max];

do {nrovec++; gotoxy(20,2);cout<<”MÓDULO DE VALIDACIÓN: “; gotoxy(10,4);cout<<”Ingrese total de dígitos(x>4): “;clreol(); cin>>x; cout<<”\nSr. el número:”<<x<<” no esta en el rango solicitado, ingrese nuevo número :”<<endl<<endl; if (nrovec>3)

exit(1);

int i,j,x,nrovec=0,dosd,fact=1,ndp=0,ndi=0;

exit(1); int i,j,x,nrovec=0,dosd,fact=1,ndp=0,ndi=0; else cout<<”Le quedan

else

cout<<”Le quedan “<<(3-nrovec)<<” oportunidades :”<<endl<<endl; } while(x<5); clrscr(); cout<<””<<endl; cout<<»\nGracias por Verificar el módulo de Validación,ahora

validar SÓLO DÍGITOS «<<endl; cout<<»\nIngrese cadena de sólo números, si edita letras estas se eliminan: «; for(i=0;i<x; i++)