Manual de Practicas para Programar en C

Centro de Enseanza Tcnica
Industrial
Organismo Pblico Descentralizado Federal
TTULO DEL TRABAJO

PRACTICAS DE PROGRAMACION
Nombre del Estudiante
ANDRES GUILLERMO PEREDO CORTES
Numero de Registro
11110182
Nombre de la Carrera
INGENIERIA EN MECATRONICA
Nombre de la Academia
CETI
Nombre delaMateria
PROGRAMACION ORIENTADA A OBJETOS
Nombre del Profesor
GERARDO GARCIA GIL
Centro de Enseanza Tcnica Industrial
Plantel:
TONALA
Turno:
VESPERTINO
ANDRES GUILLERMO PEREDO CORTES 11110182
PRACTICAS
INGENIERIA
CARRERA
INGENIERIAS
PROFE
SOR
PLAN
DE
ESTUDI
O
2011-A
ING GERARDO GARCA

GIL
PRACTI LABORATORIO
CA No. DE
COMPUTACIN
No
1
CLAVE
ASIGNATU
RA
CI-11
NOMBRE DE LA
ASIGNATURA
PROGRAMACIN
ORIENTADA A OBJETOS
EVALUACI
ON
FEC
HA
NOMBRE DE LA
PRACTICA
DURACI
N
(HORAS)
INTRODUCCION A
PUNTEROS
1.- INTRODUCCIN
Un puntero es una variable que contiene como valor una direccin de memoria.
Dicha direccin corresponde habitualmente a la direccin que ocupa otra variable
en memoria.
Se dice entonces que el puntero apunta a dicha variable. La variable apuntada
puede ser de cualquier tipo, estructurado o incluso otro puntero.
Los punteros constituyen una parte fundamental del lenguaje C y son bsicos
para comprender toda la potencia y flexibilidad que ofrece el lenguaje. Son
especialmente importantes en la programacin a bajo nivel, donde se manipula
directamente la memoria del ordenador. Algunas de las ventajas que aporta el
uso de punteros en C son:
1. Constituyen la nica forma de expresar algunas operaciones.
2. Su uso produce cdigo compacto y eficiente.
3. Son imprescindibles para el paso de parmetros por referencia a
funciones.
4. Tienen una fuerte relacin con el manejo eficiente de tablas y estructuras.
5. Permiten realizar operaciones de asignacin dinmica de memoria y
manipular estructuras de datos dinmicas.
2.-OBJETIVO (COMPETENCIA)
El alumno comprender la importancia y eficiencia en utilizar punteros cabe

advertir que los punteros son tradicionalmente la parte de C ms difcil de
comprender. Adems deben usarse con gran precaucin, puesto que al permitir
manipular directamente la memoria del ordenador, pueden provocar fallos en el
programa. Estos fallos suelen ser bastante difciles de localizar y de solucionar.
Pero al manejarlos se hace un uso eficiente de la computadora en reduccin de
cdigo y tiempo.
3.-FUNDAMENTO
Un puntero es un tipo especial de variable que contiene, ni ms ni menos que,
una direccin de memoria.
nmerohace referencia de manera
directa a una Variable que contiene el
valor 8
8
ptrnumero
Ptrnumerohace referencia de
manera indirecta a una variable
que contiene el valor 8
numero
En la declaracin de punteros y la posterior asignacin de direcciones de memoria

a los mismos, se utilizan respectivamente los operadores unarios * y &. El
operador & permite obtener la direccin que ocupa una variable en memoria. Por
su parte, el operador de indireccin * permite obtener el contenido de un objeto
apuntado por un puntero.
En la declaracin de variables puntero se usa tambin el operador * , que se
aplica directamente a la variable a la cual precede. El formato para la declaracin
de variables puntero es el siguiente:
tipo de datos * nombre variable puntero;
Tenemos el siguiente ejemplo:
int *ip;
declara una variable de nombre ip que es un puntero a un objeto de tipo int. Es
decir, ip contendr direcciones de memoria donde se almacenaran valores
enteros.
Los punteros solo pueden apuntar a _____________, ________________ y

________________
4.-PROCEDIMIENTO (DESARROLLO DE LA PRACTICA)

1.1 La funcin del siguiente programa es saber la diferencia del smbolo de
direccin & y el smbolo de indireccion * cual es la diferencia entre uno y otro.
#include "stdafx.h"
int _tmain(int argc, _TCHAR* argv[])
{
int *dirnum;
int millas, dist;
dist = 158;
millas =22;
dirnum= &millas;
Firma practica cumplida

laboratorio 1
______________________________
//almacena la direccion de millas en dirnum
printf("la direccion almacenada en dirnum es %d\n",dirnum);

printf("el valor al que apunta dirnum es %d\n",*dirnum);
dirnum=&dist;
printf("la direccion almacenada en dirnum es %d\n",dirnum);
printf("el valor al que apunta dirnum es %d\n",*dirnum);
return 0;
}
1.2 Desarrollar un programa que por medio de punteros me regrese el valor de

cada uno de los elementos del arreglo.
#include "stdafx.h"
{
int iArr[5]={3,5,7,1,9};
int v=3;
int *pv;
pv=&v;
int *pi=iArr;

laboratorio 2
______________________________
for(int i=0;i<5;i++)
{
printf("el valor de iArr[%d] es:%d\n",i,*pi+i);
}
return 0;
}
1.2 Desarrollar un programa que por medio de punteros me regrese el valor de

