Manual de Practicas para programar en C

Centro de Enseñanza Técnica IndustrialOrganismo Público Descentralizado Federal

TÍTULO 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 Enseñanza Técnica Industrial

Plantel:

TONALA

Turno:

VESPERTINO

ANDRES GUILLERMO PEREDO CORTES 11110182

PRACTICAS

INGENIERIACARRERA

PLAN DE ESTUDIO

CLAVE ASIGNATURA

NOMBRE DE LA ASIGNATURA

INGENIERIAS 2011-A CI-11 PROGRAMACIÓN ORIENTADA A OBJETOS

PROFESOR ING GERARDO GARCÍA GIL FECHA EVALUACION

PRACTICA No.

LABORATORIO DE COMPUTACIÓN No

NOMBRE DE LA PRACTICA

DURACIÓN (HORAS)

1 E INTRODUCCION A PUNTEROS 3

1.- INTRODUCCIÓN

Un puntero es una variable que contiene como valor una dirección de memoria. Dicha dirección corresponde habitualmente a la dirección 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 básicos para comprender toda la potencia y flexibilidad que ofrece el lenguaje. Son especialmente importantes en la programación 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 código compacto y eficiente.3. Son imprescindibles para el paso de parámetros por referencia a funciones.4. Tienen una fuerte relación con el manejo eficiente de tablas y estructuras.5. Permiten realizar operaciones de asignación dinámica de memoria y manipular estructuras

de datos dinámicas.

2.-OBJETIVO (COMPETENCIA)

El alumno comprenderá la importancia y eficiencia en utilizar punteros cabe advertir que los punteros son tradicionalmente la parte de C más difícil de comprender. Además deben usarse con gran precaución, puesto que al permitir manipular directamente la memoria del ordenador, pueden provocar fallos en el programa. Estos fallos suelen ser bastante difíciles de localizar y de solucionar. Pero al manejarlos se hace un uso eficiente de la computadora en reducción de código y tiempo.


3.-FUNDAMENTO

Un puntero es un tipo especial de variable que contiene, ni más ni menos que, una dirección de memoria.

númerohace referencia de manera directa a una Variable que contiene el valor 8

ptrnumero numero

Ptrnumerohace referencia de manera indirecta a una variable que contiene el valor 8

En la declaración de punteros y la posterior asignación de direcciones de memoria a los mismos, se utilizan respectivamente los operadores unarios * y &. El operador & permite obtener la dirección que ocupa una variable en memoria. Por su parte, el operador de indirección * permite obtener el contenido de un objeto apuntado por un puntero.En la declaración de variables puntero se usa también el operador * , que se aplica directamente a la variable a la cual precede. El formato para la declaración 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 ________________


8

8

4.-PROCEDIMIENTO (DESARROLLO DE LA PRACTICA)

1.1 La función del siguiente programa es saber la diferencia del símbolo de dirección & y el símbolo 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; //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 _tmain(int argc, _TCHAR* argv[]){

int iArr[5]={3,5,7,1,9};int v=3;int *pv;pv=&v;

int *pi=iArr;

for(int i=0;i<5;i++){

printf("el valor de iArr[%d] es:%d\n",i,*pi+i);}

return 0;}


Firma practica cumplida laboratorio 1

______________________________


