Ejemplos de Programacion para Extra

Ejemplo 0
#include<iostream>
using namespace std;

struct MiTipo{
int x;
double y;
char z;
};

int main(){
MiTipo *ap;
MiTipo a;
ap=&a; //operador de direccion &
cout<<"direccion= "<<ap<<endl;
cout<<"Direccion de a + 1 = "<<ap+1<<endl;
return 0;
}
Ejemplo 1
/* USO DEL OPERADOR PUNTO . Y DEL OPERADOR FLECHA ->

PARA EL ACCESO A LOS MIEMBROS DE UNA ESTRUCTURA
POR MEDIO DE SU NOMBRE O POR MEDIO DE SU DIRECCION */
#include<iostream>
struct Persona{
int Edad;
float Estatura;
float Peso;
};
int main(){
Persona Diego;
Persona *ap;
ap=&Diego; // & => operador de direccion -> La direccion de
cout<<"La direccion de Diego es "<<ap<<endl;
cout<<"Da la estatura= ";
cin>>Diego.Estatura;
cout<<"Da la edad= ";
cin>>Diego.Edad;
cout<<"Da el peso= ";
cin>>Diego.Peso;
system("cls");
cout<<"La edad de Diego es= "<<ap->Edad<<" años"<<endl;
cout<<"La estatura de Diego es= "<<ap->Estatura<<" metros"<<endl;
cout<<"El peso de Diego es= "<<ap->Peso<<" Kg"<<endl;
return 0;
}

Ejemplo 2
/* uso del operador de indireccion */

#include<iostream>
int main(){
int x;
x=12345;
int *direcc_para_int; // DECLARACION DE UN APUNTADOR
direcc_para_int=&x; // &operador de direccion "la direccion de"
cout<<"La direccion de x es= "<<direcc_para_int<<endl;
cout<<"x= "<<x<<endl;
cout<<"x= "<<*direcc_para_int<<endl; //* operador de indireccion
// * => "el contenido de la direccion a la que apunta"
return 0;
}
Ejemplo 3
#include<iostream>
int main(){
// tipo Nombre[tam] Arreglo unidimensional -> Vector
int A[10]; // UN ARREGLO TAMBIEN ES UN APUNTADOR
A[0]=12345;
cout<<*A<<endl;
return 0;
}
Ejemplo 4
/* USO DE UN ARREGLO DE ESTRUCTURAS */

/*** EL ACCESO A LOS MIEMBROS DEL ARREGLO SE PUEDE HACER MEDIANTE
EL OPERADOR PUNTO O BIEN USANDO EL OPERADOR FLECHA ***/
#include<iostream>
struct Alumno{
int Edad;
float Promedio;
float Estatura;
long Boleta;
};

int main(){
Alumno Grupo[5];
for(int i=0;i<5;i++){
cout<<"Da la edad del alumno "<<(i+1)<<" =";
cin>>Grupo[i].Edad;
cout<<"Da el promedio del alumno "<<(i+1)<<" =";
cin>>Grupo[i].Promedio;
cout<<"Da la estatura del alumno "<<(i+1)<<" =";
cin>>Grupo[i].Estatura;
cout<<"Da el numero de boleta del alumno "<<(i+1)<<" =";
cin>>Grupo[i].Boleta;
}
system("cls");
cout<<"Edad del alumno "<<(i+1)<<" ="<<Grupo[i].Edad<<endl;
cout<<"Promedio de alumno "<<(i+1)<<" ="<<(Grupo+i)->Promedio<<endl;
cout<<"Estatura del alumno "<<(i+1)<<" ="<<(Grupo+i)->Estatura<<endl;
cout<<"Numero de boleta del alumno "<<(i+1)<<" ="<<(Grupo+i)->Boleta<<endl;
}
return 0;
}
Ejemplo 5
/** USO DE ASIGNACION DINAMICA DE MEMORIA CON ESTRUCTURAS **/

#include<iostream>
#include<string.h>
#include<conio.h>
#include<ctype.h>
struct Alumno{
int Edad;
float Promedio;
char Nombre[20];
char Apellido[20];
};
int main(){
Alumno *Grupo;
int N,i,x,z=0;
char opcion;
int Superior,Inferior;
char Buscar[30];
cout<<"Cuantos alumnos tiene el grupo= ";
cin>>N;
Grupo=new Alumno[N];
if(Grupo==NULL){
cout<<"Error de memoria"<<endl;
return 0;
}
cout<<"Lectura de datos"<<endl;
for(i=0;i<N;i++){
cout<<"Da el nombre del alumno= ";
fflush(stdin);
gets((Grupo +i)->Nombre);
cout<<"Da el apellido del alumno= ";
fflush(stdin);
gets((Grupo +i)->Apellido);
cout<<"Da la edad del alumno= ";
cin>>(Grupo+i)->Edad;
cout<<"Da el promedio del alumno= ";
cin>> Grupo[i].Promedio;
}
system("cls");
cout<<"Como quieres buscar:"<<endl;
cout<<"a)Nombre"<<endl;
cout<<"b)Apellido"<<endl;
opcion=getche();
opcion=tolower(opcion);
switch(opcion){
case 'a':
cout<<"Da el nombre del alumno que buscas= ";
fflush(stdin);
gets(Buscar);
for(i=0;i<N;i++){
x=strcmpi(Buscar,Grupo[i].Nombre);
if(x==0){
cout<<"Nombre: "<<Grupo[i].Nombre<<" "<<Grupo[i].Apellido<<endl;
cout<<"La edad es de "<<Grupo[i].Edad<<endl;
cout<<"El promedio es de "<<Grupo[i].Promedio<<endl;
z++;
}
}
if(z==0)cout<<"No se encontro el alumno"<<endl;
else
cout<<"Existen "<<z<< " alumnos con ese nombre"<<endl;
break;
case 'b':
cout<<"Da el apellido del alumno que buscas= ";
fflush(stdin);
gets(Buscar);
for(i=0;i<N;i++){
x=strcmpi(Buscar,Grupo[i].Apellido);
if(x==0){
cout<<"Nombre: "<<Grupo[i].Nombre<<" "<<Grupo[i].Apellido<<endl;
cout<<"La edad es de "<<Grupo[i].Edad<<endl;
cout<<"El promedio es de "<<Grupo[i].Promedio<<endl;
z++;
}
}
if(z==0)cout<<"No se encontro el alumno"<<endl;
else
cout<<"Existen "<<z<< " alumnos con ese nombre"<<endl;
break;
default:
cout<<"Opcion no validad"<<endl;
}
system("pause>NULL");
system("CLS");
cout<<"Busqueda de alumno por rango de edad"<<endl;
do{
cout<<"Proporciona el limite superior del rango de edad= ";
cin>>Superior;
cout<<"Proporciona el limite inferior del rango de edad= ";
cin>>Inferior;
if(Superior<Inferior)cout<<"¡ERROR DE LIMITES !"<<endl;
}while(Superior<Inferior);
for(i=0;i<N;i++){
if( (Grupo[i].Edad>=Inferior)&&(Grupo[i].Edad<=Superior)){
cout<<"Nombre: ";
puts(Grupo[i].Nombre);
cout<<endl;
}
}
system("pause");
system("cls");
cout<<"Alumnos aprobrados"<<endl;
x=0;
for(i=0;i<N;i++){
if(Grupo[i].Promedio>=6){
cout<<"Nombre: ";
puts(Grupo[i].Nombre); // solo aplica para arreglos de char
cout<<"Calificacion= "<<Grupo[i].Promedio;
cout<<endl;
x++;
}
}
cout<<"En total "<<x<<" aprobados"<<endl;
delete []Grupo;
return 0;
}

Ejemplo 6
/** USO DE ASIGNACION DINAMICA DE MEMORIA CON ESTRUCTURAS **/

#include<iostream>
#include<string.h>
#include<conio.h>
#include<ctype.h>
/** PARA QUE UN PROGRAMA SE CONSIDERE
ORIENTADO A OBJETOS SE DEBE CUMPLIR EL PRINCIPIO DE ENCAPSULAMIENTO
DE DATOS: LOS ATRIBUTOS DE LA CLASE DEBE SER INACCESIBLES A
CUALQUIER ELEMENTO EXTERNO DE LA CLASE */
class Alumno{
private:
int Edad;
float Promedio;
char Nombre[30];
public:
void LeeDatos();
void ImprimeDatos();
friend void Prom( int,Alumno* );
};
// :: operador scope
//

