“programación orientada a objetos en c++”

Notas de Clase

Lenguaje de Programación I

“Programación Orientada a Objetos en C++”

Carlos Alberto Vanegas

Ingeniero de Sistemas

Especialista en Ingeniería de Software

Magíster en Ingenieria de Sistemas

Profesor Universidad Distrital - Facultad Tecnológica

Rocío Rodríguez Guerrero

Ingeniera de Sistemas

Especialista en Ingeniería de Software


Sonia Pinzón

Ingeniera de Sistemas

Especialista en Educación Tecnológica


Universidad Distrital

Francisco José de Caldas

Facultad Tecnológica - Sistematización de Datos

Lenguaje de Programación I - Programación Orientada a Objetos en C++ 2


INTRODUCCIÓN

Desde hace más de 50 años, los programadores de computadores han diseñado e

implementado aplicaciones que resuelven los problemas del mundo real, es decir, han

tenido que realizar un proceso de abstracción en donde representan las situaciones

cotidianas en modelos computacionales, pero en el transcursos de este tiempo se han creado

paradigmas de programación que facilitan esta labor.

Hoy en día el paradigma de Programación Orientada a Objetos ofrece nuevas alternativas

que permiten abstraer y conceptualizar mejor la realidad, mediante la unión e interacción de

elementos más simples (objetos) facilitando la creación de software de calidad, que

potencian el mantenimiento, la extensión y la reutilización del código existente. Esta

programación trata de amoldarse al modo de pensar del hombre y no al de la máquina. Esto

es posible gracias a la forma racional con la que se maneja la abstracción que representa a

las entidades del dominio del problema.

El enfoque que presenta la Programación Orientada a Objetos permite diseñar aplicaciones

comerciales, educativas, financieras como: Sistemas de Información, Diseño de Interfaces

Gráficas, Desarrollo Web, entre otros, rereflejando la realidad en un mayor porcentaje que

los otros paradigmas de programación.

Inicialmente se hará una breve descripción de los conceptos que involucran este paradigma,

luego se abordarán los principios fundamentales como: encapsulamiento, herencia,

polimorfismo, sobrecarga de operadores, entre otros; utilizando ejemplos codificados en el

lenguaje de programación C++. Todos los ejemplos fueron compilados y ejecutados sobre

el sistema operativo windowsX (a excepción de Windows Xp) y se utilizo el programa

Turbo C++, cabe anotar que los programas se podran compilar y ejecutar desde el sistema

operativo Linux, pero sin incluir la librería conio.h y las funciones asociadas a esta, para

ello se utiliza el compilador de C para Linux gcc.

Este material será de gran ayuda para los estudiantes que quieran incursionar en la

Programación Orientada a Objetos dado que los conceptos manejados están expresados en

un nivel básico, que facilita la comprensión de los temas tratados.


PROGRAMACIÓN ORIENTADA A OBJETOS (POO)

Es un paradigma de programación1, que permite desarrollar soluciones computacionales

utilizando componentes de software (objetos), permitiendo descomponer fácilmente un

problema en varias partes relacionadas, que a su vez se reutilizan, haciendo mas eficaz la

tarea de programar y más robusta la aplicación desarrollada.

Una ventaja de la POO frente al paradigma estructurado, es la facilidad que brinda a través

de sus herramientas el desarrollo de los procesos de análisis, modelado, diseño e

implementación del mundo, de tal forma que representa la realidad. Esto porque el mundo

está lleno de objetos, los cuales se pueden representar como tales en una solución

computarizada y para ello se necesita de un lenguaje de programación, por ejemplo: C++,

Java, Visual Basic.net, etc.

Objeto

La característica más importante de la POO es el objeto. Un objeto es simplemente una

entidad lógica que contiene datos (campo o atributo) y un código que manipula estos datos

(función ó método). Un objeto lo podemos concebir en el campo de la programación como

una variable de tipo definida por el usuario.

Los objetos pueden ser:

Reales o tangibles: lápiz, cuaderno, automóvil, animal, estudiante, roca, etc.

Intangibles (conceptos) : número, carrera_universitaria, cuenta, transacción, etc.

Campo o Atributo

Es una característica de un objeto, que ayuda a definir su estructura y permite diferenciarlo

de otros objetos. Se define con un nombre y un tipo de dato, el cual indica los valores que

puede almacenar. El conjunto de valores de los campos definen el estado del objeto.

Función ó Método

Es la implementación de un algoritmo que representa una operación en un objeto va a

realizar. El conjunto de los métodos de un objeto determinan el comportamiento del mismo.

Clase

Representa la agrupación de aquellos objetos que presentan características similares. Para

poder realizar correctamente el proceso de clasificación de los objetos es preciso identificar

previamente las cualidades o atributos de dichos objetos. En términos generales una clase

en POO la podemos simbolizar gráficamente así:

1 Conjunto de teorías, estándares, modelos y métodos que permiten organizar el conocimiento.


Figura No. 1. Representación gráfica de un objeto real

Figura No. 2. Representación gráfica de un objeto intangible

Instancia

Una instancia se refiere a la creación de un objeto a partir de una clase en particular, por

ejemplo, para la clase planeta los objetos serían : Tierra, Marte, Júpiter, Mercurio, Venus,

entre otros.

Principios de la POO

Para el desarrollo de aplicaciones orientadas a objetos se deben tener en cuenta una serie de

principios que deben estar inmersos en el diseño e implementación, estos corresponden a:

Abstracción

Esta propiedad permite distinguir a un objeto de los demás, observando sus características y

comportamientos, pensando en qué es? y no en cómo? se codificaría en un lenguaje. Con la

abstracción se destaca lo importante y se ignora lo irrelevante, o sea, hay ocultamiento de

información.

Modularidad

Proceso de crear partes de un todo que se integran perfectamente entre sí para que

funcionen por un objetivo general, y a las cuales se les pueden agregar más componentes

que se acoplen perfectamente al todo, o extraerle componentes sin afectar su

funcionamiento. En el caso que se requiera actualizar un módulo, no hay necesidad de

hacer cambios en otras partes del todo. Un ejemplo clásico es un conjunto de módulos para

mueble, que al integrarlos conforman un armario, al cual puede agregársele más

Nombre_clase

Atributos

Métodos

Planeta

nombre, diámetro, distancia,

movimiento, etc.

leer(), calcular(),mostrar()

Nombre_clase

Atributos

Métodos

Cuenta

numero_cta, saldo, clave

consignar(), retirar(),

consultar()


funcionalidades, si se agregan más módulos, o al contrario, también se puede cambiar su

finalidad si se acomodan esos módulos para darle otro objetivo: volverlo una mesa.

Encapsulación de información

El encapsulamiento permite el ocultamiento de la información, esto significa, que los

objetos saben comunicarse entre sí a través de interfaces2 (normalmente no se permite que

un objeto sepa como están implementados otros objetos).El ámbito de los datos y de los

métodos puede ser público, privado o protegido. Un ejemplo de este principio es el motor

de un carro el cual realiza una función especifica: mover el carro, sin interesar como lo

hace mecánicamente.

Herencia

Propiedad que permite a los objetos ser construidos a partir de otros, es decir que una clase

puede recibir las características de una clase superior, tales como atributos o métodos

(campos y métodos o comportamientos), para usarlos en la clase actual. Un ejemplo común

es la genética humana ya que el hijo hereda características de los padres.

Polimorfismo

Esta propiedad indica que un elemento puede tomar distintas formas. Podemos definirlo

como el uso de varios tipos en un mismo componente o método. Por ejemplo, la suma de

números es un caso de polimorfismo, ya que el operador suma dos operandos ya sean

reales, enteros, binarios, entre otros, lo importante es que el resultado siempre va a ser un

solo valor.

Diferencias entre la POO y otros paradigmas.

Se puede decir que el Paradigma Orientado a Objetos es una evolución de la programación

imperativa o procedural, aunque esta a su vez mejoró las tecnicas de programación

secuencial con el manejo de las estructuras.

Los objetos facilitan el diseño de las aplicaciones, ya que por medio de estos se puede

representar con mayor veracidad las entidades que se manejan normalemente en cualquier

proceso real, es aquí donde se evidencia la potencialidad de la abstracción, ya que dichas

entidades se pueden categorizar según sus características más comunes y además se pueden

definir acciones generales llamadas métodos, los cuales pueden ser reutilizados por otros

objetos. Adicionalemente, la POO permite el uso de patrones de diseño y lenguajes de

modelado como UML, que facilitan el diseño, la documentación, implementación y

refinamiento del código.

2 Es un método que permite comunicar al exterior o al interior cierta información que almacenan las

características del objeto


Cuadro comparativo

Aspectos Programación

Procedural

Programación

Estructurada

Programación

Orientada a Objetos

Representación de

Datos

Uso de Estructuras TAD (Tipos

abstractos de datos),

Estructura

independiente de la

funcionalidad

Clase (Estructura más

funcionalidad)

Organización del

código

Uso de funciónes y

procedimientos

Uso de módulos Las clases incorporan

la funcionalidad en

métodos.

Reutilización de

Código

Es prácticamente

imposible

aprovechar en una

aplicación nueva

las subrutinas que

se diseñaron para

otra.

Se pueden reutilizar

los módulos auque

existen dependencia

sobre los datos.

Uso de la Herencia y el

polimorfismo. Mayor

facilidad de

mantenimiento y

reutilización.

Representación Diagramas de Flujo

de Datos

Diagramas de Flujo Lenguajes de

Modelado UML

Acceso a los datos Todos los datos tienen acceso en cualquier

parte de la aplicación.

Encapsulamiento,

ocultamiento de la

complejidad interna y

detalles de los datos y

las operaciones

Enfoque Orientada a la acción Orientada a los objetos

Lenguajes de POO

Los conceptos de la programación orientada a objetos tienen origen en Simula 67, un

lenguaje diseñado para hacer simulaciones, creado por Ole-Johan Dahl y Kristen Nygaard

del Centro de Cómputo Noruego en Oslo. El trabajo que desarrollaron tenía que ver con

simulaciones de naves. La idea ocurrió para agrupar los diversos tipos de naves en diversas

clases de objetos, siendo responsable cada clase de objetos de definir sus propios datos y

comportamientos. Estos conceptos fueron refinados más tarde en Smalltalk, que fue

desarrollado en Simula en Xerox PARC (y cuya primera versión fue escrita sobre Basic),

diseñado para ser un sistema completamente dinámico, en el cual los objetos se podrían

crear y modificar "en marcha" en lugar de tener un sistema basado en programas estáticos.

La programación orientada a objetos tomó posición como la metodología de programación

dominante a mediados de los años ochenta, en gran parte debido a la influencia de C++ ,

http://es.wikipedia.org/wiki/Simula

http://es.wikipedia.org/w/index.php?title=Ole-Johan_Dahl&action=edit

http://es.wikipedia.org/w/index.php?title=Kristen_Nygaard&action=edit

http://es.wikipedia.org/w/index.php?title=Centro_de_C%C3%B3mputo_Noruego&action=edit

http://es.wikipedia.org/wiki/Oslo

http://es.wikipedia.org/wiki/Smalltalk

http://es.wikipedia.org/w/index.php?title=Xerox_PARC&action=edit

http://es.wikipedia.org/wiki/Basic

http://es.wikipedia.org/wiki/Cplusplus


una extensión del lenguaje de programación C. Su dominación fue consolidada gracias al

auge de las Interfaces gráficas de usuario, para los cuales la programación orientada a

objetos está particularmente bien adaptada.

Las características de orientación a objetos fueron agregadas a muchos lenguajes existentes

durante ese tiempo, incluyendo Ada, BASIC, Lisp, Pascal, y otros. La adición de estas

características a los lenguajes que no fueron diseñados inicialmente para ellas condujo a

menudo a problemas de compatibilidad y a la capacidad de mantenimiento del código. Los

lenguajes orientados a objetos "puros", por otra parte, carecían de las características de las

cuales muchos programadores habían venido a depender. Para saltar este obstáculo, se

hicieron muchas tentativas para crear nuevos lenguajes basados en métodos orientados a

objetos, pero permitiendo algunas características procedurales de maneras "seguras". El

Eiffel de Bertrand Meyer fue un lenguaje con esos objetivos pero ahora ha sido

reemplazado por Java, en gran parte debido a la aparición de Internet, y a la

implementación de la máquina virtual de Java en la mayoría de navegadores.

Lenguaje de programacion C++

El lenguaje C nació en los laboratorios Bell de AT&T y ha sido estrechamente asociado

con el sistema operativo UNIX, ya que su desarrollo se realizó en este sistema y debido a

que tanto UNIX como el propio compilador C y casi la totalidad de los programas y

herramientas de UNIX, fueron escritos en C. Su eficiencia y claridad han hecho que el

lenguaje ensamblador apenas haya sido utilizado en UNIX.

Este lenguaje está inspirado en el lenguaje B escrito por Ken Thompson en 1970 con

intención de recodificar el UNIX, que en la fase de arranque estaba escrito en ensamblador,

en vista a su transportabilidad a otras máquinas. B era un lenguaje evolucionado e

independiente de la máquina, inspirado en el lenguaje BCPL concebido por Martin Richard

en 1967.

En 1972, Dennis Ritchie, toma el relevo y modifica el lenguaje B, creando el lenguaje C y

reescribiendo el UNIX en dicho lenguaje. La novedad que proporcionó el lenguaje C sobre

el B fue el diseño de tipos y estructuras de datos.

Este lenguaje ha evolucionado paralelamente a UNIX. Así, en 1980 se añaden al lenguaje

C, características como las clases (Tomado de Simula67), chequeo y conversión de los

tipos de argumentos de función, etc.; el resultado fue el lenguaje denominado "C con

Clases".

En 1983/84, "C con Clases" fue rediseñado, extendido y nuevamente implementado. El

resultado se denomino "Lenguaje C++". Después de algún otro refinamiento más, C++

queda disponible en 1985. Este lenguaje fue inventado por Bjarne Stroustrup (AT&T Bell

Laboratories) y documentado por varios libros suyos.

El nombre C++ se debe a Rick Mascitti, significando "el carácter evolutivo de las

transformaciones de C" ('++' es el operador de incremento de C).

http://es.wikipedia.org/wiki/C

http://es.wikipedia.org/wiki/Interfaz_gr%C3%A1fica_de_usuario

http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n_Ada

http://es.wikipedia.org/wiki/BASIC

http://es.wikipedia.org/wiki/Lisp

http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n_Pascal

http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n_Eiffel

http://es.wikipedia.org/wiki/Java_%28lenguaje_de_programaci%C3%B3n%29

http://es.wikipedia.org/wiki/Internet

http://es.wikipedia.org/wiki/Navegadores


ELEMENTOS BÁSICO DE LA PROGRAMACIÓN EN C++

Dentro de la estructura de un programa en C++, existen elementos básicos tales como: tipos

de datos, operadores, expresiones, variables, constantes, directivas de preproceso, palabras

reservadas y caracteres especiales.

Tipos de Datos

Existen tipos de datos estándar que el compilador de C++ reconoce: enteros, coma flotante

y carácter. Los tipos de datos son:

Tabla 1. Tipos de Datos en C++

Tipo Rango Bytes

char -128 … 127 (ascii) 1

int -32.768 … 32767 2

long -2.147.483.648 …2.147.483.647 4

float 3.4 x 10 -38

… 3.4 x 10 38

4

double 1.7 x 10 -308

… 1.7 x 10 308

8

void Valor nulo

Operadores y expresiones

Los programas en C++ constan de datos, sentencias de programas y expresiones. Una

expresión es una ecuación matemática, tal como 4+8. En esta expresión, el símbolo (+) es

el operador suma y los números 4 y 8 se llaman operandos. C++ soporta diferentes tipos de

operadores: aritméticos, lógicos, de asignación, relacionales.

Operadores Aritméticos