______________________________

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 _tmain(int argc, _TCHAR* argv[]){

int iArr[5]={3,5,7,1,9};int v=3;int *pv;pv=&v;

int *pi=iArr;

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 minúscula a mayúsculas y además la contabilice.

#include "stdafx.h"#include <stdio.h>#include<ctype.h>

int a,b,c;int _tmain(int argc, _TCHAR* argv[]){char cadena[]="hola como estas"; char *pcadena;pcadena=&cadena[0];

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 demuéstralos.

a.1.2.- Realizar un programa en el cual transforme una cadena de caracteres de minúsculas a mayúsculas con un ciclo whiley además 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 (máx. 60 caracteres):\n"); gets(cadena); printf ("\t Total: %d\n", contarCaracteres(cadena));

return 0;}

a.1.3.- Realizar un analizador léxico el cual contabilice vocales, consonantes, dígitos, espacios y otros.


Firma practica cumplida tarea 1

______________________________


______________________________


______________________________

a.1.4.- haz una aplicación con punteros en la cual hayas entendido el concepto.

6.- RESULTADOS Y CONCLUCIONES

7.-REFERENCIASLIBRO AUTOR EDICION EDITORIAL

Como programar en C/C++

Programación de C

Deitel&DeitelGOTTFRIED BYRON

2da4ta

PearsonMCGRAW-HILL

ELABORO REVISO APROBO AUTORIZO

ING. GERARDO GARCIA GIL

INGENIERIACARRERA

PLAN DE ESTUDIO

CLAVE ASIGNATURA



PROFESOR

ING GERARDO GARCÍA GIL FECHA EVALUACION



______________________________

PRACTICA No.



DURACIÓN (HORAS)

2 Estructuras (Structs) 3

1.- INTRODUCCIÓN

Una estructura es un conjunto de una o más variables, de distinto tipo, agrupadas bajo un mismo nombre para que su manejo sea más sencillo. En una estructura los elementos que la componen pueden ser de distintos tipos. Así pues, una estructura puede agrupar datos de tipo carácter, enteros, cadenas de caracteres, matrices de números. . ., e incluso otras estructuras. En cualquier caso, es habitual que todos los elementos agrupados en una estructura tengan alguna relación entre ellos. En adelante nos referiremos a los elementos que componen una estructura como campos.La definición 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 agrupación. Para ello se utiliza la palabra reservada struct de la forma siguiente:

Structtipo_estructura{ tipo_variable nombre_variable1; tipo_variable nombre_variable2; tipo_variable nombre_variable3;};

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 utilización más habitual es para la programación de bases de datos, ya que están 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 función del operador punto. Crear variables para la utilización delas estructuras. aprenderá a utilizar la palabra reservada “typedef” y trataremos de utilizarla en una base de

datos que diseñaremos en el laboratorio.

3.-FUNDAMENTO

Declaración de variables


La declaración de variables del tipo definido por una estructura puede hacerse de dos maneras diferentes.Bien en la misma definición de la estructura, bien posteriormente. La forma genérica 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;

Nótese que al declararse las variables al mismo tiempo que se define la estructura, el nombre de éstajunto 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 declaración de variables en el segundo caso sería:

struct nombre estructura lista de variables;

Acceso a los camposLos campos de una estructura de manejan habitualmente de forma individual. El mecanismo que Cproporciona para ello es el operador “punto” (.). La forma general para acceder a un campo en unavariable de tipo estructura es el siguiente:

variable. Nombre campo


2.1 El siguiente es un ejercicio característico del funcionamiento de las estructuras, explique el significado de cada una de las líneas 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].ultimopago.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");}

}

2.2 Necesitamos saber cómo 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. Veámoslo en un ejemplo en el que se supone que tenemos que meter los datos de tres amigos:


#define ELEMENTOS 3

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 número %i:\n", num_amigo+1 ); printf( "Nombre: " ); fflush( stdout ); gets(amigo[num_amigo].nombre); printf( "Apellido: " ); fflush( stdout ); gets(amigo[num_amigo].apellido); printf( "Teléfono: " ); fflush( stdout ); gets(amigo[num_amigo].telefono);printf( "Edad: " ); fflush( stdout ); scanf( "%i", &amigo[num_amigo].edad ); while(getchar()!='\n');} /* Ahora imprimimos sus datos */ for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ )


Firma practica cumplida laboratorio

______________________________

{ printf( "El amigo %s ", amigo[num_amigo].nombre ); printf( "%s tiene ", amigo[num_amigo].apellido ); printf( "%i años ", amigo[num_amigo].edad ); printf( "y su teléfono es el %s.\n" , amigo[num_amigo].telefono ); }

return 0;}

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.saldo);printf("%d %c %s %.2f\n",*pc->no_cuenta,*pc->tipo_cuenta,pc->nombre,*pc->saldo);

return 0;}



______________________________


______________________________

5.-ANEXOS


#define ELEMENTOS 3

struct estructura_amigo { char nombre[30]; char domicilio[40]; char travajo[10]; char puesto[60]; };

struct estructura_amigo amigo[ELEMENTOS];


int num_amigo;