void Prom(int A, Alumno*G ){
float P=0;
for(int i=0;i<A;i++)
P+=G[i].Promedio;
P/=A;
cout<<"Promedio de los "<<A<<" alumnos= "<<P<<endl;
}

void Alumno::ImprimeDatos(){
cout<<"Nombre: ";
puts(Nombre);
cout<<"Edad= "<<Edad<<endl;
cout<<"Promedio= "<<Promedio<<endl;
}
void Alumno :: LeeDatos(){
cout<<"Da el nombre del alumno= ";
fflush(stdin);
gets(Nombre);
cin>>Edad;
cout<<"Da el promedio= ";
cin>>Promedio;
}
int main(){
Alumno x; // OBJETO: INSTANCIA DE UNA CLASE
Alumno *Grupo;
int N,i;
float P;
cout<<"Cuantos alumnos tiene el grupo= ";
cin>>N;
Grupo=new Alumno[N]; // ASIGNACION DINAMICA DE MEMORIA
if(Grupo==NULL){
cout<<"Error de memoria"<<endl;
return 0;
}
for(i=0;i<N;i++)
Grupo[i].LeeDatos();
system("cls");
for(i=0;i<N;i++)
(Grupo+i)->ImprimeDatos();
system("pause>NULL");
Prom(N,Grupo);
delete []Grupo;
return 0;
}

Ejemplo 7
// EJEMPLO 7
/** UTILIZANDO EL CONCEPTO DE FUNCIONES AMIGAS DE UNA CLASE
REALIZAR UN POO QUE REALICE LA SUMA Y RESTA DE DOS NUMEROS
COMPLEJOS DONDE CADA NUMERO COMPLEJO SEA UN OBJETO, PRESENTANDOLO
COMO UN MENU REPETITIVO **/
#include<iostream>
#include<conio.h>
#include<ctype.h>
class Complejo{
private:
float Real;
float Imaginario;
public:
// CONSTRUCTOR DE OFICIO
void LeeDatos(); // PROTOTIPO DE LA FUNCION
friend Complejo Suma(Complejo,Complejo);
friend Complejo Resta(Complejo,Complejo);
};
Complejo Resta(Complejo Sumando1,Complejo Sumando2){
Complejo Resultado;
Resultado.Real=Sumando1.Real-Sumando2.Real;
Resultado.Imaginario=Sumando1.Imaginario-Sumando2.Imaginario;
return Resultado;
}
Complejo Suma(Complejo Sumando1,Complejo Sumando2){
Complejo ComplejoSuma;
ComplejoSuma.Real=Sumando1.Real+Sumando2.Real;
ComplejoSuma.Imaginario=Sumando1.Imaginario+Sumando2.Imaginario;
return ComplejoSuma;
}
void Complejo::ImprimeDatos(){
cout<<"("<<Real;
if(Imaginario>=0)cout<<"+";
cout<<Imaginario<<"i)"<<endl;
}

void Complejo::LeeDatos(){
cout<<"Da la parte real de este numero complejo= ";
cin>>Real;
cout<<"Da la parte imaginaria= ";
cin>>Imaginario;
}
int main(){
Complejo A,B,Resultado;
char opcion;
do{
system("cls");
cout<<"Bienvenido a las operaciones entre numeros complejo"<<endl;
cout<<"dame los datos del primer complejo"<<endl;
A.LeeDatos();
cout<<"Dame los datos del segundo complejo"<<endl;
B.LeeDatos();
cout<<"Que quieres hacer"<<endl;
cout<<"A)La suma"<<endl;
cout<<"B)La resta"<<endl;
cout<<"S)alir"<<endl;
cout<<"da la opcion= ";
opcion=getche();
opcion=toupper(opcion);
switch(opcion){
case 'A':
Resultado=Suma(A,B);
cout<<endl<<"El resultado de la suma es= ";
Resultado.ImprimeDatos();
break;
case 'B':
Resultado=Resta(A,B);
cout<<endl<<"Resultado de la resta= ";
Resultado.ImprimeDatos();
break;
case 'S':
cout<<endl<<"Adios"<<endl;
break;
default:
cout<<endl<<"Opcion no valida"<<endl;
}
system("pause");
}while(opcion!='S'); // MENU REPETITIVO
return 0;
}
/** EJEMPLO 8: CONSTRUCTOR **/

// ES UNA FUNCION QUE SE LLAMA IGUAL QUE LA CLASE QUE PUEDE O NO
// TENER PARAMETROS Y QUE NO REGRESA NINGUN TIPO DE DATO
// (NI SIQUIERA void)
#include<iostream>
#include<string.h>
class Alumno{
private:
char Nombre[20];
int Edad;
float Calificacion;
public:
Alumno();// constructor vacio
Alumno(char*,int,float);//constructor con parametros
Alumno(char*,int);
Alumno(char*);
};
// CONSTRUCTOR CON PARAMETROS PARCIALES
Alumno::Alumno(char*N,int E){
cout<<"Constructor con 2 parametros"<<endl;
strcpy(Nombre,N);
Edad=E;
Calificacion=5;
}

//CONSTRUCTOR CON PARAMETROS PARCIALES
Alumno::Alumno(char *N){
cout<<"Constructor con un parametro"<<endl;
strcpy(Nombre,N);
Edad=18;
Calificacion=9.9;
}

// CONSTRUCTOR SIN PARAMETROS O POR DEFAULT O POR OMISION O VACIO
Alumno::Alumno(){
cout<<"Hola soy el constructor vacio"<<endl;
Edad=0;
Calificacion=0;
strcpy(Nombre,"");
}

// CONSTRUCTOR CON PARAMETROS TOTALES
Alumno::Alumno(char*N,int E,float C ){
cout<<"Hola soy el constructor con parametros"<<endl;
Calificacion=C;
Edad=E;
strcpy(Nombre,N);
}

cout<<"Nombre: ";
puts(Nombre);
cout<<"Calificacion= "<<Calificacion<<endl;
}

int main(){
Alumno A;
Alumno B("Susana",20,9.8);
Alumno C("juan",21);
Alumno D("Archivaldo");
cout<<"Estos son los datos objeto A:"<<endl;
A.ImprimeDatos();
cout<<"Estos son los datos del objeto B:"<<endl;
B.ImprimeDatos();
cout<<"Estos son los datos del objeto C:"<<endl;
C.ImprimeDatos();
cout<<"Estos son los datos del objeton D:"<<endl;
D.ImprimeDatos();
return 0;
}
//*** EJEMPLO 9: CONSTRUCTORES (CONTINUACION)

// CONSTRUCTOR GENERAL Y CONSTRUCTOR COPIA
#include<iostream>
#include<string.h>
#include<stdio.h>
class Alumno{
private:
string Nombre; // ==,>,>=,<,<=,!=
int Edad;
float Calificacion;
public:
void LeeDatos();
Alumno(char*,int,float);//constructor GENERAL
Alumno(Alumno&); // CONSTRUCTOR COPIA
};

// CONSTRUCTOR GENERAL:
// REALIZA LAS FUNCIONES DEL CONSTRUCTOR VACIO O DEL CONSTRUCTOR
// CON PARAMETROS TOTALES O PARCIALES
Alumno::Alumno(char*N="SIN NOMBRE" ,int E=18 ,float C=6 ){
cout<<"Hola soy el constructor GENERAL"<<endl;
Calificacion=C;
Edad=E;
Nombre=N;
}

// CONSTRUCTOR COPIA:
// GENERA NUEVOS OBJETOS A PARTIR DE OBJETOS PREVIOS CON LOS
// MISMOS DATOS
Alumno::Alumno(Alumno& ObjetoOriginal){
cout<<"Hola soy el constructor copia"<<endl;
Nombre=ObjetoOriginal.Nombre;
Edad=ObjetoOriginal.Edad;
Calificacion=ObjetoOriginal.Calificacion;
}
cout<<"Nombre: ";
cout<<Nombre<<endl;
cout<<"Calificacion= "<<Calificacion<<endl;
}

void Alumno::LeeDatos(){
cout<<"Da el nombre= ";
fflush(stdin);
getline(cin, Nombre );
cin>>Edad;
cout<<"Da la calificacion= ";
cin>>Calificacion;
}

int main(){

Alumno A;
A.LeeDatos();
A.ImprimeDatos();
Alumno B=A;
B.ImprimeDatos();
return 0;
}