Se utilizan para crear expresiones aritméticas; estas pueden resultar de la unión de

variables o constantes con operadores.

Tabla 2. Operadores Aritméticos

Operadores de

C++

Operador Expresión en C++

Suma + numero +7

Resta - numero -7

Multiplicación * numero1 * numero2

División / numero1 / numero2

Residuo % numero1 % numero2


Operadores de igualdad y relacionales (toma de decisiones)

Se utilizan para la toma de decisiones que se puedan necesitar dentro de un programa.

Tabla 3. Operadores de igualdad

Operadores de

Igualdad

C++ Ejemplo en C++ Significado en C++

= = = x==y X es igual a Y

!= x!=y X es diferente de Y

Tabla 4. Operadores relacionales

Operadores

Relacionales

C++ Ejemplo en C++ Significado en C++

> > y>x Y es mayor que X

>= >= y>=x Y es mayor o igual que X

< < y <x Y es menor X

= <= y<=x Y es menor o igual que X

Operadores de Incremento o Decremento

Estos operadores le permiten a C++ incrementar (++) ó decrementar (--) en una unidad (1)

el valor de una variable.

Ejemplos:

Tabla 5. Operadores de incremento o decremento

Ejemplo Significado

Variable++ El valor de la variable se incrementa después de hacer una operación

++Variable El valor de la variable se incrementa antes de hacer una operación

Variable— El valor de la variable se disminuye después de hacer una operación

--Variable El valor de la variable se disminuye antes de hacer una operación

También es posible crear variables de incremento o decremento mayores de una unidad de

la siguiente forma:

Tabla 6. Variables de incremento o decremento mayores de una unidad

Ejemplo Significado

Variable+=3 La variable incrementara su valor en 3 unidades

Variable -=5 La variable decrementara su valor en 5 unidades


Directiva de preproceso

Son sentencias que se sitúan normalmente al principio del código fuente, aunque pueden

aparecer en cualquier punto del programa. Estas directivas se identifican por ser líneas

precedidas por el símbolo #, que es el operador de preproceso, indicando que lo que sigue

es una línea de control. Las directivas de preprocesado no necesitan punto y coma ( ; ) al

final de la sentencia.

#include

Le indica al compilador de C++ que incluya un archivo de texto existente (archivo de

cabecera).La sintaxis es: #include <”nombre de archivo> ó #include “nombre de archivo”

Ejemplos: #0include <stdio.h> ; #include “math.h”

#define

Esta directiva permite crear definiciones de macro; la más común de éstas es la macro de

sustitución sencilla, con está se define una sustitución de un patrón particular por otro. Su

sisntaxis es:

#define nombre_constante valor_constante

Ejemplo:

(1) #define max 100 ; (2) #define p printf

En el caso uno (1) el compilador al encontrar la palabra max lo reemplazara por el valor

100.

En el caso dos (2) el compilador al encontrar la letra p la reemplaza por el método printf.

Declaración de Variables

Para declarar una variable es necesario definir el tipo de dato y el nombre de la variable; las

variables se utilizan para almacenar, recuperar información o para cambiar su valor en

cualquier punto de un programa.

Su sintaxis es: tipo_de_dato nombre_variable tipo_de_dato nombre_variable = valor_inicial

Ejemplos: char letra; int valor;

double a,b,c; float x; char letra=’a’; int valor=1;


double a=b=c=0.0; float x=20.78;

Declaración de constantes

Una constante representa un espacio de almacenamiento con un valor fijo, es decir, su

contenido no varia en ninguna parte del programa; puede ser de cualquier tipo de dato.

Normalmente se definen las constantes utilizando las palabra reservada const, también se

puede hacer uso de la directiva #define.

Ejemplos: const char letra_A=65; const Dias_semana=7;

#define vr_minuto 60

Palabras reservadas de C++

Las palabras reservadas están definidas como parte del lenguaje de programación, es decir,

no se pueden utilizar como nombre de variables ó constantes. En la siguiente tabla se

relacionan.

Tabla 7. Palabras reservadas

Palabras Reservadas de C++

asm Double new switch

auto Else operator template

break Enum private this

case Extern protected throw

catch Float public try

char For register typedef

class Friend return union

const Goto short unsigned

continue If signed virtual

default Inline sizeof void

delete Int static volatile

do Long struct while

Caracteres Especiales

En el lenguaje C++ los caracteres especiales representan símbolos, como comillas dobles,

signo ?, entre otros y algunas secuencias de escape como un salto de línea o una tabulación.

A continuación se definen algunos de estos.


Tabla 8. Caracteres especiales

Caracteres especiales

\a carácter de alerta (beep)

\b carácter de retroceso

\f carácter de alimentación de forma (papel)

\n carácter de línea nueva

\r retorno de carro

\t carácter de tabulación horizontal

\v carácter de tabulación vertical

\\ carácter diagonal invertida

\? carácter signo de interrogación

\’ carácter de apóstrofe

\” carácter de comillas

\0 carácter nulo

Creación de un primer programa en C++

Para crear un programa orientado a objetos en C++ es necesario tener en cuenta los

siguientes aspectos:

1. En cada programa se debe definir como mínimo una clase utilizando la palabra

reservada "class", su sintaxis es:

class Nombre_clase { private: datos y métodos privados; protected: datos y métodos protegidos; public: datos y métodos publicos; }lista de objetos;

2. Debe existir un método principal llamada main().

3. Incluir como mínimo un archivo de cabecera, Ejemplo: # include <iostream.h>

4. Las palabras reservadas de C++ deben ir en minúsculas

Archivos generados en C++

Cuando se crean programas en Lenguaje C++ se obtienen los siguientes archivos.

1. El código fuente que contiene las instrucciones del programa en el lenguaje de

programación, cuya extensión es .cpp . Ejemplo: Primero.cpp , Miprograma.cpp.

2. Cuando el código fuente se compila se genera un archivo con el código objeto, que

posee la extensión .obj , y otro archivo ejecutable con extensión .exe. Estos archivos

generados poseen el mismo nombre del archivo fuente.


3. También se crean archivos de cabecera o librerías que contienen métodos públicos

que pueden ser utilizados por varios programas. Dichos archivos tienen la extensión

.h.

Ejemplo 1: Hacer un programa orientado a objetos en C++ que muestre un mensaje en la

pantalla.

// el doble slash sirve para hacer comentarios dentro del programa //Nombre del programa: leyenda.cpp 1 #include <iostream.h> 2 #include <conio.h> 3 class Leyenda{ 4 public: 5 void mostrar(void); }; 6 void Leyenda::mostrar(void) { 7 cout <<”Mi primer Programa en C++”<<endl; } 8 void main () 9 { 10 Leyenda miobjeto; 11 miobjeto.mostrar(); 12 getch (); 13 }

Ahora analicemos línea por línea (en un programa en C++ no es necesaria la numeración

pero cada instrucción debe finalizar con un punto y coma).

Línea 1: se incluye el archivo de cabecera “iostream.h” para manejar el flujo de

entrada/salida del programa. En el archivo iostream.h se encuentran definidos los

objetos cin y cout. El objeto cin utiliza al operador sobrecargado >> para tomar

datos desde la entrada estándar( habitualmente el teclado ). El objeto cout utiliza al

operador sobrecargado << para enviar datos hacia la salida estándar( normalmente

la pantalla).

Línea 2: se incluye el archivo de cabecera “conio.h”, que permitira utilizar funciones para

el manejo de la pantalla por ejemplo: clrscr(), getch(), textcolor(),etc.

Línea 3: se define la clase llamada Leyenda.

Línea 4: la palabra reservada public indica que todos los datos y métodos declarados

posteriormente son publicos.

Línea 5: se define el prototipo de un método. Un método se declara para realizar una tarea

específica.

Línea 6: utilizando el operador de ámbito (::) se implementa el método, esto es, definir la

tarea que va a realizar. En este caso en la línea 6 se utiliza el objeto cout para

mostrar un mensaje en la pantalla. El método endl permite realizar un salto de

línea en la pantalla.

Línea 8: se define el método principal main().


Línea 9 y 13: las llaves ({}) sirven para indicarle al método principal main donde inicia y

termina el programa (estas llaves son obligatorias).

Línea 10: se declara un objeto llamado miobjeto. Dicho objeto puede realizar un llamado a

todos los datos y métodos públicos de la clase Leyenda.

Línea 11: se hace el llamado al método mostrar().

Línea 12: es un método que permite detener la pantalla hasta que se pulse cualquier tecla.

Ejemplo 2: hacer un programa que capture un número entero por teclado y lo imprima en

pantalla.

//Nombre del programa: numero.cpp 1 #include <iostream.h> 2 #include <conio.h> 3 class Numero { 4 int num; 5 public: 6 void leernumero (void); 7 int mostrarnumero (void); }; 8 void Numero::leernumero (void) { 9 cout<<”Digite un número”; 10 cin>>num; } 11 int Numero::mostrarnumero (void) { 12 return (num); } 13 void main () { 14 clrscr (); 15 Numero natural; 16 natural.leernumero (); 17 cout<<endl<<”El numero digitado fue:”<<natural.mostrarnumero (); 18 getch (); }

Análisis

Línea 4: Se declara una variable entera llamada num en la sección privada de la clase.

Línea 6: Se declara el método leernumero().

Línea 7: Se declara el método mostrarnumero() el cual retornara un valor.

Línea 9 y 10: se utiliza el objeto cout para visualizar en pantalla un texto y por medio del

objeto cin capturamos un valor en la variable num.

Línea 12: se utiliza la palabra reservada return, para retornar el valor de la variable num.

Línea 14: el método clrscr() permite limpiar la pantalla cada vez que se ejecuta el

programa.

Línea 17: se visualiza en pantalla el número que fue digitado el cual es retornado por el

método mostrarnumero().


Ejemplo 3: Hacer un programa que imprima la suma de dos enteros.

//Nombre del programa:suma.cpp 1 #include <iostream.h> 2 #include <conio.h> 3 class Suma{ 4 public: 5 void hacersuma(int, int); }; 6 void Suma::hacersuma(int num1, int num2) { 7 cout<<”La suma es :”<<num1 +num2<<endl; } 8 void main() { 9 clrscr(); 10 int n1,n2; 11 Suma numeros; 12 cout<< “ Digite primer numero”; 13 cin>>n1; 14 cout<< “ Digite segundo numero”; 15 cin>>n2; 16 numeros.hacersuma(n1,n2); 17 getch(); }

Análisis

Línea 5: se declara el método hacersuma(), el cual recibe dos parámetro enteros y no

retorna valores.

Línea 7: se realiza en forma directa la suma de las dos variables y se imprimen en la

pantalla.

Línea 16: se invoca al método hacersuma() por medio del objeto numeros, enviando los dos

valores almacenados en las variables n1 y n2, para que éste, sume los dos valores e

imprima el resultado.


ESTRUCTURAS DE CONTROL

Los programas vistos anteriormente son sencillos y lineales, donde se ejecutan las

instrucciones una tras otra. Sin embargo, en los programas generalmente se necesita hacer

cosas distintas dependiendo del estado de nuestras variables o realizar un mismo proceso

muchas veces sin escribir la misma línea de código una y otra vez.

Para realizar cosas más complejas en los programas se utilizan las estructuras de control,

entre ellas se encuentran la de toma de decisiones y los ciclos.

Toma de Decisiones

Al tener programas más complejos es necesario que se evalúen algunos resultados para

determinar que proceso u operación se debe ejecutar. Existen palabras reservadas de C++

que permiten tomar estas decisiones como son : if (si), if-else (si-sino), switch- case (según

sea caso).

Sentencia if (Si)

Representa una toma de decisión sencilla, es decir, si la condición que se evalúa es

verdadera se realizan las instrucciones que pertenezcan al if y continuara con el resto del

programa. Si la condición es falsa no entrara al if y por consiguiente todas las instrucciones

que están en el if no se ejecutaran. Su sintaxis puede ser:

1) if (condición) 2) if (condición) 3)if(condición)

Instrucción; { { Resto de programa Instrucciones; if (condición)

} { Resto de programa

instrucciones; }

} Resto de programa

Formato 1: Si la condición del if es verdadera se realiza la instrucción y continúa con el

resto del programa.

Formato 2: Si la condición del if es verdadera y se requiere realizar más de una instrucción

se deben encerrar entre llaves { } .

Formato 3: Se pueden anidar varios if, es decir, uno entre otro, para ingresar cada vez al if

más interno es necesario que la condición sea verdadera.


Ejemplos: 1)

#include<iostream.h>

#include <conio.h> class Si{ public: void versi(void); }; void Si::versi(void) { int n=10; i f(n>0) cout<<"Número"; cout<<"Positivo"; } void main() {clrscr(); Si verdad; verdad.versi(); getch(); }

2) // si.cpp #include<iostream.h>

#include <conio.h> class Si{ public: void versi(void); }; void Si::versi(void) { int n=10; if(n<0) cout<<"Número"; cout<<"Mayor"; } void main() {clrscr(); Si falso; falso.versi(); getch(); }

Los anteriores programas imprimirán respectivamente en pantalla

Número Positivo y Mayor

Sentencia if – else (Si –Sino)

Es una estructura compuesta que evalúa una condición. Si esta es verdadera realizara las

instrucciones contenidas en el if, en caso contrario ingresara por el else. El programa solo

tomara una de las dos alternativas y continuará con el resto del programa. Su sintaxis es la

siguiente:

1) if (condición verdadera) 2) if (condición verdadera) 3)if(condición verdadera)

Instrucción_1; { { else instrucciones_1; if (condición verdadera) Instrucción_2; } { Resto de programa else instrucciones_1; { }

Instrucciones_2; else } { Resto de programa instrucciones_2;

} } Resto de programa

Formato 1: Si la condición del if es verdadera se realiza la instrucción_1 en caso contrario

realiza la instrucción_2 y continúa con el resto del programa.

Formato 2: Si la sentencia de control if-else, necesita realizar más de una instrucción se

deben encerrar entre llaves {} ambas sentencias.


Formato 3: Se pueden anidar varios if-else, es decir, uno entre otro.

Ejemplos:

Los anteriores programas imprimirán respectivamente en pantalla

Verdadero y Falso

Sentencia Switch – case (Según sea- hacer caso n )

Es una toma de decisión con varias opciones, esto es, según sea el valor (entero o caracter)

de una variable escogerá un caso entre varias alternativas. Su sintaxis es:

switch (expresión) { case constante 1: <una o más instrucciones>

break; case constante 2: <una o más instrucciones> break; case constante 3: <una o más instrucciones> break; ... ... ... case constante n: <una o más instrucciones> break; default : <una o más instrucciones> break; }

(1) #include<iostream.h> #include<conio.h> class Uno{ public: void mensajeSi(); }; void Uno::mensajeSi() { int n=10; if(n<20) cout<<"Verdadero"<<endl; else cout<<"Falso"<<endl; } void main(){ Uno m; m.mensajeSi(); getch(); }

(2) //sino.cpp #include<iostream.h> #include<conio.h> class Uno{ public: void mensajeSi(); }; void Uno::mensajeSi() { int n=10; if(n<10) cout<<"Verdadero"<<endl; else cout<<"Falso"<<endl; } void main(){ Uno m; m.mensajeSi(); getch(); }


Para el uso de esta estructura se debe tener en cuenta lo siguiente:

1) El switch requiere de un valor entero o caractér. Este valor puede ser una constante, una

variable, el resultado de un método ó una expresión alfanumérica.

2) El valor en cada case debe ser constante.

3) Se utiliza la palabra reservada break al final de cada case para terminar la búsqueda de

alternativas.

4) La palabra default es opcional, se usa cuando al recorrer las alternativas no encuentra

una verdadera o cuando se quiere dar respuesta a cualquier otro valor que tenga la

expresión de la estructura.

Ejemplos:

Ejemplo 1: la constante del case es numérica.