cada uno de los elementos del arreglo.
#include "stdafx.h"
{
int iArr[5]={3,5,7,1,9};
int v=3;
int *pv;
pv=&v;
int *pi=iArr;

laboratorio 2
______________________________
for(int i=0;i<5;i++)
{
printf("el valor de iArr[%d] es:%d\n",i,*pi+i);
}
}
return 0;
1.3 Desarrollar un programa que por medio de punteros cambie una cadena de
caracteres de minscula a maysculas y adems la contabilice.
#include "stdafx.h"
#include <stdio.h>
#include<ctype.h>
int a,b,c;
{
char cadena[]="hola como estas";
char *pcadena;
pcadena=&cadena[0];

laboratorio 3
______________________________
while(*pcadena)
{
printf("la letra es %c\n",pcadena);

++pcadena;
return 0;
}
5.-ANEXOS
a.1.1.- Realizar las operaciones existentes que se pueden realizar con punteros
cuales son y demustralos.
Firma practica cumplida tarea

1
______________________________
a.1.2.- Realizar un programa en el cual transforme una cadena de caracteres de
minsculas a maysculas con un ciclo whiley adems contabilice la cadena.
#include "stdafx.h"
#include <cstdlib>
#include <iostream>
int contarCaracteres (char arr[])
{
int i;
for(i=0;arr[i]!='\0';i++);
return i;
}
{
char cadena[61];
int i,total;
printf ("\n\tIntroduce una frase (mx. 60 caracteres):\n");
gets(cadena);
printf ("\t Total: %d\n", contarCaracteres(cadena));
return 0;

2
______________________________
a.1.3.- Realizar un analizador lxico el cual contabilice vocales, consonantes,
dgitos, espacios y otros.

3
______________________________
a.1.4.- haz una aplicacin con punteros en la cual hayas entendido el concepto.

4
______________________________
6.- RESULTADOS Y CONCLUCIONES
7.-REFERENCIAS
LIBRO
Como programar
en C/C++
Programacin de
C
ELABORO
AUTOR
Deitel&Deitel
EDICION
2da
4ta
GOTTFRIED BYRON
REVISO
APROBO
ING. GERARDO
GARCIA GIL
EDITORIAL
Pearson
MCGRAW-HILL
AUTORIZO
INGENIERIA
CARRERA
INGENIERIAS
PROFE
SOR
PLAN
DE
ESTUDI
O
2011-A
ING GERARDO GARCA

GIL
CLAVE
ASIGNATU
RA
CI-11
PROGRAMACIN ORIENTADA
A OBJETOS
EVALUACI
ON
FEC
HA
PRACTI LABORATORIO
CA No. DE
COMPUTACIN
No
2
NOMBRE DE LA
ASIGNATURA
NOMBRE DE LA
PRACTICA
Estructuras (Structs)
DURACI
N
(HORAS)
3
1.- INTRODUCCIN
Una estructura es un conjunto de una o ms variables, de distinto tipo, agrupadas
bajo un mismo nombre para que su manejo sea ms sencillo. En una estructura
los elementos que la componen pueden ser de distintos tipos. As pues, una
estructura puede agrupar datos de tipo carcter, enteros, cadenas de caracteres,
matrices de nmeros. . ., e incluso otras estructuras. En cualquier caso, es
habitual que todos los elementos agrupados en una estructura tengan alguna
relacin entre ellos. En adelante nos referiremos a los elementos que componen
una estructura como campos.
La definicin de una estructura requiere especificar un nombre y el tipo de datos
de todos los campos que la componen, as como un nombre mediante el cual
pueda identificarse toda la agrupacin. Para ello se utiliza la palabra reservada
struct de la forma siguiente:
Structtipo_estructura
{
tipo_variable nombre_variable1;
};
Donde tipo_estructura es el nombre del nuevo tipo de dato que hemos creado.
Por ltimo, tipo_variable y nombre_variable son las variables que forman parte
de la estructura.
Su utilizacin ms habitual es para la programacin de bases de datos, ya que
estn especialmente indicadas para el trabajo con registros o fichas.
El alumno sabr utilizar y manejar las estructuras (structs) utilizar el

concepto de campo
Saber la funcin del operador punto.
Crear variables para la utilizacin delas estructuras.
aprender a utilizar la palabra reservada typedef y trataremos de
utilizarla en una base de datos que disearemos en el laboratorio.
3.-FUNDAMENTO
Declaracin de variables
La declaracin de variables del tipo definido por una estructura puede hacerse de
dos maneras diferentes.
Bien en la misma definicin de la estructura, bien posteriormente. La forma
genrica para el primer caso es la siguiente:
struct nombre estructura
{
tipo campo 1 nombre campo 1;
tipo campo 2 nombre campo 2;
. . .
tipo campo N nombre campo N;
}lista de variables;
Ntese que al declararse las variables al mismo tiempo que se define la

estructura, el nombre de sta
junto a la palabra reservada struct se hace innecesario y puede omitirse.
Por otra parte, suponiendo que la estructura nombre estructura se haya definido
previamente, la declaracin de variables en el segundo caso sera:
struct nombre estructura lista de variables;
Acceso a los campos

Los campos de una estructura de manejan habitualmente de forma individual. El mecanismo que C
proporciona para ello es el operador punto (.). La forma general para acceder a un campo en una
variable de tipo estructura es el siguiente:
variable. Nombre campo

2.1 El siguiente es un ejercicio caracterstico del funcionamiento de las

estructuras, explique el significado de cada una de las lneas y resuelva los
detalles y errores del programa.
#include "stdafx.h"
#include <stdio.h>
void leerentrada(int i);
void escribirsalida(int i);
struct fecha
{
int mes;
int dia;
int anio;
};
struct cuenta
{
char nombre[80];
char calle[80];
char ciudad[80];
int num_cuenta;
int tipo_cuenta;
float saldoanterior;
float saldonuevo;
float pago;
struct fecha ultimopago;
}cliente [100];
{
int i,n;
printf("SISTEMA DE FACTURACION DE CLIENTE\n\n");
printf("cuantos clientes hay? ");
scanf("%d",&n);
for(i=0;i<n;i++)
{
leerentrada(i);
/*determinar el estado de cuenta*/
if(cliente[i].pago>0)
cliente[i].tipo_cuenta=(cliente[i].pago<0.1*cliente[i].saldoanterior)?'R':'A
';
else
cliente[i].tipo_cuenta=(cliente[i].saldoanterior>0)?'D':'A';
/*ajustar el saldo de la cuenta*/
cliente[i].saldonuevo=cliente[i].saldoanterior-cliente[i].pago;
}
for(i=0;i<n;i++)
escribirsalida(i);
}
return 0;
void leerentrada(int i)
printf("\nCliente numero %d\n",i+1);

printf( "Nombre: \n" ); fflush( stdout );
scanf("%s",cliente[i].nombre);
printf("Calle: \n");fflush(stdout);
scanf("%s",cliente[i].calle);
printf("Ciudad: \n");fflush(stdout);
scanf("%s",cliente[i].ciudad);
printf("numero de cuenta\n");fflush (stdout);
scanf("%d",&cliente[i].num_cuenta);
printf("Saldo anterior\n");fflush (stdout);
scanf("%f",&cliente[i].saldoanterior);
printf("Pago actual\n");fflush (stdout);
scanf("%f",&cliente[i].pago);
printf("fecha de pago (mm/dd/aaaa)");
scanf("%d/%d/
%d",&cliente[i].ultimopago.mes,&cliente[i].ultimopago.dia,&cliente[i].ultimo
pago.anio);
}
void escribirsalida(int i)
{
printf("\nNombre: %s\n",cliente[i].nombre);
printf("Numero de cuenta:%d\n",cliente[i].num_cuenta);
printf("calle: %s\n",cliente[i].calle);
printf("ciudad:%s\n",cliente[i].ciudad);
printf("saldo anterior:%.2f\n",cliente[i].saldoanterior);
printf("pago actual:%.2f\n",cliente[i].pago);
printf("nuevo saldo:%.2f\n",cliente[i].saldonuevo);
printf("estado de la cuenta:");
switch(cliente[i].tipo_cuenta)
{
case 'A':
printf("al dia.\n\n");
case 'R':
printf("retrasada.\n\n");
case 'D':
printf("delincuente.\n\n");
}

laboratorio
______________________________
2.2 Necesitamos saber cmo acceder a cada elemento del array. La variable
definida es amigo, por lo tanto para acceder al primer elemento usaremos
amigo[0] y a su miembro nombre: amigo[0].nombre. Vemoslo en un ejemplo en
el que se supone que tenemos que meter los datos de tres amigos:
#include "stdafx.h"
#include <stdio.h>
#define ELEMENTOS
struct estructura_amigo {
char nombre[30];
char apellido[40];
char telefono[10];
int edad;
};
struct estructura_amigo amigo[ELEMENTOS];

{
int num_amigo;
for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ )
{
printf( "\nDatos del amigo nmero %i:\n", num_amigo+1 );
printf( "Nombre: " ); fflush( stdout );
gets(amigo[num_amigo].nombre);
printf( "Apellido: " ); fflush( stdout );
gets(amigo[num_amigo].apellido);
printf( "Telfono: " ); fflush( stdout );
gets(amigo[num_amigo].telefono);
printf( "Edad: " ); fflush( stdout );
scanf( "%i", &amigo[num_amigo].edad );
while(getchar()!='\n');
}
/* Ahora imprimimos sus datos */
{
printf( "El amigo %s ", amigo[num_amigo].nombre );
printf( "%s tiene ", amigo[num_amigo].apellido );
printf( "%i aos ", amigo[num_amigo].edad );
printf( "y su telfono es el %s.\n" , amigo[num_amigo].telefono );
}
return 0;
}

laboratorio
2.3 esta es una estructura en la cual se utilizan punteros y como se usan es un buen
recordatorio para el tema en conjunto de la unidad 1 y dos y de______________________________
gran ayuda en las
estructuras de datos como pila,cola y las lista.
#include "stdafx.h"
{
int n=33;
char t='A';
float b=99.99;
typedef struct
{
int mes,dia,anio;
}fecha;
struct
{
int *no_cuenta;
char *tipo_cuenta;
char *nombre;
float *saldo;
fecha ultimopago;
}cliente, *pc=&cliente;
cliente.no_cuenta=&n;
cliente.tipo_cuenta=&t;
cliente.nombre="lazaro";
cliente.saldo=&b;
printf("%d %c %s
%.2f\n",*cliente.no_cuenta,*cliente.tipo_cuenta,cliente.nombre,*cliente.sald
o);
printf("%d %c %s %.2f\n",*pc->no_cuenta,*pc->tipo_cuenta,pc->nombre,*pc>saldo);
return 0;

laboratorio
______________________________
5.-ANEXOS
#include "stdafx.h"
#include <stdio.h>
#define ELEMENTOS
struct estructura_amigo {
char nombre[30];
char domicilio[40];
char travajo[10];
char puesto[60];
};
struct estructura_amigo amigo[ELEMENTOS];
{
int num_amigo;
{
printf( "\nDatos del amigo nmero %i:\n", num_amigo+1 );
printf( "Nombre: " ); fflush( stdout );
gets(amigo[num_amigo].nombre);
printf( "trabajo: " ); fflush( stdout );
gets(amigo[num_amigo].travajo);
printf( "domicilio: " ); fflush( stdout );

gets(amigo[num_amigo].domicilio);
printf("puesto: ");fflush( stdout );
gets(amigo[num_amigo].puesto);
while(getchar()!='\n');
/* Ahora imprimimos sus datos */
{
printf( "El amigo %s ", amigo[num_amigo].nombre );
printf( "%s trabajo ", amigo[num_amigo].travajo );
printf( "%s puesto ", amigo[num_amigo].puesto );
printf( "domicilio %s.\n" , amigo[num_amigo].domicilio );
}
return 0;

n
______________________________
7.-REFERENCIAS
LIBRO
Como programar
en C/C++
Internet
ELABORO
AUTOR
Deitel&Deitel
EDICION
2da
REVISO
EDITORIAL
Pearson
APROBO
AUTORIZO
CLAVE
ASIGNATU
RA
NOMBRE DE LA
ASIGNATURA
ING. GERARDO
GARCIA GIL
INGENIERIA
CARRERA
INGENIERIAS
PROFE
SOR
2011-A
ING GERARDO GARCA

GIL
INGENIERIA
CARRERA
INGENIERIAS
PROFE
SOR
PLAN
DE
ESTUDI
O
PLAN
DE
ESTUDI
O
2011-A
ING GERARDO GARCA

GIL
PRACTI LABORATORIO
CA No. DE
COMPUTACIN
No
CI-11
FEC
HA
CLAVE
ASIGNATU
RA
CI-11
FEC
HA
A OBJETOS
EVALUACI
ON
NOMBRE DE LA
ASIGNATURA
A OBJETOS
EVALUACI
ON
NOMBRE DE LA
PRACTICA
DURACI
N
(HORAS)
Clases
1.- INTRODUCCIN
La clase es la principal herramienta de la programacin orientada a objetos.
Como aprender en esta leccin. Una clase es muy parecida a una estructura
ya que agrupa miembros que corresponden a los datos de un objeto, as como
funciones llamadas (mtodos) que operan sobre los datos. Como veremos, un
objeto es una cosa, digamos un telfono, un archivo o un libro. Una clase de
C++ permite que los programas definan atributos de los objetos
(caractersticas). En el caso de un objeto telfono, la clase podra tener
miembros datos, como el numero de telfono y su tipo, as como ciertas
funciones que operan sobre de el, como marcar, contestar o colgar. Al agrupar
los datos del objeto y codificarlos en una variable, usted simplifica la
programacin e incrementa el reciclaje (reso) del cdigo. En esta leccin es
una introduccin a las clases de C++. Cuando termine, debe de tener los
siguientes conceptos clave:
el alumno pueda definir una clase los programas deben de especificar

un nombre, miembros y funciones (mtodos de la clase).
La definicin de una clase proporciona una plantilla que los programas

pueden utilizar con el fin de crear objetos de tipo de la clase, de modo
muy parecido a como se crean variables de los tipos int, char, etc.
Los programas asignan valores a los miembros de datos de la clase

utilizando el operador punto.
Los programas llaman a funcin miembro de clases (mtodos) mediante

el operador punto.
3.-FUNDAMENTO
Declaracin de clases
En el sentido ms simple, un objeto es una cosa. Cuando usted crea un
programa, este casi siempre usa variables para guardar informacin sobre
cosas del mundo real; empleados, libros e incluso archivos por decir algo.
Cuando usted usa programacin orientada a objetos se centra en las cosas
que componen un sistema y las operaciones que tiene que ejecutar sobre de
ellas. Por ejemplo, un archivo cualquiera, podra tener operaciones sobre de el
. imprimir , borrar, mostrar o cambiar de direccin .en C++ usted usa una
clase para definir objetos. Cuando define una clase, su meta es incluir en ella
tanta informacin sobre el objeto como sea posible. Por tanto puede escoger
una clase que usted cree para un programa y luego utilizarlo en otros
distintos.
Una clase en C++ permite que al programa agrupar datos y funciones que
ejecutan operaciones sobre ellos, la mayora de libros y artculos sobre la POO
denominan mtodos a las funciones de la clase. Al igual que la estructura, una
clase de C++ debe de tener un nombre nico, seguido de una llave de
apertura, uno o ms miembros y una llave de cierre. De esta modo.
Class nombre_clase {
Tipo miembro_clase;
Tipo mtodo_clase();
}
Despus de que usted define una clase, puede declarar variables del tipo de
esta (llamadas objetos)
nombre_clase objeto1,objeto2,objetoN;
el siguiente ejemplo, crea dos objetos empleados. Mediante el operador
punto, el programa asigna valores a los datos miembro. Luego emplea el
miembro ver_empleado a mostrar informacin sobre el trabajador, de este
modo podra estar de la siguiente manera: Ing Gerardo Garca Gil CLASES I
#include "stdafx.h"
#include <string.h>
#include <iostream>
using namespace std;
class empleados
{
public:
char nombre [64];
long id_emp;
float salario;
void ver_empleado()
{
cout<<"Nombre "<<nombre<<endl;
cout<<"Id empleado "<<id_emp<<endl;
cout<<"salario "<<salario<<endl<<endl;
}
};
{
empleados trabajador,jefe;
strcpy(trabajador.nombre,"eva lopez" );
trabajador.id_emp=123;
trabajador.salario =2500;
strcpy(jefe.nombre,"juan perez" );
jefe.id_emp=879;
jefe.salario =25000;
trabajador.ver_empleado ();
jefe.ver_empleado ();
return 0;
}

n
______________________________

5.1 El siguiente es un ejercicio caracterstico del funcionamiento de las clases,
explique el significado de cada una de las lneas y resuelva los detalles y errores
del programa.
#include "stdafx.h"
#include <string.h>
#include <iostream>
class empleados
{
public:
char nombre [64];
long id_emp;
float salario;
void ver_empleado();
};
void empleados::ver_empleado()
{
cout<<"Nombre "<<nombre<<endl;
cout<<"Id empleado "<<id_emp<<endl;
cout<<"salario "<<salario<<endl<<endl;
}
{
empleados trabajador,jefe;

n
______________________________
strcpy(trabajador.nombre,"eva lopez" );
trabajador.id_emp=123;
trabajador.salario =2500;
strcpy(jefe.nombre,"juan perez" );
jefe.id_emp=879;
jefe.salario =25000;
trabajador.ver_empleado ();
jefe.ver_empleado ();
return 0;
}
5.2 El siguiente es un ejercicio caracterstico del funcionamiento de las clases,

explique el significado de cada una de las lneas y resuelva los detalles y errores
del programa.
#include "stdafx.h"
#include <string.h>
#include <iostream>
class perros {
public:
char raza[64];
int peso_promedio;
int alto_promedio;
void ver_raza();
};
void perros::ver_raza()
{
cout<<"Raza: "<<raza<<endl;
cout<<"Peso: "<<peso_promedio<<endl;
cout<<"Altura: "<<alto_promedio<<endl;
}
{
perros feliz,choliloco;
strcpy(feliz.raza ,"dalmata");
feliz.peso_promedio =58;
feliz.alto_promedio =24;
strcpy(choliloco.raza ,"pastor ingles");
choliloco.peso_promedio =22;
choliloco.alto_promedio =15;
feliz.ver_raza ();
choliloco.ver_raza() ;
return 0;
}

laboratorio
______________________________
5.-ANEXOS
5.3 crea un mtodo de la funcin donde se crean
los datos de la prctica 3.1
#include "stdafx.h"
#include <string.h>
#include <iostream>
class empleados
{
public:
char nombre [64];
long id_emp;
float salario;
void crear();
void imprimir();
};
void empleados::imprimir()
{
cout<<"Nombre
: "<<nombre<<endl;
cout<<"Id empleado : "<<id_emp<<endl;
cout<<"Salario
: "<<salario<<endl<<endl;
}
void empleados::crear()
{
strcpy(empleados::nombre, "Andres Peredo");
empleados::id_emp=11110182;
empleados::salario=2500;
}

{
empleados trabajador;
trabajador.crear();
trabajador.imprimir();
return 0;

n
______________________________
3.2 lo mismo que el anexo 3.1 pero para la

practica 3.2
#include "stdafx.h"
#include <string.h>
#include <iostream>
class perros
{
public:
char raza [65];
int peso_promedio;
int alto_promedio;
void crear();
void imprimir();
};
void perros::imprimir()
{
cout<<"Raza: "<<perros::raza<<endl;
cout<<"Peso: "<<perros::peso_promedio<<endl;
cout<<"Altura: "<<perros::alto_promedio<<endl;
}
void perros::crear()
{
strcpy(perros::raza,"Dalmata");
perros::peso_promedio= 60;
perros::alto_promedio= 4;
}
{
perros feliz;
feliz.crear();
feliz.imprimir();
}
return 0;

n
______________________________
3.3 elabora uno tu mismo

#include "stdafx.h"
#include <string.h>
#include <iostream>
class datos
{
public:
char nombre [65];
char callenombre[65];
int numero;
int telefono;
void crear();
void imprimir();
};
void datos::imprimir()
{
cout<<"Nombre
: "<<nombre<<endl;
cout<<"Nombre de la calle: "<<datos::callenombre<<endl;
cout<<"Numero
: "<<datos::numero<<endl;
cout<<"Telefono
: "<<datos::telefono<<endl;
}
void datos::crear()
{
strcpy(datos::nombre,"Andres");
strcpy(datos::callenombre,"Rio Nilo");
datos::numero= 2699;
datos::telefono= 36357689;
}
{
datos loco;
loco.crear();
loco.imprimir();
return 0;
}

tarea n
__________________________
Las clases nos sirve para que la programacin no sea

tan tediosa ya que podemos reciclar mucho del
cdigo y hacerlo an ms rpido
7.-REFERENCIAS
LIBRO
Como programar
en C/C++
internet
ELABORO
AUTOR
Deitel&Deitel
REVISO
EDICION
2da
APROBO
ING. GERARDO
GARCIA GIL
EDITORIAL
Pearson
AUTORIZO
PRACTI LABORATORIO
CA No. DE
COMPUTACIN
No
NOMBRE DE LA
PRACTICA
DURACI
N
(HORAS)
Constructores y
destructores
1.- INTRODUCCIN
Como aprendi en la leccin anterior, la nica forma en que los programas
puedan acceder a miembros de datos privados es emplear una funcin de clase.
Para simplificar el proceso de inicializacin de miembros de datos de la clase, C+
+ le permite definir una funcin constructor especial, sobre una base por clase,
que C++invoca de forma automtica cada vez que se crea un objeto. De modo
similar, C++ proporciona una funcin destructor que el lenguaje ejecuta cuando
usted descarga un objeto. Esta leccin estudia las funciones destructor y
constructor detalladamente.
Las funciones constructor son mtodos de la clase que facilitan los

programas la inicializacin de las variables.
Las funciones constructor tiene el mismo nombre que la clase; as, usted
no tiene que preceder su nombre con la palabra vid.
Las funciones constructor no devuelven un tipo
Cada vez que el programa crea una variable de clase, C++ invoca una
funcin destructor especial que puede liberar esa memoria, en sentido,
dejndola limpia despus del objeto.
Conforme corre el programa, muchos objetos podran reservar memoria

para guardar informacin. Cuando usted descarta un objeto, C++ invoca
una funcin destructor especial para liberar esa memoria, en sentido,
dejndola limpia despus del objeto.
Las funciones destructor tienen el mismo nombre que la clase, excepto

porque usted puede preceder su nombre con un carcter de tilde (~).
Las funciones destructor no devuelven un tipo. Al igual que las constructor,

usted no puede preceder el nombre de las funciones destructor con la
palabra clave vid.
3.-FUNDAMENTO
CMO CREAR UNA FUNCIN CONSTRUCTOR SIMPLE.
Una funcin constructores un mtodo de clase que tiene el mismo nombre de
esta. Por ejemplo, si usted usa una clase llamada empleados, el nombre de la
funcin constructor es, tambin, empleados. Asimismo, para una clase llamada
perros, el nombre de la funcin constructor debe de ser perros tambin. Si el
programa define una funcin constructor, C++automticamente la invoca cada
vez que usted crea un objeto del tipo de la clase correspondiente. El siguiente
programa, crea una clase llamada empleados. Tambin define una funcin
constructor llamada empleados que asigna los valores iniciales a los objetos. Una
funcin constructor no puede devolver un valor; sin embargo, usted no la declara
como void, ni especifica un tipo de retorno, como se muestra a continuacin.

6.1 primer constructor
#include "stdafx.h"
#include <string.h>
#include <iostream>
class empleados{
public:
empleados(char*,long,float); //constructor
void ver_empleados();
int cambiar_salario(float);
long obtener_id();
private:
char nombre[64];
long id_empleado;
float salario;
};
empleados::empleados(char *nombre, long id_empleado, float salario)
{
strcpy(empleados::nombre ,nombre);
empleados::id_empleado =id_empleado;
if(salario<50000.50)
empleados::salario =salario;
else
empleados::salario =0.0;
}
void empleados::ver_empleados ()
{
cout<<"Empleado: "<<nombre<<endl;
cout<<"Id: "<<id_empleado<<endl;
cout<<"Salario: "<<salario<<endl;
}
{
empleados trabajador("gerardo gil",101,5000.50);
empleados ejecutivo("pancho lopez",2,50000.50);
trabajador.ver_empleados ();
ejecutivo.ver_empleados ();
return 0;
}

n
______________________________
6.2 Destructor
#include "stdafx.h"
#include <string.h>
#include <iostream>
class empleados{
public:
empleados(char*,long,float);
~empleados(); //alt 126
long obtener_id();
private:
char nombre[64];
long id_empleado;
float salario;
};
empleados::empleados(char *nombre, long id_empleado, float salario)
{
if(salario<50000.50)
else
empleados::salario =0.0;
}
empleados::~empleados ()
{
cout<<"destruyendo el objeto para "<<nombre<<endl;
}
{
cout<<"Empleado: "<<nombre<<endl;
cout<<"Id: "<<id_empleado<<endl;
cout<<"Salario: "<<salario<<endl;
}

n
______________________________
6.3 Incorpora el constructor donde es igual a 10,

000
#include "stdafx.h"
#include <string.h>
#include <iostream>
class empleados{
public:
empleados(char*,long,float);
~empleados();
long obtener_id();
private:
char nombre[64];
long id_empleado;
float salario;
};
empleados::empleados(char *nombre, long id_empleado, float salario=10000.0)

{
cout<<" Si Introduces un salario menor a 50,000 se va a ciclar"<<endl;
do{
cout<<"Introduzca Salario Para " <<nombre<<" mayor a 50,000:"<<endl;
cin>>empleados::salario;
}while(empleados::salario<=50000.50);
}
empleados::~empleados ()
{
cout<<"Destruyendo El Objeto Para "<<nombre<<endl;
}
{
cout<<"Empleado : "<<nombre<<endl;
cout<<"Id
: "<<id_empleado<<endl;
cout<<"Salario : "<<salario<<endl;
}

{
empleados trabajador("Gerardo Gil",101,5000.50);
empleados ejecutivo("Pancho Lopez",2,50000.50);
trabajador.ver_empleados ();
ejecutivo.ver_empleados ();
return 0;
}

n
______________________________
5.-ANEXOS
6.1 crea un programa que demuestre lo aprendido
#include "stdafx.h"
#include <string.h>
#include <iostream>
class imprenta{
public:
imprenta(char*,long,float); //constructor
void ver_imprenta();
int cambiar_precio(float);
long obtener_cantidad();
private:
char nombre[64];
long cantidad;
float precio;
};
imprenta::imprenta(char *nombre, long cantidad, float precio)
{
strcpy(imprenta::nombre ,nombre);
imprenta::cantidad =cantidad;
if(precio<18.50)
imprenta::precio =precio;
else
imprenta::precio =2.0;
}
void imprenta::ver_imprenta ()
{
cout<<"Marca : "<<nombre<<endl;
cout<<"Cantidad : "<<cantidad<<endl;
cout<<"Precio : "<<precio<<endl;
}
{
imprenta periodico( "EL INFORMADOR",101,5000.50);
imprenta revista( "LO MAS INTERESANTE",55,50000.50);
periodico.ver_imprenta ();
revista.ver_imprenta ();
return 0;
}

n
______________________________
6.2 crea un programa que demuestre lo aprendido

#include "stdafx.h"
#include <string.h>
#include <iostream>
class imprenta{
public:
imprenta(char*,long,float);
~imprenta();
void ver_imprenta();
private:
char nombre[64];
long cantidad;
float precio;
};
imprenta::imprenta(char *nombre, long cantidad, float precio=500.0)

{
strcpy(imprenta::nombre ,nombre);
imprenta::cantidad =cantidad;
cout<<" Si Introduces un precio mayor a 300 para cualquier marca se va a repitir"<<endl;
do{
cout<< "Introduzca Precio Para " <<nombre<<" menor a 300:"<<endl;
cin>>imprenta::precio;
}while(imprenta::precio>=300);
}
imprenta::~imprenta ()
{
cout<<"Destruyendo El Objeto Para "<<nombre<<endl;
}
void imprenta::ver_imprenta ()
{
cout<<"MARCA: : "<<nombre<<endl;
cout<<"CANTIDAD : "<<cantidad<<endl;
cout<<"PRECIO : "<<precio<<endl;
}

{
imprenta periodico("EL INFORMADOR",101,5000.50);
imprenta revista("LO MAS INTERESANTE",2,50000.50);
periodico.ver_imprenta ();
revista.ver_imprenta ();
return 0;

n

______________________________
El constructor es un mtodo de la clase en el cual nos
facilita para crear un objeto y el destructor nos sirve ms
que nada para borrar un espacio de memoria que haya sido
asignado
7.-REFERENCIAS
LIBRO
Como programar
en C/C++
internet
ELABORO
AUTOR
Deitel&Deitel
REVISO
EDICION
2da
APROBO
ING. GERARDO
GARCIA GIL
EDITORIAL
Pearson
AUTORIZO
INGENIERIA
CARRERA
INGENIERIAS
PROFE
SOR
PLAN
DE
ESTUDI
O
2011-A
ING GERARDO GARCA

GIL
PRACTI LABORATORIO
CA No. DE
COMPUTACIN
No
7
CLAVE
ASIGNATU
RA
CI-11
FEC
HA
NOMBRE DE LA
ASIGNATURA
A OBJETOS
EVALUACI
ON
NOMBRE DE LA
PRACTICA
DURACI
N
(HORAS)
Sobrecarga de operadores
1.- INTRODUCCIN
La sobrecarga de operadores es el proceso de cambiar el significado de un
operador (digamos de adicin,+, que C++ utiliza generalmente para hacer
sumas) para que lo use una clase especifica. En esta seccin definiremos una
clase llamada cadena y sobrecargaremos los operadores de la adicin y
sustraccin. Para los objetos de la cadena, el operador de la adicin aadir letras
especficas al contenido actual de una cadena
Usted sobrecarga operadores para mejorar la legibilidad de los programas.

Debe sobrecargar un operador cuando, al hacerlo, sea ms fcil de
entender un programa.
Los programas de C++ usan la palabra reservada operator para sobrecarga

de un operador
Cuando usted sobrecarga un operador, especifica una funcin que C++

invoca cada vez que la clase usa un operador sobrecargado. La funcin, a
su vez, ejecuta las operaciones correspondientes.
Cuando un programa sobrecarga un operador para una clase especfica, el

significado del operador cambia solo para esa clase; el resto del programa
continua usndolo para que ejecute sus operaciones ordinarias.
C++ permite a los programas sobrecargar casi todos los operadores; sin
embargo, hay cuatro que no se pueden sobrecargar.
3.-FUNDAMENTO
Como puede ver, el programa emplea la funcin sumar_letras para agregar
caracteres a la cadena variable titulo. Adems, utiliza las funciones quitar_letras
para eliminar cada aparicin de la letra e de la cadena de caracteres leccin. En
este ejemplo usa llamadas a funcin para hacer tales operaciones. Utilizando la
sobrecarga de operadores sin embargo, el problema puede hacer operaciones
idnticas mediante los operadores de adicin (+)y sustraccin (-).
Cuando usted sobrecarga un operador, utiliza la palabra clave operator de C++
dentro del prototipo y definicin de la funcin para indicar al compilador de C++
que la clase ocupar este mtodo como operador. La siguiente definicin de
clase; por ejemplo utiliza la palabra operator para asignar operadores de adicin
y sustraccin a las funciones sumar_letras y quitar_letras. Dentro de la clase
cadena:

PRACTICA 7.1 la funcion del siguiente programa es crear una clase
llamada cadena- que contiene un mienbo de datos, el cuales la cadena
de caracteres ensi
#include "stdafx.h"
#include <string.h>
#include <iostream>
class cadena
{
public:
cadena(char *);
void sumar_letras(char *);
void quitar_letras(char);
void ver_cadena();
private:
char datos[256];
};
cadena::cadena(char *str)
{
strcpy(datos,str);
}
void cadena::sumar_letras (char *str)
{
strcat(datos,str);
}
void cadena::quitar_letras(char letra)
{
char temp[256];
int i,j;
for(i=0,j=0;datos[i];i++)
{
if(datos[i]!=letra)
temp[j++]=datos[i];
temp[j]=NULL;
}
strcp
y(dat
os,te
mp);
}
void cadena::ver_cadena()
{
cout<<datos<<endl;
CENTRO DE ENSEANZA TECNICA

INDUSTRIAL
PRACTICAS DE
LABORATORIO
{
cadena titulo("c++ al rescate");
cadena leccion("sobrecarga de operadores");
titulo.ver_cadena ();
titulo.sumar_letras (" al rescate!");
titulo.ver_cadena();
leccion.ver_cadena ();
leccion.quitar_letras ('e');
leccion.ver_cadena();
return 0;
}

n
______________________________
PRACTICA 7.2 desarrolle un programa que defina una clase con la

palabra operador- para asignar operadores de adiccin y sustraccin
de las funciones sumar_letras y quitar_letras, dentro de la clase cadena
#include "stdafx.h"
#include <string.h>
#include <iostream>
class cadena
{
public:
cadena(char *);
void operator +(char *);
void operator -(char);
void ver_cadena();
private:
char datos[256];
};
{
strcpy(datos,str);
}
void cadena::operator +(char *str)
{
strcat(datos,str);
}
void cadena::operator -(char letra)
{
char temp[256];
int i,j;
{

INDUSTRIAL
PRACTICAS DE
LABORATORIO
if(datos[i]!=letra)
temp[j++]=datos[i];
temp[j]=NULL;
strcpy(datos,temp);
}}
{
cout<<datos<<endl;
}
{
titulo + " al rescate!";
leccion - 'e';
return 0;
}

n
______________________________
PRACTICA 7.3 crea un programa que aada un operador sobre cargado,

incluyendo el operador de igualdad (==)
#include "stdafx.h"
#include <string.h>
#include <iostream>
class cadena
{
public:
cadena(char *);
char *operator +(char *);
char *operator -(char);
int operator==(cadena);
void ver_cadena();
private:
char datos[256];
};
{
strcpy(datos,str);
}
char *cadena::operator +(char *str)
{
return(strcat(datos,str));
}

INDUSTRIAL
PRACTICAS DE
LABORATORIO
char *cadena::operator -(char letra)
{
char temp[256];
int i,j;
{
//es la letra que se va a eliminar?
if(datos[i]!=letra)
// si no asignarla a temp
temp[j++]=datos[i];
temp[j]=NULL;
//copia el contenido de temp otra vez a datos
}
return(strcpy(datos,temp));
}
int cadena::operator ==(cadena cade)
{
int i;
for(i=0;datos[i]==cade.datos[i];i++)
if((datos[i]==NULL)&&(cade.datos[i]==NULL))
return(1);
return(0);
}
{
cout<<datos<<endl;
}
{
cadena cade("c++ al rescate");
if(titulo==leccion)
cout<<"titulo y leccion son iguales"<<endl;
if(cade==leccion)
cout<<"str y leccion son iguales"<<endl;
if(titulo==cade)
cout<<"titulo y str son iguales"<<endl;
return 0;
}

n
______________________________

INDUSTRIAL
PRACTICAS DE
LABORATORIO
5.-ANEXOS
7.1 realiza el de la practica 7.2 pero con la
siguiente clase
#include "stdafx.h"
#include <string.h>
#include <iostream>
class cadena
{
public:
cadena(char *);
void ver_cadena();
private:
char datos[256];
};
{
strcpy(datos,str);
}
{
}

INDUSTRIAL
PRACTICAS DE
LABORATORIO
{
char temp[256];
int i,j;
{
if(datos[i]!=letra)
temp[j++]=datos[i];
temp[j]=NULL;
}
}
int cadena::operator==(cadena cade)
{
int i;
return(1);
return(0);
}
{
cout<<datos<<endl;
}
{
cadena titulo("C++ Al Rescate");
cadena leccion("Sobrecarga De Operadores");
titulo + " Al Rescate!";
leccion -'e';
leccion -'a';
leccion -'r';
return 0;
}

n
______________________________

INDUSTRIAL
PRACTICAS DE
LABORATORIO
7.2 Realiza un programa tuyo
#include "stdafx.h"
#include <string.h>
#include <iostream>
class cadena
{
public:
cadena(char *);
void ver_cadena();
private:
char datos[256];
{
strcpy(datos,str);
}
{
}
{
char temp[256];
int i,j;
{
if(datos[i]!=letra)
temp[j++]=datos[i];
temp[j]=NULL;
}
}
int cadena::operator==(cadena cade)
{
int i;

INDUSTRIAL
PRACTICAS DE
LABORATORIO
return(1);
return(0);
}
{
cout<<datos<<endl;
}
{
cadena titulo("El Raton come mucho queso");
cadena leccion("Sobrecarga De Operadores");
titulo + "y mas queso ";
leccion - 'e';
leccion - 'o';
leccion - 'c';
return 0;
}

n
______________________________

Es una secuencia de operadores que nos sirve para
contabilizar o eliminar cadenas o caracteres de ellas. Ya sea
alguna letra en especifico o varias
7.-REFERENCIAS

INDUSTRIAL
PRACTICAS DE
LABORATORIO
LIBRO
Como programar
en C/C++
internet
ELABORO
AUTOR
Deitel&Deitel
EDICION
2da
REVISO
EDITORIAL
Pearson
APROBO
AUTORIZO
CLAVE
ASIGNATU
RA
NOMBRE DE LA
ASIGNATURA
ING. GERARDO
GARCIA GIL
INGENIERIA
CARRERA
INGENIERIAS
PROFE
SOR
PLAN
DE
ESTUDI
O
2011-A
ING GERARDO GARCA

GIL
PRACTI LABORATORIO
CA No. DE
COMPUTACIN
No
CI-11
FEC
HA
A OBJETOS
EVALUACI
ON
NOMBRE DE LA
PRACTICA
DURACI
N
(HORAS)

INDUSTRIAL
PRACTICAS DE
LABORATORIO
8
Herencia simple
1.- INTRODUCCIN
La programacin orientada a objetos le facilita volver a usar una clase que cre
para un programa dentro de otro, ahorrndole, por lo tanto, tiempo y
programacin. Cuando usted define clases, hay ocasiones en que una clase usa
algunas o todas las caractersticas de otra que ya existe y entonces aade uno o
ms miembros, ya sea de datos o funciones. En estos casos, C++ le permite
construir un objeto nuevo ocupando las caractersticas de otro que ya existe.
Dicho de otro modo, el objeto nuevo hereda los miembros de una clase existente
(llamada clase base). Cuando usted construye una clase nueva a partir de otra
que ya existe, la nueva clase derivada.
Cuando los programas usan la herencia, emplean una clase base para
derivar una clase nueva; sta, la clase derivada, hereda los miembros de
la clase base.
Para inicializar los miembros de la clase derivada, el programa debe llamar

a funciones constructor de las clases base y derivada.
Con el operador punto, los programas pueden acceder sin problema a los
miembros de las clases base y derivada.
Adems de miembros pblicos (accesibles a todos) y privados (accesibles

solo a los mtodos de la clase), C++ proporciona miembros protegidos
(protected) a los que pueden acceder las clases base y derivada.
Para resolver conflictos de nombres entre los miembros de las clases base
y derivada,los programas pueden emplear el operador de resolucin global
(::), precedido del nombre de la clase base o derivada.
3.-FUNDAMENTO
HERENCIA SIMPLE.

INDUSTRIAL
PRACTICAS DE
LABORATORIO
La herencia permite a una clase derivada heredar las caractersticas de una clase
base ya existente. Supongamos que usted tiene la siguiente clase base, llamada
empleados:
En el siguiente ejemplo, el programa tiene dos posibilidades.
Primera, puede crear una clase nueva, gerentes, que duplique varios de los
miembros de la clase empleados.
Segunda, el programa puede derivar el tipo de clase gerentes de la clase base
empleados. Al derivar la clase gerentes de la clase empleados, que ya existe,
usted reduce la programacin y elimina la duplicacin del cdigo dentro del
programa para comenzar la definicin de la clase, usted especifica la palabra
reservada class, luego el nombre gerentes seguido de un signo de dos puntos y
despus el nombre empleados.
La palabra reservada public que precede al nombre de la clase empleados indica
que los miembros pblicos (public) de esta clase sern pblicos tambin en la
clase gerentes. Por ejemplo, las siguientes instrucciones derivan la clase
gerentes.
Cuando usted deriva una clase de una clase base, los miembros privados de esta
ltima son accesibles slo para la clase derivada a travs de funciones de
interfaz de la clase base directamente mediante el operador punto. El siguiente
programa, muestra cmo usar la herencia de C++ para construir la clase
gerentes a partir de la clase empleados.

PRACTICA 8.1.
#include "stdafx.h"
#include <string.h>
#include <iostream>
class empleados
{
public:
empleados(char *,char *,float);
private:
char nombre[64];
char posicion[64];
float salario;
};
empleados::empleados(char *nombre, char *posicion, float salario)
{
strcpy(empleados::nombre,nombre);
strcpy(empleados::posicion,posicion);

INDUSTRIAL
PRACTICAS DE
LABORATORIO
}void empleados::ver_empleado()
{
cout<<"nombre: "<<nombre<<endl;
cout<<"posicion: "<<posicion<<endl;
cout<<"salario: $"<<salario<<endl;
}
Clase derivada
class gerentes:public empleados
{ Clase base
public:
gerentes(char*,char*,char*,float,float,int);
void ver_gerente();
private:
float bono_anual;
char auto_empresa[64];
int opciones_acciones;
};
gerentes::gerentes(char *nombre, char *posicion, char *auto_empresa, float
salario, float bonus, int
opciones_acciones):empleados(nombre,posicion,salario)
{
clase la cual se hereda y sus miembros del constructor
strcpy(gerentes::auto_empresa,auto_empresa);
gerentes::bono_anual =bonus;
gerentes::opciones_acciones=opciones_acciones;
}
void gerentes::ver_gerente ()
{
ver_empleado();
cout<<"auto de la empresa: "<<auto_empresa<<endl;
cout<<"bono anual: $"<<bono_anual<<endl;
cout<<"opciones de compra de acciones: "<<opciones_acciones<<endl;
}
{
empleados trabajador("pito perez","programador",35000);
gerentes jefe("cristian
gomez","vicepresidente","centra",50000.0,1000,2000);
trabajador.ver_empleado();
jefe.ver_gerente();
return 0;
}
n
______________________________

INDUSTRIAL
PRACTICAS DE
LABORATORIO
PRACTICA 8.2.
#include "stdafx.h"
#include <string.h>
#include <iostream>
class libros
{
public:
libros(char *,char *,int);
void ver_libro();
private:
char titulo[64];
char autor[64];
int paginas;
};
libros::libros(char *titulo, char *autor, int paginas)
{
strcpy(libros::titulo ,titulo);
strcpy(libros::autor ,autor);
libros::paginas =paginas;
}
void libros::ver_libro()
{
cout<<"titulo: "<<titulo<<endl;
cout<<"autor: "<<autor<<endl;
cout<<"paginas: "<<paginas<<endl;
}
class tarjetas:public libros
{
public:
tarjetas(char *, char *,int,char *,int);
void ver_tarjeta();
private:
char catalogo[64];
int prestado;
};
tarjetas::tarjetas(char *titulo, char *autor, int paginas, char *catalogo,
int prestado):libros(titulo,autor,paginas)
{
strcpy(tarjetas::catalogo ,catalogo);
tarjetas::prestado =prestado;
}void tarjetas::ver_tarjeta()
{
ver_libro();
cout<<"catalogo: "<<catalogo<<endl;
if(prestado)
n
cout<<"estado: prestado"<<endl;
else
______________________________

INDUSTRIAL
PRACTICAS DE
LABORATORIO
cout<<"estado: disponible"<<endl;
}
{
tarjetas card("C++ contigo","strauss",234,"qa 678",0);
card.ver_tarjeta();
return 0;
}
5.-ANEXOS
ANEXO 8.1. Haz una clase crculo que herede su miembro radio a una clase
derivada cilindro y me d el volumen del mismo.
#include "stdafx.h"
#include <string.h>
#include <iostream>
class autos
{
public:
autos(char *,char *,int);
void ver_autos();
private:
char marca[64];
char modelo[64];
int revoluciones;
};
autos::autos(char *marca,char *modelo, int revoluciones)
{
strcpy(autos::marca ,marca);
strcpy(autos::modelo,modelo);
autos::revoluciones=revoluciones;
}
void autos::ver_autos()
{
cout<<"Marca : "<<marca<<endl;
cout<<"Modelo : "<<modelo<<endl;
cout<<"Revoluciones Por Minuto: "<<revoluciones<<endl;
}
class tarjetas:public autos
{
public:
tarjetas(char *, char *,int,char *,int);
void ver_tarjeta();
private:

INDUSTRIAL
PRACTICAS DE
LABORATORIO
};
char edicion[64];
int vendido;
tarjetas::tarjetas(char *marca, char *modelo, int revoluciones, char *edicion, int

vendido):autos(marca,modelo,revoluciones)
{
strcpy(tarjetas::edicion ,edicion);
tarjetas::vendido =vendido;
}
void tarjetas::ver_tarjeta()
{
ver_autos();
cout<<"Edicion : "<<edicion<<endl;
if(vendido)
cout<<"Estado : Vendido"<<endl;
else
cout<<"Estado : En venta"<<endl;
}
{
tarjetas card("Honda","Civic",10000,"Limitada",1);
card.ver_tarjeta();
return 0;
}

n
______________________________
ANEXO 8.2. Haz una herencia simple de tu creacin.

#include "stdafx.h"
#include <string.h>
#include <iostream>
#define PI 3.1416
class circulo
{
public:
circulo(float);
void area_circulo();
void ver_circulo();

INDUSTRIAL
PRACTICAS DE
LABORATORIO
private:
float radio, area;
};
circulo::circulo(float r)
{
radio=r;
}
void circulo::area_circulo()
{
area=PI*radio;
}
void circulo::ver_circulo()
{
cout<<"Radio : "<<radio<<" Metros"<<endl;
cout<<"Area : "<<area<< " Metros"<<endl;
}
class cilindro:public circulo
{
float altura, volumen, base;
public:
cilindro(float , float);
void volumen_cilindro();
void ver_cilindro();
};
cilindro::cilindro(float r, float h):circulo(r)
{
cilindro::base=PI*r;
cilindro::altura=h;
}
void cilindro::volumen_cilindro()
{
volumen=base*cilindro::altura;
}
void cilindro::ver_cilindro()
{
cout<<"Base : "<<base<<" Metros cuadrados"<<endl;
cout<<"Volumen : "<<volumen<<" Metros cubicos"<<endl;
}
{
float x,y;

INDUSTRIAL
PRACTICAS DE
LABORATORIO
cout<<"ESTE PROGRAMA CREA UN CIRCULO EN FUNCION DE SU RADIO"
<<"\n Y DESPUES CREA UN CILINDRO EN FUNCION DEL CIRCULO"<<endl;
cout<<""<<endl;
cout<<"Dame El Radio Del Circulo Base"<<endl;
cin>>x;
circulo plano(x);
plano.area_circulo();
plano.ver_circulo();
cout<<""<<endl;
cout<<"Dame La Altura Del Cilindo"<<endl;
cin>>y;
cilindro espacio(x,y);
espacio.volumen_cilindro();
espacio.ver_cilindro();
return 0;
}

n
______________________________

Las herencias simples nos ayudan mas que nada a
no hacer tanto cdigo. Ya que se crea una clase
madre de la cual podemos varios mtodos para crear
una o varias subclases.
7.-REFERENCIAS
LIBRO
Como programar
en C/C++
internet
ELABORO
AUTOR
Deitel&Deitel
REVISO
EDICION
2da
APROBO
EDITORIAL
Pearson
AUTORIZO

INDUSTRIAL
PRACTICAS DE
LABORATORIO
ING. GERARDO
GARCIA GIL
INGENIERIA
CARRERA
INGENIERIAS
PROFE
SOR
PLAN
DE
ESTUDI
O
2011-A
ING GERARDO GARCA

GIL
PRACTI LABORATORIO
CA No. DE
COMPUTACIN
CLAVE
ASIGNATU
RA
CI-11
FEC
HA
NOMBRE DE LA
ASIGNATURA
A OBJETOS
EVALUACI
ON
NOMBRE DE LA
PRACTICA
DURACI
N
(HORAS)

INDUSTRIAL
PRACTICAS DE
LABORATORIO
No
9
Herencia mltiple
1.- INTRODUCCIN
C++ le deja derivar una clase a partir de otra permitindole que herede las
caractersticas de esa otra. Como veremos C++ le deja derivar una clase de ms
de una clase base; cuando la clase hereda las caractersticas de ms de una
clase base, usted construye una clase nueva utilizando herencia mltiple. Como
aprender en esta leccin, C++ soporta totalmente la herencia mltiple.
Cuando usted deriva una clase utilizando varias clases base, aprovecha la
herencia mltiple.
Usando herencia mltiple, la clase derivada recibe los atributos de dos o

ms clases base.
Cuando usted emplea la herencia mltiple para derivar una clase, la

funcin constructor de sta debe llamar al constructor de cada una de las
clases base.
Cuando usted deriva una clase de otra clase derivada, crea una cadena de
herencia.
3.-FUNDAMENTO
La herencia mltiple es una poderosa herramienta de la programacin orientada
a objetos. Experimente con los programas de esta leccin. Como ver, construir
una clase de otra que ya existe le ahorra programacin considerable.

INDUSTRIAL
PRACTICAS DE
LABORATORIO
PRACTICA 9.1
#include "stdafx.h"
#include <string.h>
#include <iostream>
class monitorcompu
{
public:
monitorcompu(char *,long,int,int);
void ver_monitor();
private:
char tipo[32];
long colores;
int resolucion_x;
int resolucion_y;
};
monitorcompu::monitorcompu(char *tipo, long colores, int res_x, int res_y)
{
strcpy(monitorcompu::tipo ,tipo);
monitorcompu::colores=colores;
monitorcompu::resolucion_x=res_x;
monitorcompu::resolucion_y=res_y;
}
void monitorcompu::ver_monitor()
{
cout<<"monitor tipo:"<<tipo<<endl;
cout<<"colores: "<<colores<<endl;
cout<<"resolucion: "<<resolucion_x<<" por "<<resolucion_y<<endl;
}
class tarjetamadre
{
public:
tarjetamadre(int,int,int);
void vertarjetamadre();
private:
int procesador;
int velocidad;
int ram;
};
tarjetamadre::tarjetamadre(int procesador, int velocidad, int ram)
{
tarjetamadre::procesador =procesador;
tarjetamadre::velocidad =velocidad;
tarjetamadre::ram =ram;
}
void tarjetamadre::vertarjetamadre()
{
cout<<"procesador: "<<procesador<<endl;

INDUSTRIAL
PRACTICAS DE
LABORATORIO
cout<<"velocidad: "<<velocidad<<endl;
cout<<"ram: "<<ram<<"Gb"<<endl;
}
class computadora:public monitorcompu,public tarjetamadre
{
public:
computadora(char*,int,char*,long,int,int,int,int,int);
void vercomputadora();
private:
char nombre[64];
int discoduro;
};
computadora::computadora(char *nombre, int discoduro, char *pantalla, long
colores, int res_x, int res_y, int procesador, int velocidad, int
ram):monitorcompu(pantalla,colores,res_x,res_y),tarjetamadre(procesador,vel
ocidad,ram)
{
strcpy(computadora::nombre,nombre);
computadora::discoduro=discoduro;
} void computadora::vercomputadora()
{
cout<<"tipo: "<<nombre<<endl;
cout<<"disco duro"<<discoduro<<" gigas"<<endl;
vertarjetamadre();
ver_monitor();
}
{
computadora mipc("compaq",300,"lcd",16000000,640,480,486,3,2);
mipc.vercomputadora();
return 0;
}

______________________________
PRACTICA 9.2
Crea esta prctica con la practica 9.1 pero haz una herencia simple con la clase
estaciontrabajo cuando la termines, te dars cuenta que manejas el concepto
de HERENCIA
#include "stdafx.h"
#include <string.h>
#include <iostream>

INDUSTRIAL
PRACTICAS DE
LABORATORIO
class monitorcompu
{
public:
monitorcompu(char *,long,int,int);
void ver_monitor();
private:
char tipo[32];
long colores;
int resolucion_x;
int resolucion_y;
};
monitorcompu::monitorcompu(char *tipo, long colores, int res_x, int res_y)
{
strcpy(monitorcompu::tipo ,tipo);
monitorcompu::colores=colores;
monitorcompu::resolucion_x=res_x;
monitorcompu::resolucion_y=res_y;
}
void monitorcompu::ver_monitor()
{
cout<<"Monitor Tipo:"<<tipo<<endl;
cout<<"Colores
: "<<colores<<endl;
cout<<"Resolucion : "<<resolucion_x<<" por "<<resolucion_y<<endl;
}
class tarjetamadre
{
public:
tarjetamadre(int,int,int);
void vertarjetamadre();
private:
int procesador;
int velocidad;
int ram;
};
tarjetamadre::tarjetamadre(int procesador, int velocidad, int ram)
{
tarjetamadre::procesador =procesador;
tarjetamadre::velocidad =velocidad;
tarjetamadre::ram =ram;
}
void tarjetamadre::vertarjetamadre()
{
cout<<"Procesador : "<<procesador<<endl;
cout<<"Velocidad : "<<velocidad<<endl;
cout<<"Ram
: "<<ram<<"Gb"<<endl;

INDUSTRIAL
PRACTICAS DE
LABORATORIO
}
class computadora:public monitorcompu,public tarjetamadre
{
public:
computadora(char*,int,char*,long,int,int,int,int,int);
void vercomputadora();
private:
char nombre[64];
int discoduro;
};
computadora::computadora(char *nombre, int discoduro, char *pantalla, long colores, int
res_x, int res_y, int procesador, int velocidad, int
ram):monitorcompu(pantalla,colores,res_x,res_y),tarjetamadre(procesador,velocidad,ram)
{
strcpy(computadora::nombre,nombre);
computadora::discoduro=discoduro;
}
void computadora::vercomputadora()
{
cout<<"Tipo
: "<<nombre<<endl;
cout<<"Disco Duro : "<<discoduro<<" Gigas"<<endl;
vertarjetamadre();
ver_monitor();
}
class estaciontrabajo:public computadora
{
public:
estaciontrabajo(char*,char*,int,char *,long ,int ,int,int ,int,int);
void ver();
private:
char sistemaoperativo[64];
};
estaciontrabajo::estaciontrabajo(char *sistemaoperativo,char *nombre, int discoduro, char
*pantalla, long colores, int res_x, int res_y, int procesador, int velocidad, int
ram):computadora(nombre,discoduro,pantalla,colores,res_x,res_y,procesador,velocidad,ram)
{
strcpy(estaciontrabajo::sistemaoperativo,sistemaoperativo);
}
void estaciontrabajo::ver()
{
cout<<"SISTEMA OPERATIVO "<<sistemaoperativo<<endl;
vercomputadora();
}

INDUSTRIAL
PRACTICAS DE
LABORATORIO
{
estaciontrabajo mipc("LINUX","Compaq",300," lcd",16000000,640,480,486,3,2);
mipc.ver();
return 0;
}

______________________________
5.-ANEXOS
ANEXO 1; de una clase persona y de clase empleado haz una clase
empleadotienda.
#include "stdafx.h"
#include <string.h>
#include <iostream>
class persona
{
public:
persona(char*,char*, int, int, long);
void ver_persona();
private:
char nombre[64];
char nacionalidad[64];
int edad;
int telefono;
long domicilio;
};
persona::persona(char* nombre,char* nacionalidad, int edad,int telefono,long domicilio)
{
strcpy(persona::nombre,nombre);
strcpy(persona::nacionalidad,nacionalidad);
persona::edad=edad;
persona::telefono=telefono;
persona::domicilio=domicilio;
}
void persona::ver_persona()
{
cout<<"Nombre
: "<<nombre<<endl;
cout<<"Nacionalidad: "<<nacionalidad<<endl;
cout<<"Edad
: "<<edad<<endl;

INDUSTRIAL
PRACTICAS DE
LABORATORIO
cout<<"Telefono : "<<telefono<<endl;
cout<<"Domicilio : "<<domicilio<<endl;
}
class empleado
{
public:
empleado(char*,long, float );
private:
char puesto[64];
long id;
float salario;
};
empleado::empleado(char* puesto,long id,float salario)
{
strcpy(empleado::puesto,puesto);
empleado::id=id;
empleado::salario=salario;
}
void empleado::ver_empleado()
{
cout<<"Id
: "<<id<<endl;
cout<<"Salario
: "<<salario<<endl;
cout<<"Puesto
: "<<puesto<<endl;
}
class empleadotienda:public persona,public empleado
{
public:
empleadotienda(char *,char*,char*, int, int, long,char*, long, float );
void ver();
private:
char sucursal[64];
};
empleadotienda::empleadotienda(char* sucursal,char* nombre,char* nacionalidad, int
edad,int telefono,long domicilio,char* puesto,long id,float
salario):persona(nombre,nacionalidad,edad,telefono,domicilio),empleado(puesto,id,salario)
{
strcpy(empleadotienda::sucursal,sucursal);
}
void empleadotienda::ver()
{

INDUSTRIAL
PRACTICAS DE
LABORATORIO
cout<<"Sucursal "<<sucursal<<endl;
ver_persona();
ver_empleado();
}
{
empleadotienda tipo("TLAQUEPAQUE","ANDRES PEREDO ","MEXICANA",20,36090173,
120,"CAJERO",320,5000);
tipo.ver();
return 0;
}
ANEXO 2; haz una hecha por ti no internet

#include "stdafx.h"
#include <string.h>
#include <iostream>

n
______________________________
class carro
{
public:
carro(char*,char*,char*,int,int);
void ver_carro();
private:
char marca[64];
char modelo[64];
char color[64];
int puertas;
int ao;
};
carro::carro(char* marca,char* modelo,char* color,int puertas,int ao)
{
strcpy(carro::marca,marca);
strcpy(carro::modelo,modelo);
strcpy(carro::color,color);
carro::puertas=puertas;
carro::ao=ao;
}
void carro::ver_carro()

INDUSTRIAL
PRACTICAS DE
LABORATORIO
{
cout<<"Marca
: "<<marca<<endl;
cout<<"Modelo
: "<<modelo<<endl;
cout<<"Color
: "<<color<<endl;
cout<<"Puertas : "<<puertas<<endl;
cout<<"Aos
: "<<ao<<endl;
}
class camioneta
{
public:
camioneta(char*,int,int);
void ver_camioneta();
private:
char sonido[64];
int llantas;
int cilindros;
};
camioneta::camioneta(char* sonido,int llantas,int cilindros)
{
strcpy(camioneta::sonido,sonido);
camioneta::llantas=llantas;
camioneta::cilindros=cilindros;
}
void camioneta::ver_camioneta()
{
cout<<"Marca del Sonido: "<<sonido<<endl;
cout<<"Llantas
: "<<llantas<<endl;
cout<<"Cilindros
: "<<cilindros<<endl;
}
class minivan:public carro,public camioneta
{
public:
minivan(char*,char*,char*,char*,int,int,char*,int,int);
void ver();
private:
char tipo_agencia[65];
};
minivan::minivan(char* tipo_agencia,char* marca,char* modelo,char* color,int puertas,int
ao,char* sonido,int llantas,int
cilindros):carro(marca,modelo,color,puertas,ao),camioneta(sonido,llantas,cilindros)
{
strcpy(minivan::tipo_agencia,tipo_agencia);
}

INDUSTRIAL
PRACTICAS DE
LABORATORIO
void minivan::ver()
{
cout<<"Agencia "<<tipo_agencia<<endl;
ver_carro();
ver_camioneta();
}

{
minivan nueva("HONDA","Honda","Civic","Negro",4,2012,"SONY",6,6);
nueva.ver();
return 0;
}

______________________________

Cuando utilizamos una herencia mltiples
empleamos una forma ms fcil de programar ya que
no empleamos tanto cdigo ya que al contener varias
clases madre de las cual podemos heredar a
subclases.
7.-REFERENCIAS
LIBRO
Como programar
en C/C++
internet
AUTOR
Deitel&Deitel
EDICION
2da
EDITORIAL
Pearson

INDUSTRIAL
PRACTICAS DE
LABORATORIO
ELABORO
REVISO
APROBO
AUTORIZO
CLAVE
ASIGNATU
RA
NOMBRE DE LA
ASIGNATURA
ING. GERARDO
GARCIA GIL
INGENIERIA
CARRERA
INGENIERIAS
PROFE
SOR
PLAN
DE
ESTUDI
O
2011-A
ING GERARDO GARCA

GIL
CI-11
FEC
HA
A OBJETOS
EVALUACI
ON

INDUSTRIAL
PRACTICAS DE
LABORATORIO
PRACTI LABORATORIO
CA No. DE
COMPUTACIN
No
NOMBRE DE LA
PRACTICA
10
DURACI
N
(HORAS)
Clases amigas
1.- INTRODUCCIN
Miembros privados y amigos.
Los programas solo pueden acceder a los miembros de clases privadas usando
funciones miembro de clase. Al usar los miembros de clase privados tan a
menudo como sea posible, usted reduce la posibilidad de que un programa use
mal el valor de un miembro ya que aquel solo puede acceder mediante funciones
de interfaz (que pueden controlar el acceso al miembro). Sin embargo,
dependiendo de cmo se utilice el programa los objetos,hay ocaciones en las que
usted puede incrementar, de modo importante, el rendimiento de un programa
dejando que una clase acceda directamente a los miembros privados de otra. De
esta forma,los programas evitan el exceso de procesamiento (tiempo de
ejecucin) al invocar las funciones de interfaz para tales casos,C++ le permite
definir una clase como amiga (friend)de otra y luego a las clase amiga acceder a
los miembros privados d ela otra.
Con la palabra reservada friend una clase puede indicarle a C++ cules
clases son sus amigas, es decir,qu otras clases pueden acceder
directamente a sus miembros privados.
Los miembros de clase privados protegen los datos de la clase; por tanto,
usted debe limitar el uso de clases amigas solo a clases que tengan
verdadera necesidad de acceder de modo directo a los miembros de clase
privados.
C++ le permite restringir el acceso de una clase amiga a un conjunto

especifico de funciones.

INDUSTRIAL
PRACTICAS DE
LABORATORIO
3.-FUNDAMENTO
COMO DEFINIR UNA CLASE AMIGA.
C++ le permite a una clase acceder a los miembros privados de una amiga. Para
indicarle a C++ que una clase es una amiga de otra, usted, sencillamente,
incluye la palabra reservada friend y el nombre de la clase amiga
correspondiente dentro de la definicin de la clase. Por ejemplo, la siguiente
clase libro indica que la clase librero es amiga. Por tanto, los objetos de la clase
librero pueden acceder directamente a los miembros privados de la clase libro
mediante el operador punto:
Ejemplo:
class libro{
public:
libro (char*,char*,char*);
Void ver_libro();
friend librero; // declaracin de la clase amiga librero
private:
char titulo[64];
char autor[64];
char catalogo[64];
};

Practica 10.1
#include "stdafx.h"
#include <string.h>
#include <iostream>
class librero;
class libro
{
public:
libro(char*,char*,char*);
void verlibro();
friend librero;

INDUSTRIAL
PRACTICAS DE
LABORATORIO
private:
char titulo[64];
char autor[64];
char catalogo[64];
};
libro::libro(char *titulo, char *autor, char *catalogo)
{
strcpy(libro::titulo ,titulo);
strcpy(libro::autor,autor);
strcpy(libro::catalogo ,catalogo);
}
void libro::verlibro()
{
}
class librero
{
public:
void cambiarcatalogo(libro*,char*);
char *darcatalogo(libro);
};
void librero::cambiarcatalogo (libro *estelibro, char *nuevocatalogo)
{
strcpy(estelibro->catalogo ,nuevocatalogo);
}
char *librero::darcatalogo(libro estelibro)
{
static char catalogo[64];
strcpy(catalogo,estelibro.catalogo );
return (catalogo);
}

n
______________________________

INDUSTRIAL
PRACTICAS DE
LABORATORIO
{
libro programacion("C ++ 4ta edicion","gerardo gil","p123");
librero biblioteca;
programacion.verlibro ();
biblioteca.cambiarcatalogo (&programacion,"C++ super facil");
return 0;
}
Como puedes observar, el programa pasa por direccin el objeto libro a la funcin
cambiarcatalogo de la clase librero. Como esta funcin cambia un miembro de
dicha clase, el programa debe pasar el parmetro por direccin y luego usar el
apuntador para acceder al miembro.Experimente con este programa omitiendo la
instruccin friend de la definicion de la clase libro. Puesto que la clase librero ya
no podra acceder a los miembros de clase privados,el compilador de C++
generara errores de sintaxs cada vez que el programa intente hacer referencia a
los datos privados de la clase libro.
QUE SON LAS CLASES AMIGAS.
Conmnmente la unica forma de que los programas puedan a acceder datos
privados de una clase es mediante funciones de interfaz. Dependiendo de la
forma en que use objetos el programa, hay ocaciones en que es util (eficiente en
velocidad de procesamiento)garantizar a una clase el acceso a los miembros
privados de otra. El compilador, a su vez, permitira a la clase amiga acceder a los
miembros privados como sea necesario. Para definir una clase amiga, coloque la
palabra reservada friend y el nombre de la clase correspondiente dentro de los
miembros publicos de la definicin de la clase, de este modo:
class jefe{
public:
friend costello;
//otros miembros;
private:
//miembros privados
}
COMO RESTRINGIR EL ACCESO A LOS AMIGOS.
Cunado usted especifica que una clase es amiga de otra proporciona acceso a los
datos privados de la amiga. No obstante, mientras mayor acceso d a los datos
privados de una clase, mayor ser la probabilidad de introducir errores en el
programa. Por tanto, si solo algunas funciones dentro de la clase amiga deben
acceder a los datos privados de otra clase,C++ le permite especificar que el
programa slo permite a funciones especificas de la clase amiga acceder a
miembros privados. Supongamos que la clae librero, presentado en la practica

INDUSTRIAL
PRACTICAS DE
LABORATORIO
anterior, tiene varias funciones. Asimismo, imaginemos que solo las funciones
cambiarcatalogo y darcatalogo necesitan acceder a los datos Ing Gerardo Garca
Gil CLASES AMIGAS

INDUSTRIAL
PRACTICAS DE
LABORATORIO
privados de la clase libro. Dentro de la definicin de la clase libro, usted puede
restringir el acceso a los miembros privados solamente a esas dos
funciones.como se muestra a continuacin:
QUE SON LAS CLASES AMIGAS.
Cuando los programas usan amigos para acceder a datos privados de una clase,
usted puede restringir el nmero de funciones miembro de la clase dentro de la
clase amiga que pueden acceder a los datos privados mediante funciones
amigas. Para declarar una funcin amiga, usted especifica la palabra reservada
friend, seguida de un prototipo completo para la funcin que debe tener acceso a
los datos, de este modo:
public:
friend nombre_clase::nombre_metodo(lista de
parametros);
slo las funciones miembro que usted indique como amigas pueden acceder
directamente a los miembros privados de clase mediante el operador punto.
Cuando los programas comienzan a hacer referencia a una clase desde otra,
usted puede cometer errores de sintaxis si el orden de las definiciones de cada
clase es incorrecto. En este caso, la definicin de la clase libro emplea
definiciones de prototipos de funcin establecidas desde la clase librero. Por lo
tanto, la definicin de la clase librero debe de ir antes que la de clase libro, sin
embargo, si analiza la clase librero, encontrar una referencia a la clase libro.
El siguiente programa utiliza funciones amigas para limitar el acceso de la clase
librero a los datos privados de la clase libro. Observe el orden de las definiciones
de cada clase:
Practica 10.2
#include "stdafx.h"
#include <string.h>
#include <iostream>
class libro;
class librero
{
public:
};

INDUSTRIAL
PRACTICAS DE
LABORATORIO
class libro
{
public:
void verlibro();
friend char *librero::darcatalogo(libro);
friend void librero::cambiarcatalogo(libro*,char*);
private:
char titulo[64];
char autor[64];
char catalogo[64];
};
{
}
void libro::verlibro ()
{
}
void librero::cambiarcatalogo(libro *estelibro,char *nuevocatalogo)
{
}
char *librero::darcatalogo (libro estelibro)
{
n
return (catalogo);
}
______________________________
{
libro programacion("C++ al rescate tercera edicion","james","PER32");
librero biblioteca;
biblioteca.cambiarcatalogo(&programacion,"c++ a lo facil");
return 0;
}
Como puede ver se usa primero una entrada de una lnea que indica al
compilador que despus definir la clase libro.Como la entrada hace que el
compilador sepa de esta clase, la definicin de la clase librero puede hacer
referencia a la clase libro, que el programa no define sino posteriormente.

INDUSTRIAL
PRACTICAS DE
LABORATORIO
Practica 10.3
#include "stdafx.h"
#include <string.h>
#include <iostream>
class paciente;
class medico
{
private:
char nombrecompleto[64],especialidad[64];
public:
medico();
medico(char *nomcom,char *esp);
char *obtenernombrecompleto();
char *obtenerespecialidad();
void imprimirdatos();
friend class paciente;
};
medico::medico(){}
medico::medico(char *nomcom, char *esp)
{
strcpy(nombrecompleto,nomcom);
strcpy(especialidad,esp);
}
char *medico::obtenernombrecompleto()
{
return nombrecompleto;
}
char * medico::obtenerespecialidad()
{
return especialidad;
}
void medico::imprimirdatos()
{
cout<<"nombre completo del medico: "<<nombrecompleto<<endl;
cout<<"especialidad: "<<especialidad<<endl;
}
class paciente
{
private:
char nombrecompleto[64];
int edad;
char padecimiento[64];
medico *medicoespecialista;
public:
paciente();
paciente(char *nomcom,int ed,char *pad);
char *obtenernombrecompleto();

INDUSTRIAL
PRACTICAS DE
LABORATORIO
int obteneredad();
char *obtenerpadecimiento();
void asociarmedico();
void imprimirdatos(); };

INDUSTRIAL
PRACTICAS DE
LABORATORIO
paciente::paciente(){}
paciente::paciente(char *nomcom, int ed, char *pad)
{
strcpy(nombrecompleto,nomcom);
edad=ed;
strcpy(padecimiento,pad);
}
char *paciente::obtenernombrecompleto()
{
return nombrecompleto;
}
int paciente::obteneredad()
{
return edad;
}
char * paciente::obtenerpadecimiento()
{
return padecimiento;
}
void paciente::asociarmedico()
{
medicoespecialista= new medico();
cout<<"ingrese el nombre completo del medico: ";
cin>>medicoespecialista->nombrecompleto);
cout<<"ingrese la especialidad: ";
cin>>medicoespecialista->especialidad;
}
void paciente::imprimirdatos()
{
cout<<"\nnombrecompleto: "<<nombrecompleto<<endl;
cout<<"edad: " <<edad<<endl;
cout<<"padecimiento: "<<padecimiento<<endl;
cout<<"datos del medico especialista"<<endl;
medicoespecialista->imprimirdatos ();
}
{
paciente a("juan garcia",25,"gripe"),b("roberto duron",14,"sifilis");
a.asociarmedico();
b.asociarmedico();
a.imprimirdatos();
n
b.imprimirdatos();
return 0;
}
______________________________

INDUSTRIAL
PRACTICAS DE
LABORATORIO
5.-ANEXOS
Anexo 10.1 a la practica 10.2 cambiar titulo y autor al libro.
#include "stdafx.h"
#include <string.h>
#include <iostream>
class libro;
class librero
{
public:
void cambiartitulo(libro*,char*);
void cambiarautor(libro*,char*);
};
class libro
{
public:
void verlibro();
friend char *librero::darcatalogo(libro);
friend void librero::cambiartitulo (libro*,char*);
friend void librero::cambiarautor(libro*,char*);
friend void librero::cambiarcatalogo(libro*,char*);
private:
char titulo[64];
char autor[64];
char catalogo[64];
};
{
}
void libro::verlibro ()
{
cout<<"Titulo : "<<titulo<<endl;
cout<<"Autor : "<<autor<<endl;
cout<<"Catalogo: "<<catalogo<<endl;
}

INDUSTRIAL
PRACTICAS DE
LABORATORIO
void librero::cambiartitulo(libro *estelibro,char *nuevotitulo)
{
strcpy(estelibro->titulo ,nuevotitulo);
}
void librero::cambiarautor(libro *estelibro,char *nuevoautor)
{
strcpy(estelibro->autor ,nuevoautor);
}
void librero::cambiarcatalogo(libro *estelibro,char *nuevocatalogo)
{
}
char *librero::darcatalogo (libro estelibro)
{
return (catalogo);
}
{
libro programacion("C++ Al Rescate Tercera Edicion","James","Aprenda C++");
librero biblioteca;
biblioteca.cambiartitulo(&programacion,"SUPER LOCO");
biblioteca.cambiarautor(&programacion,"PSYKOLOCO");
biblioteca.cambiarcatalogo(&programacion,"C++ A Lo Facil");
return 0;
}

n
______________________________
Anexo 10.2 hacer una clase amiga de tu inspiracin.
#include "stdafx.h"
#include <string.h>
#include <iostream>
class camion;
class central
{
public:
void cambiarnombre(camion*,char*);
void cambiarconductor(camion*,char*);

INDUSTRIAL
PRACTICAS DE
LABORATORIO
void cambiardestino(camion*,char*);
char *dardestino(camion);
};
class camion
{
public:
camion(char*,char*,char*);
void vercamion();
friend char *central::dardestino(camion);
friend void central::cambiarnombre (camion*,char*);
friend void central::cambiarconductor(camion*,char*);
friend void central::cambiardestino(camion*,char*);
private:
char nombre[64];
char conductor[64];
char destino[64];
};
camion::camion(char *nombre, char *conductor, char *destino)
{
strcpy(camion::nombre ,nombre);
strcpy(camion::conductor,conductor);
strcpy(camion::destino ,destino);
}
void camion::vercamion ()
{
cout<<"Nombre : "<<nombre<<endl;
cout<<"Conductor : "<<conductor<<endl;
cout<<"Destino : "<<destino<<endl;
}
void central::cambiarnombre(camion *estecamion,char *nuevonombre)
{
strcpy(estecamion->nombre ,nuevonombre);
}
void central::cambiarconductor(camion *estecamion,char *nuevoconductor)
{
strcpy(estecamion->conductor ,nuevoconductor);
}
void central::cambiardestino(camion *estecamion,char *nuevodestino)
{
strcpy(estecamion->destino ,nuevodestino);
}
char *central::dardestino (camion estecamion)
{
static char destino[64];
strcpy(destino,estecamion.destino );
return (destino);
}

INDUSTRIAL
PRACTICAS DE
LABORATORIO
{
cout<<"DATOS ORIGINALES: "<<endl;
camion programacion(" LA TORTUGA"," ANDRES"," QUERETARO");
central camionera;
programacion.vercamion ();
cout<<"DATOS CAMBIADOS: "<<endl;
camionera.cambiarnombre(&programacion, " EL TIGRE ");
camionera.cambiarconductor(&programacion," GUILLERMO");
camionera.cambiardestino(&programacion, " MICHUACAN");
programacion.vercamion ();
return 0;
}

n
______________________________

Las clases amigas es otro mtodo en el cual se
heredan de una clase amiga a otra algunos
argumentos que se acceden por los datos privados
ms son los que uno dese y se aplican menos
errores.
7.-REFERENCIAS
LIBRO
Como programar
en C/C++
internet
ELABORO
AUTOR
Deitel&Deitel
REVISO
EDICION
2da
APROBO
EDITORIAL
Pearson
AUTORIZO

INDUSTRIAL
PRACTICAS DE
LABORATORIO
ING. GERARDO
GARCIA GIL

Manual de Practicas para Programar en C

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Manual de Practicas para Programar en C

Uploaded by

Copyright:

Available Formats

Centro de Enseanza Tcnica

TTULO DEL TRABAJO

ANDRES GUILLERMO PEREDO CORTES 11110182

ING GERARDO GARCA

El alumno comprender la importancia y eficiencia en utilizar punteros cabe

En la declaracin de punteros y la posterior asignacin de direcciones de memoria

Los punteros solo pueden apuntar a _____________, ________________ y

4.-PROCEDIMIENTO (DESARROLLO DE LA PRACTICA)

Firma practica cumplida

//almacena la direccion de millas en dirnum

printf("la direccion almacenada en dirnum es %d\n",dirnum);

1.2 Desarrollar un programa que por medio de punteros me regrese el valor de

ANDRES GUILLERMO PEREDO CORTES 11110182

Firma practica cumplida

1.2 Desarrollar un programa que por medio de punteros me regrese el valor de

Firma practica cumplida

Firma practica cumplida

printf("la letra es %c\n",pcadena);

ANDRES GUILLERMO PEREDO CORTES 11110182

Firma practica cumplida tarea

printf ("\t Total: %d\n", contarCaracteres(cadena));

ANDRES GUILLERMO PEREDO CORTES 11110182

Firma practica cumplida tarea

Firma practica cumplida tarea

Firma practica cumplida tarea

6.- RESULTADOS Y CONCLUCIONES

ANDRES GUILLERMO PEREDO CORTES 11110182

ING GERARDO GARCA

El alumno sabr utilizar y manejar las estructuras (structs) utilizar el

Ntese que al declararse las variables al mismo tiempo que se define la

Acceso a los campos

4.-PROCEDIMIENTO (DESARROLLO DE LA PRACTICA)

2.1 El siguiente es un ejercicio caracterstico del funcionamiento de las

ANDRES GUILLERMO PEREDO CORTES 11110182

printf("\nCliente numero %d\n",i+1);

Firma practica cumplida

ANDRES GUILLERMO PEREDO CORTES 11110182

struct estructura_amigo amigo[ELEMENTOS];

Firma practica cumplida

ANDRES GUILLERMO PEREDO CORTES 11110182

Firma practica cumplida

ANDRES GUILLERMO PEREDO CORTES 11110182

printf( "domicilio: " ); fflush( stdout );

Firma practica cumplida tarea

6.- RESULTADOS Y CONCLUCIONES

ANDRES GUILLERMO PEREDO CORTES 11110182

ING GERARDO GARCA

ING GERARDO GARCA

ANDRES GUILLERMO PEREDO CORTES 11110182

el alumno pueda definir una clase los programas deben de especificar

La definicin de una clase proporciona una plantilla que los programas

Los programas asignan valores a los miembros de datos de la clase

Los programas llaman a funcin miembro de clases (mtodos) mediante

ANDRES GUILLERMO PEREDO CORTES 11110182

Firma practica cumplida tarea

4.-PROCEDIMIENTO (DESARROLLO DE LA PRACTICA)

ANDRES GUILLERMO PEREDO CORTES 11110182

Firma practica cumplida tarea

5.2 El siguiente es un ejercicio caracterstico del funcionamiento de las clases,

Firma practica cumplida

ANDRES GUILLERMO PEREDO CORTES 11110182

int _tmain(int argc, _TCHAR* argv[])

Firma practica cumplida tarea

Los punteros solo pueden apuntar a _, ____ y

tarjetas::tarjetas(char marca, char modelo, int revoluciones, char *edicion, int