/** CONSTRUCTORES:
OFICIO: NO LO VEO PERO ES EL QUE EL COMPILADOR ME ASIGNA CUANDO NO TENGO
VACIO: NO TIENE PARAMETROS
CON PARAMETROS: YA SEA TOTALES O PARCIALES
GENERAL: TIENE VALORES POR DEFAULT EN SUS PARAMETROS
COPIA: GENERA NUEVOS OBJETOS A PARTIR DE OBJETOS QUE YA EXISTIAN
**/

// EJEMPLO 10: REALIZAR UN PROGRAMA ORIENTADO A OBJETOS QUE

// IMPLEMENTE UN VECTOR DE X-Y Y EFECTUE LOS METODOS
// NECESARIOS PARA LEER LOS DATOS DEL VECTOR, IMPRIMIRLOS,
// CALCULAR E IMPRIMIR LA NORMA DEL VECTOR Y REALIZAR LA
// SUMA Y RESTA DE DOS VECTORES. lA CLASE DEBERA CONTENER LOS
// CONSTRUCTORES NECESARIOS Y SU DESTRUCTOR
#include<iostream>
#include<math.h>
class Vector{
private:
float x,y;
public:
Vector(float,float); // PROTOTIPO DE CONSTRUCTOR GENERAL
Vector(Vector&); // PROTOTIPO DEL CONSTRUCTOR COPIA
~Vector(); // DESTRUCTOR
void LeeVector();
void ImprimeVector();
float NormaDelVector();
friend Vector Suma(Vector,Vector);
friend Vector Resta(Vector,Vector);
};
Vector::Vector(float a=0,float b=0){
x=a;
y=b;
cout<<"Constructor general activado"<<endl;
}
Vector::Vector(Vector& Original){
x=Original.x;
y=Original.y;
cout<<"Constructor copia activado"<<endl;
}
Vector::~Vector(){
cout<<"Objeto destruido"<<endl;
}
void Vector::LeeVector(){
cout<<"Da la coordenada x= ";
cin>>x;
cout<<"Da la coordenada y= ";
cin>>y;
}
void Vector::ImprimeVector(){
cout<<"y= "<<y<<endl;
}
float Vector::NormaDelVector(){
float R;
R=sqrt(pow(x,2)+pow(y,2));
return R;
}
Vector Suma(Vector Uno,Vector Dos ){
Vector Resultado;
Resultado.x=Uno.x+Dos.x;
Resultado.y=Uno.y+Dos.y;
return Resultado;
}
Vector Resta(Vector Uno,Vector Dos){
Vector Resultado;
Resultado.x=Uno.x-Dos.x;
Resultado.y=Uno.y-Dos.y;
return Resultado;
}
int main(){
Vector A,B,S,R;
float q;
cout<<"Da las coordenadas del primer vector:"<<endl;
A.LeeVector();
cout<<"Da las coordenadas del segundo vector:"<<endl;
B.LeeVector();
system("cls");
cout<<"la magnitud del vector A= "<<A.NormaDelVector()<<endl;
q=B.NormaDelVector();
cout<<"La magnitud del vector B= "<<q<<endl;
S=Suma (A,B);
cout<<"La suma es:"<<endl;
S.ImprimeVector();
R=Resta(A,B);
cout<<"La resta es: "<<endl;
R.ImprimeVector();
return 0;
}

/** EJEMPLO 11: SOBRECARGA DE FUNCIONES **/

/** DOS O MAS FUNCIONES QUE SE LLAMAN IGUAL PERO CON LA CONDICION
DE QUE TENGAN DIFERENTE CANTIDAD Y/O TIPO DE PARAMETROS
EL TIPO DE DATO QUE DEVUELVEN NO HACE LA DIFERENCIA **/

#include<iostream>
#include<string>
class Vector{
float x,y;
public:
Vector(float,float); // constructor general
void Imprime(int);
void Imprime(float);
int Imprime();
~Vector(); //Destructor
};

x=a;
y=b;
}

void Vector::Imprime(int b){
}

void Vector::Imprime(float q){
cout<<"x= "<<(x*q)<<endl;
cout<<"y= "<<(y*q)<<endl;
}
int z=10;
int main (){
string Nombre;
cout<<"Proporciona tu nombre: ";
getline(cin,Nombre);
cin.ignore();
cout<<"Tu nombre es "<<Nombre<<endl;
float q=8.0;
int z=1;
Vector A(5,6);
A.Imprime(1);
A.Imprime(q);
cout<<"z= "<<z<<endl;
cout<<"z= "<<::z<<endl;
}
return 0;
}
Vector::~Vector(){
}
/**EJEMPLO 12***/
#include<iostream>
#include<math.h>
class Vector{
private:
float x,y;
public:
Vector(float,float); // CONSTRUCTOR GENERAL
~Vector();
friend class Operaciones;
};
x=a;
y=b;
}
Vector::~Vector(){
cout<<"Vector destruido"<<endl;
}
class Operaciones{
Vector A;
public:
void LeeDatos();
float Magnitud();
Operaciones();
~Operaciones();
};
void Operaciones::LeeDatos(){
cout<<"Da la componente x= ";
cin>>A.x;
cout<<"Da la componente y= ";
cin>>A.y;
}
void Operaciones::ImprimeDatos(){
cout<<"Componete x= "<<A.x<<endl;
cout<<"Componete y= "<<A.y<<endl;
}

float Operaciones::Magnitud(){
return (sqrt(A.x*A.x+A.y*A.y));
}

Operaciones::Operaciones(){
cout<<"Hola soy el constructor de operaciones "<<endl;
}
Operaciones::~Operaciones(){
cout<<"Destructor de operaciones"<<endl;
}
int main(){
Operaciones MiVector;
MiVector.LeeDatos();
MiVector.ImprimeDatos();
cout<<"La magnitud del vector es= "<<MiVector.Magnitud()<<endl;
return 0;
}
/** EJEMPLO 13: UTILIZANDO EL CONCEPTO DE CLASES AMIGAS REALIZAR UN

PROGRAMA ORIENTADO A OBJETOS QUE UTILICE ASIGNACION DINAMICA DE
MEMORIA PARA CREAR N OBJETOS TIPO ALUMNO QUE CONTENGAN NOMBRE Y
CALIFICACION (LA CLASE QUE DA LA AMISTAD ES LA CLASE ALUMNO
LA CUAL CONTIENE DICHOS ATRIBUTOS).LA CLASE QUE RECIBE LA AMISTAD
ES LA QUE USA LA ASIGNACIÓN DINAMICA DE MEMORIA PARA CREAR UN
GRUPO CON N ALUMNOS. ESA CLASE DEBE CONTENER LOS METODOS
NECESARIOS PARA LEER E IMPRIMIR LOS DATOS DE CADA ALUMNO, ASÍ
TAMBIEN DEBE CONTENER LOS METODOS PARA OBTENER EL PROMEDIO DE LAS
CALIFICACIONES, LA CALIFICACION MAYOR, LA CALIFICACION MENOR Y LA
DESVIACION ESTANDAR DE CALIFICACIONES. EN LA FUNCION PRINCIPAL
REALIZAR UN MENÚ REPETITIVO USANDO LAS FUNCIONES DE LA CLASE
QUE RECIBE LA AMISTAD
***/
#include<iostream>
#include<math.h>
#include<fstream>
class Alumno{
float Calificacion;
string Nombre;
public:
Alumno();
~Alumno();
friend class Grupo;
};
Alumno::Alumno(){
Calificacion=0;
Nombre="";
}
Alumno::~Alumno(){
cout<<"Alumno eliminado"<<endl;
}
class Grupo{
Alumno* ap;
int N;
public:
Grupo();
~Grupo();
float Promedio();
float DesviacionEstandar();
void LeerDatos();
void ImprimirDatos();
void MejorCalificacion();
void PeorCalificacion();
void Guardar();
};
Grupo::Grupo(){
cout<<"Cuantos alumnos hay en el grupo= ";
cin>>N;
ap =new Alumno[N];
cout<<"Grupo creado!!"<<endl;
}

Grupo::~Grupo(){
delete []ap;
}
void Grupo::LeerDatos(){
int i;
for(i=0;i<N;i++){
cout<<"Dame el nombre del alumno "<<(i+1)<<" : ";
fflush(stdin);
getline(cin,ap[i].Nombre);
cout<<"Dame la calificacion= ";
cin>>ap[i].Calificacion;
}
}