for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ ) { printf( "\nDatos del amigo número %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 */ for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ ) { 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;

}


Firma practica cumplida tarea n

______________________________




Internet

Deitel&Deitel 2da Pearson




INGENIERIACARRERA

PLAN DE ESTUDIO

CLAVE ASIGNATURA



PROFESOR


INGENIERIACARRERA

PLAN DE ESTUDIO

CLAVE ASIGNATURA



PROFESOR


PRACTICA No.



DURACIÓN (HORAS)

5 Clases 3

1.- INTRODUCCIÓN

La clase es la principal herramienta de la programación orientada a objetos. Como aprenderá en esta lección. Una clase es muy parecida a una estructura ya que agrupa miembros que corresponden a los datos de un objeto, así como funciones llamadas (métodos) que operan sobre los datos. Como veremos, un objeto es una cosa, digamos un teléfono, un archivo o un libro. Una clase de C++ permite que los programas definan atributos de los objetos (características). En el caso de un objeto teléfono, la clase podría tener miembros datos, como el numero de teléfono 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 programación e incrementa el reciclaje (“reúso”) del código. En esta lección es una introducción a las clases de C++. Cuando termine, debe de tener los siguientes conceptos clave:

2.-OBJETIVO (COMPETENCIA) el alumno pueda definir una clase los programas deben de especificar un nombre,

miembros y funciones (métodos de la clase).


La definición 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 función miembro de clases (métodos) mediante el operador punto.

3.-FUNDAMENTO

Declaración de clasesEn el sentido más simple, un objeto es una cosa. Cuando usted crea un programa, este casi siempre usa variables para guardar información sobre cosas del mundo real; empleados, libros e incluso archivos por decir algo. Cuando usted usa programación 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, podría tener operaciones sobre de el . imprimir , borrar, mostrar o cambiar de dirección .en C++ usted usa una clase para definir objetos. Cuando define una clase, su meta es incluir en ella tanta información 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 mayoría de libros y artículos sobre la POO denominan métodos 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 más miembros y una llave de cierre. De esta modo. Class nombre_clase { Tipo miembro_clase; Tipo método_clase(); } Después 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 información sobre el trabajador, de este modo podría estar de la siguiente manera: Ing Gerardo García 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; } }; int _tmain(int argc, _TCHAR* argv[]) { 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; }


5.1 El siguiente es un ejercicio característico del funcionamiento de las clases, explique el significado de cada una de las líneas y resuelva los detalles y errores del programa.

#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(); }; void empleados::ver_empleado() { cout<<"Nombre "<<nombre<<endl; cout<<"Id empleado "<<id_emp<<endl; cout<<"salario "<<salario<<endl<<endl; } int _tmain(int argc, _TCHAR* argv[]) { 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; }

5.2 El siguiente es un ejercicio característico del funcionamiento de las clases, explique el significado de cada una de las líneas y resuelva los detalles y errores del programa.#include "stdafx.h" #include <string.h> #include <iostream> using namespace std; 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; } int _tmain(int argc, _TCHAR* argv[]) { 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; }



______________________________


______________________________

5.-ANEXOS5.3 crea un método de la función donde se crean los datos de la práctica 3.1

#include "stdafx.h"#include <string.h>#include <iostream>using namespace std;

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;}



______________________________

3.2 lo mismo que el anexo 3.1 pero para la practica 3.2


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;}

3.3 elabora uno tu mismo


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;}



__________________________


Las clases nos sirve para que la programación no sea tan tediosa ya que podemos reciclar mucho del código y hacerlo aún más rápido



internet





PRACTICA No.



DURACIÓN (HORAS)

6 Constructores y destructores 3

1.- INTRODUCCIÓN

Como aprendió en la lección anterior, la única forma en que los programas puedan acceder a miembros de datos privados es emplear una función de clase. Para simplificar el proceso de inicialización de miembros de datos de la clase, C++ le permite definir una función constructor especial, sobre una base por clase, que C++invoca de forma automática cada vez que se crea un objeto. De modo similar, C++ proporciona una función destructor que el lenguaje ejecuta cuando usted descarga un objeto. Esta lección estudia las funciones destructor y constructor detalladamente.


Las funciones constructor son métodos de la clase que facilitan los programas la

inicialización 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 función destructor especial que puede liberar esa memoria, en sentido, dejándola limpia después del objeto.

Conforme corre el programa, muchos objetos podrían reservar memoria para guardar información. Cuando usted descarta un objeto, C++ invoca una función destructor especial para liberar esa memoria, en sentido, dejándola limpia después del objeto.

