Banco de Preguntas

BANCO DE PREGUNTAS 1
1 Utilizando funciones amigas y clases amigas cree un programa que me permita crear una clase aviones, con sus
atributos número de pasajeros, color, placa, destino. Y 4 métodos. La clase aviones tendrá como amiga a una
función main. Se requiere que desde la función main se utilicen los atributos y métodos de la clase.
#include<iostream>
#include<stdlib.h>
#include<cstdlib>
using namespace std;
class aviones //nombre de la clase
{
//atributos
private: // declaramos las variable
int numeropasajeros;
char color[15];
char placa[15];
char destino[15] ;
////////////////////////////////////////////////////////////////////
friend void main(); // aqui declaramos al void como amiga de la clase
/////////////////////////////////////////////////////////////////////
//metodos
public:
void encender ()
{
cout<<"EL AVION SE ENCENDIO..... "<<endl;
}
public :
void despegar()
{
cout<<"EL AVION ESTA DESPEGANDO..... "<<endl;
}
public :
void aterrizar()
{
cout<<"EL AVION ESTA ATERRIZANDO ..... "<<endl;
}
public :
void agradecimiento()
{
cout<<"GRACIAS POR VIAJAR EN TAME ..... "<<endl;
}
};
void main()
{
aviones tame;
cout<<"DATOS DEL AVION TAME :"<<endl;

cout<<"INGRESE EL NUMERO DE PASAJEROS:";
cin>>tame.numeropasajeros;cout<<endl;
cout<<"INGRESE EL COLOR : ";cin>>tame.color;cout<<endl;
cout<<"INGRESE LA PLACA : ";cin>>tame.placa;cout<<endl;
cout<<"INGRESE EL DESTINO : ";cin>>tame.destino;cout<<endl;
system("cls");
cout<<"DATOS DEL AVION TAME SON :"<<endl;
cout<<"NUMERO DE PASAJEROS: "<<tame.numeropasajeros;cout<<endl;
cout<<"COLOR : "<<tame.color;cout<<endl;
cout<<"PLACA : "<<tame.placa;cout<<endl;
cout<<"DESTINO : "<<tame.destino;cout<<endl;
tame.encender();//llamamos al metodo encender
tame.despegar();//llamamos al metodo despegar
tame.aterrizar();//llamamos al metodo aterrizar
tame.agradecimiento();// llamamos al metodo agradecimiento
system("pause");
}
2 Utilizando FUNCIONES MIEMBRO DE UNA CLASE COMO AMIGA desarrolle un programa que me permita crear
una clase persona con sus atributos nombre y edad, con una función miembro que permita imprimir los atributos
de la clase,
#include<iostream>
#include<stdlib.h>
#include<cstdlib>
//FUNCIONES MIEMBRO DE UNA CLASE COMO AMIGA
class persona
{
private:
char nombre[30];
int edad;
public:
void imprime() const;
friend void main();// aqui declaramos al void como amiga

};
void persona::imprime() const
{
cout<<"nombre :";cout<<nombre;
cout<<endl;
cout<<"edad :";cout<<edad;
cout<<endl;
}
void main()
{
Persona uno, dos;
cout<<"Ingrese el nombre de la persona uno: ";cin>>uno.nombre;
cout<<"Ingrese la edad de la persona uno: ";cin>>uno.edad;
cout<<"Ingrese el nombre de la persona dos: ";cin>>dos.nombre;
cout<<"Ingrese la edad de la persona dos: ";cin>>dos.edad;
uno.imprime();
dos.imprime();
system("pause");
}
3 Utilizando Arreglos de objetos estáticos desarrolle un programa que me permita obtener las calificaciones de 2
estudiantes, creando una clase estudiante, con 3 atributos.
#include <iostream>
#include <stdlib.h>
class estudiante
{
public:
float calificacionlenguaje, calificacioncomputacion, promedio;
void obtenercalificacion();
float mostrarpromedio();
};
void estudiante::obtenercalificacion()
{
cout<<"la calificacion de lenguaje es : ";
cin>> calificacionlenguaje;
cout<<"la calificacion de computacion es : ";
cin>>calificacioncomputacion;
};
float estudiante::mostrarpromedio()
{
return (calificacionlenguaje+calificacioncomputacion)/2;
};
void main ()
{
estudiante arreglo[2];
for (int x=0; x<2;x++)

{
cout <<"Informacion del Estudiante : "<<x+1<<endl;
arreglo[x].obtenercalificacion();
}
for (int x=0; x<2;x++)
{
cout<<"el promedio es : "<<arreglo[x].mostrarpromedio()<<endl;
}
system("pause");
4 elabore un programa que me permita obtener las calificaciones de x estudiantes usando arreglos de objetos
dinámicos, creando una clase estudiantes con 2 calificaciones como atributos más el promedio, además crear 2
funciones miembro una que me permita ingresar las calificaciones la segunda que permita mostrar los datos
ingresados.
#include <iostream>
#include <stdlib.h>
//Programa que me permita obtener las calificaciones de x estudiantes usando arreglos de objetos dinámicos
class estudiante
{
public:
float calificacionlenguaje, calificacioncomputacion, promedio;
void obtenercalificacion();
float mostrarpromedio();
};
void estudiante::obtenercalificacion()
{
cin>> calificacionlenguaje;
cin>>calificacioncomputacion;
};
float estudiante::mostrarpromedio()
{
return (calificacionlenguaje+calificacioncomputacion)/2;
};
void main ()
{
estudiante *arreglo;
int tamaño;
cout<<"Ingrese la cantidad de estudiantes a ingresar : ";
cin>>tamaño;
arreglo = new estudiante [tamaño];
for (int x=0; x<tamaño;x++)
{
arreglo[x].obtenercalificacion();
}
{
cout<<"el promedio es : "<<arreglo[x].mostrarpromedio()<<endl;
}
delete []arreglo;
system("pause");
}
5 Utilizando constructores y lista de parámetros en herencia simple desarrolle un programa que permita con una
clase mamífero y una clase hombre, la clase mamífero heredara a la clase hombre edad y peso y se podrá modificar
por medio de sus modificadores.
#include <iostream>
//clase base
class mamifero
{
private:
int edad;
int peso;
public:
//constructor
mamifero(int _edad=0, int _peso=0)
{
edad =_edad; peso=_peso;
}
//metodos consultores
int consultaredad() const
{
cout<<"la esdad es : "<<endl;
return edad;
}
int consultarpeso() const
{
return peso;
}
//modificacores
void modificaredad(int _edad)
{
edad=_edad;
}
void modificarpeso(int _peso)
{
peso=_peso;
}
};
class hombre: public mamifero
{
public:
void hablar()
{
cout<<"Hablando...";
};
void main()
{
hombre juan;
juan.modificaredad(26);
cout<<juan.consultaredad()<<endl;
juan.hablar();
cout<<endl;
system("pause");
}
6 Utilizando HERENCIA MULTIPLE elabore un programa que permita crear una clase bebe, un clase niño, y una
clase adulto, la clase adulto heredara funciones de las clases bebe a niño.
#include<iostream>
#include<stdlib.h>
#include<string>
class bebe
{
public:
void llora()
{
cout <<"esta llorando"<<endl;
}
};
class niño
{
public:
void corre()
{
cout <<"esta corriendo"<<endl;
}
};
class hombre : public bebe ,public niño
{
public:
void camina()
{
cout <<"esta corriendo.."<<endl;
}
};
void main ()
{
hombre carlos;
cout<<"carlos esta: "<<endl;
carlos.llora();
carlos.corre();
carlos.camina();
system("pause");
}
7 Utilizando Constructores y lista de parámetros en herencia múltiple desarrolle un programa que permita crear
una clase mamífero, una clase tigre y una clase hombre, la clase mamífero heredara a la clase hombre edad y peso y
la podrá modificar por medio de sus métodos, y la clase león hereda a la clase hombre una función que muestra un
mensaje "está corriendo"
#include <iostream>
//clase base
class mamifero
{
private:
int edad;
int peso;
public:
//constructor
{
}
{
cout<<"la edad es : "<<endl;
return edad;
}
{
cout<<"el peso es : "<<endl;
return peso;
}
//modificacores
{
edad=_edad;
}
{
peso=_peso;
}
};
class tigre
{
public:
void correr()
{
cout<<"corriendo..."<<endl;
};
class hombre: public mamifero, public tigre
{
public:
void hablar()
{
cout<<"Hablando..."<<endl;
};
void main()
{
hombre juan;
juan.modificarpeso(150);
cout<<juan.consultarpeso()<<endl;
juan.hablar();
juan.correr();
cout<<endl;
system("pause");
}
8 Utilizando Clases anidadas elabore un programa que me permita crear 1 clase vehículos que a su vez contenga 2
clases dentro llamadas Toyota y Chevrolet las cuales me van a dar el precio de cada marca de vehículo luego hacer
el llamado de dichas clases en el main.
#include <iostream>
#include<stdlib.h>
class vehiculos
{
public:class toyota
{
public:
void preciotoyota()
{
cout<<"El precio del toyota es: $18000"<<endl;
}
};
public:class chevrole
{
public:
void preciochevrole()
{
cout<<"el precio del chevrole es de 15000"<<endl;
}
};
};
void main()
{
vehiculos::toyota precio;
vehiculos::chevrole precio2;
precio.preciotoyota();
precio2.preciochevrole();
system("pause");
}
9 Utilizando Entrada y salida por archivos elabore un programa que permita introducir el nombre de 3
estudiantes y almacenarlos en un archivo de texto.
#include <iostream>
#include <conio.h>
FILE *doc;
void main()
{
//nombre puntero =abierto(nombrearchivo.extencion,comando a realizar en este caso a+ es para leer y
añadir)
doc= fopen("docgeneradoc++.doc","a+");
cout<<"ponga el nombre de los alumnos: ";
char alumnos[20];
for(int x=0;x<3;++x)
{
cout<<"nombre del alumno "<<x+1<<endl;
cin>>alumnos;
//comando para guardar al documento(nombrearchivo, "tipodato salto linea", nombre de la
variable)
fprintf(doc,"%s \n",alumnos);
}
//comando para cerrar la conexion del archivo
fclose(doc);
system("pause");
10 Utilizando Apertura de archivos, elabore un programa que permita extraer los datos de un archivo .txt
almacenado
#include<fstream>
#include<iostream>
#include <string>
void main()
{
ifstream archivo;
string lectura_archivo;
archivo.open("docgeneradoc++.txt");
if(archivo.fail())
{
cout<<"el archivo no se abrio"<<endl;
}
while(getline(archivo,lectura_archivo))
{
cout<<lectura_archivo<<endl;
}
archivo.close();
system("pause");
}
11 Utilizando Funciones Para Manipulación De Archivos elabore un Programa que me permita crear 2 funciones la
primera para crear e insertar datos, y la segunda que me permita mostrar los datos ingresados, ambas funciones
que sean llamadas desde la función main por medio de un menú.
#include <stdio.h>
#include<string.h>
#include<iostream>
void ingresardatos();
void consultardatos();
FILE *punteroarchivo;
char opcion[1], nombrearchivo[30],datos_a_ingresar[50];
int tamanio_de_datos;
void main()
{
do
{
fflush(stdin);
cout<<"1. abrir archivos e insertar datos "<<endl;
cout<<"2. mostrar datos ingresados "<<endl;
cout<<"3. salir "<<endl;
cout<<"elije la opcion que desees realizar : ";
opcion[0] = getchar();
fflush(stdin);
cout<<endl;
switch(opcion[0])
{
case '1':
{
ingresardatos();
}
break;
case '2':
{
consultardatos();
}
break;
case '3':
{
cout<<" GRACIAS POS USAR ESTE SISTEMA";
}
break;
}
}while (opcion!="3");
}
void ingresardatos()
{
fflush(stdin);
cout<<"ingrese el nombre del archivo : ";
gets(nombrearchivo);
fflush(stdin);
cout<<endl;
strcat(nombrearchivo,".txt");
punteroarchivo=fopen(nombrearchivo,"a+");
if(punteroarchivo==NULL)
{
puts("archivo no exciste");
}
cout<<"ingrese datos al archivo: ";
gets(datos_a_ingresar);
fflush(stdin);
//funcion para saber el tamaño de los datos que se va a ingresar
tamanio_de_datos = sizeof(datos_a_ingresar);
//funcion para grabar los datos en el archivo
fwrite(&datos_a_ingresar, sizeof(tamanio_de_datos), 1 ,punteroarchivo);
fclose(punteroarchivo);
};
void consultardatos()
{
fflush(stdin);
gets(nombrearchivo);
fflush(stdin);
cout<<endl;
strcat(nombrearchivo,".txt");
punteroarchivo=fopen(nombrearchivo,"rb");
if(punteroarchivo==NULL)
{
}
fread(&datos_a_ingresar, sizeof(tamanio_de_datos), 5 ,punteroarchivo);
cout<<"los datos del archivo son : "<<datos_a_ingresar;
cout<<endl;
fclose(punteroarchivo);
12 Utilizando Clases y funciones virtuales elabore un Programa que me permita crear una clase mamífero, una clase
tigre y una clase hombre, la clase mamífero heredara a la clase hombre edad y peso y la podrá modificar por medio
de sus modificadores, la clase león hereda a la clase hombre el estado "que está corriendo” además en la clase
mamífero crear una función virtual dormir que será reemplazada por otra función de la clase hombre con el mismo
nombre.
#include <iostream>
//clase base
class mamifero
{
private:
int edad;
int peso;
public:
//constructor
{
}
{
return edad;
}
{
return peso;
}
//modificacores
{
edad=_edad;
}
{
peso=_peso;
}
// comportamiento
virtual void dormir() // esta es la clase virtual

{
cout<<"Durmiendo..."<<endl;
};
class tigre
{
public:
void correr()
{
};
class hombre: public mamifero, public tigre
{
public:
void hablar()
{
}
void dormir() // esta funcion modificara a la clase virtual de la clase base
{
cout<<"El hombre duerme acostado sobre una cama..."<<endl;
};
void main()
{
hombre juan;
juan.modificarpeso(150);
cout<<juan.consultarpeso()<<endl;
juan.dormir();
juan.hablar();
juan.correr();
cout<<endl;
system("pause");
}
EJERCICIO 1. FUNDAMENTOS DE PO
Utilizando Fundamentos de Poo elaborar un programa que permita crear una clase llamada automóvil que
manipule dos funciones llamada adquirir_marca y decir_marca y un atributo “carro” y presentar en el main los
datos ingresados.
// fundamentosPO.cpp: define el punto de entrada de la aplicación de consola.
//
#include "stdafx.h"
#include <iostream>
// Declaración de la clase
class automovil
{
public:
void adquirirmarca();
void decirmarca();
private:
char carro[40];
};
// Declaración de funciones de la clase

void automovil::adquirirmarca()
{
cout <<"Ingrese la marca del auto: ";
cin>>carro;
}
void automovil::decirmarca()
{
cout <<"La marca es: "<<carro <<endl;
}
// función principal. Es la porción ejecutable de un programa en C++
int main()
{
int resp=0;
cout<<"Desea crear la marca de un carro? 1. SI 0. NO" <<endl;
cin >>resp;
if(resp==1)
{
automovil a;
a.adquirirmarca();
cout<<endl;
cout <<"Desea saber la marca del auto? 1. Si 0. NO" <<endl;
cin>>resp;
if(resp==1)
{
a.decirmarca();
}
}
system("Pause");
return 0;
}
EJERCICIO 2. FUNCIONES AMIGAS Y CLASES AMIGAS.
Realice un programa implementando Funciones amigas y clases amiga que permita crear una clase llamada dato,
y dentro de la clase declarar: una función amiga llamada permitir, un atributo llamado n1 y una función void
para presentar,
// funcionesAmigas_CLasesAmigas.cpp: define el punto de entrada de la aplicación de consola.
//
#include "stdafx.h"
#include <iostream>
class dato
{
friend void permitir(int, dato &); //es una funcion amiga.
public:
dato(int); //constructor.
void presenta();
private:
int n1; //dato miembro.
};
dato::dato(int n2)
{
n1=n2;
}
void dato::presenta()
{
cout <<"El numero es: " <<n1 <<endl;
}
void permitir(int n2, dato &obj)
{
obj.n1=n2; //puede modificar el dato miembro porque es amiga
}
int main()
{
cout <<"Creamos el objeto ' obj ': " <<endl;
dato obj(18);
obj.presenta();
cout<<"Modifica con la funcion amiga" <<endl;
permitir(14,obj);
obj.presenta();
system("pause");
return 0;
}
EJERCICIO 3. FUNCIONES MIEMBRO DE UNA CLASE COMO AMIGA
Teniendo en cuenta Funciones miembro de una clase como amiga elaborar un programa que permita crear una
clase llamada Numero y por medio de una función amiga de dato entero llamada famiga acceda leer un numero e
incremente ese numero++.
// funcionesmiembroclasecomoamiga.cpp: define el punto de entrada de la aplicación de consola.

//
#include "stdafx.h"
#include <iostream>
class Numero
{
friend int fAmiga(Numero &);
private:
int dato;
};
int fAmiga( Numero &num)

{
int r;
cout<<"Ingrese un numero: "<<endl;
cin>>r;
num.dato=r+1;
return num.dato; // Modifica el valor de la variable privada
}
int main()
{
cout<<"Incrementa el valor de un miembro de una clase" << endl;
Numero s;
cout<<"Incrementado es: "<<fAmiga(s);
cout<<endl;
system("pause");
return 0;
}
EJERCICIO 4. ARREGLOS DE OBJETOS ESTATICOS
Realice el ingreso de 2 números y muestre el número mayor por cada ingreso. Creando una clase número, y dos
funciones una llamada LeerNumero la cual permita el ingreso de los 2numero y la segunda función llamada mayor
que calcule el número mayor y esto lo presente en el main utilizando arreglos de objetos estáticos..
// ArreglosObjEstaticos.cpp: define el punto de entrada de la aplicación de consola.

//
#include "stdafx.h"
#include <iostream>
class numero
{
public:
int a,b;
void LeerNumero(int x);
int mayor();
};
void numero::LeerNumero(int x)
{
cout <<"Calculo de numero Mayor" <<x <<endl;
cout <<"Ingrese a: " <<endl;
cin>>a;
cout <<"Ingrese b: " <<endl;
cin>>b;
system("cls");
}
int numero::mayor()
{
if(numero::a>numero::b)
{
return numero::a;
}
else
{
return numero::b;
}
}
int main()
{
numero v[2];
for(int i=0; i<2; i++)
{
v[i].LeerNumero(i);
}
for(int i=0; i<2; i++)

{
cout <<"El numero mayor es: " <<v[i].mayor() <<endl ;
}
system("pause");
}
EJERCICIO 5. ARREGLOS DE OBJETOS DINÁMICOS
Realice el ingreso de 2 números y muestre el número mayor por cada ingreso. Creando una clase número, y dos
funciones una llamada LeerNumero la cual permita el ingreso de los 2numero y la segunda función llamada mayor
que calcule el número mayor y esto lo presente en el main utilizando arreglos de objetos dinamicos.
// ArreglosObjDinamicos.cpp: define el punto de entrada de la aplicación de consola.

//
#include "stdafx.h"
#include <iostream>
class numero
{
public:
int a,b;
void LeerNumero(int x);
int mayor();
};
void numero::LeerNumero(int x)
{
cout <<"Calculo de numero Mayor " <<x <<endl;
cout <<"Ingrese a: " <<endl;
cin>>a;
cout <<"Ingrese b: " <<endl;
cin>>b;
}
int numero::mayor()
{
if(numero::a>numero::b)
{
return numero::a;
}
else
{
return numero::b;
}
}
int main()
{
numero *p;
int dim;
cout <<"¿Cuantas veces desea hacer el mismo calculo? " <<endl;
cin>>dim;
p=new numero[dim];
for(int i=0; i<dim; i++)
{
p[i].LeerNumero(i);
}
for(int i=0; i<dim; i++)

{
cout <<"El numero mayor es: " <<p[i].mayor() <<endl ;
}
system("pause");
}
EJERCICIO 6. CONSTRUCTORES Y LISTAS DE PARAMETROS EN HERENCIA SIMPLE
Elabore un programa que mediante dos clases una llamada teléfono y otra clase llamada valor, herede datos
simples, y los presente en el main.
// ConstructoresHerenciaSImple.cpp: define el punto de entrada de la aplicación de consola.

//
#include "stdafx.h"
#include <iostream>
class telefono
{
public:
telefono(){cout<<"¿Que marca de telefono le gusta?" <<endl;}
void marca(){cout<<"Iphone 5G";}
};
class Valor: public telefono
{
public:
Valor(){cout<<"¿Que valor tiene el telf "; telefono::marca(); cout<<" ? " <<endl;}
void precio(){cout<<" vale: $280 dolares " <<endl;}
};
int main()
{
Valor datos;
datos.marca();
datos.precio();
cout<<endl;
system("pause");
return 0;
EJERCICIO 7. CONSTRUCTORES Y LISTAS DE PARAMETROS EN HERENCIA MULTIPLE
Elabore un programa que mediante 3 clases presente mensajes estáticos por cada una de ellas utilizando herencia
múltiple, y que presente en el main.
// ConstructoresHerenciaMultiple.cpp: define el punto de entrada de la aplicación de consola.

//
#include "stdafx.h"
#include <iostream>
class Mama
{
public:
Mama(){cout <<"EL nombre de la Madre es: Nancy Jaramillo A. " <<endl;}
};
class Papa: public Mama
{
public:
Papa(){cout<<"El nombre del padre es: Lorenzo Zapata P. " <<endl;}
};
class Hija: public Papa
{
public:
Hija(){cout<<"EL nombre de la hija es: Cinyu Zapata J. " <<endl;}
};
int main()
{
cout<<" Datos Completos " <<endl;
Hija datos;
cout <<endl;
system("pause");
return 0;
}
EJERCICIO 8. CLASES ANIDADAS
Elabore un programa que permita sumar dos números usando clases anidadas.
// clasesAnidades.cpp: define el punto de entrada de la aplicación de consola.

//
#include "stdafx.h"
#include <iostream>
class Numero
{
public: class Numero1{
public: int N1;
};
public: class Numero2{
public: int N2;
};
};
int main()
{
Numero::Numero1 a;
Numero::Numero2 b;
cout<<"Ingrese a: " <<endl;
cin>>a.N1;
cout<<"Ingrese b: " <<endl;
cin>>b.N2;
int r;
r=a.N1+b.N2;
cout<<"La suma de " <<a.N1 <<" + " <<b.N2 <<" : " <<r <<endl;
system("Pause");
return 0;
}
EJERCICIO 9. ENTRADA Y SALIDA POR ARCHIVOS

Elabore un programa que abra un archivo y envié un mensaje a ese archivo.
// EntradaSalidaXarchivos.cpp: define el punto de entrada de la aplicación de consola.
//
#include "stdafx.h"
#include <iostream>
#include <fstream>
int main()
{
char cadena[128];
// Crea un fichero de salida
ofstream fs("EJEMPLO5.txt");
fs << "Hola Cinyu <3" << endl;
fs.close();
ifstream fe("EJEMPLO5.txt");
fe.getline(cadena, 128);
cout << cadena << endl;

system("Pause");
return 0;
}
EJERCICIO 10. APERTURA DE ARCHIVOS Y CREACION ARCHIVOS
Elabore un programa que crea (o abre si existe) un archivo llamado milove.txt que escriba una cadena de texto en
su interior.
// AperturaArchivosCreacion.cpp: define el punto de entrada de la aplicación de consola.

//
#include "stdafx.h"
#include <fstream>
#include <iostream>
int main(){
ofstream fichout("e:\\milove.txt",ios::out);
if (!fichout)
cout << "\n Incapaz de crear este o abrir el fichero \n";
else {
cout<<"Se elaboro este archivo" <<endl;
fichout << "MI MAMÁ" << endl;
fichout.close();
}
system("pause");
}
EJERCICIO 11. FUNCIONES PARA MANIPULACION DE ARCHIVOS.
Elabore un programa que abra por medio de una función llamada fopen abra un archivo llamado milove.txt.
// FuncionMaipulacionArchivo.cpp: define el punto de entrada de la aplicación de consola.

//
#include "stdafx.h"
#include <stdio.h>
#include <iostream>
#include <fstream>
int main()
{
char a[40]="MiMama";
FILE *alias1, *alias2, *alias3;
alias1 = fopen("EJEMPLO.txt", "rb");
alias2 = fopen("milove.TXT", "ab");
alias3 = fopen("amor.txt", "w");
if(!alias1)
{
cout<<"EL archivo se creo"<<endl;
}
else
{
cout<<"error"<<endl;
}
system("pause");
return 0;
}
EJERCICIO 12. CLASES Y FUNCIONES VIRTUALES
Elabore un programa utilizando funciones virtuales y que muestre los datos simples ingresados en las clases.
// funcionVirtual.cpp: define el punto de entrada de la aplicación de consola.
//
#include "stdafx.h"
#include <iostream>
class base
{
public:
virtual void quien(){cout<<"base"<<endl;}
};
class primera: public base
{
public:
void quien(){cout<<"Primera"<<endl;}
};
class segunda: public base
{
public:
void quien(){cout<<"Segunda" <<endl;}
};
int main()
{
base obj, *pBase;
primera obj1;
segunda obj2;
pBase=&obj;
pBase->quien();
pBase=&obj1;
pBase->quien();
pBase=&obj2;
pBase->quien();
system("PAuse");
return 0;
}
1 Utilizando FUNCIONES AMIGAS Y CLASES AMIGAS cree un programa que me permita crear una clase motos, con
sus atributos modelo moto, color, matricula, año, precio. La cual tendrá diferentes estados (encender, velocidad,
frenar). Y tendrá como amiga a una función main para poder acceder a los atributos de la clase moto.
#include <iostream>
#include <windows.h>
#include <cstdlib>
//declaracion de clase
class Moto {
public: char modelo_moto [30];

public: char color [30];
public: int matricula;
public: int año;
public: float precio;
friend void main();

public:
void encender ()
{
//system("encender.mp3");
cout << endl <<"el motor se se esta encendido "<<endl;
}
public:
void velocidad ()
{
//system("velocidad.mp3");
cout << endl << " su velocidad es increible "<<endl;
public:
void frenar ()
{
//system("frenar.mp3");
cout <<endl << " la moto esta frenando "<<endl;
};
void main ()
{
Moto modelomoto;
cout<<"ingrese modelo de la moto"<<endl;

cin>> modelomoto.modelo_moto ;
cin.ignore();
cout<<endl;
cout<<"ingrese color de la moto"<<endl;
cin>> modelomoto.color ;
cin.ignore();
cout<<endl;
cout<<"ingrese matricula de la moto"<<endl;
cin>> modelomoto.matricula ;
cin.ignore();
cout<<endl;
cout<<"ingrese el año de la moto"<<endl;
cin>> modelomoto.año ;
cin.ignore();
cout<<endl;
cout<<"ingrese el precio de la moto"<<endl;
cin>> modelomoto.precio ;
cin.ignore();
cout<<endl;
cout<<endl;
system("cls");
cout<<endl;
cout<<"MODELO \t :" << modelomoto.modelo_moto<<endl;
cout<<"COLOR \t :" << modelomoto.color<<endl;
cout<<"N_MATRICULA \t :" << modelomoto.matricula<<endl;
cout<<"AÑO \t :" << modelomoto.año<<endl;
cout<<"PRECIO \t :" << modelomoto.precio <<endl;
modelomoto.encender ();
Sleep(4000);
cout<<endl;
modelomoto.velocidad ();
Sleep(5000);
cout<<endl;
modelomoto.frenar ();
Sleep(6000);
cout<<endl;
system("pause");
}
2 utilizando FUNCIONES_MIEMBRO elabore un programa que me permita crear una clase empleado con una
función miembro imprimir, la cual me permitirá mostrar los datos ingresados.
#include <iostream>
#include <conio.h>
class empleado
{
friend void main ();
public:
void leer_empleado(void);
void mostrar_empleado(void);
char nombre[15];
long numero_empleado;
float salario;
};
void empleado::leer_empleado(void)
{
cout<< "Nombre:";
cin >> nombre;
cout<< "Número:";
cin >> numero_empleado;
cout<< "Salario: Bs.";
cin >> salario;
}
void empleado::mostrar_empleado(void)
{
cout << "Nombre: " << nombre << endl;
cout << "Número: " << numero_empleado << endl;
cout << "Salario: Bs." << salario << endl;
}
void main()
{
empleado trabajador;
system("cls");
trabajador.leer_empleado();
cout<<"\nResultado después de la lectura...\n";
trabajador.mostrar_empleado();
cout<<"\nPresione una Tecla para Continuar";
getch();
}
3 Por medio de ARREGLOS DE OBJETOS ESTÁTICOS elabore un Programa que permita ingresar en una clase las
notas de dos materias, en otra clase que me de cómo resultado su promedio, y en otra clase que me permita
ingresar las calificaciones.
#include<iostream>
#include<stdlib.h>
#include<cstdlib>
#include<cstring>
#include<fstream>
class alumno
{
public:
float calilenguaje,calisociales,promedio;
void obtener_calificacion();
float mostrar_promedio();
};
void alumno::obtener_calificacion ()
{
cout<<"calificacion de lenguaje es : ";
cin>>calilenguaje;
cout<<endl;
cout<<"calificacion de sociales es : ";
cin>>calisociales;
cout<<endl;
}
float alumno::mostrar_promedio()
{
return (calilenguaje+calisociales)/2;
}
int main ()
{
alumno vector[2];
for (int i=0;i<2;i++)
{
cout<<"calificacion del estudiante"<<i+1<<endl;
vector[i].obtener_calificacion();
}
for (int i=0;i<2;i++)
{
cout<<" el priomedio es: " <<vector[i].mostrar_promedio()<<endl;
}
cout<<endl;
system ("pause");
4 por medio de ARREGLO DE OBJETOS DINÁMICOS elabore un programa que me permita ingresar las notas de dos
materias de una cantidad desconocida de estudiantes, y me muestre el promedio que será calculado por una clase.
#include<iostream>
#include<stdlib.h>
#include<cstdlib>
#include<cstring>
#include<fstream>
class alumno
{
public:
float calilenguaje,calisociales,promedio;
void obtener_calificacion();
float mostrar_promedio();
};
void alumno::obtener_calificacion ()
{
cin>> calilenguaje;
cin>>calisociales;
}
float alumno::mostrar_promedio()
{
return (calilenguaje+calisociales)/2;
}
int main ()
{
alumno *aray;
int longuitud;
cout<<"Ingrese la cantidad de alumnos : "<<endl;
cin>>longuitud;
aray = new alumno[longuitud];
for (int x=0; x<longuitud;x++)
{
cout <<"calificacion del estudiante : "<<x+1<<endl;
aray[x].obtener_calificacion();
}
for (int x=0; x<longuitud;x++)
{
cout <<"calificacion del estudiante : "<<x+1<<endl;
cout<<"PROMEDIO ES : "<<aray[x].mostrar_promedio()<<endl;
}
delete []aray;
system("pause");
5 Por medio de CONSTRUCTORES Y LISTAS DE PARÁMETROS EN HERENCIA SIMPLE elabore un programa que me
permita crear una clase mamífero y una clase hombre en la cual la clase mamífero heredara a la clase hombre edad
y peso y la podrá modificar por medio de sus modificadores que se encuentran dentro de la clase mamífero.
#include<iostream>
#include<stdlib.h>
#include<cstdlib>
#include<cstring>
#include<fstream>
#include <iostream>
//clase base
class mamifero
{
private:
int edad;
int peso;
public:
//constructor
{
}
int conltedad() const

{
cout<<"su edad es : "<<endl;
return edad;
}
int conlpeso() const
{ cout<<"el peso es :"<<endl;
return peso;
}
//modificacores
void modedad(int _edad)
{
edad=_edad;
}
void modpeso(int _peso)
{
peso=_peso;
}
};
class hombre: public mamifero
{
public:
void nadar()
{
cout<<"nadando...";
};
void main()
{
hombre eliza;
eliza.modedad(21);
cout<<eliza.conltedad()<<endl;
eliza.nadar();
cout<<endl;
eliza.modpeso(120);
cout<<endl;
cout<<eliza.conlpeso()<<endl;
system("pause");
}
6 por medio de HERENCIA MÚLTIPLE desarrolle un programa que me permita crear varias clases bebe, niña,
señorita, la clase señorita heredara de la clase bebe y niña permitiéndome mostrar las funcionalidades de bebe,
niña, por medio de la clase señorita.
#include <iostream>
#include <stdlib.h>
class bebe
{
public:
void llora()
{
cout<<" esta llorando" ;
}
private:
};
class niña
{
public:
void grita ()
{
cout<<"esta gritando";
}
private:
};
class señorita:public niña,public bebe
{
public:
void habla ()
{
cout <<"hablando";
}
private:
};
int main ()
{
cout<< "eliza esta " ;
señorita eliz;
cout<<endl;
eliz.llora();
cout<<endl;
eliz.grita();
cout<<endl;
eliz.habla();
cout<<endl;
system("pause");
return 0 ;
}
7 Utilizando CONSTRUCTORES Y LISTAS DE PARÁMETROS EN HERENCIA MÚLTIPLE elabore un Programa que me
permita crear una clase mamífero heredando a la clase niño sus atributos peso y edad, permitiendo modificar y
consultar datos por medio de sus consultores y modificadores, además crear una clase perro que herede a niño un
comportamiento “jugar” .
#include <iostream>
class mamifero
{
private:
int edad;
int peso;
public:
//constructor
{
}
int consledad() const
{
return edad;
}
int conslpeso() const
{
return peso;
}
//modificacores
void modiedad(int _edad)
{
edad=_edad;
}
void modipeso(int _peso)
{
peso=_peso;
}
};
class perro
{
public:
void juega()
{
cout<<"jugando......."<<endl;
};
class niño: public mamifero, public perro
{
public:
void llora()
{
cout<<"llorando......."<<endl;
}
};
void main()
{
niño lucas;
lucas.modiedad(8);
lucas.modipeso(80);
cout<<lucas.consledad()<<endl;
cout<<lucas.conslpeso()<<endl;
lucas.llora();
lucas.juega();
cout<<endl;
system("pause");
}
8 Utilizando CLASES _ANIDADAS diseñe un Programa con una clase reptiles dentro de ellas dos clases más llamadas
serpiente, lagartija caga una de las clases que muestre un comportamiento, en el main llamar a las funciones que se
encuentran dentro de la clase reptiles(clases anidadas).
#include <iostream>
class reptiles
{
public:class serpiente
{
public :
void venenosa()
{
cout<<"la serpiente es venenosa";
}
};
public:class lagartija
{
public: void veloz()
{
cout<<"la lagartija en veloz";
}
};
};
int main()
{
reptiles::serpiente culebra;
reptiles:: lagartija lagar;
culebra.venenosa();
cout<<endl;
lagar.veloz();
cout<<endl;
system("pause");
}
9 Utilizando ENTRADA Y SALIDAS POR ARCHIVOS diseñe un programa que me permita ingresar y guardar nombres
de x jugadores en un archivo .txt.
#include <iostream>
#include<stdlib.h>
#include<conio.h>
FILE *document;
int main ()
{
document=fopen("inspeccionamiento.tex","a+");
cout<<" ingrese los nombre de los jugadores";
char jugador[30];
char respon;
int n=1;
cout<<endl;
do{
cout<<" el juador "<<n<<endl;
cin>> jugador;
fprintf(document,"char \n" ,jugador);
n++;
cout<< "desea ingresar nuevo jugador s/n"<<endl;
respon=getch();
} while (respon =='s' || respon=='S');

cout<<endl<<endl;
fclose(document);
system("pause");
return 0;
10 por medio de FUNCIONES PARA MANIPULACIÓN DE ARCHIVOS elabore un programa que me permita crear dos
funciones la una para crear datos en un archivo .txt y la otra para consultar los datos almacenados, ambas
funciones deben ser llamadas por medio de un menú.
#include <stdio.h>
#include<string.h>
#include<iostream>
void ingresodt();
void consultadt();
FILE *ptdocumet;
char opcion[1], nombredoc[30],ingrese_datos[50];
int tamaño_datos;
void main()
{
do
{
fflush(stdin);
cout<<"1. INGRESO DATOS "<<endl;
cout<<"2. MOSTRAR DATOS "<<endl;
cout<<"3. CERRAR "<<endl;
cout<<"ELIJA LA OPCION QUE DESEE : ";
opcion[0] = getchar();
fflush(stdin);
cout<<endl;
switch(opcion[0])
{
case '1':
{
ingresodt();
}
break;
case '2':
{
consultadt();
}
break;
case '3':
{
cout<<" GRACIAS";
}
break;
}
}while (opcion!="3");
}
void ingresodt()
{
fflush(stdin);
gets(nombredoc);
fflush(stdin);
cout<<endl;
strcat(nombredoc,".txt");
ptdocumet=fopen(nombredoc,"a+");
if(ptdocumet==NULL)
{
}
cout<<"ingrese datos al archivo: ";
gets(ingrese_datos);
fflush(stdin);
//funcion para saber el tamaño de los datos que se va a ingresar
tamaño_datos = sizeof(ingrese_datos);
//funcion para grabar los datos en el archivo
fwrite(&ingrese_datos, sizeof(tamaño_datos), 1 ,ptdocumet);
fclose(ptdocumet);
};
void consultadt()
{
fflush(stdin);
gets(nombredoc);
fflush(stdin);
cout<<endl;
strcat(nombredoc,".txt");
ptdocumet=fopen(nombredoc,"rb");
if(ptdocumet==NULL)
{
}
fread(&ingrese_datos, sizeof(tamaño_datos), 5 ,ptdocumet);
cout<<"los datos del archivo son : "<<ingrese_datos;
cout<<endl;
fclose(ptdocumet);
}
11 Usando CLASES Y FUNCIONES VIRTUALES programa que me permita crear una clase mamífero, una clase perro y
una clase niño, la clase mamífero heredara a la clase perro edad y peso y la podrá modificar por medio de sus
modificadores, en la clase mamífero crear una función virtual que será reemplazada por otra función con el mismo
nombre en de la clase niño.
#include <iostream>
//clase principal
class mamifero
{
private:
int edad;
int peso;
public:
//constructores
{
}
//realizar consulta
{
return edad;
}
{
return peso;
}
//realizar _modificacores
void modedad(int _edad)
{
edad=_edad;
}
void modpeso(int _peso)
{
peso=_peso;
}
//clase virtual
virtual void comer()
{
cout<<"..comiendo.. ";
}
};
class perro
{
public:
void juega()
{
cout<<"jugando..."<<endl;
}
};
class niño: public mamifero, public perro
{
public:
void llora()
{
cout<<"llora..."<<endl;
}
void comer()
{
cout<<"niño comiendo educadamente";
}
};
void main()
{
niño lucas;
lucas.modedad(3);
lucas.modpeso(79);
cout<<lucas.consultaredad()<<endl;
cout<<lucas.consultarpeso()<<endl;
lucas.llora();
lucas.juega();
lucas.comer();
cout<<endl;
system("pause");
}
Realice un programa de Poo por el cual a través de una clase, presente (imprima) las diferentes actividades de un
perro dentro de un solo main (ladrar, orinar, comer), cada acción deberá estar contenida en una función de no
retorno
void Perro :: ladrar(){

cout << "GuauGuauGuau....\n";
}
void Perro :: orinar(){

cout << "Psssss...\n";
}
void Perro :: comer(){
cout << "mmmmmm....\n";
}
int main(){
Perro Campeon;
cout << endl;
cout << "Campeon ladra: \n";

Campeon.ladrar();
cout << endl;
cout << "Campeon orina: \n";

Campeon.orinar();
cout << endl;
cout << "Campeon come: \n";

Campeon.comer();
cout << endl << endl;

system("pause");
return 0;
Funciones amigas y clases amigas
A través de las funciones amigas realice un programa que tome un valor y a su vez sea modificable
class dato
{
friend void permitir(int, dato &); //es una funcion amiga.
public:
dato(int); //constructor.
void presenta();
private:
int n1; //dato miembro.
};
dato::dato(int n2)
{
n1=n2;
}
void dato::presenta()
{
cout <<"El numero es: " <<n1 <<endl;
}
void permitir(int n3, dato &obj)
{
obj.n1=n3; //puede modificar el dato miembro porque es amiga
}
int main()
{
cout <<"Creamos el objeto ' obj ': " <<endl;
dato obj(18);
obj.presenta();
cout<<"Modifica con la funcion amiga" <<endl;
permitir(25,obj);
obj.presenta();
system("pause");
return 0;
}
Funciones miembros de una clase como amiga
A través de una función miembro de una clase amiga ingresar un valor el cual se incrementara al tomar el valor
entro de la misma función y sumarle ++
# #include <iostream>
class EJEMPL
{
friend int funcionA(EJEMPL &);
private:
int MODIFICADOR;
};
int funcionA( EJEMPL &VARIANTE)

{
int r;
cout<<"Ingrese un numero: "<<endl;
cin>>r;
r++; // incrementa el valor de la variable +1
VARIANTE.MODIFICADOR=r;
return VARIANTE.MODIFICADOR; // Modifica el valor de la variable privada
}
int main()
{
cout<<"Incrementa el valor de un miembro de una clase" << endl;
EJEMPL s;
cout<<"Incrementado es: "<<funcionA(s);
cout<<endl;
system("pause");
return 0;
}
Arreglo de objetos estáticos
Presente dos variables (x,y), mediante un arreglo de objeto estáticos y que usando este arreglo se agregue +1 al
valor de y , en la clase deben estar contenidos las variables (x,y)
#include <iostream>
class estatica {
static int x;
static int y;
public:
void print() const {
cout << "estatica::x = " << x << endl;
cout << "estatica::y = " << y << endl;
}
};
int estatica::x = 1;
int estatica::y = x + 1;
int main() {
estatica ws;
ws.print();
system ("pause");
} ///:~
Arreglo de objetos dinámicos
Realice un programa que permita obtener el resultado del impuesto (IVA 12%) de dos valores ingresados mediante
objetos dinámicos, en la primera función se ingresen el valor de cada cliente y en la segunda que se calcule el valor
de impuesto y estos presentados en una función de no retorno dependiendo del número de clientes
#include <vector>
#include <iostream>
class cliente
{
public:
float valor1, valor2, total;
void obtenerresultado();
float mostartotal();
};
void cliente::obtenerresultado()
{
cout<<"el valor 1 es : ";
cin>> valor1;
cout<<"el valor 2 es : ";
cin>>valor2;
};
float cliente::mostartotal()
{
return (valor1+valor2)*12/100;
};
void main ()
{
cliente *arreglo;
int tamaño;
cout<<"Ingrese la cantidad de clientes : ";
cin>>tamaño;
arreglo = new cliente [tamaño];
{
cout <<"Informacion del cliente : "<<x+1<<endl;
arreglo[x].obtenerresultado();
}
{
cout <<"Informacion del cliente : "<<x+1<<endl;
cout<<"el impuesto es : "<<arreglo[x].mostartotal()<<endl;
}
delete []arreglo;
system("pause");
}
CONSTRUCTORES Y LISTAS DE PARAMETROS EN HERENCIA SIMPLE
Realice un programa que mediante 2 clases, presente su equipo favorito y la segunda tome la cantidad e goles que
noto en una temporada, presentando al final los datos en un main de los parámetros de herencia simple de estas
clases.
#include <iostream>
class equipo
{
public:
equipo(){cout<<"cual es tu equipo favorito?" <<endl;}
void nombre(){cout<<"Emelec";}
};
class goles: public equipo
{
public:
goles(){cout<<"cuantos goles anoto la ultima temporada "; equipo::nombre(); cout<<" ? " <<endl;}
void cantidad(){cout<<" anoto un total de 18 " <<endl;}
};
int main()
{
goles datos;
datos.nombre();
datos.cantidad();
cout<<endl;
system("pause");
return 0;
Herencia Multiple
De la clase "Persona". Derivaremos las clases "Empleado" y "Estudiante", y crearemos una nueva clase "Becario"
derivada de estas dos últimas. Además haremos que la clase "Persona" sea virtual, de modo que no se dupliquen
sus funciones y datos.
#include <iostream>
#include <cstring>
class Persona {
public:
Persona(char *n) { strcpy(nombre, n); }
const char *LeeNombre() const { return nombre; }
protected:
char nombre[30];
};
class Empleado : virtual public Persona {

public:
Empleado(char *n, int s) : Persona(n), salario(s) {}
int LeeSalario() const { return salario; }
void ModificaSalario(int s) { salario = s; }
protected:
int salario;
};
class Estudiante : virtual public Persona {

public:
Estudiante(char *n, float no) : Persona(n), nota(no) {}
float LeeNota() const { return nota; }
void ModificaNota(float no) { nota = no; }
protected:
float nota;
};
class Becario : public Empleado, public Estudiante {

public:
Becario(char *n, int s, float no) :
Empleado(n, s), Estudiante(n, no), Persona(n) {} // (1)
};
int main() {
Becario Fulanito("Fulano", 1000, 7);
cout << Fulanito.LeeNombre() << ","

<< Fulanito.LeeSalario() << ","
<< Fulanito.LeeNota() << endl;
return 0;
}
Constructores y listas de parámetros en herencia múltiple
Realice un programa que permita crear una clase mamífero, pantera y hombre. La clase mamífero heredara la clase
hombre edad y peso la cual podrá ser modificada por medio de sus métodos y la clase león heredara a la clase
hombre “que está corriendo”
#include <iostream>
//clase base
class mamifero
{
private:
int edad;
int peso;
public:
//constructor
{
}
{
return edad;
}
{
return peso;
}
//modificacores
{
edad=_edad;
}
{
peso=_peso;
}
};
class pantera
{
public:
void correr()
{
};
class hombre: public mamifero, public pantera
{
public:
void hablar()
{
};
void main()
{
hombre humano;
humano.modificaredad(30);
humano.modificarpeso(160);
cout<<humano.consultaredad()<<endl;
cout<<humano.consultarpeso()<<endl;
humano.hablar();
humano.correr();
cout<<endl;
system("pause");
}
Clases anidadas
Realizar un programa que permita contener la clase celulares y dentro de ella estén contenidas dos clases más
llamadas samsung y Nokia las cuales darán el precio de cada celular, y esto deberá ser llamado en el main.
#include <iostream>
#include<stdlib.h>
class celular
{
public:class samsung
{
public:
void preciosamsung()
{
cout<<"El precio del celular samsung es: $180"<<endl;
};
public:class nokia
{
public:
void precionokia()
{
cout<<"el precio del celular nokia es de 150"<<endl;
}
};
};
void main()
{
celular::samsung precio;
celular::nokia precio2;
precio.preciosamsung();
precio2.precionokia();
system("pause");
}
Entrada y salida por archivos
Crear un fichero mediante un objeto de la clase, y posteriormente lo leeremos mediante un objeto de la clase, estos
se deberá realizar mediante un solo main y la creación del archivo como un ofstream.
#include <iostream>
#include <fstream>
int main() {
char cadena[128];
ofstream fs("nombre.txt");
// Enviamos una cadena al fichero de salida:

fs << "Hola, mundo" << endl;
// Cerrar el fichero,
// para luego poder abrirlo para lectura:
fs.close();
// Abre un fichero de entrada

ifstream fe("nombre.txt");
// Leeremos mediante getline, si lo hiciéramos

// mediante el operador << sólo leeríamos
// parte de la cadena:
return 0;
Apertura de archivos, creación de archivos
Crear un fichero mediante un objeto de la clase ofstream, y posteriormente lo leeremos mediante un objeto de la
clase ifstream:
#include <iostream>
#include <fstream>
int main() {
char cadena[128];
ofstream fs("entradasalida.txt");
// Enviamos una cadena al fichero de salida:

fs << "salida de datos" << endl;
// Cerrar el fichero,
// para luego poder abrirlo para lectura:
fs.close();
// Abre un fichero de entrada

ifstream fe("entrada salida.txt");
// Leeremos mediante getline, si lo hiciéramos

// mediante el operador << sólo leeríamos
// parte de la cadena:
system ("pause");
return 0;
Funciones para manipulación de archivos
Presentar un programa que presente el contenido de un archivo .txt contenido dentro de un main y utilizanco
fopen.
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *archivo;
char caracteres[100];
archivo = fopen("prueba.txt","r");
if (archivo == NULL)
/*exit(1);*/
printf("\nEl contenido del archivo de prueba es \n\n");

while (feof(archivo) == 0)
{
fgets(caracteres,1000,archivo);
printf("%s",caracteres);
}
system("PAUSE");
fclose(archivo);
return 0;
}
Clases y funciones virtuales
Construya un programa que contenga la clase virtual quien, dentro de una clase principal base y que presente
primera y segunda clase de esta base.
#include <iostream>
class base
{
public:
virtual void quien(){cout<<"base"<<endl;}
};
class primera: public base
{
public:
void quien(){cout<<"Primera"<<endl;}
};
class segunda: public base
{
public:
void quien(){cout<<"Segunda" <<endl;}
};
int main()
{
base obj, *pBase;
primera obj1;
segunda obj2;
pBase=&obj;
pBase->quien();
pBase=&obj1;
pBase->quien();
pBase=&obj2;
pBase->quien();
system("PAuse");
return 0;
}

Banco de Preguntas

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Banco de Preguntas

Caricato da

Copyright:

Formati disponibili

BANCO DE PREGUNTAS 1

cout<<"DATOS DEL AVION TAME :"<<endl;

void imprime() const;

friend void main();// aqui declaramos al void como amiga

using namespace std;

for (int x=0; x<2;x++)

virtual void dormir() // esta es la clase virtual

// Declaración de funciones de la clase

EJERCICIO 2. FUNCIONES AMIGAS Y CLASES AMIGAS.

EJERCICIO 3. FUNCIONES MIEMBRO DE UNA CLASE COMO AMIGA

// funcionesmiembroclasecomoamiga.cpp: define el punto de entrada de la aplicación de consola.

int fAmiga( Numero &num)

EJERCICIO 4. ARREGLOS DE OBJETOS ESTATICOS

// ArreglosObjEstaticos.cpp: define el punto de entrada de la aplicación de consola.

for(int i=0; i<2; i++)

EJERCICIO 5. ARREGLOS DE OBJETOS DINÁMICOS

// ArreglosObjDinamicos.cpp: define el punto de entrada de la aplicación de consola.

for(int i=0; i<dim; i++)

EJERCICIO 6. CONSTRUCTORES Y LISTAS DE PARAMETROS EN HERENCIA SIMPLE

// ConstructoresHerenciaSImple.cpp: define el punto de entrada de la aplicación de consola.

EJERCICIO 7. CONSTRUCTORES Y LISTAS DE PARAMETROS EN HERENCIA MULTIPLE

// ConstructoresHerenciaMultiple.cpp: define el punto de entrada de la aplicación de consola.

EJERCICIO 8. CLASES ANIDADAS

// clasesAnidades.cpp: define el punto de entrada de la aplicación de consola.

EJERCICIO 9. ENTRADA Y SALIDA POR ARCHIVOS

fs << "Hola Cinyu <3" << endl;

cout << cadena << endl;

// AperturaArchivosCreacion.cpp: define el punto de entrada de la aplicación de consola.

EJERCICIO 11. FUNCIONES PARA MANIPULACION DE ARCHIVOS.

// FuncionMaipulacionArchivo.cpp: define el punto de entrada de la aplicación de consola.

public: char modelo_moto [30];

friend void main();

cout<<"ingrese modelo de la moto"<<endl;

int conltedad() const

} while (respon =='s' || respon=='S');

void Perro :: ladrar(){

void Perro :: orinar(){

cout << "Campeon ladra: \n";

cout << "Campeon orina: \n";

cout << "Campeon come: \n";

cout << endl << endl;

Funciones amigas y clases amigas

using namespace std;

Funciones miembros de una clase como amiga

int funcionA( EJEMPL &VARIANTE)

Arreglo de objetos estáticos

using namespace std;

class Empleado : virtual public Persona {

class Estudiante : virtual public Persona {

class Becario : public Empleado, public Estudiante {

cout << Fulanito.LeeNombre() << ","

Constructores y listas de parámetros en herencia múltiple

Entrada y salida por archivos

// Enviamos una cadena al fichero de salida:

// Abre un fichero de entrada

// Leeremos mediante getline, si lo hiciéramos

cout << cadena << endl;

Apertura de archivos, creación de archivos

// Enviamos una cadena al fichero de salida:

// Abre un fichero de entrada

// Leeremos mediante getline, si lo hiciéramos

cout << cadena << endl;

Funciones para manipulación de archivos

printf("\nEl contenido del archivo de prueba es \n\n");