void Grupo::ImprimirDatos(){
int i;
for(i=0;i<N;i++){
cout<<"Nombre del alumno "<<(i+1)<<" : ";
cout<<ap[i].Nombre<<endl;
cout<<"La Calificacion es= ";
cout<<ap[i].Calificacion<<endl;
}
}
float Grupo::Promedio(){
float Prom=0;
int i;
for(i=0;i<N;i++)
Prom=Prom+ap[i].Calificacion;
Prom=Prom/N;
return Prom;
}
float Grupo::DesviacionEstandar(){
float Desv=0;
for(int i=0;i<N;i++)
Desv= Desv+pow((ap[i].Calificacion-Promedio()),2);
Desv=Desv/(N-1);
Desv=sqrt(Desv);
return Desv;
}
void Grupo::MejorCalificacion(){
float Mejor=ap[0].Calificacion;
if(ap[i].Calificacion>Mejor)
Mejor=ap[i].Calificacion;
cout<<"La mejor calificacion es= "<<Mejor<<endl;
}
void Grupo::PeorCalificacion(){
float Peor=ap[0].Calificacion;
if(ap[i].Calificacion<Peor)
Peor=ap[i].Calificacion;
cout<<"La peor calificacion es= "<<Peor<<endl;
}

void Grupo::Guardar(){
char NombreArchivo[50];
ofstream Archivo;
cout<<"Da el nombre del archivo: ";
fflush(stdin);
cin.getline(NombreArchivo,50);
Archivo.open(NombreArchivo);
for(int i=0;i<N;i++){
Archivo<<ap[i].Nombre<<endl;
Archivo<<ap[i].Calificacion<<endl;
}
Archivo.close();
cout<<"Datos guardados"<<endl;

}
int main(){
Grupo Grupo8;
Grupo8.LeerDatos();
int opcion;
do{
system("cls");
cout<<"Menu de opciones:"<<endl;
cout<<"1.- Imprimir todos los datos"<<endl;
cout<<"2.- Promedio de calificaciones"<<endl;
cout<<"3.- Desviacion estandar de calificaciones"<<endl;
cout<<"4.- Mejor calificacion"<<endl;
cout<<"5.- Peor calificacion"<<endl;
cout<<"6.- Guardar en un archivo datos"<<endl;
cout<<"9.- Salir"<<endl;
cout<<"Que opcion desea= ";
cin>>opcion;
switch(opcion){
case 1:
Grupo8.ImprimirDatos();
break;
case 2:
cout<<"El promedio es= "<<Grupo8.Promedio()<<endl;
break;
case 3:
cout<<"Desviacion estandar= "<<Grupo8.DesviacionEstandar()<<endl;
break;
case 4:
Grupo8.MejorCalificacion();
break;
case 5:
Grupo8.PeorCalificacion();
break;
case 6:
Grupo8.Guardar();
break;
case 9:
cout<<endl<<"ADIOS!!"<<endl;
break;
default:
cout<<"opcion no valida"<<endl;
}
system("pause>null");
}while(opcion!=9);
return 0;
}

/** Ejemplo 14 sobrecarga de operadores. Sobrecargar el operador

de incremento (++) en notacion prefija (++A) para que se aplique
a una matriz de 3 filas, 3 columnas y devuelva la suma de todos
los elementos que contenga la matriz.
La matriz debe ser leida con la sobrecarga del operador de extraccion
de datos >>.
**/
#include <iostream>
class Matriz{
private:
float A[3][3];
public:
Matriz();
~Matriz();
friend istream& operator >> (istream&,Matriz&);
float operator++();
};
Matriz::Matriz(){
int i,j;
for(i=0;i<3;i++)
for(j=0;j<3;j++)
A[i][j]=0;
}
Matriz::~Matriz(){
}
istream& operator>>(istream& entrada,Matriz& M){
int i,j;
for(i=0;i<3;i++){
for(j=0;j<3;j++){
cout<<"Da la fila "<<i<<" columna "<<j<<" =";
entrada>>M.A[i][j];
}
}
return entrada;
}
float Matriz::operator++(){
int i,j;
float Suma=0;
for(i=0;i<3;i++)
for(j=0;j<3;j++)
Suma+=A[i][j]; // esto es lo mismo que Suma=Suma+A[i][j]
return Suma;
}
int main(){
Matriz Mia;
cout<<"Lectura de la matriz"<<endl;
cin>>Mia;
cout<<"La suma de elemento de la matriz es= "<<++Mia<<endl;
return 0;
}

/*** Ejemplo 15: realizar la sobrecarga del operador de negacion
para que aplicado a un numero entero devuelva el factorial de
ese numero ***/
#include<iostream>
class Entero{
int x;
public:
Entero();
friend istream& operator>>(istream&,Entero&);
friend int operator!(Entero&);
~Entero();
};
Entero::Entero(){
x=0;
}
istream& operator>>(istream&Entrada,Entero& F ){
Entrada>>F.x;
return Entrada;
}
Entero::~Entero(){
}
int operator!(Entero& F){
int Factorial=1,i;
for(i=1;i<=F.x;i++)
Factorial*=i;
return Factorial;
}
int main(){
Entero x;
cout<<"Da el numero del que quieres obtener el factorial= ";
cin>>x;
cout<<"El factorial de ese numero es= "<<!x<<endl;
return 0;
}
Matriz Dinamica
#include<iostream>
class Matriz{
float **A;
int Filas,Columnas;
public:
Matriz(); // CONSTRUCTOR VACIO
~Matriz(); // DESTRUCTOR
Matriz(Matriz&); // CONSTRUCTOR COPIA
friend ostream& operator<<(ostream&,const Matriz&);
friend istream& operator>>(istream&,Matriz&);
};
Matriz::Matriz(){
int i,j;
cout<<"Cuantas filas= ";
cin>>Filas;
cout<<"Cuantas Columnas= ";
cin>>Columnas;
A=new float*[Filas];
for(i=0;i<Filas;i++)
A[i]=new float[Columnas];
for(j=0;j<Columnas;j++)
A[i][j]=0;
}
Matriz::Matriz(Matriz&Copia){
int i,j;
Filas=Copia.Filas;
Columnas=Copia.Columnas;
A=new float*[Filas];
A[i]=new float[Columnas];
for(j=0;j<Columnas;j++)
A[i][j]=Copia.A[i][j];
}
Matriz::~Matriz(){
for(int i=0;i<Filas;i++)
delete []A[i];
delete []A;
}
ostream& operator<<(ostream& Salida,const Matriz& Objeto){
int i,j;
for(i=0;i<Objeto.Filas;i++){
for(j=0;j<Objeto.Columnas;j++){
Salida<<Objeto.A[i][j]<<'\t';
}
Salida<<endl;
}
return Salida;
}
istream& operator>>(istream& Entrada,Matriz& Objeto){
int i,j;
for(i=0;i<Objeto.Filas;i++){
for(j=0;j<Objeto.Columnas;j++){
cout<<"Da la fila "<<i<<","<<j<<"= ";
Entrada>>Objeto.A[i][j];
}
}
}