Las funciones destructor tienen el mismo nombre que la clase, excepto porque usted puede preceder su nombre con un carácter 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

CÓMO CREAR UNA FUNCIÓN CONSTRUCTOR SIMPLE.

Una función constructores un método de clase que tiene el mismo nombre de esta. Por ejemplo, si usted usa una clase llamada empleados, el nombre de la función constructor es, también, empleados. Asimismo, para una clase llamada perros, el nombre de la función constructor debe de ser perros también. Si el programa define una función constructor, C++automáticamente la invoca cada vez que usted crea un objeto del tipo de la clase correspondiente. El siguiente programa, crea una clase llamada empleados. También define una función constructor llamada empleados que asigna los valores iniciales a los objetos. Una función constructor no puede devolver un valor; sin embargo, usted no la declara como void, ni especifica un tipo de retorno, como se muestra a continuación.

4.-PROCEDIMIENTO (DESARROLLO DE LA PRACTICA)6.1 primer constructor

#include "stdafx.h" #include <string.h> #include <iostream> using namespace std; 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; } int _tmain(int argc, _TCHAR* argv[]) { empleados trabajador("gerardo gil",101,5000.50); empleados ejecutivo("pancho lopez",2,50000.50); trabajador.ver_empleados (); ejecutivo.ver_empleados (); return 0;

}

ANDRES GUILLERMO PEREDO CORTES 11110182Firma practica cumplida tarea n

______________________________

6.2 Destructor

#include "stdafx.h" #include <string.h> #include <iostream> using namespace std; class empleados{ public: empleados(char*,long,float); ~empleados(); //alt 126 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; } empleados::~empleados () { cout<<"destruyendo el objeto para "<<nombre<<endl; } void empleados::ver_empleados () { cout<<"Empleado: "<<nombre<<endl; cout<<"Id: "<<id_empleado<<endl; cout<<"Salario: "<<salario<<endl;

}

6.3 Incorpora el constructor donde es igual a 10, 000

#include "stdafx.h" #include <string.h> #include <iostream> using namespace std; class empleados{ public:



______________________________

empleados(char*,long,float); ~empleados(); 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=10000.0) { strcpy(empleados::nombre ,nombre); empleados::id_empleado =id_empleado; 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; } void empleados::ver_empleados () { cout<<"Empleado : "<<nombre<<endl; cout<<"Id : "<<id_empleado<<endl; cout<<"Salario : "<<salario<<endl; }

int _tmain(int argc, _TCHAR* argv[]) { empleados trabajador("Gerardo Gil",101,5000.50); empleados ejecutivo("Pancho Lopez",2,50000.50); trabajador.ver_empleados (); ejecutivo.ver_empleados (); return 0; }



______________________________

5.-ANEXOS

6.1 crea un programa que demuestre lo aprendido

#include "stdafx.h" #include <string.h> #include <iostream> using namespace std; 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; } int _tmain(int argc, _TCHAR* argv[]) { imprenta periodico( "EL INFORMADOR",101,5000.50); imprenta revista( "LO MAS INTERESANTE",55,50000.50); periodico.ver_imprenta (); revista.ver_imprenta (); return 0; }



______________________________

6.2 crea un programa que demuestre lo aprendido

#include "stdafx.h" #include <string.h> #include <iostream> using namespace std; 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; }

int _tmain(int argc, _TCHAR* argv[]) { imprenta periodico("EL INFORMADOR",101,5000.50); imprenta revista("LO MAS INTERESANTE",2,50000.50); periodico.ver_imprenta (); revista.ver_imprenta (); return 0; }



______________________________

6.- RESULTADOS Y CONCLUCIONESEl constructor es un método de la clase en el cual nos facilita para crear un objeto y el destructor nos sirve más que nada para borrar un espacio de memoria que haya sido asignado



internet





INGENIERIACARRERA

PLAN DE ESTUDIO

CLAVE ASIGNATURA



PROFESOR


PRACTICA No.



DURACIÓN (HORAS)

7 Sobrecarga de operadores 3

1.- INTRODUCCIÓN