Ejemplo 2: la constante es de tipo carácter por lo tanto en cada case la constante debe ir

encerrada entre comillas sencillas.

(1) //caso1.cpp #include<iostream.h> #include<conio.h> class Caso{ public: void función(); }; void Caso::función() { int n; cout<<”Digite número:”; cin>>n; switch(n) { case 1: cout<<”Es el número 1; break; case 2: cout<<”Es el número 2; break; case 3: cout<<”Es el número 3; break; ... ... case n: cout<<”Es el número n; break; } } } void main(){ Caso uno; uno.función(); getch(); }

(2) //caso2.cpp #include<iostream.h> #include<conio.h> class Caso{ public: void función(); }; void Caso::función() { char n; cout<<”Digite Caracter:”; cin>>n;

switch(n) { case 'a': cout<<”Es la letra A; break; case 'b': cout<<”Es La letra B; break; case 'c': cout<<”Es la letra C; break; ... ... ... case n: cout<<”Es la letra n; break; } } } void main(){ Caso uno; uno.función(); getch(); }


Ciclos (estructuras repetitivas)

Los ciclos permiten repetir varias veces una o más instrucciones, en C++ se usan las

estructuras: while (mientras ), dowhile (haga – mientras) y for (para).

while (mientras)

Sirve para repetir una secuencia de instrucciones siempre que la condición evaluada sea

verdadera. Su sintaxis es:

a) while(condición ) b) while (condición ) c) while(condición) instrucción; { { while(condición) instrucciones; { } instrucciones; } }

Ejemplos: 1)n=10; 2)n=10; while(n<20) while(n<10) { cout<<”hola”; cout<<”hola”; cout<<”topo gigio”; n++; } cout<<”Topo gigio”;

Ejemplo 1: como la condición es verdadera imprimirá 10 veces la palabra “hola” y luego

“Topo gigio”.

Ejemplo 2: como la condición es falsa no ingresara al ciclo y por lo tanto solo imprimirá la

palabra “Topo gigio”.

dowhile (haga – mientras)

Existen muchas situaciones en las que se desea que un ciclo se ejecute al menos una vez

antes de comprobar la condición de repetición. En la estructura mientras si el valor de la

expresión booleana es inicialmente falso, las instrucciones del ciclo no se ejecutarán; por

ello, se necesitan otros tipos de estructuras repetitivas como do-while, que se ejecuta por lo

menos una vez. Su sintaxis es:

1) do { 2) do {

instrucciones; do{ ó instrucciones;

instrucción; }while(cond verdadera); }while(cond. Verdadera); }while(condición verdadera);


Ejemplo: Hacer un programa que imprima los números del 1 al 10 inclusive, utilizando el

ciclo do - while: //Nombre del programa:dowhile.cpp #include <conio.h> #include<iostream.h> class Hacer{ public: void imprimir(); }; void Hacer::imprimir() { int n=1; do { cout<<n<<endl; n=n+1; }while(n<11); } void main() { Hacer objeto Objeto.imprimir(); getch() ; }

for (Desde – para)

Sirve para repetir una o varias instrucciones, usando una variable que por lo general es

llamada contador; esta estructura inicializa el contador y evalúa su valor por medio de una

condición, si esta es verdadera se ejecutaran las instrucciones del ciclo y aumentará o

disminuirá el contador automáticamente, de lo contrario se finalizará el ciclo. Su sintaxis

es: 1) for (inicialización de variables; condición (s) ; incrementos ó decrementos) 2) for (inicializador; condición; incremento) { for (inicializador; condición; incremento) { instrucciones; } }

A continuación se presentan las formas más comunes que puede tener un for. Se puede

observar que en todos los ciclos for siempre entre los paréntesis se utiliza como separador

el punto y coma (;), por lo tanto, a un ciclo for no le pueden faltar estos. En el caso de que

solo lleve los puntos y comas se creara un ciclo infinito o sea que nunca terminará. A

continuación se presentan algunas formas de utilizar está estructura:

for(n=0;n<10;n++) for(;n<10;n++) for(;;n++) for(; ; ) for(n=0,y=0;y<10;n++) for(n=0,y=20;y>10,n<10;y--,n++)


Ejemplo 1: Hacer un programa que imprima la suma de los números del 1 al 10, utilizando

el ciclo for. //Nombre del programa:for.cpp #include<iostream.h> #include<conio.h> class For{ public: void sumar(); }; void For::sumar() { int n, suma=0; for(n=1; n<11;n++) suma=suma+n; cout<<”la suma del 1 al 10 es:”<<suma; } void main() { For objeto; objeto.sumar(); getch(); }

Ejemplo 2: Hacer un programa que imprima los factoriales del 2 al 10

//Nombre del programa: for2.cpp #include <conio.h> #include<iostream.h> class Numero{ public: void hacer(); }; void Numero::hacer() { int f, n,x; for(n=2;n<=10;n++) { f=1; for(x=n; x>0; x--) { f= f * x; } cout<<”\nEl factorial de:”<<n<<”es :”<<f; } } void main() { Numero objeto; objeto.hacer(); getch(); }


Como se puede observar en el ejemplo 2 el for se puede anidar cuantas veces se requiera,

primero termina el for más interno y continua con los más externos.

Ejercicios Propuestos

1. Escriba un programa que pida al usuario digitar dos números, e imprima las operaciones

con los operadores aritméticos, los operadores relacionales y los operadores de

igualdad.

2. Realizar un programa que pida al usuario digitar dos números enteros, e imprima él

numero mayor seguido del texto "Es mayor".

3. Escriba un programa que capture tres números enteros, e imprima él numero mayor, el

del medio y el menor.

4. Hacer un programa que convierta una temperatura dada en grados celsius a grados

fahrenheit. La formula de conversión es F=9/5c +32

5. Realizar un programa que pida al usuario digitar la hora, los minutos y los segundos e

imprima la hora, los minutos y los segundos un segundo después.

6. Capturar 10 números e imprimir el mayor y el menor.

7. Sumar los números enteros de 1 a 100 usando las estructuras: for, while, do while.

8. Imprimir todos los números primos entre 2 y 1000 inclusive.

9. Una estación climática proporciona un par de temperaturas diarias (máxima, mínima)

(no es posible que alguna o ambas temperaturas sea 0 grados). La pareja fin de

temperaturas es 0,0. Se pide determinar el número de días, cuyas temperaturas se

proporcionaron, las medias máximas y mínima, el número de errores – temperaturas de

0 grados – y el porcentaje que representan.

10. Los números astromg o cubos perfectos, son aquellos que sumados los cubos de cada

uno de sus dígitos nos dan el mismo número. Por ejemplo 153 es un cubo perfecto, pues

(1) elevado a 3 + (5) elevado a 3 + (3) elevado a 3 es igual a 153. Escriba un programa

que dado un número entero, diga si es o no es, un cubo perfecto.


MÉTODOS

Un método se define como un conjunto de instrucciones agrupadas bajo un nombre que

cumple una tarea específica dentro de un programa. Para invocar o llamar a un método sólo

es necesario especificar el nombre y entre paréntesis la lista de parámetros. Su sintaxis es:

tipo_de_ retorno nombre_del_ método (lista de parámetros)

{ instrucciones; }

Ejemplo: void metodo1(void) { instrucciones; }

Para crear los métodos en C++, se pueden implementar de dos formas, como se presentan a

continuación:

Definida dentro de una clase e implementados fuera de la clase class Proceso {public:

void metodo(void); }; void Proceso::funcion(void) { instrucciones; }

void main() {

Proceso objeto; objeto.metodo();

}

Definida e implementada dentro de una clase class Proceso {public:

void metodo(void) { instrucciones; }

}; void main() {

Proceso objeto; objeto. metodo();

}


Tipos de Métodos

Métodos que no retornan valores ni reciben parámetros

Estos métodos, tanto en el tipo de retorno como en la lista de parámetros utilizan ir la

palabra reservada void, indicando al compilador que el retorno será un valor de nulo.

Ejemplo: hacer un programa que imprima un mensaje en pantalla.

//Nombre del programa:funcion1.cpp #include <conio.h> #include<iostream.h> class Uno { public: //declaración de la parte pública de la clase uno void mensaje(void) { cout<<”esta es un método que no retorna ni recibe valores”; } }; //terminación de la clase void main(void) { clrscr(); Uno objeto1; //Declaración de un objeto (objeto1) de la clase uno //llamado al método mensaje a través del objeto y el operador punto(.) objeto1.mensaje(); getch(); }

En el ejemplo anterior al ejecutar y compilar el programa el método principal main()

invocará al método mensaje() e imprimirá en pantalla el texto que se encuentra en el cuerpo

del método, cabe anotar, que en la lista de parámetros no es indispensable colocar la

palabra reserrvada void.

Métodos que reciben parámetros pero que no retornan valores

Para éstos métodos, el tipo de retorno es nulo, por lo cual se utiliza la palabra reservada

void, y en la lista de parámetros se definen cada uno de los tipos de datos que se recibirán.

Ejemplo: hacer un programa donde se reciban tres valores en un método y se impriman en

pantalla.

//Nombre del programa:funcion2.cpp #include <conio.h> #include<iostream.h> class Valor{ public: void metodo(int a, float b, double c) {


cout<<”los valores recibidos fueron:”<<a<<” “<<b<<” “<<c<<endl; } }; main() { clrscr(); Valor objeto; int x; float y; double z; cout<<"Digite tres valores"<<endl; cin>>x; cin>>y; cin>>z; objeto.metodo (x,y,z); getch(); }

En el ejemplo anterior desde el main() se envían tres valores, almacenados en las variables

x,y,z respectivamente y el método los reciben en ese orden en las variables a,b,c, por

consiguiente la variable a recibirá el valor de x, la variable b el valor de y, la variable c el

valor de z.

Métodos que reciben parámetros y retornan valores

En estos métodos, el retorno debe ser un tipo de dato diferente de void (int, float, double,

etc.) y en la lista de parámetros cada uno de los tipos de datos que se deseen. Se debe

incluir como instrucción de retorno la palabra reservada return; en este tipo de métodos

solo puede retornarse un valor.

Ejemplo: hacer un programa donde se reciban tres valores en un método y ésta realice la

sumatoria de los tres valores y los retorne al método main.

//Nombre del programa:funcion3.cpp #include <conio.h> #include<iostream.h> class Calculadora{ public: int funcion(int a, int b, int c); }; int Calculadora:: metodo (int a, int b, int c) { int suma; suma=a+b+c; return (suma); } void main() { Calculadora objeto; int x=2,y=3,z=4; cout<<”La suma de los tres valores es:”<<objeto. metodo (x,y,z)<<endl; getch(); }


En el ejemplo anterior desde el main() se envían tres valores enteros, en las variables x,y,z

respectivamente, el método los recibe en ese orden en las variables de tipo entero a,b,c. En

el método crea una variable suma que sirve para retornar la sumatoria de los tres números.

Métodos que no reciben parámetros y retornan un valor

Para éstos métodos, en el retorno debe ir el tipo de dato que devolverá el método (int, char,

float, etc.) y en la lista de parámetros la palabra void.

Ejemplo: hacer un programa donde se lean dos valores desde un método y éste calcule y

retorne el cociente de la división de los valores.

//Nombre del programa:funcion2.cpp #include <conio.h> #include<iostream.h> class Valor{ private: int a, b; public: void metodo1( ) { cout<<”Digite dos valores :”; cin>>a; cin>>b; } float metodo2( ) { float cociente; cociente=a/b; return(cociente); } }; main() { clrscr(); valor objeto; objeto. metodo1(); cout<<"El cociente es:"<<objeto. metodo2()<<endl; getch(); }

En el ejemplo anterior desde el main() se invoca a metodo1(), que solicitará y almacenará

dos valores enteros en las variables a,b respectivamente y metodo2() retorna al main() el

cociente de la division de las variables a y b.

Métodos homónimos

Los métodos homónimos son aquellos que tiene el mismo nombre del método pero es

distinta la lista de parámetros (cantidad ó tipos de datos).


Ejemplo: hacer un programa donde se capture tres valores. En un método se debe retornar

la sumatoria de los tres valores y en otra la sumatoria de los dos primeros valores.

//Nombre del programa: homo.cpp #include <conio.h> #include<iostream.h> class Homo{ public: int funcion(int, int); int funcion(int, int, int); }; int Homo:: metodo(int a, int b) { return (a+b); } int Homo:: metodo (int a, int b, int c) { return (a+b+c); } void main() { Homo objeto; int x,y,z; cout<<”digite primer numero :”; cin>>x; cout<<”digite segundo numero :”; cin>>y; cout<<”digite tercer numero :”; cin>>z; cout<<”la suma de X y Y es:<<objeto. metodo (x,y)<<endl; cout<<”la suma de X,Y y Z es:<<objeto. metodo (x,y,z)<<endl; getch(); }

Métodos con parámetros predefinidos

A estos métodos se les puede asignar valores predefinidos a la lista de parámetros que

recibe, permitiendo cambiar los valores de las variables del método.

Ejemplo: Hacer un programa que imprima los siguientes valores en pantalla utilizando un

método con valores predefinidos:

a=100 b=200 c=300 a=2 b=200 c=300 a=2 b=3 c=300 a=2 b=3 c=4

//Nombre del programa: valores.cpp #include <conio.h> #include<iostream.h>


class Valores { public: int metodo (int a=100, int b=200, int c=300); }; int valores:: metodo (int a=100, int b=200, int c=300) { cout<<”a=”<<a<<” b=”<<b<<” c=”<<c<<endl; } main() { Valores objeto; objeto. metodo (); objeto. metodo (2); objeto. metodo (2,3); objeto. metodo (2,3,4); getch(); }

Métodos Recursivos

Un método recursivo es aquel que se llama a sí mismo ya sea directa o indirectamente a

través de otro método. Así que para cada repetición hay una nuevo llamado al método

original.

- Ejemplo: Utilizando recursividad crear un POO que realice la serie de fibonacci, la cual

se define: Fibonacci(0)=0 Fibonacci(1)=1 Fibonacci(n)=Fibonacci(n-1)+Fibonacci(n-2)

//Nombre del programa: fibonacci.cpp #include <conio.h> #include<iostream.h> class Recursividad { int dato; public: void leer() { cout<< “Digite un numero: ”; cin>>dato; } void mostrar () { cout<< “El numero fibonacci de” <<dato<< “es: ”<<fibonacci(dato); } long fibonacci(long n) { if(n==0 || n==1) return n; else


return fibonacci(n-1)+fibonacci(n-2); // caso recursivo } }; void main() { Recursividad objeto; objeto. leer(); objeto. mostrar(); getch(); }

Nota: en el método fibonacci() se realiza la recursividad, dado que este se llama asi mismo

directamente, por ejemplo sí digitamos el numero 3 y evaluamos fibonacci(3) se realizaran

dos llamadas recursivas: fibonacci(2) y fibonacci(1).


1. Realizar un programa que utilice métodos que capture un número e imprima el factorial

de este.

2. Utilizando métodos realizar un programa que capture tres números e imprima la media

de los números en el programa principal.

3. Utilizando métodos realizar un programa que capture dos números por medio de un

método e imprima el mayor de los dos en otro método.

4. Utilizando métodos realizar un programa que capture un numero e imprima si es

perfecto o no. Un número es perfecto si la suma de sus factores incluyendo el 1 es igual

al número. Ej: 6= 3+2+1.

5. Realizar un programa que capture los valores de a,b,c y por medio de un método halle

las raíces de una ecuación de segundo grado.

6. Utilizando métodos realizar un programa que capture dos numeros enteros y retorne la

multiplicación de estos por medio de sumas sucesivas.

7. Utilizando métodos recursivas realizar un programa que genere la siguiente serie:

1,3,4,7,11,18,29,47........

8. Crear un programa que contenga un método que reciba un número entero y retorne el

número con sus dígitos invertidos. Ejemplo: dado el número 7631 el método deberá