int main(){
Matriz A;
cout<<"Da la matriz A"<<endl;
cin>>A;
Matriz B=A;
cout<<"La matriz B es"<<endl<<B;
return 0;
}
Ejemplo 17
#include <iostream>
//* CLASE BASE (DA LA HERENCIA)
class Persona{
protected:
string Nombre;
int Edad;
public:
Persona(string,int);
~Persona();
friend istream& operator>>(istream&,Persona&);
friend ostream& operator<<(ostream&,Persona&);
};
Persona::Persona(string N="",int E=0){
cout<<"Objeto persona construido"<<endl;
Nombre=N;
Edad=E;
}
Persona::~Persona(){
cout<<"Objeto Persona destruido"<<endl;
}
istream& operator>>(istream&Entrada,Persona&P){
cout<<"Da el nombre: ";
fflush(stdin);
getline(cin,P.Nombre);
Entrada>>P.Edad;
return Entrada;
}
ostream& operator<<(ostream&Salida,Persona&P){
Salida<<"Nombre: "<<P.Nombre<<endl;
Salida<<"Edad= "<<P.Edad<<endl;
return Salida;
}
// CLASE DERIVADA (RECIBE LA HERENCIA)
class Alumno:public Persona {
float Calificacion;
public:
Alumno(float,string,int);
~Alumno();
// LA AMISTAD ES UNA CUALIDAD DE LA P.O.O. QUE NO SE HEREDA
friend istream& operator>>(istream&,Alumno&);
friend ostream& operator<<(ostream&,Alumno&);
};
// EL CONSTRUCTOR DE UNA CLASE DERIVADA DEBE MANDAR LLAMAR AL
// CONSTRUCTOR DE SU CLASE BASE
Alumno::Alumno(float C=0,string Name="",int E=0):Persona(Name,E){
cout<<"Objeto alumno construido"<<endl;
Calificacion=C;
}
Alumno::~Alumno(){
cout<<"Objeto Alumno destruido"<<endl;
}
istream& operator>>(istream&Entrada,Alumno&A ){
fflush(stdin);
getline(cin,A.Nombre);
Entrada>>A.Edad;
cout<<"Da la calificacion= ";
Entrada>>A.Calificacion;
return Entrada;
}
ostream& operator<<(ostream&Salida,Alumno& A ){
Salida<<"Nombre: "<<A.Nombre<<endl;
Salida<<"Edad= "<<A.Edad<<endl;
Salida<<"Calificacion= "<<A.Calificacion<<endl<<endl;
return Salida;
}
int main(){
Alumno Yo;
cin>>Yo;
cout<<"Alumno: "<<endl<<Yo;
Persona Tu;
cin>>Tu;
cout<<"Persona:"<<endl<<Tu;
return 0;
}
/** EJEMPLO 18 HERENCIA: Realizar un P.O.O. que utilice el concepto de

herencia para crear una clase base que contenga un vector de 2 dimensiones
y una clase derivada (que recibe herencia de la clase base) que
contenga un vector de 3 dimensiones. Realice la sobrecarga de los
operadores de insercion y extraccion de datos, asi como la
sobrecarga de los operadores suma y resta para que se puedan aplicar
a cualquier vector ya sea de 2 o 3 dimensiones **/
#include<iostream>
class Vector2D{
protected:
float x,y;
public:
Vector2D(float,float);
~Vector2D();
friend istream& operator>>(istream&,Vector2D&);
friend ostream& operator<<(ostream&,Vector2D&);
Vector2D operator+(Vector2D&);
Vector2D operator-(Vector2D&);
float Suma();
};
float Vector2D::Suma(){
return (x+y);
}

Vector2D::Vector2D(float a=0,float b=0){
x=a;
y=b;
}
Vector2D::~Vector2D(){
}

istream& operator>>(istream& e,Vector2D& V){
cout<<"Da x= ";
e>>V.x;
cout<<"Da y= ";
e>>V.y;
return e;
}
ostream& operator<<(ostream& s,Vector2D& V){
s<<"("<<V.x<<","<<V.y<<")"<<endl;
return s;
}
Vector2D Vector2D:: operator+(Vector2D&B){
Vector2D r;
r.x=x+B.x;
r.y=y+B.y;
return r;
}
Vector2D Vector2D:: operator-(Vector2D&B){
Vector2D r;
r.x=x-B.x;
r.y=y-B.y;
return r;
}

class Vector3D:public Vector2D{
private:
float z;
public:
Vector3D(float,float,float);
~Vector3D();
friend istream& operator>>(istream&,Vector3D&);
friend ostream& operator<<(ostream&,Vector3D&);
Vector3D operator+(Vector3D&);
Vector3D operator-(Vector3D&);
float SUMA();
};

float Vector3D::SUMA(){
return( z+Suma() );
}

Vector3D::Vector3D(float a=0,float b=0,float c=0):Vector2D(a,b){
z=c;
}
}

istream& operator>>(istream& e,Vector3D& V){
cout<<"Da x= ";
e>>V.x;
cout<<"Da y= ";
e>>V.y;
cout<<"Da z= ";
e>>V.z;
return e;
}
ostream& operator<<(ostream& s,Vector3D& V){
s<<"("<<V.x<<","<<V.y<<","<<V.z<<")"<<endl;
return s;
}

Vector3D Vector3D:: operator+(Vector3D&B){
Vector3D r;
r.x=x+B.x;
r.y=y+B.y;
r.z=z+B.z;
return r;
}
Vector3D Vector3D:: operator-(Vector3D&B){
Vector3D r;
r.x=x-B.x;
r.y=y-B.y;
r.z=z-B.z;
return r;
}

int main(){
Vector2D uno,dos,resul;
Vector3D A,B,C;
cin>>uno>>dos;
resul=uno+dos;
cout<<"Suma= "<<resul<<endl;
cin>>A>>B;
C=A-B;
cout<<"Resta= "<<C<<endl;
cout<< C.SUMA()<<endl;
return 0;
}

/** EJEMPLO 19 HERENCIA MULTIPLE INDIRECTA **/
// UNA SUPERCLASE PERSONA LE DA HERENCIA A LA CLASE ALUMNO
// LA CUAL A SU VEZ LE DA HERENCIA A LA CLASE BECADO
// SIENDO ESTA ULTIMA LA QUE RECIBE HERENCIA MULTIPLE INDIRECTA
#include<iostream>
class Persona{
protected:
string Nombre;
public:
Persona(string);
~Persona();
friend ostream& operator<<(ostream&,Persona&);
friend istream& operator>>(istream&,Persona&);
};
Persona::Persona(string N="sin nombre"){
cout<<"Objeto Persona construido"<<endl;
Nombre=N;
}
cout<<"Objeto persona destruido"<<endl;
}
ostream& operator<<(ostream&S,Persona&A){
S<<"Nombre: "<<A.Nombre<<endl;
return S;
}

istream& operator>>(istream&E,Persona&A){
fflush(stdin);
getline(E,A.Nombre);
return E;
}

//CLASE DERIVADA ALUMNO RECIBE HERENCIA DE PERSONA
class Alumno:public Persona{
protected:
float Promedio;
public:
Alumno(string, float);
~Alumno();
};
Alumno::Alumno(string Nom="",float P=0.0):Persona(Nom){
cout<<"objeto Alumno construido"<<endl;
Promedio=P;
}
Alumno::~Alumno(){
cout<<"Objeto Alumno destruido"<<endl;
}
ostream& operator<<(ostream&S,Alumno&A){
S<<"Promedio= "<<A.Promedio<<endl;
return S;
}
istream& operator>>(istream&E,Alumno&A){
fflush(stdin);
E>>A.Promedio;
return E;
}
// CLASE BECADO: RECIBE HERENCIA DIRECTA DE LA CLASE ALUMNO Y HERENCIA
// INDIRECTA DE LA CLASE PERSONA
class Becado:Alumno{
private:
float Monto;
public:
Becado(string,float,float);
~Becado();
friend ostream& operator<<(ostream&,Becado&);
friend istream& operator>>(istream&,Becado&);
};
Becado::Becado(string Name="no tiene",float P=8,float M=0):Alumno
(Name,P){
Monto=M;
cout<<"Objeto tipo Becado construido"<<endl;
}
Becado::~Becado(){
cout<<"Objeto tipo becado destruido"<<endl;
}
ostream& operator<<(ostream&S,Becado&A){
S<<"Promedio= "<<A.Promedio<<endl;
S<<"Monto de la beca= "<<A.Monto<<endl;
return S;
}
istream& operator>>(istream&E,Becado&A){
fflush(stdin);
E>>A.Promedio;
cout<<"Da el monto de la beca= ";
E>>A.Monto;
return E;
}
int main(){
Persona Yo;
Alumno Tu;
Becado El;
cout<<"Da los Datos de persona"<<endl;
cin>>Yo;
cout<<"Da los datos de alumno: "<<endl;
cin>>Tu;
cout<<"Da los datos del alumno becado"<<endl;
cin>>El;
system("cls");
cout<<"Persona"<<endl<<Yo<<endl;
cout<<"Alumno"<<endl<<Tu<<endl;
cout<<"Alumno becado"<<endl<<El<<endl;
return 0;
}