La sobrecarga de operadores es el proceso de cambiar el significado de un operador (digamos de adición,+, que C++ utiliza generalmente para hacer sumas) para que lo use una clase especifica. En esta sección definiremos una clase llamada cadena y sobrecargaremos los operadores de la adición y sustracción. Para los objetos de la cadena, el operador de la adición añadirá letras específicas al contenido actual de una cadena


Usted sobrecarga operadores para mejorar la legibilidad de los programas. Debe sobrecargar

un operador cuando, al hacerlo, sea más fácil 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 función que C++ invoca cada vez que la clase usa un operador sobrecargado. La función, a su vez, ejecuta las operaciones correspondientes.

Cuando un programa sobrecarga un operador para una clase específica, el significado del operador cambia solo para esa clase; el resto del programa continua usándolo 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 función sumar_letras para agregar caracteres a la cadena variable titulo. Además, utiliza las funciones quitar_letras para eliminar cada aparición de la letra e de la cadena de caracteres lección. En este ejemplo usa llamadas a función para hacer tales operaciones. Utilizando la sobrecarga de operadores sin embargo, el problema puede hacer operaciones idénticas mediante los operadores de adición (+)y sustracción (-).


Cuando usted sobrecarga un operador, utiliza la palabra clave operator de C++ dentro del prototipo y definición de la función para indicar al compilador de C++ que la clase ocupará este método como operador. La siguiente definición de clase; por ejemplo utiliza la palabra operator para asignar operadores de adición y sustracción 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> using namespace std; 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; } strcpy(datos,temp); } void cadena::ver_cadena() { cout<<datos<<endl; }


CENTRO DE ENSEÑANZA TECNICA INDUSTRIAL PRACTICAS DE LABORATORIO

int _tmain(int argc, _TCHAR* argv[]) { 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; }

PRACTICA 7.2 desarrolle un programa que defina una clase con la palabra –operador- para asignar operadores de adicción y sustracción de las funciones sumar_letras y quitar_letras, dentro de la clase cadena

#include "stdafx.h" #include <string.h> #include <iostream> using namespace std; class cadena { public: cadena(char *); void operator +(char *); void operator -(char); void ver_cadena(); private: char datos[256]; }; cadena::cadena(char *str) { strcpy(datos,str); } void cadena::operator +(char *str) { strcat(datos,str); } void cadena::operator -(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; strcpy(datos,temp);



______________________________


}} void cadena::ver_cadena() { cout<<datos<<endl; } int _tmain(int argc, _TCHAR* argv[]) { cadena titulo("c++ al rescate"); cadena leccion("sobrecarga de operadores"); titulo.ver_cadena (); titulo + " al rescate!"; titulo.ver_cadena(); leccion.ver_cadena (); leccion - 'e'; leccion.ver_cadena(); return 0; }

PRACTICA 7.3 crea un programa que añada un operador sobre cargado, incluyendo el operador de igualdad (==)#include "stdafx.h" #include <string.h> #include <iostream> using namespace std; class cadena { public: cadena(char *); char *operator +(char *); char *operator -(char); int operator==(cadena); void ver_cadena(); private: char datos[256]; }; cadena::cadena(char *str) { strcpy(datos,str); }

char *cadena::operator +(char *str) { return(strcat(datos,str)); } char *cadena::operator -(char letra) { char temp[256]; int i,j; for(i=0,j=0;datos[i];i++) { //¿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); } void cadena::ver_cadena() { cout<<datos<<endl; } int _tmain(int argc, _TCHAR* argv[]) { cadena titulo("c++ al rescate"); cadena leccion("sobrecarga de operadores"); 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; }



______________________________


5.-ANEXOS

7.1 realiza el de la practica 7.2 pero con la siguiente clase

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

using namespace std;

class cadena{public:

cadena(char *); char *operator +(char *); char *operator -(char); int operator==(cadena); void ver_cadena();

private: char datos[256];

};

cadena::cadena(char *str){

strcpy(datos,str);}

char *cadena::operator +(char *str){

return(strcat(datos,str));}

char *cadena::operator -(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;

}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);

}

void cadena::ver_cadena() {

cout<<datos<<endl;}


cadena titulo("C++ Al Rescate");cadena leccion("Sobrecarga De Operadores");

titulo.ver_cadena ();titulo + " Al Rescate!";titulo.ver_cadena();

leccion.ver_cadena (); leccion -'e';