retornar 1367.

9. Realizar un programa que contenga métodos para obtener el cambio óptimo (minimo

numero de monedas posible) de una cantidad entera positiva en monedas de 100, 50,

25, 5 y 1 peso.

10. Realizar un programa que decida si dos números son amigos. Dos números son amigos

si la suma de los divisores del primer numero, excluido el, es igual al segundo numero,

y viceversa; es decir, si la suma de los divisores del segundo numero, excluido el, es

igual al primer numero.


ARREGLOS

Un arreglo es un grupo de posiciones de memoria contiguas, que poseen el mismo nombre

y el mismo tipo de dato. Para referirnos a un elemento del arreglo especificamos el nombre

del arreglo y el número de la posición del elemento en el arreglo. El primer elemento del

arreglo es el elemento numero cero (0). Él numero de la posición en corchetes recibe el

nombre de subíndice, un subíndice debe ser un entero.

Arreglos de una Dimension o Unidimensionales

Un arreglo de una dimension se conoce como vector, para la declaracion de un vector en

C++ se tiene la siguiente sintaxis:

<Tipo de dato> <nombre del arreglo> [<numero de elementos>]; int mercancía [12];

También podemos inicializar los vectores, de la siguiente manera:

int ventas[5]={100,254,478,125,458}; float ventas[5]={100.0,254.25,36.23,25.2,258.47};

Ejemplo: Hacer un programa que lea diez números e imprima la suma de estos, el

promedio y los números mayores del promedio.

//Nombre del programa: lista.cpp #include <conio.h> #include<iostream.h> class Lista { int m[10],suma,i; public: void leer(); void mostrar( ); }; void Lista::leer() { suma=0; for(i=0;i<10;i++) { cout<<”Digite un numero entero:”; cin>>m[i] ; suma=suma+m[i]; } } void Lista::mostrar() { float promedio; cout<<”La suma de los números es:”<<suma<<endl; promedio=suma/10; cout<<”El promedio es:”<<promedio<<endl; cout<<”Los números mayores del promedio son:”<<endl;


for(i=0;i<10;i++) { if(m[i]>promedio) cout<<m[i]<<” - “; } } void main() { Lista objeto; objeto.leer(); objeto.mostrar(); getch(); }

Arreglos de más de una dimensión ó Multidimensionales

Un arreglo puede ser definido de dos, tres o más dimensiones, este tipo de arreglos se

denominan matrices. La sintaxis para declarar una matriz es:

<tipo de dato> <Nombre de la matriz> [fila][columna];

int matriz [4][5];

También podemos inicializar las matrices, de la siguiente forma:

int ventas[2][3]={10,25,47,

12,45,38};

Ejemplo: Hacer un programa que capture numeros enteros en una matriz de 3 filas por 2

columnas e imprima la suma de cada fila y de cada columna.

//Nombre del programa: matriz.cpp #include<iostream.h> #include<conio.h> class Matriz{ private: int i,j,a[3][2]; public: void capturar(); void mostrar(); }; void Matriz::capturar() { for(i=0;i<3;i++) { for(j=0;j<2;j++) { cout<<"Digite número"; cin>>a[i][j]; }


} } void Matriz::mostrar() { int filas=0,columnas=0; for(i=0;i<3;i++) { filas=0; for(j=0;j<2;j++) { cout<<a[i][j] <<"\t"; filas+=a[i][j]; } cout<< " La suma de la fila es:"<<filas; cout<<endl; } for(i=0;i<2;i++) { columnas=0; for(j=0;j<3;j++) columnas+=a[j][i]; cout<<" La suma de la columna es:"<<columnas; cout<<endl; } } void main() {clrscr(); Matriz objeto; objeto.capturar(); objeto.mostrar(); getch(); }

Envio de Arreglos a Métodos

Para enviar arreglos a un método debemos pasar el nombre del arreglo y él numero de

elementos de este. El método lo recibe con el mismo tipo de dato con el que fue creado y

con el número de elementos del arreglo.

- Creación del Arreglo int m[5];

- Paso al método Funcion(m,5);

- Recibo en el método Funcion(int m[],int x)

Ejemplo: Realizar un programa que capture 10 números enteros y los ordene de mayor a

menor.

//Nombre del programa: arrefunc.cpp #include <conio.h> #include<iostream.h> class Numero


{ public: void lee(int a[],int n); void ordenar(int a[],int n); void mostrar(int a[],int n); }; void Numero::lee(int a[],int n) { int i; for(i=0;i<n;i++) { cout<<”Digite un numero entero:”; cin>>a[i] ; } } void Numero:: ordenar(int a[], int n) { int i,j,aux; for(i=0;i<n;i++) { for(j=i;j<n;j++) { if(a[i]<a[j]) { aux=a[i]; a[i]=a[j]; a[j]=aux; } } } } void Numero::mostrar(int a[],int n) { int i; cout<<”Arreglo ordenado”<<endl; for(i=0;i<n;i++) { cout<<a[i]<<” “ ; } } main() { int m[10],x; Numero objeto; cout<<"Digite el tamaño"<<endl; cin>>x; objeto.lee(m,x); objeto. ordenar (m,x); objeto.mostrar(m,x); getch(); }



1. Escribir un programa que permita obtener el número de elementos positivos de un

vector de 10 elementos.

2. Calcular el número de elementos negativos, cero y positivos de un vector dado 20

elementos.

3. Calcular la suma de los elementos de sus diagonales en una matriz cuadrada. Se debe

capturar la dimensión de la matriz.

4. Se dispone de las notas de 40 alumnos. Cada uno de ellos puede tener una o varias

notas. Escribir un programa que permita obtener la media de cada alumno y la media de

la clase a partir de la entrada de las notas desde el teclado.

5. Se dispone de una lista de 100 números enteros. Calcular su valor máximo y el orden

que ocupan en el vector.

6. Hacer un programa que le permita insertar o eliminar elementos de un arreglo (los

elementos deben mostrarse como se ingresaron).

7. Leer una matriz cuadrada A. Calcular si la matriz es simétrica. Se considera una matriz

simétrica si A[i,j]=A[j,i] y esto se cumple para todos los elementos i, j de la matriz.

8. Sean A[m,n] y B[n], una matriz y un arreglo respectivamente, haga un programa que

asigne valores a A , a partir de B teniendo encuenta los siguientes criterios

a) A[i,j]=[i] si i<=J

b) A[i,j]=0 si i>j

9. Haga un programa que intercambie las filas de una matriz. Los elementos de la fila 0

deben intercambiarse con los de la fila N, la fila 1 con los de la fila N-1 y así

sucesivamente. Imprimir las dos matrices.

10. Se Tiene un arreglo unidimensional C de N elementos, calcular:

El numero de datos repetidos en el arreglo

El numero de valores impares

El numero de valores pares

La cantidad de ceros.


CADENA DE CARACTERES

En algunos programas es necesario utilizar cadenas de caracteres para guardar nombres de

usuario, nombres de archivos y alguna otra información basada en caracteres. Para declarar

una cadena de caracteres dentro de un programa solamente es necesario crear un arreglo de

tipo char con los suficientes elementos para guardar la información requerida. El primer

elemento ira en la posición cero (0) y él ultimo elemento será un carácter nulo, el cual, no

se debe contar como información sino como un elemento que permite saber hasta donde

existe información en el arreglo y se simboliza por ‘\0’. Este carácter nulo es necesario para

recorrer el arreglo carácter por carácter.

Ejemplo: char nombre[64] ;

Este arreglo guarda 64 caracteres del 0 al 63 y la posición 63 deberá contener el carácter

nulo. Si no se alcanza a llenar el arreglo, el carácter nulo debe ir en la siguiente posición

donde termina la información.

Ejemplo: Hacer un programa que capture una cadena de caracteres y la imprima por

pantalla.

//Nombre del programa: cadena.cpp #include <conio.h> #include<iostream.h> class Cadena{ char nombre[64]; public: void leer(); void mostrar(); }; void Cadena::leer() { cout<<”Digite su nombre”; cin>>nombre; } void Cadena::mostrar() { cout<<nombre; } void main() { Cadena objeto; objeto.leer(); objeto.mostrar(); getch(); }

En el anterior ejemplo se captura una cadena de caracteres y al pulsar enter se guarda el

carácter nulo en la siguiente posición donde termina la información. Si al digitar la


información utilizó espacios, solamente se imprimirá en pantalla la información hasta

donde se realizo el primer espacio.

- Si digito: CLASEDEC++

- Imprimirá: CLASEDEC++

- Si digito: CLASE FÁCIL

- Imprimirá: CLASE

Si se desea imprimar la información y que se incluyan los espacios se puede corregir el

programa de dos formas:

Ejemplo A:

//Nombre del programa: cadena2.cpp #include <conio.h> #include<iostream.h> class Cadena{ char nombre[64]; public: void leer(); void mostrar(); }; void Cadena::leer() { cout<<”Digite su nombre”; cin.getline(nombre,sizeof(nombre)); } void Cadena::mostrar() { cout<<nombre; } void main() { Cadena objeto; objeto.leer(); objeto.mostrar(); getch(); }

Ejemplo B:

//Nombre del programa: cadena3.cpp #include <conio.h> #include<stdio.h> #include<iostream.h> class Cadena{ char nombre[64]; public: void leer(); void mostrar(); };


void Cadena::leer() { cout<<”Digite su nombre”; gets(nombre); } void Cadena::mostrar() { cout<<nombre; } void main() { Cadena objeto; objeto.leer(); objeto.mostrar(); getch(); }

En el Ejemplo A se utiliza el metodo cin.getline(), el cual permite imprimir en pantalla

todos caracteres incluidos los espacios.

En el Ejemplo B se utiliza el metodo gets() que pertenece a la librería stdio.h (se debe

incluir en el programa) y permite imprimir una cadena de caracteres incluidos sus espacios.

Envio de cadena de caracteres a métodos

Para pasar cadena de caracteres a un método es semejante a pasar un arreglo como

parámetro. Dentro del método simplemente se especifica el tipo de dato (char) el nombre y

las llaves. No es necesario definir el tamaño del arreglo.

Ejemplo: Hacer un programa que utilice paso de cadenas a métodos y permita capturar una

cadena e imprima carácter por carácter, como también la longitud de esta.

#include<iostream.h> #include<conio.h> #include<stdio.h> //Nombre del programa : cadena4.cpp class Cadena { public: void leer(char cad[]); void mostrar(char cad[]); }; void Cadena::leer(char cad[]) { cout <<"Digite cadena"<<endl; gets(cad); } void Cadena::mostrar(char cad[]) { for(int i=0;cad[i]!='\0';i++) cout<<cad[i]; cout<<endl;


cout<<"La longitud es :"<<i<<endl; } void main(void) { clrscr(); char c[100]; Cadena objeto; objeto. leer(c); objeto.mostrar(c); getch(); }


PUNTEROS (APUNTADORES)

Un puntero corresponde a una variable que contiene una dirección de memoria. Al hacer

uso de este tipo de variables el espacio de almacenamiento utilizado es menor. Cuando los

programas pasan arreglos (ejemplo cadena de caracteres) a un método, lo que se envía es la

dirección de la primera posición del arreglo. Para declarar un apuntador al nombre de la

variable se le antepone un asterisco (*), la sintaxis para definir un apuntador es:

(1) int *cab;

(2) char *Fra;

En el primer caso se crea una variable *cab que contiene la dirección de memoria de un

valor entero y en el segundo caso la variable *Fra contiene la dirección de memoria donde

esta almacenado un valor de caratér.

Manejo de punteros para una cadena de caracteres

Para declarar en un programa un apuntador a una cadena de caracteres, se asigna el tipo de

dato char, el carácter especial asterisco (*) y el nombre del apuntador.

Ejemplo: Hacer un programa que envie una cadena de caracteres a un método y la imprima

utilizando punteros.

//Nombre del programa : puntero1.cpp #include<iostream.h> #include<conio.h> class Cadena { public: void ver(char *t); }; void Cadena::ver( char *t) { while (*t!=’\0’) { cout<<*t; t++; } } void main(void) { clrscr(); Cadena objeto; objeto.ver(“punteros con cadenas”); }


Punteros con otros tipos de arreglos

Aunque el manejo de punteros es más común en las cadenas de caracteres es posible

utilizarlo con otro tipo de arreglos.

Ejemplo: Hacer un programa que inicialice un arreglo de reales y lo imprima en pantalla

utilizando punteros.

//Nombre del programa: puntero2.cpp #include<iostream.h> #include<conio.h> class Cadena{ public: void leer(); void mostrar(float*, int n); }; void Cadena::mostrar(float *a, int n) { int i; for(i=0;i<n;i++) cout<<*(a+i)<<endl; } void Cadena::leer() { int i; float *a; for(i=0;i<10;i++) { cout<<"Digite un numero"; cin>>*(a+i); } mostrar(a,10); } void main(void) {clrscr(); Cadena objeto; objeto.leer(); }

Métodos que cambian valores de los parámetros (paso por referencia)

Para cambiar el valor de un parámetro, un método debe conocer la dirección de memoria de

dicho parámetro. Para ello se utiliza el símbolo (&) que precede al nombre del parámetro al

llamar al método. Dentro del método se definen los apuntadores que recibirán las

direcciones de memoria. Para hacerlo se declaran variables tipo apuntador, es decir, a cada

nombre de variable se le antepone el símbolo (*).

Ejemplo: hacer un programa que imprima en pantalla el siguiente texto usando métodos y

apuntadores:


Valores antes de ir al método 200 400 Valores dentro del método 800 900 Valores Después de ir al método 800 900

//Nombre del programa:cambio.cpp #include <conio.h> #include<iostream.h> class Cambio{ public: void cambiando_valores( int *a, int *b); }; void Cambio::cambiando_valores( int *a, int *b) { *a=800; *b=900; cout<<”Valores dentro del método”<<*a<<” “<<*b<<endl; } void main(void) { Cambio objeto; int valor1=200, valor2=400; cout<<”Valores antes de ir al método”<<valor1<<” “<<valor2<<endl; objeto.cambiando_valores(&valor1,&valor2); cout<<”Valores Después de ir al método”<<valor1<<” “<<valor2<<endl; getch(); }


ESTRUCTURAS

En algunos casos se necesita agrupar diferentes tipos de datos que se relacionan entre sí.

Por ejemplo para la información de un empleado se puede necesitar: - Nombre (char) - Apellido (char) - Dirección (char) - Telefono (char) - Edad (int) - Salario (float)

Para almacenar estos datos relacionados se utiliza una estructura. Una estructura es una

plantilla, en la cual se declaran una serie de variables de diferentes tipos de dato. Para

definir una estructura en C++ se utiliza la palabra reservada struct, seguida del nombre de

esta y se definen los datos que va a contener entre llaves ({}) , una estructura puede

contener una o mas variables definidas a estas se les llama miembros.

Para cada estructura se pueden definir etiquetas que reemplazaran al nombre de la

estructura dentro del programa. La sintaxis es la siguiente: Nombre_estructura

{ miembros (tipos de datos); }etiquetas;

Ejemplo: Hacer un programa que capture e imprima la información básica de un empleado

usando estructuras.

//Nombre del Programa : estruct1.cpp #include<iostream.h> #include<stdio.h> #include<conio.h> class Dato { struct emp{ char nombre[64]; int id; float salario; char telefono[10]; int cargo ; }trab; public: void leer(void); void mostrar(void); }; void Dato::leer(void) { cout<<"digite Nombre:"; gets(trab.nombre); cout<<"\ndigite identificacion:"; cin>>trab.id;