/*** EJEMPLO 20: HERENCIA MULTIPLE DIRECTA
DOS O MAS CLASES BASE LE DAN HERENCIA DE FORMA DIRECTA A UNA O MAS
CLASES DERIVADAS ***/
#include<iostream>
class Papa{
private:
string Nombre;
protected:
string ApellidoP;
string Automovil;
public:
Papa(string,string,string);
~Papa();
friend istream& operator>>(istream&, Papa&);
friend ostream& operator<<(ostream&,Papa&);
};
Papa::Papa(string Ap="",string Au="",string N=""){
ApellidoP=Ap;
Automovil=Au;
Nombre=N;
cout<<"objeto papa construido"<<endl;
}
Papa::~Papa(){
cout<<"objeto papa destruido"<<endl;
}
istream& operator>>(istream& e,Papa& P){
cout<<"Nombre: ";
fflush(stdin);
getline(e,P.Nombre);
cout<<"Apellido: ";
fflush(stdin);
getline(e,P.ApellidoP);
cout<<"Auto: ";
fflush(stdin);
getline(e,P.Automovil);
return e;
}
ostream& operator<<(ostream& s, Papa& P){
s<<"Nombre: "<<P.Nombre<<endl;
s<<"Apellido: "<<P.ApellidoP<<endl;
s<<"Auto: "<<P.Automovil<<endl;
return s;
}
class Mama{
private:
string Nombre;
string Camioneta;
protected:
string ApellidoM;
public:
Mama(string,string,string);
~Mama();
friend istream& operator>>(istream&, Mama&);
friend ostream& operator<<(ostream&,Mama&);
};
Mama::Mama(string Ap="",string Au="",string N=""){
ApellidoM=Ap;
Camioneta=Au;
Nombre=N;
cout<<"objeto mama construido"<<endl;
}
Mama::~Mama(){
cout<<"objeto Mama destruido"<<endl;
}
istream& operator>>(istream& e,Mama& P){
cout<<"Nombre: ";
fflush(stdin);
getline(e,P.Nombre);
cout<<"Apellido: ";
fflush(stdin);
getline(e,P.ApellidoM);
cout<<"Camioneta: ";
fflush(stdin);
getline(e,P.Camioneta);
return e;
}
ostream& operator<<(ostream& s, Mama& P){
s<<"Nombre: "<<P.Nombre<<endl;
s<<"Apellido: "<<P.ApellidoM<<endl;
s<<"Auto: "<<P.Camioneta<<endl;
return s;
}
class Hijo:public Papa,public Mama{
private:
string Nombre;
int Edad;
public:
Hijo(string,string,string,string,int);
~Hijo();
friend istream& operator>>(istream&,Hijo&);
friend ostream& operator<<(ostream&,Hijo&);
};
Hijo::Hijo(string N="",string Ap="",string Am="",string Au="",
int E=0):Papa(Ap,Au),Mama(Am){
Nombre=N;
Edad=E;
cout<<"objeto hijo construido"<<endl;
}
Hijo::~Hijo(){
cout<<"objeto hijo destruido"<<endl;
}

istream& operator>>(istream& e,Hijo& H){
cout<<"Nombre: ";
fflush(stdin);
getline(e,H.Nombre);
cout<<"Apellido Paterno: ";
fflush(stdin);
getline(e,H.ApellidoP);
cout<<"Apellido Materno: ";
fflush(stdin);
getline(e,H.ApellidoM);
cout<<"Auto: ";
getline(e,H.Automovil);

cout<<"Edad= ";
e>>H.Edad;
return e;
}
ostream& operator<<(ostream& s,Hijo& H){
s<<"Nombre: "<<H.Nombre<<endl;
s<<"Apellido Paterno: "<<H.ApellidoP<<endl;
s<<"Apellido Materno: "<<H.ApellidoM<<endl;
cout<<"Auto: "<<H.Automovil<<endl;
cout<<"Edad= "<<H.Edad<<endl;
return s;
}
int main(){
cout<<"Construyendo un hijo"<<endl;
Hijo Tu;
cin>>Tu;
cout<<"construyendo un papa"<<endl;
Papa Yo;
cin>>Yo;
cout<<"Construyendo una mama"<<endl;
Mama Ella;
cin>>Ella;
system("cls");
cout<<Ella<<Yo;
cout<<Tu;
return 0;
}
// EJEMPLO 21: HERENCIA MULTIPLE DIRECTA E INDIRECTA

#include<iostream>
class Persona{
protected:
string Nombre;
int Edad;
public:
Persona(string,int);
~Persona();
};
Persona::Persona(string N="",int E=0){
cout<<"Objeto persona construido"<<endl;
Nombre=N;
Edad=E;
}
cout<<"objeto persona destruido"<<endl;
}
class Mascota{
protected:
string Raza;
string Color;
public:
Mascota(string,string);
~Mascota();
};
Mascota::Mascota(string R="",string C=""){
cout<<"objeto mascota construido"<<endl;
Raza=R;
Color=C;
}
Mascota::~Mascota(){
cout<<"objeto mascota destruido"<<endl;
}

class Alumno:public Persona{
protected:
long NBoleta;
public:
Alumno(string,int,long);
~Alumno();
};
Alumno::Alumno(string N="", int E=0,long B=0):Persona(N,E){
cout<<"objeto alumno construido"<<endl;
NBoleta=B;
}
Alumno::~Alumno(){
cout<<"objeto alumno destruido"<<endl;
}

class AlumnoConMascota:public Alumno, public Mascota{
private:
float Comida;
public:
AlumnoConMascota(string,int,long,string, string,float);
~AlumnoConMascota();
friend ostream& operator<<(ostream&,AlumnoConMascota&);
};
ostream& operator<<(ostream& S,AlumnoConMascota&A){
S<<"Edad= "<<A.Edad<<endl;
S<<"Numero de boleta= "<<A.NBoleta<<endl;
S<<"Raza de la mascota: "<<A.Raza<<endl;
S<<"Color de la mascota: "<<A.Color<<endl;
S<<"Gasto de comida= $"<<A.Comida<<endl;
return S;
}

AlumnoConMascota::AlumnoConMascota(string N="",int E=0, long NB=0,
string R="",string C="",float Com=0):Alumno(N,E,NB),Mascota(R,C){
Comida=Com;
cout<<"objeto alumno con mascota construido"<<endl;
}
AlumnoConMascota::~AlumnoConMascota(){
cout<<"objeto alumno con mascota destruido"<<endl;
}
int main(){
AlumnoConMascota Fulano("Luis Perez",18,2021305684,"Guau","Negro",100);
cout<<Fulano;
return 0;
}
Ejemplo 22
#include<iostream>
#include<time.h>
#include<ctype.h>
#include<conio.h>
#include<windows.h>
class Aleatorio{
int Numero;
public:
Aleatorio();
~Aleatorio();
int GeneraUnNumeroAleatorio();
};
Aleatorio::Aleatorio(){
Numero=0;
srand(time(NULL));
}
Aleatorio::~Aleatorio(){
}
int Aleatorio::GeneraUnNumeroAleatorio(){
return(rand());
}
int main(){
Aleatorio Generador;
int x;
char respuesta;
cout<<"BIENVENIDO A MI JUEGO DE VOLADOS"<<endl;
system("cls");
cout<<"Que pides? "<<endl;
do{
cout<<endl;
cout<<"a)guila"<<endl;
cout<<"s)ol"<<endl;
respuesta=getche();
respuesta=tolower(respuesta);
}while(respuesta!='a'&&respuesta!='s');
x=Generador.GeneraUnNumeroAleatorio()%2;
if(x==0)
cout<<endl<<"Cayo aguila"<<endl;
if(x==1)
cout<<endl<<"cayo sol"<<endl;
if( (respuesta=='a'&&x==0)||(respuesta=='s'&&x==1) )
cout<<endl<<"Ganaste!!!"<<endl;
else
cout<<endl<<"Perdiste :-( "<<endl;
cout<<x<<endl;
}
return 0;
}
Ejemplo 23
#include<iostream>
#include<time.h>
#include<ctype.h>
#include<conio.h>
#include<windows.h>
class Aleatorio{
int Numero;
public:
Aleatorio();
~Aleatorio();
};
Numero=0;
srand(time(NULL));
}
}
return(rand());
}
int main(){
Sleep(1000);
Aleatorio Generador2;
int x,y;
char respuesta;
cout<<"BIENVENIDO A MI JUEGO DE DADOS"<<endl;
x=Generador.GeneraUnNumeroAleatorio()%6+1;
y=Generador2.GeneraUnNumeroAleatorio()%6+1;
cout<<"dados= "<<x<<","<<y<<endl;
}
return 0;
}
Ejemplo 24
#include<iostream>
#include<time.h>
#include<ctype.h>
#include<conio.h>
#include<windows.h>
class Aleatorio{
int Numero;
public:
Aleatorio();
~Aleatorio();
};
Numero=0;
srand(time(NULL));
}
}
return(rand());
}
int main(){
int x;
char c;
cout<<"BIENVENIDO A MI PALABRA"<<endl;
x=Generador.GeneraUnNumeroAleatorio()%26+65;
c=x;
cout<<c;
}
cout<<endl;
return 0;
}
Ejemplo 25
// FUNCIONES VIRTUALES
/* PUEDEN EXISTIR FUNCIONES CON EL MISMO NOMBRE EN DOS CLASES DIFERENTE
DE TAL MANERA QUE UNA LE DA HERENCIA A LA OTRA, PUDIENDOSE ACCESAR
A CADA UNA DE ESTAS FUNCIONES POR MEDIO DE UN APUNTADOR Y ESTE
APUNTADOR DEBE DEL TIPO DE LA CLASE BASE**/

