universidad nacional del callao 1 2015 facultad de...
TRANSCRIPT
UNIVERSIDAD NACIONAL DEL CALLAO ® 1
FACULTAD DE INGENIERÍA INDUSTRIAL Y DE SISTEMAS ,
INSTITUTO DE INVESTIGACIÓN DE LA FACULTAD DE INGENIERÍA INDUSTRIAL Y DE SISTEMAS
INFORME FINAL DEL TEXTO
"TEXTO: LENGUAJE DE PROGRAMACIÓN I- C++"
AUTOR: ING. JOSÉ ANTONIO FARFÁN AGUaAR
(PERÍODO DE EJECUCIÓN: Del 01/08/2013 al31/07/14)
RESOLUCION DE APROBACIÓN No 797- 2013 -R.
CALLA0-2014
~ 2015
DEDICATORIA
A Dios nuestro Señor por protegerme y guía.
A mis padres Wilfredo y Elvia su apoyo
incondicional, infinitas gracias, ya que sin su
ayuda no hubiera llegado hasta aquí.
ÍNDICE
l. ÍNDICE .................................................................................... 1
II. RES liMEN ................................................................................ 3
III. INTRODUCCIÓN ........................................................................ 4
IV. MAR.CO TEÓRICO ...................................................................... 6
V. MATERIALES Y MÉTODOS ......................................................... 8
VI. RESULTADOS ........................................................................... 9
6.1 CAPÍTULO I: CONCEPTOS BÁSICOS ...................................... 1 O
6 .1.1 Concepto de algoritmo ................................................... 1 O
6.1.2 Lenguajes de Programación ............................................. 10
6.1.3 El ciclo de vida del software ........................................... 10
6.1.4 Lenguaje de programación C++ ........................................ 11
6.1.5 Lenguajes de bajo nivel.. ................................................ 12
6 .1. 6 Estructura general de un programa. . ................................... 13
6.1. 7 Declaraciones globales ................................................... 13
6.1. 8 Función main ( ).. .. .. . .. . .. . .. . . . . .. . .. . .. . .. . . . . .. . .. . . . . . .............. 14
6.1.9 Creación de un programa ................................................ 15
6.1.10 Los elementos de un programa en C++ ................................ 16
6.1.11 Archivos de cabecera .................................................... 17
6.1.12 Variables ................................................................... 18
6.2 CAPÍTULO II: ESTRUCTURAS LÓGICAS DE CONTROL. ............ 20
6.2.1 Conceptos de las estructuras lógicas de control. ....................... 20
6.2.2 Método secuencial. ...................................................... 20
6.2.3 Estructuras de selección ................................................. 21
6.2.4 Estructura switch ... case ... brake ... default. ........................... 24
6.2.5 Estructura while .......................................................... 26
6.2.6 Estructura do ... while .................................................... 27
6.2.7 Estructura for ............................................................. 28
6.3 CAPITULO III: ARRA Y. ....................................................... 29
6.3.1 Arreglos unidimensionales ............................................... 29
6.3.2 Ejemplos propuestos ..................................................... 31
6.3.3 Arreglos bidimensionales o matrices ................................. 33
Página: 1
6.3.4 Ejemplo propuestos ...................................................... 39
6.4 CAPÍTULO IV: CADENAS .................................................... .41
6.4.1 Tipos de funciones de cadenas ........................................ .42
6.4.2 Problemas propuestos .................................................... 43
6.5 CAPITULO V: FUNCIONES ................................................... 44
6.5.1 Funciones ................................................................... 44
6.5.2 Nombre de una función ................................................ .44
6.5.3 Tipo de dato de retomo ................................................ .45
6.5.4 Parámetros de una función ............................................. .46
6.5.5 Ejemplos propuestos ..................................................... 49
6.6 CAPITULO VI: ESTRUCTURAS ............................................. 50
6.6.1 Estructuras ................................................................. 50
6.6.2 Ejemplos propuestos ..................................................... 58
6. 7 CAPÍTULO VII: OBJETOS Y MÉTODOS .................................. 59
6.7.1 Programación orientada a objetos ....................................... 59
6.7.2 Clases y herencia ......................................................... 60
6.7.3 Concepto de objetos ...................................................... 61
6. 7.4 Constructores y destructores ............................................ 62
VIL DISCUSIÓN ......................................................................... 67
VIII. BIBLIOGRAFÍA .................................................................... 68
IX. APÉNDICE ........................................................................... 69
X. ANEXOS ............................................................................. 74
Página: 2
ll. RESUMEN.
La elaboración, desarrollo y la ejecución de la investigación del "Texto: Lenguaje
de Programación I-e++", está basado en el uso y desarrollo de software en el
Lenguaje de Programación-e++.
En la actualidad, e++, sirve para desarrollar WinForms, tales como sistemas
operativos, compiladores, aplicaciones de escritorio, juegos y hasta de
administración de bases de dato que permite la manipulación de objetos. En ese
sentido, desde el punto de vista de los lenguajes orientados a objetos, el e++ es un
lenguaje híbrido.
Posteriormente se añadieron facilidades de programación genérica, que se sumó a
los otros dos paradigmas que ya estaban admitidos (programación estructurada y
la programación orientada a objetos).
Por esto se suele decir que el e++ es un lenguaje de programación
multiparadigma.
Aunque ya es muy viejo aún mucha gente lo sigue usando y como dato adicional,
es donde se genera la mayoría de los virus para Windows (bajo la plataforma de
Linux).
Por intermedio del texto, se pretende dar los conocimientos básicos,
fundamentales de la programación estructurada, utilizando el programa e++' este
Lenguaje de Programación; trabaja en el entorno D.O.S. carece de un interfaz
gráfico, permite el desarrollo de diversos sistemas para uso en forma general.
Lo que significa escribir un código, ejecutar para obtener los resultados
requeridos. Este texto: "Texto: Lenguaje de Programación I-e++", contribuirá al
estudiante en dar un enfoque sistémico en el desarrollo de software empresariales.
ágina: 3
ID. INTRODUCCIÓN
Este texto de investigación; "Texto: Lenguaje de Programación 1-e++", permite
dar conocer las herramientas principales para la programación estructura y
orientada a objetos. En este proyecto de investigación se verán los aspectos
principales, fundamentales de la programación de estructuras de datos,
programación orientada a objetos.
Al comienzo era una extensión del lenguaje e que fue denominada e with classes.
Este nuevo lenguaje comenzó a ser utilizado fuera de la ATT en 1983.
El nombre e++ es también de ese año, y hace referencia al carácter del operador
incremento de e ( ++ ). Ante la gran difusión y éxito que iba obteniendo en. el
mundo de los programadores, En la actualidad, el e++ es un lenguaje versátil,
potente y general. Su éxito entre los programadores profesionales le ha llevado a
ocupar el primer puesto como herramienta de desarrollo de aplicaciones. El e++
mantiene las ventajas del e en cuanto a riqueza de operadores y expresiones,
flexibilidad, concisión y eficiencia. Además, ha eliminado algunas de las
dificultades y limitaciones del e original. La evolución de e++ ha continuado con
la aparición de Java, un lenguaje creado simplificando algunas cosas de e++ y
añadiendo otras, que se utiliza para realizar aplicaciones en Internet.
En el "Texto del Lenguaje de programación 1 -C++"; nos permite conocer los
elementos básicos, operadores y expresiones, estructuras de control, funciones,
arreglos, estructuras y la programación orientada a objetos.
La programación orientada a objetos consiste en un enfoque distinto al proceso
procedimental. El enfoque orientado a objetos guarda analogía con la vida real, el
desarrollo de software orientado a objetos se basa en el diseño y construcción de
objetos que se componen a su vez de datos que manipulan estos datos. El
programador define en primer lugar los objetos del problema y a continuación los
datos y operaciones que actuaran sobre esos datos. Las ventajas de la
programación orientada objetos se derivan esencialmente de la estructura modular
existente en la vida real y el modo de respuesta en estos módulos u objetos a
mensajes o eventos que se producen en cualquier instante. El lenguaje de e++
orientado a objetos, por excelencia, es una extensión del lenguaje e y contiene las
Página: 4
tres propiedades más importantes tales como encapsulamiento, herencia,
polimorfismo.
En el desarrollo del texto se da a conocer sobre los conceptos básicos, el flujo de
control de un programa, estructuras secuenciales, estructura selectiva, alternativas
simples, alternativas múltiples, estructuras de control, tipos de arreglos, cadenas,
funciones, estructuras, clases y objetos.
Nos da conocer las herramientas básicas, fundamentales para el desarrollo de
aplicaciones para el mercado competitivo que nos encontramos.
Página: S
IV. MARCO TEÓRICO
El lenguaje de programación C++ de propósito general que ha estado y sigue
estando asociado con el sistema operativo UNIX. Permite trabajar en la
plataforma de Windows 95,98, NT, Windows XP, Windows 8, en la actualidad se
utiliza Linux, la versión abierta, gratuita de Unix que junto con el entorno. Esta
revolución, paradójicamente, proporciona fuerza al lenguaje de programación de
Sistemas C.
Todavía y durante muchos años C seguirá siendo uno de los lenguajes líderes en
la enseñanza de la programación tanto a nivel profesional como universitario
sigue siendo el lenguaje más empleado en Facultades y Escuelas de Ciencias e
Ingeniería, y en los centros de enseñanza de formación profesional, y en particular
los innovadores ciclos de grado superior, así como en centros de enseñanza media
y secundaria, para el aprendizaje de legiones de promociones (generaciones) de
estudiantes y profesionales.
En 1975 se publica Pascal User Manual and Report la especificación del joven
lenguaje Pascal; cuya suerte corre en paralelo con C, aunque al contrario que el
compilador de Pascal construido por la casa Borland, que prácticamente no se
comercializa, C sigue siendo uno de los reyes de la iniciación a la programación.
Programming Language se considera también el manual del estándar ANSI C.
Actualmente en la Facultad de Ingeniería Industrial y de Sistemas existen diversos
libros, manuales, revistas; información actualizada. Se pudo observar que hay una
debilidad en textos respecto al lenguaje de programación turbo C++.
En vista a la necesidad que existe esta debilidad; en base a textos relacionados de
programación estructurada; el Ingeniero De Sistemas tiene la capacidad de
análisis, abstracción de entender el problema en el mundo real y tomar decisiones
en el entorno que nos rodea.
La ingeniería, es un modo de enfoque interdisciplinario que permite estudiar y
comprender la realidad, con el propósito de implementar u optimizar sistemas
complejos.
"La sobrecarga de funciones es un tipo específico de polimorfismo. El
polimorfismo es uno de los conceptos fundamentales de la programación
orientada a objetos" (L. Joyanes Aguilar, página 153).
Página: 6
Existe la necesidad de contar con textos relacionados de programación estructura
y orientada a objetos~ el ingeniero de sistemas tiene el análisis, abstracción de
entender el problema, tomar decisiones en el entorno que nos rodea. Los
resultados deben ser óptimos.
La ingeniería es un modo de enfoque interdisciplinario que permite estudiar y
comprender la realidad, con el propósito de implementar y optimizar sistemas
complejos.
"El paradigma imperativo o procedimental representa el enfoque o método
tradicional de programación, un lenguaje imperativo es un conjunto de
instrucciones que se ejecutan una por una, de principio a fin, de modo secuencial
excepto cuando intervienen instrucciones de salto de secuencia o control. Este
paradigma se define el proceso de programación como el desarrollo de una
secuencia de ordenes (comandos) que manipulan los datos para producir los
resultados deseados. Por consiguiente, el paradigma imperativo señala un enfoque
del proceso de programación mediante la realización de un algoritmo que resuelve
de modo manual el problema y a continuación expresa ese algoritmo como una
secuencia de órdenes" (Joyanes Aguilar, 2008).
Página: 7
V. MATERIALES Y MÉTODOS.
La investigación es de carácter teórico-práctico~ la presente investigación permite
entrar al mundo de la programación estructurada, es la base fundamental de la
programación. Permite crear y desarrollar programas simples hasta muy
complejos. Se necesita contar para la asignatura con un laboratorio de
computadora, instalado el sistema operativo Windows o Linux. Tener el software
de C++.
La metodología empleada fue descriptivo analítico con el objeto de identificar los
temas más necesarios para la formación profesional del ingeniero de Sistemas o
ingeniero Industrial.
Para la elaboración del presente texto: de "Texto: Lenguaje de programación I
C++," se desarrolló en base a la sumilla del silabo del curso de Lenguaje de
Programación l. de la Escuela Profesional de Ingeniería de Sistemas de la UNAC.
Página: 8
VI. RESULTADOS
El resultado de la investigación, fue la elaboración del texto "Texto: Lenguaje de
Programación I-C++", que será de mucha utilidad para estudiantes y profesionales
de ingeniería de sistemas e industrial, a fin de ser más competitivos en el mundo
globalizado en que nos encontramos.
El texto desarrollado consta de cinco capítulos y un apéndice.
El contenido de los capítulos es el siguiente:
CAPITULO 1: CONCEPTOS BÁSICOS
CAPITULO 2: ESTRUCTURAS LÓGICAS DE CONTROL
CAPITULO 3: ARRA Y
CAPITULO 4: CADENAS
CAPITULO 5: FUNCIONES
CAPITULO 6: ESTRUCTURAS
CAPITULO 7: CLASES Y OBJETOS
6.1 CAPÍTULO 1: CONCEPTOS BÁSICOS.
6.1.1 Concepto de algoritmo.
Es la descripción ordenada paso a paso de la solución de un problema
o el desarrollo de un proceso. Un algoritmo es un método para
resolver un problema; los algoritmos se clasifican en tres
caracteri sticas:
a) algoritmo lineal.- nos permite la comunicación de persona a
persona una de sus formas más conocidas es el seudocódigo.
b) Algoritmo grafico.- nos permite la visualización lógica de la
solución. Se le conoce como diagrama de flujo.
e) Algoritmo codificado.- nos permite la comunicación entre la
persona y la maquina (computadora). Se le conoce como
programa.
Las características de un algoritmo son:
• Debe ser preciso e indicar el orden de realización de cada paso.
• De estar definido. Si se sigue un algoritmo dos veces, se debe
obtener el mismo resultado cada vez.
• Debe ser finito. Si se sigue un algoritmo, se debe terminar en algún
momento; o sea, debe tener un numero finito de pasos.
La definición de un algoritmo debe describir tres partes: entrada,
proceso, salida.
6.1.2 Lenguajes de Programación.
Nos permiten construir programas para aplicaciones específicas, estos
lenguajes normalmente tiene su ámbito de aplicación o sea tiene
diferentes enfoques.
6.1.3 El ciclo de vida del software.
Existen dos niveles en la construcción de programas; el primer nivel se
denomina programación a pequeña escala; el segundo nivel se
denomina programación a gran escala.
La programación en pequeña escala se preocupa de los conceptos que
ayudan a crear pequeños programas; en estos programas se suele
requerir claridad y precisión mental y técnica. En realidad, el interés
mayor desde el punto de vista del futuro programador profesional está
en los programas de gran escala que requiere de unos principios sólidos
y firmes de lo que se conoce como ingeniería de software y que
constituye un conjunto de técnicas para facilitar el desarrollo de
programas de computadora. Estos programas o mejor proyectos de
software están realizados por equipos de personas dirigidos por un
director de proyectos (analista o ingeniero de software) y los programas
pueden tener más de 100.000 líneas de código.
El desarrollo de un buen sistema de software se realiza durante el ciclo
de vida que es el período de tiempo que se extiende desde la concepción
inicial del sistema hasta su ·eventual retirada de la comercialización o
uso del mismo. Las actividades humanas relacionadas con el ciclo de
vida implican procesos tales como análisis de requisitos, diseño,
implementación, codificación, pruebas, verificación, documentación,
mantenimiento y evolución del sistema y obsolescencia.
6.1.4 Lenguaje de programación C++.
Es Bjame Stroustrup. El desarrollo el C++ para tratar de programar
simulaciones de eventos sobre las que había estado trabajando años
atrás.
Stroustrup trabajó con los laboratorios Bell de la AT &T para desarrollar
y mejorar el C++durante varios años. El American Nacional Standards
Institute, grupo que norma la mayoría de los lenguajes de computación,
ha estandarizado el C++, aunque también el estándar de la AT &T es
considerado como el que se debe emular.
Borland Intemational es el productor del Turbo C++ y del Borland
C++. Todos los productos del lenguaje C++ de Borland, comenzando
con la versión 3.0 con compatibles con el estándar 3.0 de AT&T.
Ser compatible con la versión 3.0 de AT&T es la prueba que determina
si un compilador es lo suficientemente moderno como para ser usado
como un compilador serio de C++.
Página: 11
6.1.5 Lenguajes de bajo nivel.
Son lenguajes totalmente dependientes de la máquina, es decir que el
programa que se realiza con este tipo de lenguajes no se pueden migrar
o utilizar en otras maquinas.
Al estar prácticamente diseñados a medida del hardware, aprovechan al
máximo las características del mismo.
Dentro de este grupo se encuentran:
a) El lenguaje maquina.- Este lenguaje ordena a la máquina las
operaciones fundamentales para su funcionamiento. Consiste en la
combinación de O's y 1 's para formar las ordenes entendibles por el
hardware de la máquina.
b) El lenguaje ensamblador.- Es un derivado del lenguaje máquina y
está formado por abreviaturas de letras y números llamadas
mnemotécnicos. Con la aparición de este lenguaje se crearon los
programas traductores para poder pasar los programas escritos en
lenguaje ensamblador a lenguaje máquina.
• Lenguajes de alto niveL-Son aquellos que se encuentran más
cercanos al lenguaje natural que al lenguaje máquina.
• Están dirigidos a solucionar problemas mediante el uso de EDD's.
"El EDD 's son las abreviatura de Estructuras Dinámicas de Datos
y esto es algo muy utilizado en todos los lenguajes de
programación.
Se tratan de lenguajes independientes de la arquitectura del ordenador.
Por lo que, en principio, un programa escrito en un lenguaje de alto
nivel, lo puedes migrar de una máquina a otra sin ningún tipo de
problema.
Estos lenguajes permiten al programador olvidarse por completo del
funcionamiento interno de la maquina/s para la que están diseñando el
programa. Tan solo necesitan un traductor que entiendan el código
fuente como las características de la máquina.
Página: 12
Sun describe a Java como "simple, orientado a objetos, distribuido,
interpretado, robusto, seguro, de arquitectura neutra, portable, de altas
prestaciones, multitarea y dinámico".
Java 2 es la tercera versión importante del lenguaje de programación
Java. Parte de la versión 1.1 sin introducirle cambios sustanciales,
simplemente ampliándolo.
6.1.6 Estructura general de un programa.
Un programa en C++ se compone de una o más funciones. Una de las
funciones debe ser obligatoriamente main. Una función en C++ es un
grupo de instrucciones que realizan una o más acciones. Asimismo, un
programa contendrá una serie de directivas #include que permitirán
· incluir en el mismo archivo de cabecera que a su vez constaran de
funciones y datos predefinidos en ellos. Un programa en C++ se puede
incluir en:
a) Directivas de procesador
b) Declaraciones globales
e) La función main()
d) Funciones definidas por el usuario
e) Comentarios del programa( utilizados en su totalidad)
6.1. 7 Declaraciones globales
Las declaraciones globales indican la compilador que .las funciones
definidas por el usuario o variables así declaradas son comunes a todas
las funciones de su programa. Las declaraciones globales se sitúan antes
de la función main( ) . Las declaraciones de función se denominan
prototipos La zona de declaraciones globales de un programa puede
incluir declaraciones de variables además.
int media(int a, int b) ~
Página: 13
i
6.1.8 Función main ( ).
Cada programa C tiene una función main ( ) que es el punto de entrada
al programa. Su estructura es:
main(){
Bloque de sentencias
}
Las sentencias incluidas entre las llaves { . . . . . } se denominan bloque.
Un programa debe tener sólo una función main (). Si se intenta hacer
dos funciones main ( ) se produce un error. Además de la función main
( ) , un programa C consta de una colección de funciones .... bloque de
sentencias una función en C++ es un subprograma que devuelve un
único valor; en un programa corto, el programa completo puede
incluirse totalmente en la función main ( ) . Un programa largo, sin
embargo, tiene demasiados códigos para incluirlo en esta función. La
función main ( ) en un programa largo consta prácticamente de
llamadas a las funciones definidas por el usuario.
El programa siguiente se compone de tres funciones:
Obtener datos ( ), alfabetizar ( ) y ver palabras ( ) que se invocan
sucesivamente.
int main ()
obtenerDatos ();
alfabetizar();
verPalabras ( );
return O;
Las variables y constantes globales se declaran y definen fuera de la
definición de las funciones, generalmente en la cabecera del programa,
· Página: 14
antes de main ( ) , mientras que las variables y constantes locales se
declaran y definen en la cabecera del cuerpo o bloque de la función
principal, o en la cabecera de cualquier bloque. Las sentencias situadas
en el interior del cuerpo de la función main ( ), o cualquier otra función,
deben terminar en punto y coma.
6.1.9 Creación de un programa.
Una vez creado un programa, se debe ejecutar.
En general, los pasos serían:
Utilizar un editor de texto para escribir el programa y grabarlo en un
archivo. Este archivo constituye el código fuente de un programa.
Compilar el código fuente. Se traduce el código fuente en un código
objeto (extensión.obj) (lenguaje máquina entendible por la
computadora). Un archivo objeto contiene instrucciones en lenguaje
máquina que se pueden ejecutar por una computadora. Los archivos
estándar C y los de cabecera definidos por el usuario son incluidos
(#include) en su código fuente por el preprocesador. Los archivos de
cabecera contienen información necesaria para la compilación, como es
el caso de stdio.h que contiene información scanf() y de printf().
Enlazar el código objeto con las bibliotecas correspondientes. Una
biblioteca C contiene código objeto de una colección de rutinas o
funciones que realizan tareas, como visualizar informaciones en la
pantalla o calcular la raíz cuadrada de un número. El enlace del código
objeto del programa con el objeto de las funciones utilizadas y
cualquier otro código empleado en el enlace, producirá un código
ejecutable. Un programa C consta de un número diferente de archivos
objeto y archivos. Las etapas de creación de un programa son: código
fuente, compilador (archivo cabecera), código objeto, enlazador
(bibliotecas), código ejecutable.
Página: 15
6.1.10 Los elementos de un programa en C++.
Un archivo es traducido en diferentes fases. La primera fase es el
preprocesador, que realiza la inclusión de archivos y la sustitución de
macros. El preprocesador se controla por directivas introducidas por
líneas que contienen # como primer carácter. El resultado del
preprocesador es una secuencia de tokens (elementos léxicos de los
programas).
Existen cinco clases de tokens: identificadores, palabras reservadas,
literales, operadores y otros.
a) Los identificadores en borland C/C++ .• el identificador puede ser
de cualquier longitud; sin embargo, el compilador ignora cualquier
carácter fuera de los 32 primeros. e es sensible a las mayúsculas.
Por consiguiente, e reconoce como distintos los identificadores
ALFA, reglas básicas de formación de identificadores.
o Secuencia de letras o dígitos; el primer carácter puede ser una
letra o un subrayado.
o Los identificadores son sensibles a las mayúsculas:
(compiladores de Borland, entre otros). ·
o Los identificadores pueden tener cualquier longitud, pero sólo
son significativos los 32.
o Los identificadores no pueden ser palabras reservadas, tales
como if, switch o else.
o
b) Las palabras reservadas.- una palabra reservada (keyword o
resewed word), tal como void es una característica del lenguaje e asociada con algún significado especial. Una palabra reservada no
se puede utilizar como nombre de identificador o función.
void void( ) 1 * error * 1
int char; 1 * error * 1
Página: 16
Los siguientes identificadores están reservados para utilizarlos
como palabras reservadas, y no se deben emplear para otros
propósitos.
auto extem sizeof
break float static
case for struct
char goto switch
const if typede
default long unsigned
do register void
double return volatile
el se short while
6.1.11 Archivos de cabecera.
Un archivo de cabecera es un archivo especial que contiene
declaraciones de elementos y funciones de la biblioteca. Para utilizar
macros, constantes, tipos y funciones almacenadas en una biblioteca,
un programa debe utilizar la directiva #include para insertar el archivo
de cabecera correspondiente. Por ejemplo, si un programa utiliza la
función pow que se almacena en la biblioteca matemática math.h,
debe contener la directiva #include<math.h>. Para hacer que el
contenido de la biblioteca matemática esté disponible a un programa.
La mayoría de los programas contienen líneas como ésta al principio,
que se incluyen en el momento de compilación. #include<stdio.h>,
#include<conio. h> ,#include<iostream. h> ,#include<math. h> ,#include
<string.h>.
Página: 17
6.1.12 Variables:
a) Inicialización de variables.- Se ha proporcionado un valor
denominado valor inicial, a una variable
Cuando se declara. El formato general de una declaración de
inicialización es:
tipo nombre-varíable =expresión
Expresión es cualquier expresión válida cuyo valor es del mismo
tipo que tipo.
Esta sentencia declara y proporciona un valor inicial a una variable.
Las variables se pueden inicializar a la vez que se declaran, o bien,
inicializarse después de la declaración.
Por ejemplo: char respuesta= 'S'~
int contador = 1;
float peso= 156.45;
int anyo = 1993;
Estas acciones crean variables respuesta, memoria los valores
respectivos situados a su derecha.
b) Declaración o definición.... La diferencia entre declaración y
definición es sutil Una declaración introduce un nombre de una
variable y asocia un tipo con la variable. Una definición es una
declaración que asigna simultáneamente memoria a la variable.
double x; 1 * declara el nombre de la variable x de tipo double * 1
char c-var; 1 *declara c-var de tipo char */
int i; /* definido pero no inicializado * 1
int i = O; /* definido e inicializado a cero.* 1
e) Variables locales.- son aquéllas definidas en el interior de una
función y son visibles sólo en esa función específica. Las reglas por
las que se rigen las variables locales son:
• En el interior de una función, una variable local no puede ser
modificada por ninguna sentencia externa a la función.
• Los nombres de las variables locales no han de ser Únicos. Dos,
tres o más funciones pueden definir variabl de nombre
Página: 18
Interruptor: Cada variable es distinta y pertenece a la función en
que está declarada.
• Las variables locales de las funciones no existen en memoria
hasta que se ejecuta la función.
Esta propiedad permite ahorrar memoria, ya que permite que varias
funciones compartan la misma memoria para sus variables locales
(pero no a la vez).
d) Variables globales.-Las variables globales son variables que se
declaran fuera de la función y por defecto (omisión) son visibles a
cualquier función, incluyendo main( ) .
Todas las variables locales desaparecen cuando termina su bloque.
Una variable global es visible desde el punto en que se define hasta
el final del programa (archivo fuente). La memoria asignada a una
vari.able global permanece asignada a través de la ejecución del
programa, tomando espacio válido según se utilice. Por esta razón,
se debe evitar utilizar muchas variables globales dentro de un
programa. Otro problema que surge con variables globales es que
una función puede asignar un valor específico a una variable
global. Posteriormente, en otra función, y por olvido, se pueden
hacer cambios en la misma variable. Estos cambios dificultarán la
localización de errores.
e) Variables dinámicas.-tienen características que en algunos casos
son similares tanto a variables locales como a globales. Al igual
que una variable local, una variable dinámica se crea y libera
durante la ejecución del programa. La diferencia entre una variable
local y una variable dinámica es que la variable dinámica se crea
tras su petición (en vez de automáticamente, como las variables
locales), es decir, a su voluntad, y se libera cuando ya no se
necesita. Al igual que una variable global, se pueden crear
variables dinámicas que son accesibles desde múltiples funciones.
Página: 19
6.2 CAPÍTULO ll: ESTRUCTURAS LÓGICAS DE CONTROL.
6.2.1 Conceptos de las estructuras lógicas de control.
'6.2.2
Los operadores relacionales se usan normalmente en sentencias de
selección y de iteración para comprobar una condición. Operadores
relacionales en C++:
Operador Significado Ejemplo
(<Ojo!, no=) Igualaa=b
!= No igual a a !=b
> Mayor que a>b
< Menor que a<b
>= Mayor o igual a>=b
<= Menor o igual a<=b
Método secuencial.
Se ejecuta en forma secuencial sin alterar el flujo o la secuencia.
Ejemplo 01:
Escriba un algoritmo para calcular el monto a pagar por un artículo. Los datos
de entrada son: el precio de venta y el número de unidades adquiridas.
Considere un descuento fijo de 20%, y 18 % de igv. El algoritmo deberá
mostrar el monto del descuento y el monto a pagar.
Solución:
#include <iostream.h>
#include <conio.h>
#include <stdio.h>
void main(){
int pv,mc,mt,mp,d,u;
cout<<"\ningrese el precio de venta: ";
cin>>pv;
cout<<"\ningrese el número de unidades:";
cin>>u;
mc=pv*u;
Página: 20
d=mc*0.2;
mt=mc-d;
mp=mt+(O.l8*mt);
cout<<"\n el monto a pagar es: "<<mp;
cout<<"\n el descuento es: "<<d;
getch();
}
6.2.3 Estructuras de selección.
La sentencia if elige entre varias alternativas en base al valor de una o
más expresiones booleanas.
Sintaxis:
if ( <expres _ bool>) <bloque_ sent>
{else if(<expres_bool>) <bloque_sent>}
[else <sec_sent>]
Ejemplo 02:
Un curso se evalúa en base a 5 prácticas de las cuales se elimina la nota menor
y se promedia las cuatro restantes. Escriba un algoritmo que ingrese la cinco
notas de un alumno obtenga su promedio y determine si el alumno aprobó.
Mostrar el promedio y un mensaje que diga aprobado o desaprobado.
Solución.
#include <conio.h>
#include <stdio.h>
#include <iostream.h>
voidmain(){
float nl,n2,n3,n4,n5,menor;
float p;
cout<<"ingresar el numero l:";cin>>nl;
cout<<"ingresar el numero 2:";cin>>n2;
cout<<"ingresar el numero 3:";cin>>n3;
Página: 21
cout<<"ingresar el numero 4:";cin>>n4;
cout<<"ingresar el numero 5:";cin>>n5;
if(nl>=O && n2>=0 && n3>=0 && n4>=0 && n5>=0 && nl<=20 &&
n2<=20 && n3<=20 && n4<=20 && n5<=20)
{
menor=nl;
if(n2<menor)
{menor=n2;}
if(n3<menor)
{ menor=n3; }
if( n4<menor)
{ menor=n4; }
if(n5<menor)
{ menor=n5; }
p=(nl +n2+n3+n4+n5-menor)/4;
cout<<"\nel promedio es: "<<p;
if(p>=l0.5) {
cout<<"\nAprobado";}
else {
cout<<"\nDesaprobado ";
}
}
el se
cout<<"No existe";
getch();
}
Ejemplo 03:
Un curso se evalúa de la siguiente forma: se toman 5 prácticas calificadas, se
determina el promedio de las 4 notas más altas y se le da al estudiante una
categoría que puede ser A, B, C o D según la tabla.
Solucion:
Página: 22
#include <conio.h> #include <stdio.h> #include <iostream.h> void main (){ float nl,n2,n3,n4,n5,menor; float p; cout<<"ingresar el numero l:";cin>>nl; cout<<"ingresar el numero 2:";cin>>n2; cout<<"ingresar el numero 3:";cin>>n3; cout<<"ingresar el numero 4:";cin>>n4; cout<<"ingresar el numero 5:";cin>>n5; if(nl>=O && n2>=0 && n3>=0 && n4>=0 && n5>=0 && n1<=20 && n2<=20 && n3<=20 && n4<=20 && n5<=20)
{
}
menor=nl; if(n2<menor)
menor=n2; if(n3<menor)
menor=n3; if(n4<menor)
menor=n4; if(n5 <menor)
menor=n5; p=(nl +n2+n3+n4+n5-menor)/4; cout<<"\nel promedio es: "<<p;
if(p>=10.5) cout<<"\nAprobado";
else cout<<"\nDesaprobado ";
if(p>=l7&&p<=20) cout<<"\nla categoria es A";
if(p>=14&&p<=17) cout<<"\nla categoria es B ";
if(p>=lO&&p<=14) cout<<"\nla categoría es C ";
if(p>=O&&p<= 10) cout<<"\nla categoría es D ";
else cout<<"No existe";
getch(); }
Página: 23
6.2.4 Estructura switch ... case ... brake ... default.
Selección múltiple o multialtemativa. En situaciones donde el
Valor de una expresión detennina que sentencias serán ejecutadas es
mejor utilizar una sentencia switch en lugar de una if.
La ejecución saltea todos los case hasta que encuentra uno con el valor
de la variable, y ejecuta desde allí hasta el final del case o hasta que
encuentre un break, en cuyo caso salta al final del case. El default
permite poner una serie de instrucciones que se ejecutan en caso de
que la igualdad no se dé para ninguno de los case.
Sintaxis:
switch (variable) {
case valor 1 :
}
sentencias ...
break
case valor 2 :
sentencias ...
break
case valor n :
sentencias ...
break
default:
sentencias ...
Ejemplo 04:
Una empresa ha puesto en oferta tres productos a,b,c cada uno de ellos
en 3 calidades diferentes cl,c2,c3. El costo de cada producto según su
calidad se da la tabla:
Solución:
#include <iostream.h> #include <conio.h> #include <stdio.h> void main(){
Página: 24
char p; int n,q; float c=O,t,d,tt; cout<<"\n ingrese la cantidad del producto:"; cin>>n; cout<<"\n ingrese el producto:a,b,c: "; cin>>p; cout<<"\n ingrese la calidad del producto:1,2,3: "; cin>>q; switch (p){ case 'a':switch (q) {
case 1: c=23. 5; break;
};break; case 'b':switch (q) {
case 2: c=21;break; case 3: c=-19.5;break;
case 1: c=32;break;
};break; case 'c':switch (q) {
case 2: c=30;break; case 3: c=28.5;break;
case 1: c=52.5;break; case 2: c=61;break; case 3: c=49;break;
};break; default: cout<<"\n tecla incorrecta"; } t=n*c; if(t>500) {d=t*O.l; tt=t-d; }else{ d=O; tt=t;} cout<<"\n el subtotal es: "<<t;
cout<<"\n el descuento es: "<<d; cout<<"\n monto a pagar es: "<<tt; getch();
}
Página: 25
6.2.5 Estructura while.
Es que su condición de terminación ( <expres bool>) se comprueba
cada vez antes de que el cuerpo del bucle ( <sec sent>) sea ejecutado.
El cuerpo se ejecuta mientras se cumpla la condición de control. Si la
condición es false (0), entonces el cuerpo no se ejecuta. Hay que hacer
notar que, si la condición es true ( 1) inicialmente, la sentencia while
no terminara (bucle infinito) a menos que en el cuerpo de la misma se
medique de alguna forma la condición de control del bucle. Una
sentencia while se ejecutara a cero o más veces.
Sintaxis:
<sent_while> ::= while (<expres_bool>)
<sec sent>
Ejemplo 05:
Una empresa dedicada a la venta de varios productos paga a sus
trabajadores quincenalmente un porcentaje del total de ]as ventas
efectuadas de acuerdo a las siguientes condiciones:
a) Monto de la venta>= 2800, el porcentaje de pago es 20%.
b) 200<=Monto de la venta< 2800, el porcentaje de pago es 15%.
e) 800<=Monto de la venta< 2000 , el porcentaje de pago es 12%.
Solucion:
#include<iostream.h>
#include<conio.h>
#include<stdio.h>
void main(){
float MV ,MT;
cout<<"\nlngrese monto total de ventas";
cin>>MV;
while(MV<O){
cout<<"\nMonto invalido";
Página: 26
cout< <"\nlngrese monto total de ventas";
cin>>MV;
}
if(MV<800)
MT=MV*O.l;
else if(MV>=800&&MV <2000)
MT=MV*0.12;
else if(MV>=2000&&MV<2800)
MT=MV*1.5;
else if(MV>=2800)
MT=MV*0.2;
cout<<"\nEl monto total de venta es"<<MV;
cout<<"\nEI monto a pagar al trabajador es"<<MT;
}
6.2.6 Estructura do ... while.
Al igual que en la sentencia while, en esta sentencia el cuerpo del
bucle se ejecuta mientras que sea verdad la expresión booleana que
constituye la condición de control.
Además, esta condición se comprueba cada vez tras la ejecución del
cuerpo, no antes, como en el while. El cuerpo de una sentencia
do/while siempre se ejecuta al menos una vez. Cuando esto pueda
ocurrir es más conveniente su uso que la sentencia while.
Sintaxis:
do {
sentencia 1
sentencian
} while (condición) ;
Página: 27
Ejemplo 06:
Diseñar un programa que imprima el termino 100 de la siguiente
serie: 1 2 4 7 11 16 22 ..... .
#include<iostream. h>
#include<conio.h>
#include<stdio.h>
void main(){
int S=O;
float N=l;
do{
N+=S;
S+=1;
} while(S<1 00);
cout<<"\nEl termino es\t"<<N;}
6.2. 7 Estructura for.
El bucle for contiene las cuatro partes siguientes:
a) Parte de inicialización (<expres ini>), que inicializa las variables
de control del bucle. Se puede utilizar variables de control de bucles
simples o múltiples. Lo más normal es inicializar en este punto una
sola variable cuyo valor varía luego en la parte de incremento. Si se
inicializan varias variables de control, cada inicialización se separa de
la anterior con una coma.
b) Parte de iteración (<expres_bool>), que contiene una expresión
lógica que hace que el bucle realice las iteraciones de las sentencias,
mientras que a expresión sea verdadera.
e) Parte de incremento (<expres_inc>), que modifica la variable o
variables de control de bucle. Si se modifican varias variables de
control, cada operación se separa de la anterior por una coma.
Sintaxis:
For ( <expres _ini>;<expres _ bool>;<expres _ inc>)
<sec sent>
jJJl Página: 28
Ejemplo 07:
Cree un algoritmo que ingrese un número decreciente de 5 en 5 que
sea mayor o igual que 50 y menor o igual que 100
#include<iostream.h>
#include<conio.h>
voidmain() {
int i;
clrscr();
for(i=lOO;i>=50;i-=5) {
cout<<i;
cout<<"\n";
getch();
} }
6.3 CAPITULO ill: ARRA Y.
6.3.1 Arreglos unidimensionales.
Un arreglo es una estructura de datos, o más técnicamente, un
espacio de memoria que permite almacenar una colección de
elementos, todos del mismo tipo. Conviene imaginar un arreglo
como una secuencia contigua de celdas (espacios de memoria), o
casillas, en cada una de las cuales se puede guardar un elemento de
la colección. Además, es usual dibujarlo como lo ilustra la figura
siguiente:
El primer elemento del arreglo tiene índice cero (O) y el último tiene
índice tamaño_ del_ arreglo - l.
V e e to r
in dice ~ O tam año-1 ¡r-----r-----r-----r-----r¡-----,
Sintaxis:
<NOMBRE> : arreglo [<N>] de <TIPO>
Página: 29
Ejemplo 08:
#include <iostream.h>
#include <conio.h>
intbilly [] = {16, 2, 77, 40, 12071};
int n, result=O;
int main ()
{
for ( n=O ; n<5 ; n++ ) {
result += billy[n];
}
cout << result;
return O;}
Ejemplo 09:
/*burbuja.cpp - ordenamiento de un vector
por burbuja */
//#include<stdio.h>
//#include<conio.h>
#in e lude<iostream. h>
#define LIMITE 50
main(){
intdato[LIMITE],temp;
intn,ij;
cout<<"Ingrese numero de datos:";
cin>>n;
/* ingreso de datos * 1
for( i=O;i<n;i++)
cin>>dato[i];
/*ordenando los datos*/
//nro de pasadas
for (i=O;i<n-1; i++)
Página: 30
//nro de intercambios
{forG=Oj<n-1-i; j++)
if ( dato[j] >dato[j+ 1])
{ temp=dato[j];
dato[j]=dato[j+ 1 ];
dato[j+ 1 ]=temp;}
}
/* impresion de datos en pantalla* 1
for (i=O;i<n;i++)
cout<<"\t"<<dato[i];
return O;
}
6.3.2 Ejemplos propuestos.
l. Diseñar un programa que ingrese los sueldos de 20 empleados
de una compañía e imprima un listado de todos los sueldos
inferiores al sueldo promedio. Considere que el sueldo mínimo
es de S/. 750.
2. Diseñar un programa que ingrese los sueldos de 20 empleados
de una empresa en un arreglo y determine el menor sueldo, el
sueldo total y el sueldo promedio.
3. Calcular la suma de todos los elementos de un vector de
dimensión 100, así como su media aritmética.
4. Calcular el número de elementos negativos, cero y positivos de
un vector dado de 60 elementos.
5. Diseñe un programa que calcule el mayor valor de un arreglo de
N elementos.
6. Dado un arreglo de N elementos diseñar un programa que
calcule de forma independiente la suma de los números pares y
la suma de los números impares.
Página: 31
7. Dado un arreglo de 20 elementos que almacenan masas. Se
desea calcular la suma total, el promedio de masas y el número
de masas menores que el promedio.
8. Diseñar un programa que ingrese 20 números enteros en un
arreglo y determine:
a) La suma de todos los elementos del arreglo
b) el número menor y su índice (dentro del arreglo).
9. Diseñar un programa que rellene aleatoriamente un arreglo
unidimensional con 20 números enteros comprendidos entre 20
y 90. Ordene luego el arreglo en forma descendente e imprima
el arreglo. (sugerenciaRandom.~ <iomanip.h>).
10. Diseñe un programa que ingrese un arreglo de N enteros, ordene
el arreglo descendentemente e imprima el arreglo ordenado
descendentemente.
11. Diseñar un programa que defina un arreglo de 20 elementos
formados por enteros y luego ingrese 1 O enteros cualquiera y
luego ingrese un elemento x, y determine si ese entero existe en
el arreglo o no y en qué posición se encuentra del arreglo.
(Búsqueda secuencial en arreglos desordenados)
12. En un arreglo se almacenan las calificaciones finales de N
alumnos. Escriba un programa que calcule e imprima:
13. Diseñe un programa que lea las estaturas de un grupo de 1 O
personas y determine:
a~ La estatura promedio.
b" La estatura máxima y la estatura mínima.
e" el número de personas con una estatura menor que l. 60 m.
d." el número de personas con una estatura mayor que 1.70 m.
15." Diseñar un programa que defina un arreglo de 20 elementos
formados por enteros y luego ingrese 1 O enteros cualquiera y
luego ingrese un nllinero x, y luego lo elimine. (eliminar en
arreglos desordenados)
;J)} Página: 32
16.-Diseñar un programa que defina un arreglo de 20 elementos
formados por enteros y luego ingrese 1 O enteros cualquiera y
luego ingreseun niunero y, luego lo inserte. (insertar en arreglos
desordenados).
6.3.3 Arreglos bidimensionales o matrices.
Los Arreglo bidimensional, también conocidas como matriz.
Utiliza índices (filas y columnas), los índices de la primera posición
lógica [0](0] y usa dos pares de corchetes [fila] [columna].
Sintaxis:
Tipo de datos nombre [ ] [ ]
Ejemplo: 10.
Diseñar un programa que ingrese una matriz de enteros de 6 x 5 y
determine el mayor elemento de cada fila y el mayor elemento de
cada columna.
#include<conio.h>
#include<conio.h>
#include<conio.h>
float mat[6][5];
int ij;
void ingreso();
void fila();
void columna();
voidmain(){
ingreso(),
fila();
columna();}
for(i=O;i<6;i++ ){
for(j=O;j<6;j++ ){
count<<"ingrese el numero en orden:";
Página: 33
cin>>mat[i][j]
}}} void fila(){
int aux;
for(i=O;i<6;i++ ){
aux2=mat[i][O];
for(j=Oj<6; j++ ){
if (mat[i][j])>aux)
aux2=mat[i][j];
}
cout<<"en la fila n"<<(i+ l)<<"el mayor "<<aux<<endl;
}} void columna(){
int aux2;
}
for(j=O;j<6j++ ){
aux2=mat[O][j];
for(i=Oij<6; i++ ){
if (mat[i][j])>aux2)
aux2=mat[i][j];
cout<<"en la fila n"<<(j+ l)<<"el mayor "<<aux2<<endl;
}} Ejemplo 11.
Escribir un procedimiento que realice el cálculo de los salarios
semanales de los empleados de una empresa, sabiendo que estos se
calculan en base a las horas semanales trabajadas y de acuerdo a un
precio especifico por cada hora. Si se pasan de 40 horas semanales,
las horas extraordinarias se pagaran a razón de l. 5 veces las hora
ordinaria. Con pase de referencia.
Solución:
#include<iostream.h>
#include<math.h>
Página: 34
#include<conio.h>
float calcularsalario(float HT,float PH,float HE);
main() {
float ht,ph,he,sal;
int resp=O;
clrscr();
do {
cout<<"\n ingrese el pago por hora trabajada: ";cin>>ph;
cout<<"\n ingrese el número de horas semanales trabajadas: ";cin>>ht;
if(ht>40)
{he=ht-40;
ht=40;}
else
{he=O; }
sal=calcularsalario(ht,ph,he);
cout<<"\n el salario es: "<<sal;
cout<<"\n desea seguir (l=si,2=no) \n";
cin>>resp;
}
while( resp= 1 );
getch();
retum O;
}
float calcularsalario(float HT, float PH,float HE)
{
retum ( (PH*HT)+( l. 5 *PH*HE));
}
Página: 35
Ejemplo 12.
Crear un algoritmo que pennita ingresar la base y la altura y permita hallar
su área del rectángulo (función sin pase de parámetros)
#include<iostream.h>
#include<conio. h>
#include<math.h>
float a~
void ingreso()~
void salida();
voidmain()
{ingreso();
salida();
getch()~
}
void ingreso()
{float b,h;
cout<<"lngrese la base del rectángulo:";
cin>>b;
cout<<"Ingrese la altura del rectángulo:";
cin>>h;
a=b*h;
}
void salida()
{
cout<<"El área del rectángulo es: "<<a<<endl;
}
Ejemplo 13:
//Cálculo de personas que miden más que la media y menos que la media -
arreglo unidimensional
#include <iomanip.h>
#include <iostream.h>
Página: 36
int i,masmedia,menosmedia;
float matriz[S],media;
void ingreso();
void calculo();
main(){
ingreso();
calculo();
return O;
}
void ingreso()
{
media=O;
for(i=O;i<S;i++)
{
cout<<"Ingrese estatura de persona N "<<(i+ 1 )<<":\n";
cin>>matriz[i];
media+=matriz[i];
}
}
void calculo()
{
media/=5;
cout<<"\nLa estatura media es:"<<setiosflags(ios::fixed 1 ios::showpoint 1
íos ::left) <<setprecision(2)<<media<<"centimetros";
masmedia=O;
menosmedia=O;
for(i=O;i<S;i++)
{
if( matriz[ i]>media)
masmedia++;
el se
menosmedia++;
Página: 37
}
cout<<"\n\nEl número de personas más altos que la estatura media
es:"<<masmedia;
cout<<"\nEl número de personas más bajos que la estatura media
es:"<<menosmedia;
}
Ejemplo 14:
//Calcula la población nacional en una array bidimensional
#include <iostream.h>
main(){
intij;
longint depart[ 5] [3 ],pob _ dep,pob _ tot;
//ingreso
for(i=O;i<5;i++) {
cout<<"\nDepartamento N° "<<(i+ 1 )<<endl;
for(j=O;j<3;j++ ){
cout<<"Población de Provincia N° "<<(j+ 1 )<<":";
cin> >depart[ i] [j];
} } pob_tot=O;
//imprime poblacion 1 departamento
for(i=O;i<5;i++ ){
cout<<"\nPoblación del Departamento N° "<<(i+1)<<":";
pob_dep=O;
for(j=O;j<3;j++) {
pob _ dep+=depart[i][j];
}
cout<<pob _ dep;
pob _tot+=pob _ dep;
}
cout<<"\nPoblación Nacional: "<<pob _ tot;
return O;}
Página: 38
6.3.4 Ejemplo propuestos.
1) Diseñar un programa que ingrese una matriz cuadrada de 5 X 5
compuesta de letras del alfabeto y determine cuántas veces se
repite cada una de las 5 vocales.
2) Diseñar un programa que ingrese una matriz de enteros de 4 x 5
y determine la suma total de sus elementos.
3) Almacenar las notas de 5 alumnos correspondientes a 4
intervenciones (PO,PE,TR, LAB) en una matriz bidimensional; ·
calcular el promedio de cada alumno y luego mostrar dichos
promedios.
4) Diseñar un programa que ingrese una matriz de enteros de 6 X 5
y determine el mayor elemento de cada fila y el mayor elemento
de cada columna.
5) Diseñar un programa que lea el siguiente arreglo bidimensional:
4 7 1 3 5
2 o 6 9 7
3 1 2 6 4
y lo imprima como:
4 2 3
7 o 1
1 6 2
3 9 6
5 7 4
6) Diseñe un programa que ingrese una matriz cuadrada de orden
N*N y determine la suma de los elementos de la diagonal
principal.
Página: 39
7) Usando funciones Diseñar un programa que rellene un arreglo
bidimensional A de 4 filas por 5 columnas. Determine luego la
suma de los elementos de cada fila y de cada columna y guarde
los resultados en dos arreglos B y C, el primero para la suma de
las filas y el segundo de las columnas. Luego imprima el
arreglo A y al costado de cada fila (a la derecha) el valor de la
suma de los elementos de cada fila y debajo de cada columna el
valor de los elementos de cada columna. Así la matriz A es:
4 5
2 1
6 4
1 4
6
2
7
5
7
8
2
9
1
6
8
o
entonces debería imprimir:
4 5 6 7 1
2 1 2 8 6
6 4 7 2 8
1 4 5 9 o
13 14 20 26 15
23
19
27
19
8) Se tienen los costos de producción de tres departamentos
(dulces, bebidas y conservas), correspondientes a los 12 meses
del año anterior.:
9) Escriba un algoritmo que pueda proporcionar la siguiente
información:
a) ingreso de datos
b) ¿Cuáles son los costos de producción total por cada mes?
10) Ejemplo: los costos de producción del mes de Enero serían: 120
+ 150 + 100 = 370
Página: 40
11) ¿Cuáles son los costos de producción total por cada
Departamento?
12) Se tiene una tabla con las calificaciones obtenidas por 30 ·
alumnos en 6 exámenes diferentes:: (Grabar como pc5-28)
13) Por medio de un arreglo de doble subíndice, resuelva el
siguiente problema. Una compañía tiene 4 vendedores (1 a 4)
que venden 5 productos (1 a 5). Una vez por día cada vendedor
entrega una hoja por cada tipo de producto vendido. Las hojas
contienen:
a) El número del vendedor
b) El número del producto
e) El importe de las ventas de dicho producto en el día
14) Por lo tanto, cada vendedor entrega entre O a 5 hojas de ventas
por día. Suponga que están a la mano las hojas de información
de las ventas del último mes. Escriba un programa que tome
como entrada esta información y resuma las ventas totales por
vendedor y producto. Todos los totales deben almacenarse en el
arreglo de doble subíndice sales. Tras procesar la información
del último mes, imprima el resultado en forma de tabla; que
cada columna represente un vendedor y cada fila represente un
producto. Totalice cada fila para obtener las ventas totales por
producto; totalice cada columna para determinar las ventas
totales por vendedor. La impresión tabular deberá incluir estos
totales a la derecha de las filas y al fmal de las columnas.
6.4 CAPÍTULO IV: CADENAS
Es un tipo de dato conpuesto, un array de caracteres(char), terminado por
un carácter nulo.
Declaración de variables de una cadena, se declaran como los restantes de
tipo de array, el operador postfijo [] contiene el tamaño del objeto. El tipo
base, naturalmente, es char, o bien unsigned char:
Página: 41
Char text[50];
Char order[80];
Ejemplo:
#include<iostream.h>
#include<conio.h>
#include<stdio.h>.
voidmain(){
char ejemplo[]="abcd";
for(int i=O;i>5;i++){
count <<"ejemplo["<<i<<="<<ejemplo[]<<"\n";
}}
6.4.1 Tipos de funciones de cadenas.
a) Strcpy.- copia en la cadena nombre y añade un carácter nulo al
final de la cadena resultante.
Ejemplo 15:
#include<iostream. h>
#include<conio.h>
#include<stdio.h>
main(){
char text[lOO]="curso de lenguaje de programación";
char ejemplo[lOO];
strcpy( texto,ejemplo );
strcpy(texto+ l,"mr. e++");
count<<text<<texto<<end;
b) StrlenQ.- calcula el número de caracteres del parámetro
cadena, incluyendo el carácter nulo de detenninación de la
cadena.
Ejemplo 16:
#include<iostream.h>
·Página: 42
#include<conio.h>
#include<stdio. h>
main(){
char text[]="abcdef';
count< <"strlen("<<texto< <")=<<strlen( texto)< <end;
count<<"strlen("<<\n<<")=<<strlen(" ")<<end;
char buffer[ SO];
count< <"introduzca la cadena:";
cin>>buffer;
count< <"strlen("< <buffer<<")=< <strlen(buffer )< <end;
}
e) Stricmp.- compara las cadenas cadl y cad2 sm haber
distinción entre mayúsculas y minúsculas.
d) Strncmp.- compara los números caracteres mas a la izquierda
de las dos cadenas cadl y cad2.
e) Strupr.- convierte las letras mayúsculas de una cadena a
mayúsculas.
t) Strlwr.- convierte las letras mayúsculas de una cadena a
minúsculas
g) Atoi.- convierte una cadena· a un valor entero.
h) Atof.- convierte una cadena a un valor de coma flotante.
6.4.2 Problemas propuestos.
l. Escribir un programa que permita; contar el numero el número
de ocurrencias de la letra e.
2. Escribir un programa que permita leer una secuencia de
nombres, uno por líneas terminado por un valor centinela 'S'
3. Escribir un programa que permita; ingresar por teclado los
nombres y dirección. Convertir a mayúscula
Página: 43
6.5 CAPITULO V: FUNCIONES
6.5.1 Funciones.
La programación modular divide el problema en módulo (rutinas pequeñas
denominadas funciones). Cada programa contiene un módulo Principal que
controla todo lo que sucede, este transfiere el control a los submodulos para
que puedan ejecutar sus funciones.
Por ejemplo, si está escribiendo un programa que obtenga una lista de
caracteres del teclado, los ordene alfabéticamente y los visualice a
continuación en la pantalla, se pueden escribir todas estas tareas en un único
gran programa (función main ()).
Ventajas:
• Es sencillo de escribir y depurar.
• Se puede cambiar un módulo, sin afectar a los otros.
• Permite chequear solo donde hay problemas.
• Primero son chequeadas las interfaces principales.
Conjunto de Instrucciones cuya ejecución se lleva a cabo cada vez que es
Invocada cuando termina la ejecución de la función, se retoma al punto de
llamada, para continuar con las siguientes instrucciones. Todas las
funciones, menos las de tipo void, devuelven un valor.
6.5.2 Nombre de una función.
Comienza con una letra o un subrayado ( -) y puede contener tantas
letras, números o subrayados como desee. El compilador ignora, sin
embargo, C es sensible a mayúsculas, lo que significa que las letras
mayúsculas y minúsculas son distintas a efectos del nombre de la
función.
int max (int x, int y); 1 *nombre de la función max * 1
double media ( double xl, double x2); 1 * nombre de la función media
*/
double MAX (int* m, int n); 1 * nombre de función MAX, distinta de
max * 1
Página: 44
6.5.3 Tipo de dato de retorno.
Si la función no devuelve un valor int, ·se debe especificar el tipo de dato
devuelto (de retorno) por la función~ cuando devuelve un valor int, se puede
omitir ya que por defecto el e asume que todas las funciones son enteras, a
pesar de ello siempre conviene especificar el tipo aun siendo de tipo int,
para mejor legibilidad. El tipo debe ser uno de los tipos simples de e, tales
como int, char o float, o un puntero a cualquier tipo e, o un tipo s t ruc t.
int max(int x, int y) /* devuelve un tipo int * 1
double media(double xl, double x2) 1 *devuelve un tipo double */
float funcOO { .. .I /* devuelve un float * 1
char funcl() { ... } 1 * devuelve un dato char * 1
int *func3 () { ... } 1 * devuelve un puntero a int * 1
char *func4() { .. .I 1 * devuelve un puntero a char * 1
int func5 (1 l.. .} 1 *devuelve un int (es opcional)*/
Si una función no devuelve un resultado, se puede utilizar el tipo void, que
se considera como un tipo de dato especial. Algunas declaraciones de
funciones que devuelven distintos tipos de resultados son:
int calculo-kilometraje(int litros, int kilometros);
char mayusculas( char car);
float DesvEst ( void) ;
struct Infopersona BuscarRegistro( int num-registro );
Muchas funciones no devuelven resultados. La razón es que se utilizan
como subrutinas para realizar una tarea concreta. Una función que no
devuelve un resultado, a veces se denomina procedimiento. Para indicar al
compilador que una función no devuelve resultado, se utiliza el tipo de
retomo void, como en este ejemplo:
void VisualizarResultados(float Total, int num-elementos);
Si se omite un tipo de retorno para una función, como en
VerResultados(float Total, int longitud)~
Página: 45
6.5.4 Parámetros de una función.
Para que una función devuelva un valor a través de un argumento hay que
pasar la dirección de la variable, y que el argumento correspondiente de la
función sea un puntero, es la forma de conseguir en C un paso de parámetro
por referencia. Esta sección examina el mecanismo que C utiliza para pasar
parámetros a funciones y cómo optimizar el paso de parámetros,
dependiendo del tipo de dato que se utiliza.
Suponiendo que se tenga la declaración de una función circulo con tres
argumentos.
void circulo(int x, int y, int didmetro);
Cuando se llama a circulo se deben pasar tres parámetros a esta función. En
el punto de llamada cada parámetro puede ser una constante, una variable o
una expresión.
Ejemplo 17. De una función sin pase de parámetros.
calcula el area de void ingreso()
1 /la esfera {real r
real a
void ingreso();
void salida();
principal
{
Leerr
a=4* 3.14.16 *r *r;
}
void salida()
{
ingreso();
salida();
Imprimir "El área de esfera es:" a
Ejemplo 18:
include<iomanip.h>
#include<iostream.h>
#include<ctype.h>
#include<stdlib.h>
void cuadrado();
void rectangulo();
}}
Página: 46
main(){
char e~
for(;;){ system("cls ");
do{
cout<<"\n\nCalculo de Areas de figuras geometricas"<< endl~
cout<<"\n(C)uadrado ";
cout< <"\n(R )ectangulo" ~
cout<<"\n(T)erminar";cout<<"\nlngrese Opción: ";cin>>c; c=toupper(c); }
while(c!='C' && c!=R' && cl='T');
switch(c) {
case 'C':cuadrado();break;
case 'R':rectangulo();break;
case 'T':return(O);
} } }
void cuadrado(){int lado,ac;cout<<"\nlngrese el
lado:"~cin>>lado;ac=lado*lado;cout<<"\nEl area del cuadrado
es:"<<ac~}void rectangulo(){
int base,alto,ar~
cout<<"\nlngrese base:"<<endl~cin>>base;
cout<<"lngrese alto:"<<~ndl;cin>>alto;
ar=base*alto;
cout<<"El area del triangulo es: "<<ar;
}
Página: 47
Ejemplo 19: De una función sin pase de parámetros.
#include<iostream. h>
float areaesfera(float radio);
main(){
double M _PI=3.1416,r,a;nlngrese radio de la esfera:"; cin>>r;
a=areasesfera(r );
cout<<"\nEl area de la esfera es:"<<a;
getch();
cout<<"\nlngrese radio de la esfera:"; cin>>r;
a=areasesfera( r );
cout<<"\nEl area de la esfera es:"<<a;
getch();
return O;
.}
/* definicion de la funcion
float areaesfera( float radio)
{
return 4*M _Pl*radio*radio;
}
Ejemplo 20: Una función parámetros por referencia. Que calcula el área y
perímetro de un rectángulo.
Solución:
#include<iostream.h>
#include<iomanip.h>
void rectangulo(float ancho, float alto, float &area, float &perim);
/*funcion principal*/
voidmain()
{
float Area, perimetro, Ancho, Alto;
cout<<"area y perímetro de un rectangulo\n";
cout<<"lngrese el ancho:"; cin>>Ancho;
Página: 48
}
cout<<"Ingrese la altura:"; cin>>Alto;
rectangulo(Ancho, Alto, Area, perímetro);
cout<<"el area es: "<<setprecision(2)<<Area<<endl;
cout<<"el perímetro es: "<<setw(2)<<perimetro;
/* el retorno es void porque no vamos a retornar nada* 1
void rectangulo(float ancho, float alto, float &area, float &perim)
{ area= ancho*alto;
perim=2 *(ancho+ alto);
}
6.5.5 Ejemplos propuestos:
l.-Escribir un procedimiento que realice el cálculo de los salarios
semanales de los Empleados de una Empresa, sabiendo que estos
se calculan en base a las horas semanales trabajadas y de acuerdo
a un precio especificado por cada hora. Si se pasan de 40 horas
semanales, las horas extraordinarias se pagarán a razón de l. 5
veces las hora ordinaria. (Función con pase de parámetros)
2.-Escribir un programa que mediante un procedimiento acepte un
número de día, mes y año y lo visualice en el formato:
dd/mm/aa.
Ejemplo, los valores 8,10 y 1946 se visualizan domo
8/10/46 (función con pase de parámetros)
3.-Hacer una función que Ingrese 3 números, y encuentre el mayor
de ellos. (Función con pase de parámetros por valor).
4.-Escribir un programa que permita al Usuario elegir, el cálculo del
área de cualquiera de las figuras geométricas: círculo, cuadrado,
rectángulo o triángulo, mediante funciones. (Función sin pase de
parámetros)
5.-Diseñar una función que calcule la media de 3 números leídos por
teclado. (Función con pase de parámetros por valor).
Página: 49
6.-Escriba una función vol ( r) que devuelva el volumen de una
esfera de radio r, dado por: 4/3*PI*r3 ; (función con pase de
parámetros por valor).
?.,.Usando programación modular diseñe un programa que calcule el
área y el perímetro de un rectángulo. (Función sin pase de
parámetros).
6.6 CAPITULO VI: ESTRUCTURAS
6.6.1 Estructuras.
Una estructura contiene múltiples variables que pueden ser de
diferente tipo. Cada componente individual de una estructura se
denomina miembro, cada miembro o elemento de la estructura puede
pertenecer a diferentes tipos de datos. Si la infonnación que se
almacena es CLIENTE (Nombre, Dirección, DN1, RUC, Telefono ).
Se puede observar que está compuesto por 5 campos. Solamente
faltaría definir qué tipo de dato corresponde a cada miembro.
Declaración de una Estructura.
La declaración solamente especifica el nombre y la composición de
los datos, pero no almacena la información en la memoria. Es un tipo
de dato definido por el usuario que se debe declarar antes de que se
pueda utilizar.
SINTAXIS:
Struct <nombre de la estructura>{
Tipo de dato miembro 1 nombre miembro 1;
Tipo de dato miembro 2 nombre miembro 2;
};
Ejemplo 21:
Struct cliente{
Char nombre[30]
Char dirección[20]
Página: 50
Char RUC[ll];};
a) Definición de variables de tipo estructura
Al definir una variable para una determinada estructura, esta
reserva un área de memoria donde los datos se podrán
almacenar de acuerdo al formato especificado en la declaración
de la estructura.
Se puede definir una estructura de dos formas:
Primera forma.-Definiéndolas después de la llave de cierre de
la declaración de la estructura.
Struct <nombre de la estructura>
{
Tipo de dato miembro 1 nombre miembro1;
Tipo de dato miembro 2 nombre miembro 2;
Tipo de dato miembro n nombre miembro n;
} <nombre de la variable>;
Ejemplo 22:
struct cliente {
char nombre[30];
char dirección[20];
char ruc[ll];
} cliente _1;
Segunda forma.- Listando el nombre de la estructura seguida
por las variables correspondientes en cualquier parte del
programa:
Struct <nombre de la estructura>{
Tipo de dato miembro 1 nombre miembro1;
Tipo de dato miembro 2 nombre miembro 2;
Tipo de dato miembro n nombre miembro n;
} ;
Página: 51
<nombre de la estructura> <nombre de la variable>;
Ejemplo 23:
struct cliente
{
char nombre[30];
char dirección[20];
char ruc[ll];
} cliente cliente _1;
b) Acceso a los Miembros de una Variable Estructuras
Para acceder a los miembros de una estructura, podemos hacerlo
con algunas de estas dos formas: utilizando en operador
punto(.) o operador(->).
Sintaxis:
Utilizando el operador punto(.)
<nombre de la estructura>. <nombre de la variable>=datos;
Ejemplo 24:
struct cliente {
char nombre[30];
char dirección[20];
char ruc[ll];
} cliente;
intmain(){
strcpy( Cliente.nombre, "Agustín Cervantes");
strcpy(Cliente.direccion,"Av. Proceres de la ind. 456");
strcpy(Cliente.RUC,"Juan Valverde");
strcpy(Cliente.nombre,"10666612027");
ReturnO;}
Página: 52
Ejemplo 25:
Realizar un programa que utilice una estructura alumno con los
respectivos campos (código, curso, notal, nota2, nota3 y
promedio). se debe ingresar las 3 notas y calcular el promedio.
#include<iostream.h>
#include<conio.h>
#include<iomanip.h>
int main(){
struct alumno{
int codigo;
char curso[30];
int notal;
int nota2;
int nota3;
float promedio;
} ; alumno alumnosec;
cout< <"ingrese curso:"; cin. getline( alumnosec.curso,31 );
cout<<"ingrese notal :"; cin>>alumnosec.notal;
cout<<"ingrese nota2:"; cin>>alumnosec.nota2;
cout<<"ingrese nota3:"; cin>>alumnosec.nota3;
alumnosec. promedio=( alumnosec.notal + alumnosec.nota2+
alumnosec.nota3)/3;
cout<<"\nel promedio del alumno es: "<<alumnosec.promedio;
cout<<"\nel tamaño de la variable alumnosec en bytes es";
cout< <sizeof( alumnosec );
getch();
retum o;
}
e) Estructuras Anidadas.
Es cuando varias estructuras contengan entre sus miembros
datos similares, se suele utilizar un tipo de declaración de
estructura que ahorra tiempo al escribir un programa, y sobre
Página: 53
todo espacio en memoria, declarando una estructura dentro de la
otra.
Ejemplo 26:
Declarar una estructura Fecha_edicion, Datos_libros, que utiliza
como uno de sus campos a la estructura Fecha_ edicion.
Finalmente la estructura Libro donde uno de sus campos es la
estructura Datos libros.
Fecha_ edicion( dia, mes, año)
Datos _libro( nombre,autor,editorial,fecha
fecha_edicion)
Libros(Datos _libros instancia de Datos _libro)
instancia de
Realizar el ingreso y listado de datos (utilizar los manipuladores
de salida).
#include<iostream.h>
#include<conio.h>
#include<iomanip.h>
struct Fecha edicion
{
};
int dia;
int mes;
int anyo;
struct datos libro
{
char nombre[40];
char autor[30];
char editorial[30];
fecha_ edicion fecha;
'. J '
struct libro
{
datos _libro.datos _libros;
Página: 54
double costo~
};
int main(){
libro lib;
cout<<"\nnombre del libro ... :";
cin.getline(lib.datos _libro.nombre,51 );
cout<<"\nnombre del autor. .. :";
cin.getline(lib.datos _libro.autor,31 )~
cout<<"\nnombre del editorial...:";
cin.getline(lib.datos _libro.editorial,31 );
cout<<''\n\nfecha de edicion dellibro\n";
cout<<"dia:"; cin>>lib.datos_libro.fecha.dia;
cout< <"mes:"; cin>>lib.datos _libro.fecha.mes;
cout<<"año:"; cin>>lib.datos _libro.fecha.anyo;
cout<<"\n\n listado de datos \n";
cout< <" ----------------------------\n \n";
cout<<setiosflags(ios::left); // arg.modo de entrada a la
alineacion
cout<<setw(20)<<''libro";
cout<<setw(20)<<''autor";
cout<<setw(20)<<''editorial";
cout<<setw(20)<<''fecha edicion\n\n";
cout< <setw(20 )<<''lib. datos _libro.nombre;
cout<<lib.datos _libro. fecha. dia;
cout< <"f' < <lib.datos _libro. fecha. mes;
cout< <"f' < <lib.datos _libro. fecha.anyo;
cout<<endl;
getch();
retum O;}
ejemplo:
#include<conio.h>
#include<stdio. h>
Página: 55
#include<iostream. h>
#include<string. h>
void main( ){
int b;
char reps;
int tam, stockfinal,prodsacar;
char prodsolicitado[lO];
struct empresa {
char codprod [5];
char nomprod[15];
char descprod[25];
float cantprod;
float precprod;
float stockseg;
}producto[3];
cout<<"escribir los siguientes datos:\n";
for(int i=O;i<2;i++)
{
cout <<"codigo del producto :";gets(producto [i].codprod);
cout<<" nombre del producto:" ;gets ( producto[i].nomprod);
cout< <"descuento del productyo:" ;gets(producto[ i]. descprod);
cout<<"precfio del producto:"; cin>> producto[i].cantprod;
cout<<"precio del producto:"; cin>> producto[i].precprod;
cout<<"stock del producto:"; cin>> producto[i].stockseg;
cout<< endl<< endl;
}
clrscr();
gotoxy(1,2);cout<<"codigo";
gotoxy( 15,2 );cout< <"nombre";
· gotoxy(30,2);cout<<"dsct";
gotoxy( 45,2);cout<<"cant";
gotoxy(60,2);cout<<"prec";
Página: 56
gotoxy(75,2);cout<<"stock";
cout < < "-------------------.,---------------------------\n";
for( int j=O;j<2;j++ ){
gotoxy( 1,j+4);cout<<producto [i].codprod;
gotoxy( 15 ,j+4 );cout< <producto [i]. nomprod;
gotoxy(30,j+4);cout<<producto[i].descprod;
gotoxy(45j+4);cout<<producto[i].cantprod;
gotoxy(60,j+4);cout<<producto[i].precprod;
gotoxy(75j+4);cout<<producto [i].stockseg;
}
cout<<"\n\nresponder las siguientes preguntas:\n:";
do
{
cout<<"escriba el nombre de producto:\n";gets(prodsolicitado);
cout << endl<< endl;
cout<<"escriba la cantidad que va ha sacar:";
cin> >prodsacar;cout< <endl;
for(int k=O;k<3;k++)
{
if( strcmp(producto[k]. nomprod,prodsolicitado )=O);
{
tam=k;}}
stockfinal=producto[tam] .cantprod-prodsacar;
if(stockfinal<producto[tam].stockseg)
Ejemplo 27:
/*cade 1 O lee un arreglo de cadenas y cuenta el numero de
vocales usando toupper-Ctype.h* 1
#include<stdio. h>
#include<string.h>
#include<iostream. h>
#include<ctype.h>
voidmain(){
Página: 57
int i=O,vocales=O,Otros=O;
clrscr();
char s[80]; /*separa un arreglo de caracteres*/
cout<<"\n Ingrese cadena:";
gets( s );/* lee una cadena del teclado * 1
while(s[i])
{
s[i]=toupper( s[ i]);
switch(s[i]) {
case 'A': ++vocales;break;
case 'E': ++vocales; break;
case 'I': ++vocales;break;
case '0': ++vocales;break;
case 'U': ++vocales;break;
case ' ': break;
default: ++Otros;
}
++i; }
cout<<"vocales: "<<vocales<<endl;
cout<<"Otros : "<<Otros<<endl; }
6.6.2 Ejemplos propuestos.
l. Hacer un programa que mediante un arreglo de estructuras
ingrese:
Nombre, Sueldo de 5 personas, y luego muestre los sueldos de
las personas que ganan más de 2000.
2. Diseñar un programa que ingrese los datos (nombre, codigo,
edad y sexo) de 5 empleados de una compañía e imprima la
lista de empleados ordenados alfabéticamente por el nombre.
3. Un array de estructuras contiene la descripción de personas
para efectos estadísticos. Cada estructura tiene los campos:
Página: 58
Nombre, edad, sexo, altura, color de piel, color de OJOS,
nacionalidad Escribir un programa que mediante un menú
realice.
Lea y almacene datos en este array, ordene el array por orden
alfabético de nombres imprima su contenido.
4. Desarrolle un programa, que presente el sgte menú:
a.- introducir notas
b.-Listar promedio final por pantalla
c.- Salir
Donde la estructura de los datos es la sgte:
codigo (int)
nombre char[30]
parcial (int)
final (int)
trabajo (int)
Y PF= (parcial + final + trabajo) /3
Asuma que el nro máximo de alumnos es 30.~
5. Un médico almacena la siguiente información de sus pacientes:
nombre, dirección, teléfono, fecha última visita, si es o no
privado, si tiene alergias, y un campo de observaciones. Se
desea un programa con las siguientes opciones: Introducción
de registros interactivamente.
6. 7 CAPÍTULO VII: OBJETOS Y MÉTODOS.
6.7.1 Programación orientada a objetos
Cuando los proyectos crecen, con la programación estructurada la
programación se vuelve compleja. Como solución a este problema
nace la programación orientada a objetos, que se basa en conceptos
como: objetos, clases, polimorfismo y herencia. Una de las ventajas
Página: 59
de la programación orientada a objetos es el ahorro de código, a
través de la herencia.
Tipos de acceso
PRIVATE.- Cuando los miembros sólo son accesibles por los
miembros de la misma clase.
PUBLIC.-Los miembros son accesibles desde cualquier parte del
programa.
PROTECTED.-Se comportan como privados, pero los miembros
son accesibles por los miembros de las clases derivadas.
6. 7.2 Clases y herencia.
Se agrupa en una sola entidad tanto datos como funciones que
manipulan dichos datos. Por defecto todos los elementos definidos
en una clase son privados (PRIVATE).
Proporciona una plantilla con la que el programa puede crear objetos
similares.
Sintáxis:
class nombre_ clase {
datos y funciones privados
public:
datos y funciones públicos
}
· void nombre_ clase: :nombre_ funcionl ()
{ ...
}
Ejemplo 28:
class triangulo{private:
int ladol;
int lado2;
int lado3;
public: void inicializa();
void mostrar();};
Página: 60
void triangulo::inicializa() {
cout< <"lado 1:" ;cin> >lado 1;
cout<<"lado2:";cin>>lado2;
cout<<"lado3:";cin>>lado3;
};
6.7.3 Concepto de objetos
Es una instancia de una clase. Ej: Ud. es un objeto de la clase
alumno. Es la variable cuyo tipo de dato es una clase.
Es a través de los objetos que las ftmciones cobran vida,
produciéndose los mensajes.
Sintáxis
voidmain()
{nombre_ clase nombre_ objeto;
nombre_ objeto.nombre _función!();
nombre_ objeto.nombre _ función2();
}
Ejemplo 29:
class triangulo{
int lado1, lado2, lado3;
public:
void inicializa();
void mostrar();
};
void triangulo: :inicializa()
{
cout< <"lado 1: ";cin> >lado 1;
cout<<"lado2:";cin>>lado2;
cout<<"lado3:";cin>>lado3;
t· J '
void triangulo: :mostrar() {
float area,p,sp;
p=lado1+lado2+lado3; sp=p/2;
Página: 61
area=sqrt(sp*(sp-ladol)*(sp-lado2)*(sp-lado3));
cout<<"\n Area:"<<area<<" Perimetro:"<<p;
};
voidmain()
{ triangulo x;
x. inicializa();
x.mostrar();}
6.7.4 Constructores y destructores.
Los constructores, como los destructores, deben ser miembros de
clase públicos.
Sirven para inicializar los datos de los objetos (por defecto).
Es una función que se ejecuta automáticamente cada vez que se
crea un objeto de una clase específica.
Pueden aceptar argumentos, no está precedida por la palabra void,
usa el mismo nombre que la clase.
Una clase puede tener varios constructores, un constructor puede
estar sobrecargado.
Destructor:
Un destructor es una función miembro de una clase, que se utiliza
para eliminar un objeto de esa clase.
los programas no pueden pasar parámetros a una función
destructora.
La destructora tiene el mismo nombre que la clase, no es del tipo
void, va precedida por una tilde (-)y tampoco produce un valor.
Un destructor se utiliza generalmente para liberar la memoria
asignada dinámicamente.
Los objetos creados con el operador new son destruidos por el
operador delete. un destructor no puede estar sobrecargado.
Página: 62
EJEMPLO 30: Constructor con argumentos:
class triangulo{
intladol,lado2,lado3;
public:
triangulo(int ladl, int lad2, int lad3);
-triangulo( void);
void mostrar();
};
triangulo::triangulo(int ladl, int lad2, int lad3)
{ladol =ladl; lado2=lad2; lado3=lad3; } ;
triangulo::-triangulo(void) {
cout<<"destructor de triangulo de
lados:"<<ladol<<","<<lado2<<","<<lado3;
};
void triangulo::mostrar() (
float area,p,sp;
p=ladol+lado2+1ado3; sp=p/2;
area=sqrt( sp*( sp-lado 1 )*(sp-lado2)*( sp-lado3) );
cout<<"\n Area:"<<area<<" Perimetro;"<<p;
};
voidmain()
{triangulo x(6,6,6);
x.mostrar();
}
EJEMPLO 31: Constructor sin argumentos
class triangulo{
prívate:
int lado 1, int lado2, int lado3;
public:
triangulo();
-triangulo( void);
Página: 63
void mostrar();
};
triangulo::triangulo() ·
{ cout< <"lado 1 :";e in> >lado 1;
cout<<"lado2:";cin>>lado2;
cout<<"lado3:";cin>>lado3;
};
triangulo:: -triangulo( void)
{ cout<<"\n\ndestructor de triangulo"<<endl;
};
void triangulo: :mostrar()
{ float area,p,sp;
p=ladol+lado2+lado3; sp=p/2;
area=sqrt(sp*(sp-ladol)*(sp-lado2)*(sp-lado3));
cout<<"\nArea:"<<area<<" Perimetro:"<<p;
};
void main()
{ triangulo x;
x.mostrar();
}
EJEMPLO 32: constructores múltiples
class mensaje {
char mensaje_secreto[64];
public:
mensaje( char *mensaje_ del_ usuario);
mensaje(void);
void mostrar_ mensaje( void);
};
mensaje: :mensaje( char *mensaje_ del_ usuario) {
strcpy(mensaje_secreto, mensaje_ del_ usuario);}
mensaje::mensaje(void) {
Página: 64
strcpy(mensaje_secreto, "Hola mundo");}
void mensaje::mostrar_mensaje(void) {
cout <<"El mensaje es"<< mensaje_secreto << endl;}
void main(void) {
mensaje saludo;
mensaje libro("Exito con C++");
saludo.mostrar _mensaje();
libro.mostrar _mensaje();
}
EJEMPLO 33: destructora y constructora
#include <iostream.h>
#include <string.h>
#include <conio.h>
class película {
public:
void mostrar_pelicula( void);
película( char *nombre, char *principal, char *secundario);
~pelicula(void);
prívate:
char nombre[64];
char actor _principal [ 64 ];
char actor _secundario[64];};
void película: :mostrar _pelicula( void) {
cout << "Nombre de la película: " << nombre<< endl;
cout << "Estelarizada por: "<<actor _principal<<" y"<<
actor _secundario << endl << endl; }
pelicula::pelicula(char *nombre, char *actor _principal, char
*actor_ secundario) {
strcpy(pelicula: :nombre, nombre);
strcpy(pelicula: :actor _principal, actor _principal);
strcpy(pelicula: :actor _secundario, actor_ secundario);
Página: 65
}
pelicula::~pelicula(void) {
cout <<"Entra el destructor de pel¡cula para"<< nombre<< endl;
}
void main(void) {
clrscr();
película fugitivo("El fugitivo", "Harrison Ford",
"Tommy Lee Jones");
película sintonia("Sinton¡a de amor",
"Tom Hanks", "Meg Ryan");
}
fugitivo.mostrar _película();
sintonía. mostrar _película(); getch();
Página: 66
Vll. DISCUSIÓN
Para la elaboración del texto: "Texto: Lenguaje de Programación 1-C++" se ha
requerido de varias fuentes de verificación y bibliográficos que pennita establecer
las bases teóricas y prácticas para el desarrollo de problemas pequeños y
complejos; para diferentes tipos de empresas.
El texto está dirigido a estudiantes y docentes de nivel superior y universitario,
está orientado a promover una enseñanza equilibrada teórico-práctico, para el
dominio y manejo de las herramientas que se necesita para programar diversas
aplicaciones.
En conclusión se ha cumplido con el problema de investigación, con los objetivos
a desarrollar el texto: "Texto: Lenguaje de Programación 1-C++" tanto teórico
como práctico.
Página: 67
VIII. BffiLIOGRAFÍA
l. DEITEL, PAUL, cómo programar en C++ sexta edición ,México:
Pearson/Prentice Hall, Versión (2010),
2. DEITEL P. J/DEITEL H.M,, como programar en C++, México: editorial
Prentice Hall, Versión (2008)
3. JOY ANES AGUILAR, LIDS, fundamentos de programación algoritmos,
estructuras de datos y objetos, Madrid: Me Graw Hill, cuarta edición,
2008.
4. JOYANES AGUILAR, LIDS. Programación C++ algoritmos, estructuras
de datos y objetos, Madrid: Me. Graw. primera edición, 2000.
5. PANTIGOSO SIL VA, ROBERTO JAIME, programación en C++ 5.0,
lima: editorial megabyte E.I.R.L., 2002.
Página: 68
IX. APÉNDICE
Silabo de la Asignatura de Lenguaje de programación I, de acuerdo al Plan de
Estudios de la Escuela Profesional de Ingeniería de Sistemas de la Universidad
Nacional del Callao.
Página: 69
UNIVERSIDAD NACIONAL DEL CALLAO
FACULTAD DE INGENIERÍA INDUSTRIAL Y DE SISTEMAS
Escuela Profesional de Ingeniería de Sistemas - EPIS
SYLLABUS
l. INFORMACIÓN GENERAL
1.1 Nombre de la Asignatura : LENGUAJE DE PROGRAMACIÓN 1
1 . 2 Carácter
1. 3 Pre-requisito
1.4 Número de créditos
Horas semanales
Teoría
Laboratorio
l. 5 Ciclo Académico
1.6 Semestre Académico
2. SUMILLA
: Obligatorio
: Algoritmos y Estructuras de Datos.
Introducción a la Ingeniería de Sistemas.
:04
:Seis (06):
:02 Hrs.
:04 Hrs.
: Tercer Ciclo
: 2014-A
El curso pone énfasis en el aspecto lógico de la programación, especialmente en el
desarrollo de algoritmos que involucran modelos matemáticos de iteración y su
aplicación a resolver problemas de ingeniería y de gestión empresarial. Se
desarrolla el lenguaje de programación C++ e introduce en la programación
orienta~ a objetos.
Página: 70
3. OBJETIVOS ESPECÍFICOS
l. Desarrollar programas en seudocódigo.
2. Aplicar algoritmos y programas en C++ a la solución de problemas de
Ingeniería y de gestión empresarial.
3. Proporcionar al estudiante los conocimientos básicos sobre software de
programación y aplicar el mismo a la solución de problemas de ingeniería
de sistemas.
4. CONTENIDO PROGRAMÁTICO
SEMANA 1
Programación en C++. Introducción a la programación en C++.
SEMANA2
El entorno integrado de desarrollo. Programas en pseudocodigo. Diagramas de
flujo. Estructura de un programa en C++.
SEMANA3
Elementos de un programa. Tipos de datos. Elementos de entrada- salida y
operadores.
SEMANA4
Estructura de selección. Sentencia if e if-else. switch. exit.
SEMANA5
Estructura de Control en C++. Sentencia while, do while, for.
SEMANA6
Estructura de datos. Datos tipo array. Array unidimensional, bidimensional,
N dimensional.
SEMANA 7
Programación modular en C++. Funciones. Tipos.
PRACTICA CALIFICADA
SEMANA&
EXAMEN PARCIAL
SEMANA9
Librerías propias en C++.
Página: 71
SEMANA 10
Datos tipo cadena. Ejercicios.
SEMANA 11
Datos tipo puntero. Ejercicios
SEMANA 12
Estructuras. Datos Tipos de Registro.Ejercicios.
SEMANA13
Estructuras anidadas. Ejemplos.
Práctica calificada.
SEMANA 14
Introducción a la Programación orientada a objetos. Conceptos orientados a
objetos.
SEMANA 15
Abstracción de datos. Herencia. Polimorfismo. Clases. Ejercicios
SEMANA 16
Archivos, Aplicaciones.
PRACTICA CALIFICADA
SEMANA 17
EXAMEN FINAL
5. SISTEMA DE ENSEÑANZA- APRENDIZAJE
El presente curso está diseñado para exponerse y desarrollarse en diecisiete
semanas, para ello se empleara lectura de textos y revistas especializadas en
el software C++. El docente expondrá y será un conductor del aprendizaje.
La participación del alumno es fundamental, por lo que en cada sesión
presentara un avance del trabajo de Laboratorio asignado.
6. EQUIPOS Y MATERIALES REQUERIDOS
Se utilizara Microcomputador Pentium o similar, Sistema Operativo Windows y
Software de programación C++.
Página: 72
7. SISTEMA DE EVALUACIÓN
Examen Parcial
Examen Final
Práctica Calificada
:E.P. Peso 1
: E.F. Peso 1
: PC Peso 1
Promedio Laboratorios :PL. Peso 2
Promedio Final E.P. + E.F + PC. + 2P.L.
5
Si Promedio Final del Curso >=10.5 alumno aprobado.
8. BffiLIOGRAFÍA
l. CHRIS H. PAPPAS/WILLIAM H. MURRA Y,
KRIS JAMSA, Aprenda C++, Computec.
BorlanD C++ 4/4.5,
2. DEITEL PAUL J., C++ como programar sexta edición, México: Pearson
educación, 2009.
3. DEITEL P. J/DEITEL H.M , como programar en C++, México: editorial
Prentice Hall, Versión (2008)
4. LUIS JOY ANES AGUILAR, C++ a su alcance. Un enfoque orientado a
objetos. Ed. Me. Graw Hill 2008.
5. DEITEL H. M.,Programación en "C". Prentice Hall, C # . Net,Erika
Alarcón Herrera. Megabyte.
6. JOYANES AGUILAR, LUIS, Programación en C, C++, Java y UML,
México: Me Graw Hill, 2010.
Página: 73
X. ANEXOS
10.1 Que es la programacion orientada a objetos.- Es un metodo de
implementacion en el que los problemas se organizan como colecciones
cooperativas de objetos, cada uno de los cuales representan mas instancia de
alguna clase, y cuyas clases son todas miembros de una jerarquía de clases
unidas mediante relaciones de herencia. (Aguilar, 1999)
Encapsulamiento.- Existen datos y procedimientos que actúan sobre esos
datos. No hay una relación aparente entre datos y procedimientos
(funciones) y esta relación se establece de manera más o menos pecisa de
acuerdo a la profesionalidad del programador.
• Estado -----------> Propiedades
• Comportamiento ---> Métodos
La programacion orientada a objetos en e++, los datos y los procedimientos
que los gestionan están relacionados explícitamente y se "encapsulan" en un
objeto. La especificación de las propiedades de un objeto y los métodos de
acceso se realiza en la declaración de la clase de la que se va a destruir.
Herencia.-Cuando una clase hereda de otra, la clase derivada incorpora
todos los miembros de la clase base además de los suyos propios. La
herencia es una herramienta muy importante en muchos aspectos del
desarrollo de aplicaciones:
• Organización del diseño.
• Reusabilidad de clases (propias o no).
• Mejora del mantenimiento.
Clases Abstractas.- Es una clase que no está completamente especificada
posee métodos sin implementar, por lo tanto no se pueden crear instancias
de la misma. Una clase abstracta se usa para servir de clase base a otras
clases. En terminología C++ se dice que una clase abstracta es aquella que
posee al menos un método virtual puro.
Página: 74