cout<<"\ndigite salario:"; cin>>trab.salario; cout<<"\ndigite telefono:"; gets(trab.telefono); cout<<"\ndigite cargo"; cin>>trab.cargo; } void Dato::mostrar(void) { cout<<"\nSu nombre es::"<<trab.nombre; cout<<"\nSe Identifica con::"<<trab.id; cout<<"\nEl salario es::"<<trab.salario; cout<<"\nEl Telefono es:"<<trab.telefono; cout<<"\nSu cargo es::"<<trab.cargo; } void main() { clrscr(); Dato objeto; objeto.leer(); objeto.mostrar(); getch(); }

En el programa anterior se creó una estructura llamada emp, luego se definió la etiqueta

trab, la cual permite manipular las variables de la estructura sin referirse propiamente al

nombre de la misma.

Para capturar o visualizar un miembro de la estructura se utiliza el nombre de la etiqueta

seguida de un punto y el nombre de la variable Ejemplo: trab.nombre = “Pepe”.

Envio de estructuras a métodos

De la misma forma como se pueden enviar parámetros desde el programa principal a

cualquier método, también se pueden enviar estructuras, para ello se envía el nombre de la

etiqueta que se halla definido y en el método se define el tipo de estructura y la etiqueta que

va a recibir los datos.

//Nombre del programa: estruct2.cpp #include<iostream.h> #include<stdio.h> #include<conio.h> #include<stdlib.h> class Dato{ struct emp{ char nombre[64]; int id; float salario; char telefono[10]; int cargo; };


public: void leer(emp trab); void mostrar(emp trab); }; void Dato::mostrar(emp trab) { cout<<"Nombre del Empleado:"<<trab.nombre; cout<<"\nIdentificación del Empleado:"<<trab.id; cout<<"\nSalario del Empleado:"<<trab.salario; cout<<"\nTelefono del Empleado:"<<trab.telefono; cout<<"\nCargo del Empleado:"<<trab.cargo; } void Dato::leer(emp trab) { int sw=0; while(sw==0) { clrscr(); cout<<"digite Nombre:"; cin>>trab.nombre; cout<<"\ndigite Identificación:"; cin>>trab.id; cout<<"\ndigite Salario:"; cin>>trab.salario; cout<<"\ndigite Telefono:"; cin>>trab.telefono; cout<<"\ndigite cargo:"; cin>>trab.cargo; ver(trab); cout<<"\ncontinuar 0"; cin>>sw; if(sw==0) clrscr(); else exit(0); } } void main() { clrscr(); emp trab; Dato objeto; objeto.leer(trab); getch(); }

Estructuras con arreglos

Las estructuras permiten tener información relacionada de diferente tipo, pero a veces es

necesario poder guardar esa información en un campo de memoria específica. Por ejemplo

en el caso de los empleados de una empresa, cada uno tiene su información personal, para

solucionar el problema de almacenamiento se utilizan arreglos de estructuras.


Ejemplo: El siguiente programa nos permite capturar la información básica de dos

empleados y guardar los datos en un vector.

// Nombre del programa: estruct3.cpp #include<iostream.h> #include<stdio.h> #include<conio.h> class Datos{ struct emp{ char nombre[64]; int id; float salario; char telefono[10]; int cargo; }; emp trab[2]; // creamos una etiqueta arreglo de 2 posiciones public: void leer(void); void mostrar(void); }; void Datos:: leer (void) { int i; for (i=0;i<2;i++) { cout<<"digite Nombre:"; cin>>trab[i].nombre; cout<<"\ndigite Identificación:"; cin>>trab[i].id; cout<<"\ndigite salario:"; cin>>trab[i].salario; cout<<"\ndigite telefono:"; cin>>trab[i].telefono; cout<<"\ndigite codigo de cargo:"; cin>>trab[i].cargo; } } void Datos::mostrar(void) { for (int i=0;i<2;i++) { cout<<"Nombre del Empleado:"<<trab[i].nombre<<endl; cout<<"\nIdentificación del Empleado:"<<trab[i].id<<endl; cout<<"\nSalario del Empleado:"<<trab[i].salario<<endl; cout<<"\nTelefono del Empleado:"<<trab[i].telefono<<endl; cout<<"\nCargo del Empleado:"<<trab[i].cargo<<endl; } } void main() { clrscr(); Datos empleado;


empleado.leer(); empleado.mostrar(); getch(); }

Estructuras con Punteros

Otra forma de almacenar los datos relacionados con las estructuras es la utilización de

punteros.

Ejemplo: Programa que permite capturar la información básica de dos empleados y

guardarlos en una estructura de punteros.

//Nombre del programa : estruct4.cpp #include<iostream.h> #include<stdio.h> #include<conio.h> class Empresa{ struct emp{ char nombre[64]; int id; float salario; char telefono[10]; int cargo; }; emp trab[2],*p; // creamos dos etiquetas un arreglo y un puntero public: void leer(); void mostrar(); }; void Empresa::leer() { int i; p=&trab[0]; // asignamos al puntero la posición cero del arreglo for (i=0;i<2;i++) { cout<<"digite Nombre:"; cin>>p->nombre; cout<<"\ndigite Identificación:"; cin>>p->id; cout<<"\ndigite Salario:"; cin>>p->salario; cout<<"\ndigite Telefono:"; cin>>p->telefono; cout<<"\ndigite Cargo:"; cin>>p->cargo; p++;// incremento del puntero } } void Empresa::mostrar() { p=&trab[0]; // volvemos a la primera posición del arreglo for (int i=0;i<2;i++) { cout<<"\nNombre del Empleado:"<<p->nombre;


cout<<"\nIdentificación del Empleado:"<<p->id; cout<<"\nSalario del Empleado:"<<p->salario; cout<<"\nTelefono del Empleado:"<<p->telefono; cout<<"\nCargo del Empleado:"<<p->cargo; p++; // incremento del puntero getchar(); } } void main() { Empresa objeto; objeto.leer(); objeto.mostrar(); getch(); }

Envio de estructuras de punteros a métodos

Una ventaja de programación de C++ es el manejo de las estructuras con apuntadores,

tambien se pueden definir métodos cuyos parámetros sean punteros.

Ejemplo: Programa que captura los datos de dos estudiantes y los envie a un método por

medio de punteros ( paso por referencia).

//Nombre del programa: estruct5.cpp #include <stdio.h> #include <conio.h> #include <iostream.h> class Materia{ public: struct est{ char nom[40]; int tel; float nota; }; void leer(struct est *as); void mostrar(struct est *as); }; void Materia::leer(struct est *as) {int i; for(i=0;i<2;i++) { cout<<"Digite nombre"<<endl; gets(as->nom); cout<<"Digite telefono "<<endl; cin>>as->tel; cout<<"Digite Nota"<<endl; cin>>as->nota; as++; } }


void Materia::mostrar(struct est *as) {int i; for(i=0;i<2;i++) { cout<<"Nombre : "<<as->nom<<endl; cout<<"Telefono : "<<as->tel<<endl; cout<<"Nota : "<<as->nota<<endl; as++; } } void main() { clrscr(); est pilo[2],*p; Materia objeto; p=&pilo[0]; objeto.leer(p); p=&pilo[0]; objeto.mostrar(p); getch(); }


1. Leer una cadena de caracteres e imprimir si la cadena es un palindromo o no.

2. Leer una cadena de caracteres e imprimir cuantas vocales hay de cada una.

3. Hacer un programa que lea una cadena de caracteres S y un factor de multiplicación N,

cuya función sea generar la cadena dada N veces. Ej: !hola! 3

Imprimira: !hola! !hola! !hola!

4. Leer una cadena de caracteres, e imprimir por separado cada palabra

5. Leer una cadena de caracteres, y dos caracteres adicionales se debe imprimir la cadena

de caracteres modificada, de tal forma que se reemplace el segundo carácter por el

primer carácter leido en la cadena.

6. Leer una cadena de caracteres, e imprimir la cantidad de digitos que contiene dicha

cadena.

7. Leer una cadena de caracteres, e imprimirla carácter por carácter

8. Leer una cadena de caracteres, e imprimir la palabra que contenga la silaba do.

9. Dada una matriz cuadrada de 4×4 (leída previamente por pantalla), escribir un

programa que calcule la suma de todos los elementos que no pertenecen a la diagonal

principal.

10. Escribir un programa que defina una estructura de datos Fecha (compuesta de día, mes

y año), a continuación solicite al usuario dos fechas válidas y las compare imprimiendo

las fechas ordenadas (una en cada línea).

11. Resolver el problema anterior definiendo ahora un puntero a la estructura de datos

Fecha.

12. Se dice que una matriz tiene un punto de silla si alguna posición de la matriz es el

menor valor de su fila, y a la vez el mayor de su columna. Escribir un programa que lea


una matriz de números reales y dimensión 4×4, y calcule la posición de un punto de

silla (si es que existe).

13. Escribir un programa que averigüe si un vector de enteros de tamaño N está contenido

en otro vector de enteros de tamaño M (siendo (NM).

14. Dado un vector, el método de ordenación por inserción directa consiste en insertar “en

su sitio” en cada iteración un elemento del vector, recorriendo el vector de izquierda a

derecha (la parte ordenada). Para ello, se compara el elemento a ordenar, en cada

iteración, con los que lo preceden (subvector ordenado) para “poner dicho elemento en

su sitio”. El siguiente ejemplo ilustra la secuencia de pasos seguida para ordenar un

vector cualquiera por inserción directa.

Figura No. 3. Vector de ordenación

15. 8 16. 1 17. 7 18. 4 19. 2

20. 1 21. 8 22. 7 23. 4 24. 2

25. 1 26. 7 27. 8 28. 4 29. 2

30. 1 31. 4 32. 7 33. 8 34. 2

35. 1 36. 2 37. 4 38. 7 39. 8

En la figura anterior para un vector de 5 elementos, las posiciones sombreadas representan

la parte del vector (subvector) ya ordenada. Escribir un programa que implemente este

método de ordenación por inserción directa.


CLASES EN C++

Introducción a los objetos y a la programación orientada a objetos

A partir de este capitulo se profundizará en la utilización de clases, identificando los

conceptos de: ocultamiento de información, herencia simple y multiple, polimorfismo, así

como el concepto de constructores y destructores, clases amigas, clases virtuales y plantilla

de clases.

Desde que se realizo el primer programa en C++, se ha utilizado la palabra reservada class,

permitiendo definir una clase, que es similar a una estructura, pero, difiere en que ademas

de dicha estructura agrega tambien un comportamiento a los objetos.

Cuando se utilizan objetos en los programas no se necesita saber como realizan las

operaciones los métodos, por ejemplo, en el caso de una clase llamada Archivo, si se

supone que se tiene un método llamado imprimir() ó un método llamado borrar(), no es

necesario saber como estan implementados, esto es lo que se llama ocultamiento de la

información, lo cual, permite tener acceso a cierto datos que son necesario para que el

objeto realice las correspondientes operaciones. En las clases se utilizan miembros public,

private y protected, que se utilizan como modificadores de acceso para ocultar la

información dentro de los programas, a continuación se describe el tipo de acceso que

presenta cada modificador:

- public: permite manipular los miembros datos y los métodos por fuera de la clase.

- private: permite manipular los miembros datos y los métodos solamente dentro de la

clase.

- protected: permite manipular los miembros datos y los métodos para crear herencia.

Empleo de los miembros public y private

Por defecto al crearse una clase si no se define lo contrario todos los miembros son

privados. Sí se intentan modificar datos privados desde fuera de la clase se generara un

error.

Ejemplo: Hacer un programa que capture un ángulo, lo convierta a radianes e imprima el

seno, coseno, la tangente, la secante, la cosecante y la cotangente del ángulo. Los datos

deben ser privados y los métodos públicos. //Nombre del programa: clase1.cpp #include<iostream.h> #include<math.h> #include<stdio.h> const double gra_rad=0.0174532925; class Grado { // datos privados por defecto double valor;


// a partir de aquí todos los datos son publicos public: void pone_v(double ang); double calc_seno(void); double calc_coseno(void); double calc_tang(void); double calc_seca(void); double calc_cose(void); double calc_cotan(void); }grad; void Grado::pone_v(double ang) { valor=ang; } double Grado::calc_seno(void) { double resp; resp=sin(gra_rad*valor); return(resp); } double Grado::calc_coseno(void) { double resp; resp=cos(gra_rad*valor); return(resp); } double Grado::calc_tang(void) { double resp; resp=tan(gra_rad*valor); return(resp); } double Grado::calc_seca(void) { double resp; resp=1.0/sin(gra_rad*valor); return(resp); } double Grado::calc_cose(void) { double resp; resp=1.0/cos(gra_rad*valor); return(resp); } double Grado::calc_cotan(void) { double resp; resp=1.0/tan(gra_rad*valor); return(resp); } void main(void)


{ Grad.pone_v(25.0); cout<<"El Seno del ángulo es :"<<grad.calc_seno()<<endl; cout<<"El Coseno del ángulo es :"<<grad.calc_coseno()<<endl; cout<<"La tangente del ángulo es :"<<grad.calc_tang()<<endl; cout<<"La Secante del ángulo es :"<<grad.calc_seca()<<endl; cout<<"La Cosecante del ángulo es:"<<grad.calc_cose()<<endl; cout<<"La cosecante del ángulo es:"<<grad.calc_cotan()<<endl; getchar(); }

Clases con clases

Dentro de una clase pueden existir una o varias clases para manipular diferentes tipos de

información, es decir, anidamiento de clases.

Ejemplo: Hacer un programa que capture la información básica de un empleado y lo

imprima en pantalla.

#include<iostream.h> #include<math.h> #include<stdio.h> //Nombre del programa: clase2.cpp class Empleado { class datos_emp{ public: char nombre[20]; char apellido[20]; char segundoape[20]; }nom; class Horas_tra{ public: double horas; double salario_base; double salario_extra; }horas; public: void entrada_emp(void); void salida_emp(void); }; void Empleado::entrada_emp(void) { char cr; cout<<"Digite El nombre del Empleado: "; cin>>nom.nombre; cin.get(cr); cout<<"Digite El Primer Apellido: "; cin>>nom.apellido; cin.get(cr);


cout<<"Digite El Segundo Apellido: " ; cin>>nom.segundoape; cin.get(cr); cout<<"Digite Total de horas trabajadas:"; cin>>horas.horas; cin.get(cr); cout<<"Digite El Sueldo base por Horas:"; cin>>horas.salario_base; cin.get(cr); cout<<"Digite El pago por horas Extras:"; cin>>horas.salario_extra; cout<<"\n\n";; }; void Empleado::salida_emp(void) { cout<<nom.nombre<<" "<<nom.apellido<<" "<<nom.segundoape<<endl; if(horas.horas<=40) cout<<"Pago Basico $:"<<horas.horas*horas.salario_base<<endl; else { cout<<"Pago Basico $:"<<40*horas.salario_base<<endl; cout<<"pago Extras $:"<<(horas.horas-40)*horas.salario_base<<endl; } } void main(void) { Empleado trabajador; trabajador.entrada_emp(); trabajador.salida_emp(); getchar(); }

Métodos constructores

Cuando en un programa se crean objetos, una de las operaciones más comunes es inicializar

los miembros datos del objeto. Para inicializar a estos se puede crear un método

constructor, el cual lleva el mismo nombre de la clase y se ejecuta automáticamente, es

decir, no necesita ser invocado.

Los constructores pueden recibir parámetros pero no pueden retornar ningún valor. Cuando

se invoca a un constructor se asigna memoria al objeto que se instancio de la clase.

Ejemplo: Programa que utilice un constructor para inicializar los datos.

//Nombre del programa: clase2.cpp #include <iostream.h> #include<string.h> #include<stdio.h> #include<conio.h> class Emp{ char nom[64]; long id, salario;