#include <iostream>
#include<math.h>
class Vector2D{
protected:
float x,y;
public:
Vector2D(float,float);
~Vector2D();
virtual void LeeDatos();
virtual float Magnitud();
};
Vector2D::Vector2D(float a=0,float b=0){
x=a;
y=b;
}
}
void Vector2D::LeeDatos(){
cin>>x;
cin>>y;
}
float Vector2D::Magnitud(){
return(sqrt(pow(x,2)+pow(y,2)));
}

class Vector3D:public Vector2D{
protected:
float z;
public:
Vector3D(float,float,float);
~Vector3D();
virtual void LeeDatos();
virtual float Magnitud();
};
Vector3D::Vector3D(float a=0,float b=0, float c=0):Vector2D(a,b){
z=c;
}
}
void Vector3D::LeeDatos(){
cin>>x;
cin>>y;
cout<<"Da la coordenada z= ";
cin>>z;
}
float Vector3D::Magnitud(){
return(sqrt(x*x+y*y+z*z));
}

int main(){
Vector2D A;
Vector3D B;
Vector2D* ap;
ap=&A;
cout<<"Lectura de datos del vector 2D"<<endl;
ap->LeeDatos();
cout<<"Su magnitud es= "<<ap->Magnitud()<<endl;
cout<<"Lectura de datos del vector 3D"<<endl;
ap=&B;
ap->LeeDatos();
cout<<"Su magnitud es= "<<ap->Magnitud()<<endl;
return 0;
}
Ejemplo 26
#include<iostream>
class Animales{
protected:
string Especie;
public:
Animales();
~Animales();
virtual void Lee();
virtual void Imprime();
};
Animales::Animales(){
Especie="Sin especie";
}
Animales::~Animales(){
cout<<"Animal destruido"<<endl;
}
void Animales::Lee(){
cout<<"Da la especie= ";
fflush(stdin);
getline(cin,Especie);
}
void Animales::Imprime(){
cout<<"Especie: "<<Especie<<endl;
}
class Vertebrados:public Animales{
protected:
int Huesos;
public:
Vertebrados();
~Vertebrados();
virtual void Lee();
};
Vertebrados::Vertebrados():Animales(){
Huesos=0;
}
Vertebrados::~Vertebrados(){
cout<<"Animal vertebrado destruido"<<endl;
}
void Vertebrados::Lee(){
fflush(stdin);
cout<<"Numero de huesos= ";
cin>>Huesos;
}
void Vertebrados::Imprime(){
cout<<"Especie= "<<Especie<<endl;
cout<<"Numero de huesos= "<<Huesos<<endl;
}

class Terrestres:public Vertebrados{
protected:
int Patas;
public:
Terrestres();
~Terrestres();
virtual void Lee();
};
Terrestres::Terrestres():Vertebrados(){
Patas=0;
}
Terrestres::~Terrestres(){
cout<<"Animal vertebrado terrestre destruido"<<endl;
}
void Terrestres::Lee(){
fflush(stdin);
cout<<"Da numero de huesos= ";
cin>>Huesos;
cout<<"Da el numero de patas= ";
cin>>Patas;
}
void Terrestres::Imprime(){
cout<<"Especie= "<<Especie<<endl;
cout<<"Numero de huesos= "<<Huesos<<endl;
cout<<"Numero de patas= "<<Patas<<endl;
}

int main(){
Animales MiAnimal;
Vertebrados MiVertebrado;
Terrestres MiAnimalTerrestre;
Animales *ap;
ap=&MiAnimal;
cout<<"*****ANIMAL*****"<<endl;
ap->Lee();
ap->Imprime();
ap=&MiVertebrado;
cout<<"****ANIMAL VERTEBRADO****"<<endl;
ap->Lee();
ap->Imprime();
cout<<"***ANIMAL VERTEBRADO TERRESTRE****"<<endl;
ap=&MiAnimalTerrestre;
ap->Lee();
ap->Imprime();
return 0;
}
Ejemplo 27
#include<iostream>
/** EJEMPLO 27: HERENCIA VIRTUAL **/
class Base{
protected:
float x;
public:
Base();
~Base(){ }
};
Base::Base():x(20){
}
void Base::Imprime(){
}
class Derivada1:virtual public Base{
protected:
float y;
public:
Derivada1();
~Derivada1(){ }
};
Derivada1::Derivada1():Base(){
y=10;
}
void Derivada1::Imprime(){
}
class Derivada2:virtual public Base{
protected:
float z;
public:
Derivada2();
~Derivada2(){ }
};
Derivada2::Derivada2():Base(){
z=5;
}
}

class Derivada3:public Derivada1,public Derivada2{
private:
float w;
public:
Derivada3();
~Derivada3(){ }
};
Derivada3::Derivada3():Derivada1(),Derivada2(){
w=1;
}
cout<<"w= "<<w<<endl;
}

int main(){
Base A;
Derivada1 B;
Derivada2 C;
Derivada3 D;
Base* ap;
ap=&A;
cout<<"Objeto base "<<endl;
ap->Imprime();
ap=&B;
cout<<"objeto derivada 1"<<endl;
ap->Imprime();
ap=&C;
ap->Imprime();
ap=&D;
ap->Imprime();
return 0;
}
Ejemplo 28
/* EJEMPLO 28: POLIMORFISMO EN TIEMPO DE EJECUCION **/

// EN ESTE EJEMPLO NO HAGO OBJETOS DE LA CLASE BASE, PERO
// SI SE CREAN LAS FUNCIONES VIRTUALES DE ESA CLASE BASE
// AUNQUE ESTEN VACIAS
#include<iostream>
#include<math.h>
#include<conio.h>
#include<ctype.h>
class Base{ // CLASE ABSTRACTA: NO HAGO OBJETOS DE LA CLASE BASE
protected:
float a,b,c;
public:
Base();
~Base();
virtual void Lee(){
}
virtual void Calcular(){
}
};
Base::Base(){
a=b=c=0;
}
Base::~Base(){
}
class Vector:public Base{
private:
float r;
public:
Vector();
~Vector();
virtual void Lee();
virtual void Calcular();
};
Vector::Vector():Base(){
r=0;
}
Vector::~Vector(){
}
void Vector::Lee(){
cout<<"Da la primer coordenada x= ";
cin>>a;
cout<<"Da la segunda coordenada y= ";
cin>>b;
cout<<"Da la tercer coordenada z= ";
cin>>c;
}
void Vector::Calcular(){
r=sqrt(pow(a,2)+pow(b,2)+pow(c,2));
cout<<"La magnitud del vector= "<<r<<endl;
}
class Ecuacion:public Base {
private:
float r1,r2;
public:
Ecuacion();
~Ecuacion();
virtual void Lee();
virtual void Calcular();
};
Ecuacion::Ecuacion():Base(){
r1=r2=0;
}
Ecuacion::~Ecuacion(){
}
void Ecuacion::Lee(){
cout<<"Ecuacion de segundo grado ax^2+bx+c"<<endl;
cout<<"Da el coeficiente a= ";
cin>>a;
cout<<"Da el coeficiente b= ";
cin>>b;
cout<<"Da el coeficiente c= ";
cin>>c;
}
void Ecuacion::Calcular(){
float Discriminante;
Discriminante=pow(b,2)-4*a*c;
if(Discriminante==0){
r1=r2=-b/(2*a);
cout<<"Raiz doble"<<endl;
}
if(Discriminante>0){
r1=(-b+sqrt(Discriminante))/(2*a);
r2=(-b-sqrt(Discriminante))/(2*a);
}
if(Discriminante<0){
cout<<"Raices complejas"<<endl;
Discriminante*=-1;
r1=-b/(2*a);
r2=sqrt(Discriminante)/(2*a);
cout<<"r1= "<<r1;
if(r2>=0)
cout<<"+";
cout<<r2<<"i"<<endl;
cout<<"r2= "<<r1;
r2=r2*-1;
if(r2>=0)
cout<<"+";
cout<<r2<<"i"<<endl;
return;
}
cout<<"r1= "<<r1<<endl;
cout<<"r2= "<<r2<<endl;
}
int main(){
Vector V;
Ecuacion E;
Base *ap;
char opcion;
do{
system("cls");
cout<<"Que desea realizar: "<<endl;
cout<<"a)Calculo de un vector"<<endl;
cout<<"b)Calculo de una ecuacion"<<endl;
cout<<"c)Salir"<<endl;
opcion=getche();
opcion=tolower(opcion);
if(opcion=='a'){
ap=&V;
ap->Lee();
ap->Calcular();
}
if(opcion=='b'){
ap=&E;
ap->Lee();
ap->Calcular();
}
if(opcion=='c')
cout<<endl<<"Adios"<<endl;
}while(!(opcion=='c'));
return 0;
}
Ejemplo 29
/** EJEMPLO 29 PLANTILLA **/
// PLANTILLA DE LA FUNCION DEL METODO DE LA BURBUJA
#include<iostream>
#include<string.h>
class Alumno{
private:
string Nombre;
char Grupo[20];
int Edad;
float Promedio;
public:
Alumno();
~Alumno();
friend bool operator>(Alumno&,Alumno&);
Alumno& operator=(Alumno&);
};
Alumno& Alumno::operator=(Alumno&Dos){
Nombre=Dos.Nombre;
Edad=Dos.Edad;
Promedio=Dos.Promedio;
strcpy(Grupo,Dos.Grupo);
return *this;
}