leccion -'a';leccion -'r';leccion.ver_cadena();

return 0;}

7.2 Realiza un programa tuyo

#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];



______________________________


cadena::cadena(char *str){

strcpy(datos,str);}

char *cadena::operator +(char *str){

return(strcat(datos,str));}

char *cadena::operator -(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;

}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);

}

void cadena::ver_cadena() {

cout<<datos<<endl;}


cadena titulo("El Raton come mucho queso");cadena leccion("Sobrecarga De Operadores");

titulo.ver_cadena ();titulo + "y mas queso ";titulo.ver_cadena();

leccion.ver_cadena (); leccion - 'e';

leccion - 'o'; leccion - 'c';



leccion.ver_cadena(); return 0;}

6.- RESULTADOS Y CONCLUCIONESEs una secuencia de operadores que nos sirve para contabilizar o eliminar cadenas o caracteres de ellas. Ya sea alguna letra en especifico o varias



internet






______________________________


INGENIERIACARRERA

PLAN DE ESTUDIO

CLAVE ASIGNATURA



PROFESOR


PRACTICA No.



DURACIÓN (HORAS)

8 Herencia simple 3

1.- INTRODUCCIÓN

La programación orientada a objetos le facilita volver a usar una clase que creó para un programa dentro de otro, ahorrándole, por lo tanto, tiempo y programación. Cuando usted define clases, hay ocasiones en que una clase usa algunas o todas las características de otra que ya existe y entonces añade uno o más miembros, ya sea de datos o funciones. En estos casos, C++ le permite construir un objeto nuevo ocupando las características 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.

Además de miembros públicos (accesibles a todos) y privados (accesibles solo a los métodos 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 resolución global (::), precedido del nombre de la clase base o derivada.



3.-FUNDAMENTO

HERENCIA SIMPLE. La herencia permite a una clase derivada heredar las características 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 programación y elimina la duplicación del código dentro del programa para comenzar la definición de la clase, usted especifica la palabra reservada class, luego el nombre gerentes seguido de un signo de dos puntos y después el nombre empleados. La palabra reservada public que precede al nombre de la clase empleados indica que los miembros públicos (public) de esta clase serán públicos también 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 sólo para la clase derivada a través de funciones de interfaz de la clase base directamente mediante el operador punto. El siguiente programa, muestra cómo 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> using namespace std; class empleados { public: empleados(char *,char *,float); void ver_empleado(); 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); empleados::salario =salario; }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; } int _tmain(int argc, _TCHAR* argv[]) { empleados trabajador("pito perez","programador",35000); gerentes jefe("cristian gomez","vicepresidente","centra",50000.0,1000,2000); trabajador.ver_empleado(); jefe.ver_gerente(); return 0; }

PRACTICA 8.2. #include "stdafx.h" #include <string.h> #include <iostream> using namespace std;



______________________________


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) cout<<"estado: prestado"<<endl; else cout<<"estado: disponible"<<endl; } int _tmain(int argc, _TCHAR* argv[]) { tarjetas card("C++ contigo","strauss",234,"qa 678",0); card.ver_tarjeta(); return 0; }



______________________________


5.-ANEXOSANEXO 8.1. Haz una clase círculo 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>using namespace std;

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: 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;}

ANEXO 8.2. Haz una herencia simple de tu creación.

#include "stdafx.h" #include <string.h> #include <iostream> #define PI 3.1416


class circulo{ public:

circulo(float); void area_circulo();void ver_circulo();

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;

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

float x,y;

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;}



______________________________


6.- RESULTADOS Y CONCLUCIONESLas herencias simples nos ayudan mas que nada a no hacer tanto código. Ya que se crea una clase madre de la cual podemos varios métodos para crear una o varias subclases.



internet






INGENIERIACARRERA

PLAN DE ESTUDIO

CLAVE ASIGNATURA



PROFESOR


PRACTICA No.



DURACIÓN (HORAS)

9 Herencia múltiple 3

1.- INTRODUCCIÓN

C++ le deja derivar una clase a partir de otra permitiéndole que herede las características de esa otra. Como veremos C++ le deja derivar una clase de más de una clase base; cuando la clase hereda las características de más de una clase base, usted construye una clase nueva utilizando herencia múltiple. Como aprenderá en esta lección, C++ soporta totalmente la herencia múltiple.