public : // se crea un constructor con el mismo nombre de la clase Emp(char *,long ,long); void mostrar(); }; Emp::Emp(char *n,long i, long s) { //Copia una cadena de caracteres strcpy(nom,n); id=i; salario=s; } void Emp::mostrar() { cout<<"\nNombre empleado:"<<nom<<endl; cout<<"\nIdenticación:"<<id<<endl; cout<<"\nsalario:"<<salario; getchar(); } main() { char alt[64]; long anc,pro; cout<<"digite Nombre"; cin.getline(alt,sizeof(alt)); cout<<"\ndigite identificación:"; cin>>anc; cout<<"\ndigite Salario"; cin>>pro; Emp demo(alt,anc,pro); demo.mostrar(); getch(); }

Métodos destructores

También se pueden crear destructores que se invocan automáticamente y permiten liberar

memoria. La diferencia con los constructores es que no se pueden hacer operaciones o

recibir parámetros. El nombre del método debe ser igual al de la clase y se le antepone el

signo de negación (~).

Ejemplo: Programa que utilice un constructor para inicializar los datos y un destructor para

liberar la memoria.

//Nombre del programa: clase3.cpp #include <iostream.h> #include<string.h> #include<stdio.h> #include<conio.h>


class Emp{ char nom[64]; long id, salario; public : // se crea un constructor con el mismo nombre de la clase Emp(char *,long ,long); ~Emp(); void mostrar(); }; Emp::Emp(char *n,long i, long s) { //Copia una cadena de caracteres strcpy(nom,n); id=i; salario=s; } Emp::~Emp() { Cout<<”\n Destruyendo la instancia para:”<<nom<<endl; } void Emp::mostrar() { cout<<"\nNombre empleado:"<<nom<<endl; cout<<"\nIdenticación:"<<id<<endl; cout<<"\nsalario:"<<salario; getchar(); } main() { char alt[64]; long anc,pro; cout<<"digite Nombre"; cin.getline(alt,sizeof(alt)); cout<<"\ndigite identificación:"; cin>>anc; cout<<"\ndigite Salario"; cin>>pro; Emp demo(alt,anc,pro); demo.mostrar(); getch(); }

Sobrecarga de Constructores

Una forma por la que C++ consigue el polimorfismo es mediante el uso de sobrecarga de

métodps. En C++, dos o más métodos pueden tener el mismo nombre, siempre que su

declaración de parámetros sea diferente. Se dice que los métodos que comparten el mismo

nombre están sobrecargados. También se puede realizar la sobrecarga en los constructores.

Ejemplo: Hacer un programa que capture un entero, un float y un double e imprima la raíz

cuadrada de cada uno de ellos utilizando la sobrecarga de constructores.


//Nombre del programa: clase4.cpp #include<iostream.h> #include<conio.h> #include<math.h> class Construye{ int entero, sw; float flotante; long largo; public: Construye (int i); Construye (float f); Construye (long l); void raiz();}; Construye:: Construye (int i) { entero=i; sw=1;} Construye:: Construye (float f) {flotante=f; sw=2;} Construye:: Construye (long l) { largo=l; sw=3;} void Construye:: raiz() { switch(sw) { case 1: { cout<<"La raiz del entero es: "<<sqrt(entero)<<endl; break; } case 2: { cout<<"La raiz del flotante es: "<<sqrt(flotante)<<endl;break; } case 3: { cout<<"La raiz del entero largo es: "<<sqrt(largo)<<endl;break; } } } void main() { clrscr(); Construye objeto1(20); Construye objeto2(35.5f); Construye objeto3(1000000); objeto3.raiz(); objeto1.raiz(); objeto2.raiz(); getch(); }


Herencia

Un objetivo de la programación orientada a objetos es reutilizar código, para ello por medio

de la herencia se puede usar el código de una clase creada para usarlo en otra, lo que

permitirá un ahorro de tiempo y programación. Habrá momentos en que una clase utilice

muchas o todas las características de una clase o miembros método, en otras palabras el

objeto nuevo heredara a los miembros de la clase existente (clase base). Cuando se

construye una nueva clase a partir de una existente, suele llamarse a la clase nueva una

clase derivada.

Herencia Simple

Figura No. 4. Herencia simple

La herencia simple se presenta cuando una clase derivada hereda las características

(atributos y métodos) de una clase base como se observa en el gráfico. Este proceso puede

efectuarse de dos formas: en el caso en que la clase es publica o privada para la clase

derivada. Cuando la clase base es public para la clase derivada, esta solo hereda los

miembros public y protected de dicha clase. En el segundo caso, cuando la clase base es

private para la clase derivada, esta hereda todos los miembros de la clase como private.

En la siguiente tabla se describen los controles de acceso a los miembros según el tipo de

herencia.

Tabla 9. Controles de acceso a miembros en la herencia

Tipo de miembro Tipo de herencia

Public private

Private No accesible

directamente

No accesible

directamente

Protected Protected Private

Public Public Private

Ejemplo: Hacer un programa que simule el retiro de una cuenta de ahorros utilizando

herencia para crear la cuenta.


#include "iostream.h" #include "conio.h" class Cuenta{ protected: float saldo; public: Cuenta(float); float mostrarSaldo(); }; Cuenta::Cuenta(float s) { saldo=s;} float Cuenta::mostrarSaldo() {return saldo;} class CuentaAhorros:public Cuenta{ long clave; public: CuentaAhorros(long,float); void retirar(long , float); }; CuentaAhorros::CuentaAhorros(long cl, float sal):cuenta(sal) {clave=cl;} void CuentaAhorros::retirar(long cl, float val) { if (cl==clave) if (saldo >= (val+10000)) { saldo=saldo-val; cout<<"TRANSACCION EXITOSA";} else cout<<"SALDO INSUFICIENTE"; else cout<<"CLAVE INCORRECTA"; } void main() { long cl; float ret; clrscr(); CuentaAhorros Pedro(1234,100000); cout<<"Digite la clave"; cin>>cl; cout<<"Digite la cantidad a retirar"; cin>>ret; Pedro.retirar(cl,ret); cout<<endl<<"Su saldo es: "<<Pedro.mostrarSaldo(); getch(); }

Herencia multiple


La herencia compuesta o múltiple se presenta cuando una clase derivada hereda las

características de varias clases base. Un ejemplo típico de la herencia múltiple se presenta

en nuestra genética, dado que nosotros heredamos los genes de nuestros padres, asumiendo

que Madre y Padre son cada una un tipo de clase base, Hijo correspondería a una clase

derivada, el cual heredaría los miembros X de la clase Madre y los miembros Y de la Clase

Padre. En la siguiente figura se representa este concepto.

Figura No. 5. Herencia Múltiple


herencia multiple para crear la cuenta.

#include "iostream.h" #include "conio.h" #include "string.h" class Cuenta{ protected: float saldo; public: Cuenta(float); float mostrarSaldo(); }; Cuenta::Cuenta(float s) { saldo=s;} float Cuenta::mostrarSaldo() {return saldo;} class Cliente{ protected: char nombre[64]; char telefono[8];


public: Cliente(char * ,char *); void mostrarDatos(); } Cliente::Cliente(char *nom, char *tel) { strcpy(nombre,nom); strcpy(telefono,tel); } void Cliente::mostrarDatos() { cout<<"Nombre: "<<nombre<<endl; cout<<"Telefono: "<<telefono<<endl; } class CuentaAhorros:public Cuenta, public Cliente{ long clave; public: CuentaAhorros(char *, char *, long,float); void retirar(long , float); }; CuentaAhorros::CuentaAhorros(char *nom, char *tel, long cl, float sal):cliente(nom,tel),cuenta(sal) {clave=cl;} void CuentaAhorros::retirar(long cl, float val) { if (cl==clave) if (saldo >= (val+10000)) { saldo=saldo-val; cout<<"TRANSACCION EXITOSA"<<endl;} else cout<<"SALDO INSUFICIENTE"<<endl; else cout<<"CLAVE INCORRECTA"<<endl; } void main() { long cl; float ret; clrscr(); CuentaAhorros objeto("Pedro","2232425",1234,100000); cout<<"Digite la clave"; cin>>cl; cout<<"Digite la cantidad a retirar"; cin>>ret; objeto.retirar(cl,ret); objeto.mostrarDatos(); cout<<endl<<"Su saldo es: "<<objeto.mostrarSaldo(); getch(); }


Polimorfismo

Semánticamente polimorfismo significa múltiples formas (Poli = Multiple, morfismo=

Formas). En el Paradigma Orientado a Objetos, es la capacidad que poseen los objetos de

clases diferentes, relacionados mediante la herencia, a responder de forma diferente a una

misma llamada de un método miembro. En C++, el polimorfismo se puede presentar como:

métodos virtuales o sobrecarga de operadores.

Figura No. 6. Polimorfismo

En la figura No. 5, se puede observar que en los niveles de las clases está definido el

método hallarArea(), lo cual no implica que dicho método sea igual en todas las clases,

aunque el objetivo sea realizar una operación similar sobre diferentes tipos de objetos. Es

lógico que a cualquier objeto de la clase Figura se le pueda hallar el área, pero los datos y

la forma de hallarla es diferente según el tipo de Figura, es decir, no es lo mismo hallar el

área de un círculo que la de un cuadrado, por consiguiente la implementación del método

hallarArea() varía de un objeto Circulo a un objeto Rectángulo.

Métodos virtuales

Con los métodos virtuales se tiene la posibilidad de realizar polimorfismo, en tiempo de

ejecución. El polimorfismo es el principio de la POO que permite a un método comportarse

de manera diferente sin importar la clase en donde se encuentra, pero, el prototipo del

método se mantiene. Para declarar métodos virtuales utilizamos la palabra reservada

virtual.

Se puede declarar un método virtual en una clase base, y definir varios métodos virtuales en

las clases derivadas, aun si el número y tipo de argumentos son los mismos.

Si dos métodos con el mismo nombre tienen argumentos diferentes, C++ las considera

diferentes y los mecanismos virtuales son ignorados.

Los métodos virtuales pueden ser puros o nulos. Los métodos virtuales puros son aquellos

que se igualan a cero y no se implementan en la clase base, la clase que posee este tipo de


métodos se hace abstracta es decir que no permite que se le instancien objetos pero si

pueden crear apuntadores hacia estas clases.

Continuando con el ejemplo de Figuras, para que los métodos de cada clase puedan tener

una implementación diferente es necesario crear una clase llamada Figura que contenga un

método hallarArea() de tipo virtual.

Ejemplo: public class Figura { protected:

integer x; integer y; virtual double hallarArea()=0; };

La notación virtual double hallarArea()=0; indica que el método hallarArea() es un método

virtual puro, es decir, que en las clases derivadas deberá implementarse.

public class Circulo: public Figura public class Rectangulo: public Figura { { private: private: double radio; double ancho, alto; virtual double hallarArea() virtual double hallarArea() { double PI=3.1416; { return PI*(radio*radio); return (ancho*alto); } } }; };


herencia, métodos virtuales puros y clases abstractas para crear la cuenta. #include "iostream.h" #include "conio.h" class Cuenta{ protected: float saldo; public: Cuenta(float); float mostrarSaldo(); virtual void retirar(long,float)=0; }; Cuenta::Cuenta(float s) { saldo=s;} float Cuenta::mostrarSaldo() {return saldo; } class CuentaAhorros:public cuenta{ long clave;


public: CuentaAhorros(long,float); void retirar(long , float); }; CuentaAhorros::CuentaAhorros(long cl, float sal):cuenta(sal) {clave=cl;} void CuentaAhorros::retirar(long cl, float val) { if (cl==clave) if (saldo >= (val+10000)) { saldo=saldo-val; cout<<"TRANSACCION EXITOSA";} else cout<<"SALDO INSUFICIENTE"; else cout<<"CLAVE INCORRECTA"; } class CuentaCte:public Cuenta{ long cheques; public: CuentaCte(long,float); void retirar(long,float); }; CuentaCte::CuentaCte(long ch, float sal):cuenta(sal) {cheques=ch;} void CuentaCte::retirar(long ch, float val) { cheques-=ch; if (cheques>0) if (saldo >= (val+10000)) { saldo=saldo-val; cout<<"TRANSACCION EXITOSA";} else cout<<"SALDO INSUFICIENTE"; else cout<<"NO POSEE CHEQUES DISPONIBLES PARA LA TRANSACCION"; } void main() { long dato; float ret; int op; clrscr(); CuentaAhorros Pedro(1234,100000); CuentaCte Carlos(10,200000); cout<<"1. Retirar Cuenta de Ahorros"<<endl;; cout<<"2. Retirar Cuenta Corriente"<<endl; cout<<"3. Salir"<<endl; cin>>op; switch(op) { case 1:


cout<<"Digite la clave"; cin>>dato; cout<<"Digite la cantidad a retirar"; cin>>ret; Pedro.retirar(dato,ret); cout<<endl<<"Su saldo es: "<<Pedro.mostrarSaldo(); break; case 2: cout<<"Digite la cantidad de cheques a utilizar para la transaccion "; cin>>dato; cout<<"Digite la cantidad a retirar"; cin>>ret; Carlos.retirar(dato,ret); cout<<endl<<"Su saldo es: "<<Carlos.mostrarSaldo(); break; case 3: cout<<"FIN DE APLICACION"; break; } getch(); }

Ejercicio 2: Realizar un programa que lee una cadena de caracteres del teclado y halle el

número de vocales que contiene. Utilizar dos métodos virtuales; uno que cuente las vocales

y otro que retorne el valor para ser impreso.

//Nombre del programa: base.cpp #include<iostream.h> #include<conio.h> #include<string.h> #include<stdio.h> class Base{ public: virtual void contar(){} virtual int mostrar(){return 0;} //Siempre se declaran en la clase base con la palabra virtual }; class A:public Base{ int i; public: A(int j=0){i=j;} void contar(){i++;} int mostrar(){return i;} }; class E:public Base{ int i; public: E(int j=0){i=j;} void contar(){i++;} int mostrar (){return i;}


}; class I:public Base{ int i; public: I(int j=0){i=j;} void contar(){i++;} int mostrar (){return i;} }; class O:public Base{ int i; public: O(int j=0){i=j;} void contar(){i++;} int mostrar (){return i;} }; class U:public Base{ int i; public: U(int j=0){i=j;} void contar(){i++;} int mostrar (){return i;} }; void main() {Base nada,*p; A a; E e; I i; O o; U u; cout<<"De una cadena de caracteres"<<endl; char cadena[70]; gets(cadena); for(int j=0;cadena[j]!='\0';j++){ switch(cadena[j]) { case 'a': p=&a;break; case 'e': p=&e;break; case 'i': p=&i;break; case 'o': p=&o;break; case 'u': p=&u;break; default : p=&nada;break; } p->contar(); } cout<<"Numero de vocales A= "<<a.A::mostrar()<<endl; cout<<"Numero de vocales E= "<<e.E:: mostrar()<<endl; cout<<"Numero de vocales I= "<<i.I:: mostrar()<<endl; cout<<"Numero de vocales O= "<<o.O:: mostrar()<<endl; cout<<"Numero de vocales U= "<<u.U:: mostrar()<<endl; getch(); }


Cuando se trabaja con métodos virtuales, se debe tener encuenta los siguiente:

No es necesario implementar código dentro del método en la clase base.

No se pueden definir objetos de la clase base, dado que los métodos virtuales puros

no pueden ser llamados por los objetos, aunque se pueden utilizar punteros a la

clase base, para hacer uso de sus miembros. Para ello se definen las clases

abstractas.

Clases abstractas

Una clase abstracta corresponde a aquella que posee uno o varios métodos virtuales, lo cual

implica que no podrá implementarse, es decir, no se podrán instanciar objetos de la misma.

Las clases que deriven de una clase abstracta deben implementar los métodos virtuales; a

este tipo de clases se les denomina clases derivadas concretas.

Por lo general se definen las clases abstractas para generalizar las características comunes

de una categoría, lo que facilita el diseño de la Programación Orientada a Objetos y

garantiza el principio de abstracción.

Por ejemplo, cuando se desea trabajar con dos entidades, Docente y Estudiante, es evidente

que las dos poseen características comunes como: nombre, apellido, edad, dirección, y