ostream& operator<<(ostream& Salida,Alumno &A){
Salida<<"Nombre: "<<A.Nombre<<endl;
Salida<<"Edad= "<<A.Edad<<endl;
Salida<<"Promedio= "<<A.Promedio<<endl;
Salida<<"Grupo= "<<A.Grupo<<endl;
return Salida;
}
bool operator>(Alumno&Uno,Alumno&Dos){
if(Uno.Nombre>Dos.Nombre) return true;
else
return false;
}
istream& operator>>(istream& Entrada, Alumno& A){
fflush(stdin);
getline(Entrada,A.Nombre);
Entrada>>A.Edad;
Entrada>>A.Promedio;
fflush(stdin);
cout<<"Da el grupo: ";
Entrada.getline(A.Grupo,20);
return Entrada;
}
Alumno::Alumno(){
Nombre="";
Edad=0;
Promedio=0.0;
Grupo[0]='\0';
}
Alumno::~Alumno(){
}
template <class Tipo>
void Burbuja( Tipo * Arreglo){
int N,i,j;
Tipo Temporal;
cout<<"Cuantos datos quieres ordenar= ";
cin>>N;
Arreglo=new Tipo[N];
for(i=0;i<N;i++){
cout<<"Proporciona el dato "<<(i+1)<<" : "<<endl;
cin>>Arreglo[i];
}
for(j=1;j<=N;j++)
for(i=0;i<(N-1);i++){
if(Arreglo[i]>Arreglo[i+1]){
Temporal=Arreglo[i+1];
Arreglo[i+1]=Arreglo[i];
Arreglo[i]=Temporal;
}
}
cout<<"Los elementos del arreglo ordenados"<<endl;
for(j=0;j<N;j++)
cout<<Arreglo[j]<<'\t';
cout<<endl;
}
int main(){
int *A1;
float *A2;
char *A3;
string *A4;
Alumno *A5;
int x;
cout<<"Que tipo de dato quieres ordenar:"<<endl;
cout<<"1.- Enteros"<<endl;
cout<<"2.- Numeros con punto flotante"<<endl;
cout<<"3.- Caracteres"<<endl;
cout<<"4.- Cadenas"<<endl;
cout<<"5.- Alumnos"<<endl;
cout<<"Que opcion deseas= ";
cin>>x;
switch(x){
case 1:
Burbuja(A1);
break;
case 2:
Burbuja(A2);
break;
case 3:
Burbuja(A3);
break;
case 4:
Burbuja(A4);
break;
case 5:
Burbuja(A5);
break;
}
return 0;
}
/* EJEMPLO 30: CLASE PLANTILLA **/

#include<iostream>
#include<iomanip>
class Arreglo{
private:
Tipo *MiArreglo;
int N;
public:
Arreglo();
~Arreglo();
void Lee();
void Imprime();
};
Arreglo<Tipo>::Arreglo(){
N=0;
MiArreglo=NULL;
}
Arreglo<Tipo>::~Arreglo(){
delete [] MiArreglo;
}
void Arreglo<Tipo>::Lee(){
cout<<"Cuantos datos tiene el arreglo= ";
cin>>N;
MiArreglo=new Tipo[N];
for(int i=0;i<N;i++){
cout<<"Da el dato "<<(i+1)<<" = ";
cin>>MiArreglo[i];
}
}
void Arreglo<Tipo>::Imprime(){
cout<<setw(10)<<setprecision(4)<<MiArreglo[i];
cout<<endl;
}
int main(){
Arreglo<int> A1;
Arreglo<float> A2;
Arreglo<string> A3;
cout<<"Arreglo de enteros: "<<endl;
A1.Lee();
A1.Imprime();
cout<<"Arreglo de numeros reales: "<<endl;
A2.Lee();
A2.Imprime();
cout<<"Arreglo de cadenas: "<<endl;
A3.Lee();
A3.Imprime();
return 0;
}
/* Ejemplo 31: funcion plantilla con dos tipos de datos genericos*/
#include<iostream>
template<class Tipo1,class Tipo2>
void Funcion(Tipo1 x, Tipo2 y){
cout<<"El dato enviado para x= "<<x<<endl;
cout<<"El dato enviado para y= "<<y<<endl;
}
int main(){
int a;
string b;
cout<<"Proporciona un entero= ";
cin>>a;
cout<<"Proporciona un nombre: ";
fflush(stdin);
getline(cin,b);
Funcion(a,b);
return 0;
}
/*Ejemplo 32: Clase plantilla con dos tipos de datos genericos*/

#include<iostream>
template <class Tipo1, class Tipo2>
class Ejemplo32{
private:
Tipo1 x;
Tipo2 y;
public:
Ejemplo32();
~Ejemplo32();
void LeeDatos();
};
Ejemplo32<Tipo1,Tipo2>::Ejemplo32(){
}
Ejemplo32<Tipo1,Tipo2>::~Ejemplo32(){
}
void Ejemplo32<Tipo1,Tipo2>::LeeDatos(){
fflush(stdin);
cout<<"Da el dato 1= ";
cin>>x;
fflush(stdin);
cout<<"Da el dato 2= ";
cin>>y;
}
template<class Tipo1, class Tipo2>
void Ejemplo32<Tipo1,Tipo2>::ImprimeDatos(){
cout<<"El dato x= "<<x<<endl;
cout<<"El dato y= "<<y<<endl;
}
int main(){
Ejemplo32<int,float>Objeto1;
Objeto1.LeeDatos();
cout<<"Los datos son: "<<endl;
Objeto1.ImprimeDatos();
Ejemplo32<string,int>Objeto2;
Objeto2.LeeDatos();
cout<<"Los datos son: "<<endl;
Objeto2.ImprimeDatos();
return 0;
}

Ejemplos de Programacion para Extra

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Ejemplos de Programacion para Extra

Cargado por

Copyright:

Formatos disponibles

Ejemplo 0

/* USO DEL OPERADOR PUNTO . Y DEL OPERADOR FLECHA ->

/* uso del operador de indireccion */

/* USO DE UN ARREGLO DE ESTRUCTURAS */

/ USO DE ASIGNACION DINAMICA DE MEMORIA CON ESTRUCTURAS /

/ USO DE ASIGNACION DINAMICA DE MEMORIA CON ESTRUCTURAS /

/ EJEMPLO 8: CONSTRUCTOR /

//*** EJEMPLO 9: CONSTRUCTORES (CONTINUACION)

// EJEMPLO 10: REALIZAR UN PROGRAMA ORIENTADO A OBJETOS QUE

/ EJEMPLO 11: SOBRECARGA DE FUNCIONES /

/** EJEMPLO 13: UTILIZANDO EL CONCEPTO DE CLASES AMIGAS REALIZAR UN

/** Ejemplo 14 sobrecarga de operadores. Sobrecargar el operador

/** EJEMPLO 18 HERENCIA: Realizar un P.O.O. que utilice el concepto de

// EJEMPLO 21: HERENCIA MULTIPLE DIRECTA E INDIRECTA

/* EJEMPLO 28: POLIMORFISMO EN TIEMPO DE EJECUCION **/

/* EJEMPLO 30: CLASE PLANTILLA **/

/Ejemplo 32: Clase plantilla con dos tipos de datos genericos/

También podría gustarte