Cuando usted deriva una clase utilizando varias clases base, aprovecha la herencia múltiple.

Usando herencia múltiple, la clase derivada recibe los atributos de dos o más clases base.

Cuando usted emplea la herencia múltiple para derivar una clase, la función 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 múltiple es una poderosa herramienta de la programación orientada a objetos. Experimente con los programas de esta lección. Como verá, construir una clase de otra que ya existe le ahorra programación considerable.




PRACTICA 9.1 #include "stdafx.h" #include <string.h> #include <iostream> using namespace std; 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; } 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(); } int _tmain(int argc, _TCHAR* argv[]) { computadora mipc("compaq",300,"lcd",16000000,640,480,486,3,2); mipc.vercomputadora(); return 0; }

PRACTICA 9.2 Crea esta práctica con la practica 9.1 pero haz una herencia simple con la clase estaciontrabajo cuando la termines, te darás cuenta que manejas el concepto de HERENCIA


class monitorcompu{public: monitorcompu(char *,long,int,int); void ver_monitor();


Firma practica cumplida tarea

______________________________


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;}

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();}

int _tmain(int argc, _TCHAR* argv[]){estaciontrabajo mipc("LINUX","Compaq",300," lcd",16000000,640,480,486,3,2);mipc.ver();return 0;}



______________________________


5.-ANEXOSANEXO 1; de una clase persona y de clase empleado haz una clase empleadotienda.


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;cout<<"Telefono : "<<telefono<<endl;cout<<"Domicilio : "<<domicilio<<endl;}

class empleado{public:

empleado(char*,long, float );void ver_empleado();

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(){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”


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 año;

};

carro::carro(char* marca,char* modelo,char* color,int puertas,int año){

strcpy(carro::marca,marca);strcpy(carro::modelo,modelo);strcpy(carro::color,color);carro::puertas=puertas;carro::año=año;

}

void carro::ver_carro(){cout<<"Marca : "<<marca<<endl;cout<<"Modelo : "<<modelo<<endl;cout<<"Color : "<<color<<endl;cout<<"Puertas : "<<puertas<<endl;cout<<"Años : "<<año<<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 año,char* sonido,int llantas,int cilindros):carro(marca,modelo,color,puertas,año),camioneta(sonido,llantas,cilindros){

strcpy(minivan::tipo_agencia,tipo_agencia);}

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 múltiples empleamos una forma más fácil de programar ya que no empleamos tanto código ya que al contener varias clases madre de las cual podemos heredar a subclases.



internet






INGENIERIACARRERA

PLAN DE ESTUDIO

CLAVE ASIGNATURA



PROFESOR


PRACTICA No.



DURACIÓN (HORAS)

10 Clases amigas 3

1.- INTRODUCCIÓN

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 cómo 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 ejecución) 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++ cuáles 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.



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 definición 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; // declaración 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> using namespace std; class librero; class libro { public: libro(char*,char*,char*); void verlibro(); friend librero; 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() { cout<<"titulo: "<<titulo<<endl; cout<<"autor: "<<autor<<endl; cout<<"catalogo: "<<catalogo<<endl; } 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); }



______________________________


int _tmain(int argc, _TCHAR* argv[]) { libro programacion("C ++ 4ta edicion","gerardo gil","p123"); librero biblioteca; programacion.verlibro (); biblioteca.cambiarcatalogo (&programacion,"C++ super facil");

programacion.verlibro (); return 0; } Como puedes observar, el programa pasa por dirección el objeto libro a la función cambiarcatalogo de la clase librero. Como esta función cambia un miembro de dicha clase, el programa debe pasar el parámetro por dirección y luego usar el apuntador para acceder al miembro.Experimente con este programa omitiendo la instrucción 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 sintaxìs cada vez que el programa intente hacer referencia a los datos privados de la clase libro. QUE SON LAS CLASES AMIGAS. Conmúnmente 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 definiciòn 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 sólo permite a funciones especificas de la clase amiga acceder a miembros privados. Supongamos que la clae librero, presentado en la practica anterior, tiene varias funciones. Asimismo, imaginemos que solo las funciones cambiarcatalogo y darcatalogo necesitan acceder a los datos Ing Gerardo García Gil CLASES AMIGAS