teléfono, entre otras, pero que cada una se desempeña de forma diferente, por lo cual

cuando se va a diseñar alguna aplicación que haga referencia a estos datos, se puede

presentar la siguiente gerarquía.

Figura No. 7. Clase abstracta

En la figura No. 6, se puede observar que tanto un objeto de tipo docente Planta y un objeto

estudiante Monitor heredan los miembros de la clase Persona, y es normal, dado que los

dos son personas, aunque su funcionalidad no sea la misma. En este caso la clase Abstracta

Persona, encapsula los datos básicos de cualquier persona del sistema y la funcionalidad

común, por ejemplo todas las personas del sistema podran adicionar materias, aunque un

Docente deberá adicionar las materias que deberá dictar y un Estudiante las que debe ver

durante un semestre. Por lo tanto la clase Persona debe tener un método virtual puro

denominado adicionarMateria() y cada clase derivada lo deberá implementar según sea el

caso.

Ejemplo: class Persona { private: char nom[35];


char apell[35]; integer ed; char dir[35]; char tel[7];

virtual void adicionarMateria()=0; };

Sobrecarga de Operadores (Operadores Homónimos)

En algunas ocasiones se puede utilizar los operadores homónimos para reemplazar un

nombre de un método. Por ejemplo se podriá tener un método llamado suma, este nombre

se puede reemplazar por el operador “+” utilizando el comando operator.

método normal: void suma(int x, int z);

método con operador homónimo: void operator +(int x, int z);

La siguiente tabla muestra los operadores que se pueden sobrecargar.

Tabla 10. Operadores para sobrecargar

+ - * / % ^ &

| ~ ! = < > +=

-= *= /= %= ^= &= |=

<< >> >>= <<= == != <=

>= && || ++ -- ->* ,

-> [] () new new[] delete delete[]

El objetivo de la sobrecarga de operadores es hacer que los operadores cumplan su función

independiente del tipo de dato o de objeto que los invoque.

Ejemplo: Hacer un programa que sume dos objetos tipo Vector utilizando la sobrecarga del

operador +.

#include <iostream.h> #include <conio.h> class Vector { public: float x, y; Vector(); Vector operator+(Vector); void leerX(float x); void leerY(float y); float mostrarX(); float mostrarY(); ~Vector(); }; Vector::Vector()


{ x=0; y=0; cout<<"Objeto creado"<<endl;} Vector::~Vector() { cout<<"Objeto Destruido"<<endl;} Vector Vector::operator+ (Vector v2) { Vector vr; // objeto temporal vr.x=(x + v2.x); vr.y=(y + v2.y); return vr; }; void Vector::leerX(float vx) {x=vx;} void Vector::leerY(float vy) {y=vy;} float Vector::mostrarX() {return x;} float Vector::mostrarY() {return y;} void main () { Vector Objeto1,objeto2,objeto3; objeto1.leerX(5); objeto1.leerY(6); objeto2.leerX(4); objeto2.leerY(3); objeto3 = objeto1 + objeto2; cout << "Rx = " << objeto3.mostrarX() << endl; cout << "Ry = " << objeto3.mostrarY() << endl; cout << "objeto1.x = " << objeto1.mostrarX() << " objeto1.y = " << objeto1.mostrarY() << endl; getch(); }

Miembros Friends

Dependiendo del uso de un objeto, habrá ocasiones en que resulte posible incrementar el

rendimiento de un programa, permitiendo que una clase ingrese a miembros privados de

otra en forma directa. De esta manera, los programas evitan el tiempo en exceso de

procesamiento (tiempo de ejecución) necesario para llamar a los métodos de la interfaz. En

tales casos se pueden definir clases como friends (amigas) de otra, lo que deja que la clase

entre a los miembros privados de la clase amiga.

Ejemplo 1: Hacer un programa que permita manejar los datos de un libro con un usuario

específico, utilizando clases amigas.

#include<iostream.h> #include<stdio.h> #include <string.h> class Libro{ public : Libro(char *,char *,char *); void mostrar(void);


friend Bibliotecario; private : char titulo[64]; char autor[64]; char catalogo[64]; }; Libro::Libro(char *t,char *a,char *ca) { strcpy(lib::titulo,t); strcpy(lib::autor,a); strcpy(lib::catalogo,ca); } void Libro::mostrar(void) { cout<<"Titulo:"<<titulo<<endl; cout<<"Autor:"<<autor<<endl; cout<<"Catalogo:"<<catalogo<<endl; } class Bibliotecario{ public: void captura_catalogo(libro * ,char *); }; void Bibliotecario::captura_catalogo( libro *es, char *nvoc) { strcpy(es->catalogo,nvoc); } void main(void) { Libro objeto("Lenguaje C++","Deitel","Programación"); Bibliotecario admin; objeto.mostrar(); admin.capturar_catalogo(&objeto,"Lenguajes de Programación"); objeto.mostrar(); getchar(); }

Ejemplo 2: Hacer un programa que implementa una clase amiga con restricciones, es decir,

que se puede tener acceso a los métodos pero no a los atributos.

#include<iostream.h> #include<stdio.h> #include<conio.h> #include <string.h> class Libro; class Bibliotecario { public: void captura_catalogo(libro * ,char *); char *ob(libro); };


class Libro{ public : Libro(char *,char *,char *); void mostrar(void); friend char *Bibliotecario::ob(libro); friend void Bibliotecario::captura_catalogo(libro * ,char *); private : char tit[64]; char autor[64]; char catalogo[64]; }; Libro::Libro(char *t,char *a,char *catalogo) { strcpy(libro::tit,t); strcpy(libro::autor,a); strcpy(libro::catalogo,catalogo); } void Libro::mostrar(void) { cout<<"titulo:"<<tit<<endl; cout<<"autor:"<<autor<<endl; cout<<"Catalogo:"<<catalogo<<endl; } void Bibliotecario::captura_catalogo( libro *es, char *nvoc) { strcpy(es->catalogo,nvoc); } char *Bibliotecario::ob(libro es) { static char catalog[64]; strcpy(catalog,es.catalogo); return catalog; } void main(void) { clrscr(); Libro objeto("Lenguaje C++","Deitel","Programación"); Bibliotecario biblia; objeto.mostrar(); biblia.captura_catalogo(&objeto,"Lenguajes de Programación"); cout<<"Nuevo catalogo: "<<biblia.ob(objeto)<<endl; objeto.mostrar(); getchar(); }


Ejemplo 3: realizar un programa que dibuje un cuadro y una linea, le coloque un color al

cuadro y luego pinte del mismo color la linea, utilizando clases amigas.

//Nombre del programa: amigas3.cpp #include<iostream.h> #include<conio.h> #include<string.h> #include<stdio.h> class Linea; class Cuadro{ int color; int six,siy; int idx,idy; public: friend int mismo_color(linea l, cuadro b); void poner(int c); void define(int x1,int y1, int x2, int y2); void mostrar(void); }; class Linea{ int color;int prinx,priny; int largo; public: friend int mismo_color(linea l, cuadro b); void poner(int c); void definelinea(int x,int y, int l); void mostrarlinea(void); }; int mismo_color(linea l, cuadro b) { if(l.color==b.color) return 1; return 0; } void Cuadro::poner(int c) { color=c; } void Linea::poner(int c) { color=c; } void Cuadro::define(int x1,int y1, int x2, int y2) { six=x1; siy=y1; idx=x2; idy=y2; } void Cuadro::mostrar(void) { int i;


textcolor(color); gotoxy(six,siy); for(i=six;i<=idx;i++) cprintf("-*"); gotoxy(six,idy-1); for(i=six;i<=idx;i++) cprintf("-*"); gotoxy(six,siy); for(i=siy;i<=idy;i++) { cprintf("|"); gotoxy(six,i); } gotoxy(idx+7,siy); for(i=siy;i<=idy;i++) {cprintf("|"); gotoxy(idx+7,i); } } void Linea::definelinea(int x,int y, int l) { prinx=x; priny=y; largo=l; } void Linea::mostrarlinea(void) { int i; textcolor(color); gotoxy(prinx,priny); for(i=0;i<largo;i++) cprintf("-"); } void main() { clrscr(); Cuadro b; Linea l; b.define(10,10,15,15); b.poner(5); b.mostrar(); l.definelinea(20,20,30); l.poner(7); l.mostrarlinea(); if(!mismo_color(l,b)) cout<<"\nColores diferentes"<<endl; cout<<"\nDigite enter para continuar"<<endl; getch(); //clrscr(); l.definelinea(20,20,30); l.poner(5); l.mostrarlinea(); if(mismo_color(l,b)) cout<<"\nColores Iguales "<<endl; cout<<"\nDigite enter para continuar"<<endl; getch(); }


Empleo del almacenamiento libre

Cuando se declara un arreglo se asigna memoria para almacenarlo. Con el tiempo es

posible que el tamaño del arreglo no sea lo suficientemente grande para contener los datos

necesarios, para solucionar este inconveniente se utiliza el operador new. Así mismo en

algunos casos es necesario liberar memoria por lo cual se utiliza el operador delete.

Operador new

Permite asignar memoria durante la ejecución de un programa. Para utilizar new se debe

especificar el número de bytes que requiere el arreglo.

Operador Delete

Permite liberar memoria que previamente ha sido asignada con el operador new.

Ejemplo: Hacer un programa que inicialice dos arreglos, uno de enteros y otro de flotantes

por medio de asignación de memoria dinamica, que utilice los operaores new y delete.

//Nombre del programa: libre.cpp #include<iostream.h> #include<string.h> #include<conio.h> #define max 20 class Libre{ int* arreglo_enteros; float* arreglo_flotantes; int i; public: Libre(); void enteros(void); void flotantes(void); }; Libre::Libre(){ arreglo_enteros= new int [max]; arreglo_flotantes=new float[max]; } void Libre::enteros(void) { if (arreglo_enteros!=NULL) { for(i=0;i<max;i++) arreglo_enteros[i]=i+1; for(i=0;i<max;i++) cout<<arreglo_enteros[i]<<' '; cout<<endl;


delete arreglo_enteros; } } void Libre::flotantes(void) { if (arreglo_flotantes!=NULL) { for(i=0;i<max;i++) arreglo_flotantes[i]=i+1.5; for(i=0;i<max;i++) cout<<arreglo_flotantes[i]<<"\t"; cout<<endl; delete arreglo_flotantes; } } void main(void) { clrscr(); Libre objeto; cout<<"\t\t\tLista de Enteros \n\n"; objeto.enteros(); cout<<"\n\t\t\tLista de Reales \n\n"; objeto.flotantes(); getch(); }


1. Realizar un programa que solicite los datos de un Empleado ( nombre, cargo, horas

trabajadas, valor del día) y calcule el valor que se le debe cancelar.

2. Hacer un programa que cree una cuenta corriente y permita hacer las siguientes

operaciones:consignar, retirar, ver saldo, sobregiro de 100000, tantas veces como el

usuario desee, tenga en cuenta que se debe generar un numero aleatorio para el

Numero de cuenta.

3. Crear un programa que dibuje las siguientes figuras geométricas: círculo, cuadrado.

4. realizar un programa que calcule el área de un circulo y el volumen de un cilindro.

5. hacer un programa que calcule el área de un triangulo y/o el área de un

paralelogramo.

6. Hacewr un programa que solicite dos números y verifique si son amigos o no.

Tenga en cuenta el siguiente diagrama de clases.

Figura No. 8.

perfecto amigo

Protected:

int num;

Public: Public :

Void leer( );


int verifica_perfecto ( int) void verifica _ amigo(int);

int mostrar( );

El método verifica_amigo(), recibe un entero correspondiente a otro numero

almacenado en otro objeto de tipo amigo, está verifica por medio del método

verifica_perfecto() si dos números son amigos. El main () quedaría así:

int main()

{ amigo obj1,obj2;

obj1.leer( ) ;

obj2.leer( ) ;

obj1.verifica _ amigo( obj2.mostrar( ));

return(0);

}

7. Cree un programa que solicite 3 notas de tres estudiantes y calcule el promedio de

cada uno y el promedio total (cree la clase persona y la clase estudiante).

8. Hacer un programa que solicite los datos necesarios para imprimir el área de un

cuadrado y/o el volumen de un cubo.

9. Realice un programa que solicite los datos necesarios para imprimir el resultado de

la siguiente ecuación y = 5*x+(x!). (cree la clase factorial y la clase formula).

10. Cree un programa que simule el funcionamiento de una calculadora científica

(además de las operaciones básicas (+, -, /, *, mod), los métodos tan (), sec( ), cosec

() , etc, (cree las clases calculadora_estandar y calculadora_cientifica).


PLANTILLAS

Cuando se crean métodos en los programas, pueden existir métodos que realicen un

procesamiento semejante, pero trabajen con tipos diferentes. Como se observo

anteriormente existen métodos homónimos que contienen distintos parámetros pero el

mismo nombre del método. Sin embargo cuando los métodos utilizan diferentes tipos de

datos y realizan un mismo proceso se pueden crear plantillas.

Una plantilla (template) define un método sin tipo, para la cual los programas especificaran

posteriormente los tipos correctos conforme necesite el método. Como ejemplo se puede

considerar un método que devuelva el valor minimo de dos valores independiente de su

tipo, se podria definir un método por cada tipo de dato que se puedan presentar (int, float,

double, long, etc.), aunque se puede, en este caso es ideal utilizar plantillas, de la siguiente

manera: //Declaración de la plantilla de métodos Template < class T> T minimo(T a, T b);

En este caso con <class T> se está indicando que se trata de una plantilla cuyo parámetro va

a hacer de tipo T y que el valor de retorno y cada uno de los parámetros van a ser de tipo de

dato T. la definición de la pantillas seria: //Declaración de la plantilla de métodos Template < class T> T minimo(T a, T b) { If (a<b) return a; else return b; }

De una manera semejante como se hace para los métodos se puede realizar para las clases

por medio de las plantillas de clases. Se define un parámetro que indica el tipo de dato con

el que se crearan objetos.

Ejemplo: Crear dos programas (con y sin plantillas) que almacene 20 numeros en un

arreglo de tipo entero y 20 numeros en un arreglo de tipo flotante e imprima la suma y el

promedio de cada lista de numeros.

Programa sin plantillas

#include<iostream.h> #include<conio.h> #include<stdlib.h> #include<string.h> class Arreglo{ int *datos; int tama; int i;


public: Arreglo(int tama); long suma(void); int promedio(void); void mostrar(void); int sumar(int); }; Arreglo::Arreglo(int tama) { datos=new int[tama]; if(datos==NULL) { cerr<<"Memoria insuficiente ...FIN!!!!"<<endl; exit(1); } Arreglo::tama=tama; Arreglo::i=0; } long Arreglo::suma(void) { long suma=0; int j; for(j=0;j<i;j++) suma +=datos[j]; return (suma); } int Arreglo::promedio(void) { long suma=0; int j; for(j=0;j<i;j++) suma+=datos[j]; return (suma /i); } void Arreglo::mostrar(void) { int j; for(j=0;j<i;j++) cout<<datos[j]<<' '; cout<<endl; } int Arreglo::sumar(int valor) { if(i==tama) return (-1); else { datos[i]=valor; i++; return 0; }


} main() { clrscr(); Arreglo numeros(100); int j; for(j=0;j<50;j++) numeros.sumar(j); numeros.mostrar(); cout<<"La suma de los numeros es : "<<numeros.suma()<<endl; cout<<"El promedio es: "<<numeros.promedio()<<endl; getch(); return 0; }

Programa con plantillas

#include<iostream.h> #include<conio.h> #include<stdlib.h> #include<string.h> template<class T,class T1> class Arreglo { T *datos; int tama; int i; public: Arreglo(int tama); T1 suma(void); T promedio(void); void mostrar(void); int sumar(T); }; template<class T,class T1> Arreglo<T,T1>::Arreglo(int tama) { datos=new T[tama]; if(datos==NULL) { cerr<<"Memoria insuficiente ...FIN!!!!"<<endl; exit(1); } Arreglo::tama=tama; Arreglo::i=0; } template<class T,class T1> T1 Arreglo<T,T1>::suma(void) { T1 suma=0; int j;


for(j=0;j<i;j++) suma +=datos[j]; return (suma); } template<class T,class T1> T Arreglo<T,T1>::promedio(void) { T1 suma=0; int j; for(j=0;j<i;j++) suma+=datos[j]; return (suma /i); } template<class T,class T1> void Arreglo<T,T1>::mostrar(void) { int j; for(j=0;j<i;j++) cout<<datos[j]<<endl; cout<<endl; } template<class T,class T1> int Arreglo<T,T1>::sumar(T valor) { if(i==tama) return (-1); else { datos[i]=valor; i++; return 0; } } main() { clrscr(); Arreglo<int, int>numeros(20); Arreglo<float, float>valores(20); int j; for(j=0;j<20;j++) numeros.sumar(j); numeros.mostrar(); cout<<"La suma de los numeros es : "<<numeros.suma()<<endl; cout<<"El promedio es: "<<numeros.promedio()<<endl; for(j=0;j<20;j++) valores.sumar(j*100.2); valores.mostrar(); cout<<"La suma de los numeros es : "<<valores.suma()<<endl; cout<<"El promedio es: "<<valores.promedio()<<endl; getch(); return 0; }


OPERACIONES DE E/S CON ARCHIVOS

En ocasiones es necesario guerdar información en un medio de almacenamiento fijo, y

tambien poderla recuperar, para ello se utilizan los archivos. C++ proporciona un conjunto

de clases de flujo de archivo que hacen fáciles las operaciones de entrada y salida en un

archivo. Para trabajar con archivos en C++ es necesario incluir el archivo de cabecera

fstream.h.

Creacion de un archivo

Un archivo se crea utilizando la clase ofstream de la siguiente forma:

Sintaxis

ofstream nombre_objeto (“nombre del arhivo”);

Ejemplo

ofstream archivo(“datos.txt”);

Apertura de un archivo

La clase que permite la apertura de un archivo que previamente se ha creado es la ifstream

Sintaxis

ifstream nombre_objeto(“nombre del arhivo”,<parametros de apertura>);

Ejemplo

ifstream archivo(“datos.txt”);

Existen diferentes parámetros de apertura de archivos que permiten abrir el archivos con

restricciones.

Formatos:

Para agregar mas información al final de un archivo, el parámetro a utilizar es ios::app,

su sintaxis es : ifstream archivo (“nombre del archivo”, ios::app);

Para colocar el apuntador al final de un archivo el parámetro a utilizar es ios::ate, su

sintaxis es : ifstream archivo (“nombre del archivo”, ios::ate);

Si el archivo existe y fallá la operación de apertura del archivo, y no se quiere

reemplaza el archivo el parámetro a utilizar es : ios::noreplace, su sintaxis es: ifstream archivo (“nombre del archivo”, ios::noreplace);

El parámetro que permite especificar que el archivo es de solo lectura es ios::out, su

sintaxis es: ifstream archivo (“nombre del archivo”, ios::out);


Prueba de error en la apertura de un archivo

Es necesario controlar la apertura de un archivo. Si el archivo existe se podra leer, en caso

contrario, se debe generar un error, indicando que el archivo no existe. Para esto utilizamos

el método fail().

Sintaxis nombre_objeto.fail( )

Ejemplo

if(archivo.fail()) cerr <<”Error el archivo no existe”<<endl;

Cierre de un archivo

Cuando no se necesita realizar mas operaciones con un archivo, es necesario cerrarlo para

proteger la información, para esto se utiliza el metodo close( ) del objeto creado a partir de

ofstream.

Sintaxis nombre_objeto.close( );

Ejemplo Archivo.close( );

Escritura de información en un archivo

Para escribir información en un archivo, se debe previamente crear el objeto de tipo

ofstream( para crear un archivo) o un objeto de tipo ifstream ( para generar la apertura de

un archivo que ya ha sido creado).

Para escribir informacion en un archivo despues de la creacion del mismo, se debe utilizar

el operador <<.

Ejemplo: realizar un programa que permita guardar información en un archivo llamado

DATOS.TXT.

#include<fstream.h> #include<conio.h> class Datos{ public: void escribir(void) {ofstream archivo("DATOS.TXT"); //apertura de un archivo if(archivo.fail()) cerr <<"Error el archivo no existe"<<endl; else { archivo<<"Universidad Distrital"<<endl; archivo<<"Facultad Tecnologica"<<endl;


archivo<<"Sistematizacion de Datos"<<endl; archivo.close(); } } }; void main() { clrscr(); Datos objeto; objeto.escribir(); getch(); }

Leer la información de un archivo

Para la leer la información de un archivo debemos utilizar la clase ifstream del archivo de

cabecera stream.h. este objeto en los programas enviara la salida hacia la pantalla.

Ejemplo: Hacer un programa que lea toda la información que contiene un archivo de texto

llamado DATOs.DAT.

#include<iostream.h> #include<fstream.h> #include<stdio.h> class Datos { public: void mostrar() { char letra; ifstream archivo("DATOS.DAT") ; if(archivo.fail()) cerr <<”Error el archivo no existe”<<endl; else { while (!archivo.eof()) { letra=archivo.get(); cout<<letra<<endl; } } //se cierra el archivo archivo.close(); } }; void main()


{ Datos objeto; objeto.mostrar(); getchar(); }

Leer un archivo linea por línea

La información almacenada en los archivos se puede leer de diversas formas, una de ellas

es leerlo línea por línea.

Ejemplo 1: Realizar un programa que lea la información de un archivo línea por línea.

#include<iostream.h> #include<fstream.h> #include<stdio.h> class Datos { public: void mostrar() { char uno[64], dos[64],tres[64]; ifstream archivo("DATOS.DAT") ; if(archivo.fail()) cerr <<”Error el archivo no existe”<<endl; else { archivo.getline(uno,sizeof(uno)); archivo.getline(dos,sizeof(dos)); archivo.getline(tres,sizeof(tres)); cout<<uno<<endl; cout<<dos<<endl; cout<<tres<<endl; } //se cierra el archivo archivo.close(); } }; void main(void) { Datos objeto; objeto.mostrar(); getchar(); }

En el programa anterior se lee un archivo linea por linea, pero si el archivo contiene

demasiadas líneas, seria muy tedioso leerlo.


Ejemplo 2: Realizar un programa que lea la información de un archivo línea por línea,

utilizando bucles de control.

#include<iostream.h> #include<fstream.h> #include<stdio.h> class Datos { public: void mostrar() { char linea[64]; ifstream archivo("DATOS.DAT") ; if(archivo.fail()) cerr <<”Error el archivo no existe”<<endl; else while (!archivo.eof()) { archivo.getline(linea,sizeof(linea)); cout<<linea<<endl; } archivo.close(); } }; void main(void) { Datos objeto; objeto.mostrar(); getchar(); }

Se utilizo el bucle while controlado por la condición (!archivo.eof()) que permite leer un

archivo mientras no sea fin de archivo.

Leer un archivo palabra por palabra

La información almacenada en los archivos también es posible leerla palabra por palabra.

Ejemplo: Hacer un programa que lea un archivo e imprima las palabras que contiene dicho

archivo.

#include<iostream.h> #include<fstream.h> #include<stdio.h> #include<conio.h>


class Datos { public: void mostrar() { char palabra[64]; ifstream archivo("DATOS.DAT") ; if(archivo.fail()) cerr <<”Error el archivo no existe”<<endl; else { while (!archivo.eof()) { archivo>>palabra; cout<<palabra<<endl; } archivo.close(); } } }; void main(void) { Datos objeto; objeto.mostrar(); getchar(); }

Leer un archivo letra x letra

Además de las anteriores formas de mostrar la información de un archivo es posible leer el

archivo y mostrar su contenido letra por letra.

Ejemplo: Hacer un programa que lea un archivo e imprima todo el archivo letra por letra.

#include<iostream.h> #include<fstream.h> #include<stdio.h> class Datos { public: void mostrar() { char letra; ifstream archivo("DATOS.DAT") ; if(archivo.fail()) cerr <<”Error el archivo no existe”<<endl; else { while (!archivo.eof()) { letra=archivo.get(); cout<<letra<<endl; }


archivo.close(); } } }; void main(void) { Datos objeto; objeto.mostrar(); getchar(); }


Bibliografía

Becerra S, Cesar A., Lenguaje C, el nuevo concepto, Editorial Kimpresxltda, 1987.

Brian M., Ritchie., El lenguaje de programación C, Prentice Hall, 1991.

Ceballos, Franscisco J., Enciclopedia del Lenguaje C, Editorail Alfaomega, 1997.

Ceballos, Francisco J.: Programación orientada a objetos con C++. Ra-ma.

Charte Ojeda, F., Programación con C++ Builder 5. Anaya Multimedia, 2000.

Deitel, H.M., Como Programar C++, Editorial Prentice Hall, 1999.

Jamsa, Kris., Aprenda C++ paso a paso, Editorial Alfaomega, 1997.

Joyanes Aguilar, Luis., Borland C++ 4/4.5 Iniciación y Referencia, Mc Graw Hill,

1996.

Joyanes Aguilar, L.: Programación en C++. McGraw-Hill, 2000.

Reisdorph, K.: Aprendiendo Borland C++ Builder 3 en 21 días. Prentice-Hall, 1999.

Schildt, H.: C. Manual de referencia. Osborne/McGraw-Hill, 1990.


Infografia

http://www.itlp.edu.mx/publica/tutoriales/tutorc/t173.htm

http://es.tldp.org/Manuales-LuCAS/doc-tutorial-c++/html/c347.html

http://lorca.umh.es/isa/es/asignaturas/ia/temas/Tema%207-Clases%20en%20C++.pdf

http://es.wikipedia.org/wiki/Programaci%C3%B3n_orientada_a_objetos

http://ieee.udistrital.edu.co/concurso/programacion_orientada_objetos/poo/historia.html

http://www.ati.es/novatica/1995/mar-abr/n114obje.html

http://www.itlp.edu.mx/publica/tutoriales/tutorc/t173.htm

http://es.tldp.org/Manuales-LuCAS/doc-tutorial-c++/html/c347.html

http://lorca.umh.es/isa/es/asignaturas/ia/temas/Tema%207-Clases%20en%20C++.pdf

http://es.wikipedia.org/wiki/Programaci%C3%B3n_orientada_a_objetos

http://ieee.udistrital.edu.co/concurso/programacion_orientada_objetos/poo/historia.html

http://www.ati.es/novatica/1995/mar-abr/n114obje.html


EJERCICIOS ANEXOS

Ejemplo: programa en C++ donde utilizamos algunos de los caracteres especiales

//Nombre del programa: especial.cpp # include <iostream.h> class Especial{ public: void ver(void); }; void Especial::ver(void) { cout<<”Aquí realizamos un saldo de línea \n”; cout<<”Aquí realizamos una Tabulación horizontal\t...cierto..que chevere”; cout<<”\n\a realiza un salto de línea ,pita y escribe esto”; } main(){ clrscr() //Método que limpia pantalla Especial caracter; carater.ver(); getch();}

Representación de valores en Octal y Hexadecimal

El siguiente programa mostrara inicialmente un numero en formato decimal, luego por

medio de la orden oct lo convertiremos en octal y con hex lo convertiremos en

hexadecimal.

//Nombre del programa:octhex.cpp #include <iostream.h> class OcHex{ public: void ver(void); }; void OcHex::ver(void) { int a=10; cout<<”Valor en decimal”<<a<<endl; cout<<”Su valor en octal “<<oct<<a<<endl; cout<<”Su valor en hexadecimal”<<hex<<a<<endl; cout<<”Nuevamente en decimal”<<a<<endl; } main() { clrscr() //Método que limpia pantalla OcHex numero; numero.ver(); getch(); }


Control de ancho

Para seleccionar el ancho de una impresión en pantalla podemos utilizar la instrucción setw

ó la instrucción cout.width que se encuentran en el archivo de cabecera iomanip.h.

Ejemplo 1: Hacer un programa que imprima él numero 1250 con 4, 5, 6, 7 espacios en

pantalla utilizando setw.

//Nombre del programa: ancho.cpp #include<iostream.h> #include<iomanip.h> class Ancho{ public: void ver(void); }; void Ancho::ver(void) { cout<<”La impresión sin espacios :”<<setw(4)<<1250<<endl; cout<<”La impresión con un espacio :”<<setw(5)<<1250<<endl; cout<<”La impresión con dos espacios:”<<setw(6)<<1250<<endl; cout<<”La impresión con tres espacios:”<<setw(7)<<1250<<endl; } main() { clrscr() //Método que limpia pantalla Ancho formato; formato.ver(); getch(); }

Ejemplo 2: Hacer un programa que imprima él numero 1250 con 4, 5, 6, 7 espacios en

pantalla utilizando cout.width.

//Nombre del programa: ancho2.cpp #include<iostream.h> #include<iomanip.h> class Ancho2{ public: void ver(void); }; void Ancho2::ver(void) { cout.width(4); cout<<”La impresión sin espacios :”<<1250<<endl; cout.width(5); cout<<”La impresión con un espacio :”<<1250<<endl; cout.width(6); cout<<”La impresión con dos espacios:”<<1250<<endl; cout.width(7); cout<<”La impresión con tres espacios:”<<1250<<endl;


} void main() { clrscr() //Método que limpia pantalla Ancho2 tamaño; tamaño.ver(); getch(); }

Al compilar y ejecutar cualquiera de los dos programas, la representación en pantalla será

de la siguiente forma:

La impresión sin espacios :1250 La impresión con un espacio : 1250 La impresión con dos espacios: 1250 La impresión con tres espacios: 1250

Relleno de caracteres

Existirán casos en que se requiera utilizar un carácter en vez de espacios en blanco para

rellenar cierta información. Se utiliza el comando cout.fill(‘carácter para rellenar’).

Ejemplo: Hacer un programa que imprima en pantalla una información en la siguiente

forma:

Tabla de Información Lenguaje de Programación.............15 Practica VI.......................................20 Bases de Datos Foxpro..................18

El programa seria:

//Nombre del programa: relleno.cpp #include<iostream.h> #include<iomanip.h> class Relleno{ public: void ver(void); }; void Relleno::ver(void) { cout<<”Tabla de Información”<<endl; cout.fill(‘.’); cout<<”Lenguaje de Programación”<<setw(13)<<15<<endl; cout<<”Practica VI”<<setw(30)<<20<<endl; cout<<”Bases de Datos Foxpro”<<setw(18)<<18<<endl; }


main() { clrscr() //Método que limpia pantalla Relleno todo; todo.ver(); getch(); }

Control de los decimales a mostrar en pantalla

Para mostrar en pantalla un numero determinado de decimales en los reales podemos

utilizar el comando setprecision , el cual especifica él numero de decimales deseado.

Ejemplo: Hacer un programa que imprima el número decimal 2.56897 con 1,2,3,4,5

decimales.

//Nombre del programa: control.cpp #include<iostream.h> #include<iomanip.h> class Control { public: void ver(void); }; void Control::ver(void) { float valor=2.56897; cout<<setprecision(1)<<valor<<endl; cout<<setprecision(2)<<valor<<endl; cout<<setprecision(3)<<valor<<endl; cout<<setprecision(4)<<valor<<endl; cout<<setprecision(5)<<valor<<endl; } main() { clrscr() //Método que limpia pantalla Control decimal; decimal.ver(); getch(); }

Cuando se compila y se ejecuta el programa en la pantalla se verá lo siguiente: 2.6 2.57 2.569 2.569 2.56897

“programación orientada a objetos en c++”

Documents