privados de la clase libro. Dentro de la definición de la clase libro, usted puede restringir el acceso a los miembros privados solamente a esas dos funciones.como se muestra a continuación: QUE SON LAS CLASES AMIGAS. Cuando los programas usan amigos para acceder a datos privados de una clase, usted puede restringir el número de funciones miembro de la clase dentro de la clase amiga que pueden acceder a los datos privados mediante funciones amigas. Para declarar una función amiga, usted especifica la palabra reservada friend, seguida de un prototipo completo para la función que debe tener acceso a los datos, de este modo: public: friend nombre_clase::nombre_metodo(lista de parametros); sólo 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 definición de la clase libro emplea definiciones de prototipos de función establecidas desde la clase librero. Por lo tanto, la definición 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> using namespace std; class libro; class librero { public: void cambiarcatalogo(libro*,char*); char *darcatalogo(libro); };



class libro { public: libro(char*,char*,char*); void verlibro(); friend char *librero::darcatalogo(libro); friend void librero::cambiarcatalogo(libro*,char*); 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 () { cout<<"titulo: "<<titulo<<endl; cout<<"autor: "<<autor<<endl; cout<<"catalogo: "<<catalogo<<endl; } 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); } int _tmain(int argc, _TCHAR* argv[]) { libro programacion("C++ al rescate tercera edicion","james","PER32"); librero biblioteca; programacion.verlibro (); biblioteca.cambiarcatalogo(&programacion,"c++ a lo facil"); programacion.verlibro (); return 0; } Como puede ver se usa primero una entrada de una línea que indica al compilador que después definirá la clase libro.Como la entrada hace que el compilador sepa de esta clase, la definición de la clase librero puede hacer referencia a la clase libro, que el programa no define sino posteriormente.



______________________________


Practica 10.3 #include "stdafx.h" #include <string.h> #include <iostream> using namespace std; 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(); int obteneredad(); char *obtenerpadecimiento(); void asociarmedico(); void imprimirdatos(); };



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 (); } int _tmain(int argc, _TCHAR* argv[]) { paciente a("juan garcia",25,"gripe"),b("roberto duron",14,"sifilis"); a.asociarmedico(); b.asociarmedico(); a.imprimirdatos(); b.imprimirdatos();

return 0; }



______________________________


5.-ANEXOSAnexo 10.1 a la practica 10.2 cambiar titulo y autor al libro.

#include "stdafx.h"#include <string.h>#include <iostream>using namespace std;class libro;class librero{public:void cambiartitulo(libro*,char*);void cambiarautor(libro*,char*);void cambiarcatalogo(libro*,char*);char *darcatalogo(libro);};class libro{public:libro(char*,char*,char*);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];};libro::libro(char *titulo, char *autor, char *catalogo){strcpy(libro::titulo ,titulo);strcpy(libro::autor,autor);strcpy(libro::catalogo ,catalogo);}void libro::verlibro (){cout<<"Titulo : "<<titulo<<endl;cout<<"Autor : "<<autor<<endl;cout<<"Catalogo: "<<catalogo<<endl;}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)



{strcpy(estelibro->catalogo ,nuevocatalogo);}char *librero::darcatalogo (libro estelibro){static char catalogo[64];strcpy(catalogo,estelibro.catalogo );return (catalogo);}int _tmain(int argc, _TCHAR* argv[]){libro programacion("C++ Al Rescate Tercera Edicion","James","Aprenda C++");librero biblioteca;programacion.verlibro ();biblioteca.cambiartitulo(&programacion,"SUPER LOCO");biblioteca.cambiarautor(&programacion,"PSYKOLOCO");biblioteca.cambiarcatalogo(&programacion,"C++ A Lo Facil");programacion.verlibro ();return 0;}

Anexo 10.2 hacer una clase amiga de tu inspiración.

#include "stdafx.h"#include <string.h>#include <iostream>using namespace std;class camion;class central{public:void cambiarnombre(camion*,char*);void cambiarconductor(camion*,char*);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);}int _tmain(int argc, _TCHAR* argv[]){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;}




______________________________


Las clases amigas es otro método en el cual se heredan de una clase amiga a otra algunos argumentos que se acceden por los datos privados más son los que uno dese y se aplican menos errores.



internet





Manual de Practicas para programar en C

Documents

Transcript of Manual de Practicas para programar en C