SOBRECARGA DE OPERADORES

1. Escribir el cdigo para la estructura complejo y la sobrecarga de los operadores

que se dan a continuacin(para realizar las diferentes operaciones con
complejos como se muestra en el programa principal)

Struct complejo
{
private:
double re, im;
public:
void Cplx_Print(const complejo c)
complejo operator + (const complejo & a, const complejo & b) //suma
complejo operator - (const complejo & a, const complejo & b) //resta
complejo operator * (const complejo & a, const complejo &
b)//multiplicacin
complejo operator ~ (const complejo & c) //conjugada
complejo operator - (const complejo & c) //cambio de signo
complejo operator + (const complejo & c) // operador unario de conservacin
de signo.
complejo operator ! (const complejo & c) // inverso
complejo operator / (const complejo & a, const complejo &b) //divisin
double Cplx_Mod(const complejo & c) //modulo
void operator += (complejo & a, const complejo & b) //
void operator -= (complejo & a, const complejo & b)//
void operator *= (complejo & a, const complejo & b) //
void operator /= (complejo & a, const complejo & b) //
};
SOLUCIN
#include <conio.h>
#include<iostream>
#include<math.h>
double Sqr(double d) {
return d * d;
}
struct complejo {
double re, im;
};
complejo Cplx_Crear(double re, double im) {
complejo Temp;

Temp.re= re;
Temp.im= im;

return Temp;
}
void Cplx_Print(const complejo c) {
cout << c.re << " + " << c.im << "i";
}
complejo operator + (const complejo & a, const complejo & b) {
complejo Temp;
Temp.re= a.re + b.re;
Temp.im= a.im + b.im;
return Temp;
}
complejo operator - (const complejo & a, const complejo & b) {
complejo Temp;
Temp.re= a.re - b.re;
Temp.im= a.im - b.im;
return Temp;
}
complejo operator * (const complejo & a, const complejo & b) {
complejo Temp;
// (a + Ai) * (b + Bi) = (ab - AB) + (aB + Ab)i
Temp.re= (a.re * b.re) - (a.im * b.im);
Temp.im= (a.re * b.im) + (a.im * b.re);
return Temp;
}

complejo operator ~ (const complejo & c) {

complejo Temp;
Temp.re = c.re;
Temp.im = -c.im;
return Temp;
}
complejo operator - (const complejo & c)
{
complejo Temp;
Temp.im = -c.im;
Temp.re = -c.re;
return Temp;
}
complejo operator + (const complejo & c)
{
return c;
}
void Div_Cero()
{
cout << "Divisin por cero!! ";
}
complejo operator ! (const complejo & c)
{
double Den= Sqr(c.re) + Sqr(c.im);
 if (!Den) {
Div_Cero();
return Cplx_Crear(0, 0);
}
complejo Temp;
Temp.re= c.re / Den;
Temp.im= -c.im / Den;
return Temp;
}
complejo operator / (const complejo & a, const complejo &b)
{
// Divisin
return a * !b;
}
double Cplx_Mod(const complejo & c)
{
return sqrt(Sqr(c.re) + Sqr(c.im));
}
void operator += (complejo & a, const complejo & b)
{
}
void operator -= (complejo & a, const complejo & b)
{
a= a - b;
}
void operator *= (complejo & a, const complejo & b)
{
a= a * b;
}
void operator /= (complejo & a, const complejo & b)
{
a= a / b;
}
int main() {
complejo a, b, c, d;

a= Cplx_Crear(1.0, 1.0);
b= Cplx_Crear(2.0, 2.0);
c= Cplx_Crear(1.0, 0);
b+= a;
c= a / c;
d*= b + c - a;
c+= -b * d + c / d - ~a;
c*= Cplx_Crear(2.0, 0.0);
d= ~c;
d= -c;
d= +d;
 d= !a;

cout << Cplx_Mod(d);

a= Cplx_Crear(1.0, 0.0);
a= !a;

cout << "\n\n";

cout << "a = ";
Cplx_Print(a);
cout << endl;
cout << "c = ";
Cplx_Print(c);
cout << endl;
cout << "d = ";
Cplx_Print(d);
cout << endl;
getch();
}

2. Escribir el cdigo para la clase complejo y la sobrecarga de los operadores que

se dan en el anterior problema.
SOLUCIN:

#include<iostream>
#include <conio.h>
#include <math.h>

double Sqr(double d) {
return d * d;
}

class complejo
{private:
double re;
double im;
public:
complejo();
complejo(double,double);
void imprimir(const complejo);
complejo operator +(const complejo & a, const complejo & b);
complejo operator - (const complejo & a, const complejo & b);
complejo operator * (const complejo & a, const complejo & b);
complejo operator ~ (const complejo & c);
complejo operator - (const complejo & c);
complejo operator + (const complejo & c);
 void complejo:: Div_Cero();
complejo operator ! (const complejo & c);
complejo operator / (const complejo & a, const complejo &b);
double Cplx_Mod(const complejo & c);
void operator += (complejo & a, const complejo & b);
void operator -= (complejo & a, const complejo & b);
void operator *= (complejo & a, const complejo & b);
void operator /= (complejo & a, const complejo & b);

};
complejo::complejo()
{}
complejo::complejo(double r,double i )
{
re=r;
im=i;
}
void complejo::imprimir(const complejo c)
{
cout << c.re << " + " << c.im << "i";
}
complejo complejo::operator+(const complejo & a, const complejo & b)
{
re= a.re + b.re;
im= a.im + b.im;

return complejo(re,im);
}
complejo complejo::operator - (const complejo & a, const complejo & b)
{
re= a.re - b.re;
im= a.im - b.im;

return complejo(re,im);
}
complejo complejo::operator * (const complejo & a, const complejo & b)
{
re= (a.re * b.re) - (a.im * b.im);
im= (a.re * b.im) + (a.im * b.re);

return complejo(re,im);
}
complejo complejo::operator ~ (const complejo & c)
{
re = c.re;
im = -c.im;
return complejo(re,im);
}
complejo complejo::operator - (const complejo & c)
{

}
complejo complejo::operator + (const complejo & c)
{
im = -c.im;
re = -c.re;
return complejo(re,im);
}
void complejo:: Div_Cero()
{
cout << "Divisin por cero!! ";
}
complejo complejo::operator ! (const complejo & c)
{
double Den= Sqr(c.re) + Sqr(c.im);
if (!Den) {
Div_Cero();
return complejo(0, 0);
}

re= c.re / Den;

im= -c.im / Den;
return complejo(re,im);
}
complejo complejo::operator / (const complejo & a, const complejo &b)
{
return a * !b;
}
double complejo::Cplx_Mod(const complejo & c)
{
return sqrt(Sqr(c.re) + Sqr(c.im));
}
void complejo::operator += (complejo & a, const complejo & b)
{
a= a + b;
}
void complejo::operator -= (complejo & a, const complejo & b)
{
a= a - b;
}

void complejo::operator /= (complejo & a, const complejo & b)

void complejo::operator *= (complejo & a, const complejo & b) {
a= a * b;
}

void complejo::operator /= (complejo & a, const complejo & b)

{
a= a / b;
}

int main() {
complejo a, b, c, d;

a(1.0, 1.0);
b(2.0, 2.0);
c(1.0, 0);
b+= a;
c= a / c;
d*= b + c - a;
c+= -b * d + c / d - ~a;
c*(2.0, 0.0);
d= ~c;
d= -c;
d= +d;
d= !a;

cout << Cplx_Mod(d);

a(1.0, 0.0);
a= !a;

cout << "\n\n";

cout << "a = ";
imprimir(a);
cout << endl;
cout << "c = ";
imprimir(c);
cout << endl;
cout << "d = ";
imprimir(d);
cout << endl;
getch();
}

#include<iostream.h>
#include<math.h>
double Sqr(double d) {
return d * d;
}

class complejo {
private:
double re, im;
static void Div_Cero();
public:
const complejo & Poner(double re, double im);
void Print();

complejo operator + (const complejo & );

complejo operator - (const complejo & );
complejo operator * (const complejo & );
complejo operator ~ ();
complejo operator - ();
complejo & operator + ();
complejo operator ! ();
complejo operator / (const complejo & );
double Mod();
const complejo & operator += (const complejo & );
const complejo & operator -= (const complejo & );
const complejo & operator *= (const complejo & );
const complejo & operator /= (const complejo & );
};

// Implementaciones

const complejo & complejo::Poner(double r, double i) {

re= r;
im= i;
return *this;
}

void complejo::Print() {
cout << re << " + " << im << "i";
}

complejo complejo::operator + (const complejo & b) {

// Suma
complejo Temp;

Temp.re= re + b.re;
Temp.im= im + b.im;
 return Temp;
}

complejo complejo::operator - (const complejo & b) {

// resta
complejo Temp;

Temp.re= re - b.re;
Temp.im= im - b.im;

return Temp;
}

complejo complejo::operator * (const complejo & b) {

// multiplicacin
complejo Temp;

// (a + Ai) * (b + Bi) = (ab - AB) + (aB + Ab)i

Temp.re= (re * b.re) - (im * b.im);
Temp.im= (re * b.im) + (im * b.re);

return Temp;
}

complejo complejo::operator ~ () {
// conjugado
complejo Temp;
Temp.re = re;
Temp.im = -im;
return Temp;
}

complejo complejo::operator - () {
// cambio de signo
complejo Temp;
Temp.im = -im;
Temp.re = -re;
return Temp;
}

complejo & complejo::operator + () {

// operador unario de conservacin de signo. O sea, nada.
return *this;
}

void complejo::Div_Cero() {
cout << "Divisin por cero!! ";
}

complejo complejo::operator ! () {
// Inverso
complejo Temp;
double Den= Sqr(re) + Sqr(im);
if (!Den) {
Div_Cero();
Temp.Poner(0., 0.);
}
else {
Temp.re= re / Den;
Temp.im= -im / Den;
}
return Temp;
}

complejo complejo::operator / (const complejo &b) {

// Divisin
return *this * !b;
}

double complejo::Mod() {
// mdulo
return sqrt(Sqr(re) + Sqr(im));
}

const complejo & complejo::operator += (const complejo & b) {

return *this= *this + b;
// Usando la operacin suma anterior es m s lento que hacerlo directamente
pero ahorramos cdigo.
}

const complejo & complejo::operator -= (const complejo & b) {

return *this= *this - b;
}

const complejo & complejo::operator *= (const complejo & b) {

return *this= *this * b;
}

const complejo & complejo::operator /= (const complejo & b) {

return *this= *this / b;
}

void main() {
complejo a, b, c, d;
 (void)a.Poner(1.0, 1.0);
(void)b.Poner(2.0, 2.0);
(void)c.Poner(1.0, 0);
b+= a;
c= a / c;
d*= b + c - a; // Qu lindo
c+= -b * d + c / d - ~a; // Lindsimo
complejo Temp;
(void)Temp.Poner(2.0, 0.0);
c*= Temp; // Multiplicar por 2
d= ~c; // El conjugado
d= -c; // Negado
d= +d; // Nada;
d= !a; // El inverso

cout << d.Mod();

a.Poner(1.0, 0.0); // 1
a= !a; // El inverso de 1 es 1

cout << "\n\n";

cout << "a = ";
a.Print();
cout << endl;
cout << "c = ";
c.Print();
cout << endl;
cout << "d = ";
d.Print();
cout << endl;
}
 HERENCIA
3. Desarrollar la clase persona, estudiante y profesor, y que al ejecutar el
programa te indique las opciones a ingresar:

1. Introduccin de un alumno
2. Introduccin de un profesor
3. Mostrar datos (muestra los datos ingresados)
4. Salir(salir del programa)

Y segn la opcin elegida pide los datos que se pueden observar en la ventana
de aplicacin.

#include <iostream>
#include <conio.h>
#include <string>
using namespace std;
class Persona{
protected:
int edad;
char estado_civil;
char *nombre;
public:
Persona(int e,char ec,char *n);
virtual void Mostrar();
};

Persona::Persona(int e,char ec,char *n)

{edad=e;
estado_civil=ec;
nombre=n;
}

void Persona::Mostrar()
{cout<<"Edad= "<<edad<<"\nEstado civil= "<<estado_civil<<"\nNombre=
"<<nombre;

class Alumno:public Persona {

private:
int curso;
int num_asignaturas;
public: Alumno(int e,char ec,char n[10],int c,int na);
void Mostrar();
};

Alumno::Alumno(int e,char ec,char n[10],int c,int na):Persona(e,ec,n)

{curso=c;
num_asignaturas=na;
}

void Alumno::Mostrar()
{Persona::Mostrar();
cout<<"\nCurso= "<<curso<<"\nNumero de asignaturas=
"<<num_asignaturas<<endl;
}

class Profesor:public Persona{

private: char *departamento; // tambin se puede hacer con char*
char *adscripcion;
public: Profesor(int e,char ec,char n[10],char d[10],char *a);
void Mostrar();
};
Profesor::Profesor(int e,char ec,char n[10],char d[10],char *a):Persona(e,ec,n)
{departamento=d;
adscripcion=a;
}

void Profesor::Mostrar()
{Persona::Mostrar();
cout<<"\nDepartamento= "<<departamento<<"\nAdscripcion=
"<<adscripcion<<endl;
}

int main()
{Persona *datos[50];
int op,p=0,e,c,na,i;
char ec;
char n[10],d[10],a[10];
do {
cout<<"\n1. Introduccion de un alumno \n";
cout<<"2. Introduccion de un profesor\n";
cout<<"3. Mostrar datos \n";
cout<<"4. Salir\n";
cout<<"Introduce opcion: ";
cin>>op;
if (op<1 || op>4)
cout<<"Opcion incorrecta\n";
else
switch (op)
{
case 1:if (p<50)
{cout<<"Introduce la edad: "; cin>>e;
cout<<"Introduce el estado civil (C=casado, S=Soltero, O=Otros: ";
cin>>ec;
cout<<"Introduce el nombre: "; cin>>n;
cout<<"Introduce el curso: ";cin>>c;
cout<<"Introduce el nmero de asignaturas: ";
cin>>na;
datos[p]=new Alumno(e,ec,n,c,na); p++;
}
else cout<<"\nNo se pueden introducir mas datos\n";
break;
case 2:if (p<50)
{cout<<"Introduce la edad: ";
cin>>e;
cout<<"Introduce el estado civil (C=casado, S=Soltero, O=Otros: ";
cin>>ec;
cout<<"Introduce el nombre: ";
 cin>>n;
cout<<"Introduce el departamento: ";
cin>>d;
cout<<"Introduce la adscripcion: ";
cin>>a;
datos[p]=new Profesor(e,ec,n,d,a); p++;
}
else cout<<"\nNo se pueden introducir mas datos\n";
break;
case 3: cout<<"\nDatos\n";
for (i=0;i<p;i++)
{
datos[i]->Mostrar();
if ((i%3==0) && (i!=0))
{ cout<<"\nPulsa una tecla para continuar";
getch();cout<<endl;}
}
cout<<"\nPulsa una tecla para continuar";getch();cout<<endl;
break;
case 4:for (i=0;i<p;i++) delete datos[i];
}

}while (op!=4);

4. Ejercicio de clases aplicando herencia y Funciones virtuales

#include <iostream>
#include <math.h>
#include <conio.h>
using namespace std;
class Punto
{
private:
double x , y ;
public:
Punto ( ) ;
Punto ( double a , double b ) ;
~Punto() ;
void trasladar ( double a , double b ) ; //incrementa las coordenadas del punto
double distancia ( Punto pto ) ; // devuelve la distancia entre este punto y el
argumento pto
void ponX( double _x) ;
void ponY( double _y) ;
double dameX() ;
double dameY() ;
virtual double area() { return( 0);}
virtual double perimetro() { return( 0);}
};
Punto::Punto( )
{
x=y=0;
}
Punto::Punto( double a , double b )
{
x=a;
y=b;
}
Punto::~Punto()
{
}
void Punto::trasladar ( double a , double b )
{
x += a ;
y += b ;
}
double Punto::distancia( Punto pto )
{
return( sqrt( pow( x - pto.x, 2) + pow( y - pto.y, 2))) ;
}
void Punto::ponX( double _x)
{
x = _x ;
}
void Punto::ponY( double _y)
{
y = _y ;
}
double Punto::dameX( )
{
return x;
}
double Punto::dameY( )
{
return y;
}
class Rectangulo: public Punto
{
private:
double lh, lv ;
public:
Rectangulo ( ) ;
Rectangulo( Punto p, double _lh, double _lv) ;
~Rectangulo() ;
void ponLH( double _lh) ;
void ponLV( double _lv) ;
double dameLH( ) ;
double dameLV( ) ;
virtual double area() ;
virtual double perimetro() ;
};
Rectangulo::Rectangulo ( ): Punto()
{
lv = 10 ;
lh = 10 ;
}

Rectangulo::Rectangulo( Punto p, double _lh, double _lv): Punto( p)

{
lh = _lh ;
lv = _lv ;
}

Rectangulo::~Rectangulo()
{
}
void Rectangulo::ponLH( double _lh)
{
lh = _lh ;
}
void Rectangulo::ponLV( double _lv)
{
lv = _lv ;
}
double Rectangulo::dameLH( )
{
return( lh) ;
}
double Rectangulo::dameLV( )
{
return( lv) ;
}
double Rectangulo::area()
{
return( lh * lv) ;
}
double Rectangulo::perimetro()
{
return( 2 * lh + 2 * lv) ;
}
class Circulo: public Punto
{
private:
double radio ;

public:
Circulo ( ) ;
Circulo( Punto p, double r) ;
~Circulo() ;
void ponRadio( double _r) ;
double dameRadio( ) ;
virtual double area() ;
virtual double perimetro() ;
};
Circulo::Circulo ( ) :Punto()
{
radio = 10 ;
}
Circulo::Circulo( Punto p, double r): Punto( p)
{
radio = r ;
}
Circulo::~Circulo()
{
}
void Circulo::ponRadio( double _r)
{
radio = _r ;
}
double Circulo::dameRadio( )
{
return( radio) ;
}
double Circulo::area()
{
const double PI = 3.1514 ;
return( PI * pow( radio, 2)) ;
}
double Circulo::perimetro()
{
const double PI = 3.1514 ;
return( 2 * PI * radio) ;
}
class Cilindro: public Circulo
{
private:
double altura ;
// Constructores para inicializar las coordenadas
public:
Cilindro ( ) ;
Cilindro( Circulo c, double a) ;
~Cilindro() ;
void ponAltura( double _a) ;
double dameAltura( ) ;
virtual double area() ;
// virtual double perimetro() ; NO TIENE
};
Cilindro::Cilindro ( ): Circulo()
{
altura = 15 ;
}
Cilindro::Cilindro( Circulo c, double a): Circulo( c)
{
altura = a ;
}
Cilindro::~Cilindro()
{
}
void Cilindro::ponAltura( double _a)
{
altura = _a ;
}
double Cilindro::dameAltura( )
{
return( altura) ;
}
double Cilindro::area()
{
const double PI = 3.1514 ;
double aLateral = 2*PI * dameRadio() * altura ;
double base = Circulo::area() ;
return( aLateral + 2 * base) ;
}
int main()
{
//int argc, char* argv[];
Circulo c1 ; //= new Circulo;
Punto p1 ;
Punto *p2 ;
Cilindro ci( c1, 20) ;
p2 = new Circulo( p1, 30) ;
cout << endl << " Circulo C1" ;
cout << endl << "El centro es: ( " << c1.dameX() << ", " << c1.dameY() << ")";
cout << endl << "El radio es: " << c1.dameRadio() ;
cout << endl << "El area es: " << c1.area() ;
cout << endl << "El perimetro es: " << c1.perimetro() ;
cout << endl ;
cout << endl << " Circulo P2" ;
cout << endl << "El centro es: ( " << p2->dameX() << ", " << p2->dameY() << ")";
cout << endl << "El radio es: " << ((Circulo*)p2)->dameRadio() ;
cout << endl << "El area es: " << p2->area() ;
cout << endl << "El perimetro es: " << p2->perimetro() ;
cout << endl ;
cout << endl << " Cilindro ci" ;
cout << endl << "El centro es: ( " << ci.dameX() << ", " << ci.dameY() << ")";
cout << endl << "El radio es: " << ci.dameRadio() ;
cout << endl << "La altura es: " << ci.dameAltura() ;
cout << endl << "El area es: " << ci.area() ;
//cout << endl << "El perimetro es: " << p2->perimetro() ;
delete p2 ;
getch();

return 0;
}

FUNCIONES CON PLANTILLAS

5. Implementar el programa con el uso de funciones con plantillas de tal manera
que al introducir un nmero lmite para obtener el ordenamiento que
muestran en las ventanas de aplicacin.
 #include <iostream>
#include <valarray>
#include <conio.h>

using namespace std;

template <class T> void muestra(const valarray <T> &l)

{ int s,i;
// nmero de elementos de l
s=l.size();
for (i = 0; i<s; ++i)//Recorre y muestra el valarray
cout << l[i] << " ";
cout << endl;

}
int main() {
int n,i,v1[20];

cout<<"ingresar el numero limite";

cin>>n;
int m=0;
for(i=0;i<n;i++)
{m=m+1;
v1[i]=m;
}
valarray<int> va1(v1,n);
muestra(va1);
for (i=1;i<n;i++)
{
va1=va1.cshift(1);
muestra(va1);
}
getch();
}
6. Realizar un programa usando plantillas en el que se ingrese los elemento de un
vector, previamente obteniendo la cantidad de estos, luego se pide inserta el
elemento a remplazar por otro nmero, si se ingresa un nmero que no existe
entonces debe tener la indicacin correspondiente.
#include<iostream>
#include<stdlib.h>
using namespace std;
const int N=50;
template<class T>
void leer(T a[N],int na)
{
int i;
for(i=0;i<na;i++)
{
cout<<"ingrese elemento"<<i<<":";
cin>>a[i];

}
}
template<class T>
void mostrar( T a[N],int na)
{
int i;
for(i=0;i<na;i++)
{
cout<<a[i]<<" ";
cout<<endl<<endl;
}
}
template<class T>
int reemplazar(T a[N],int na,T x,T y)
{
int i,r;
r=0;
for(i=0;i<na;i++)
if(a[i]==x)
for(i=0;i<na;i++)
if(a[i]==x)
{
a[i]=y;
r++;
}
return r;
}
int main()
{
int ae[N];
char ac[N];
int n,nr,w,k;
cout<<"ingrese cantidad de elemtos";
cin>>n;
cout<<"arreglo de enteros"<<endl<<endl;
leer(ae,n);
 mostrar(ae,n);
cout<<"ingresar dato que ser reemplazado";
cin>>k;
cout<<"ingrese nuevo dato";
cin>>w;
nr=reemplazar(ae,n,k,w);
if(nr==0)
cout<<"no se raalizaron reemplazos"<<endl;
leer(ac,n);
mostrar(ac,n);
system("pause");
return 0;
}
7. Usando Plantillas realizar un programa que dada dos matrices A y B
intercambiar los mnimos de A con los mximos de B

#include <stdio.h>
#include <conio.h>
template<class T>
void llenar (T M[20][20], int f, int c)
{
for (int i = 1 ; i <= f ; i++)
{
for (int j = 1 ; j <= c ; j++)
{
printf ("Inserte pos[%d][%d]: ",i,j);
scanf("%d",&M[i][j]);
}
}
}
template<class T>
void mostrar (T M[20][20], int f, int c)
{
for (int i = 1 ; i <= f ; i++)
{
printf("\n");
for (int j = 1 ; j <= c ; j++)
{
printf ("[%d]",M[i][j]);
}
}
}
template<class T>
int menor (T M[20][20], int f, int c)
{
int men = M [1] [1];
for (int i = 1 ; i <= f ; i++)
{
 for (int j = 1 ; j <= c ; j++)
{
if (M [i] [j] < men)
men = M [i] [j];
}
}
return (men);
}
template<class T>
int maximo (T M[20][20], int f, int c)
{
int max = M [1] [1];
for (int i = 1 ; i <= f ; i++)
{
for (int j = 1 ; j <= c ; j++)
{
if (M [i] [j] > max)
max = M [i] [j];
}
}
return (max);
}
template<class T>
void intercambiar (T A[20][20], int fa, int ca, T B[20][20], int fb, int cb)
{
int min_a = menor (A, fa, ca);
int max_b = maximo (B, fb, cb);
//para cambiar los minimos de A con los maximos de B
for (int i = 1 ; i <= fa ; i++)
{
for (int j = 1 ; j <= ca ; j++)
{
if (A[i][j] == min_a)
A[i][j]=max_b;
}
}
//para intercambiar los maximos de con los minimos de A
for (int i = 1 ; i <= fb ; i++)
{
for (int j = 1 ; j <= cb ; j++)
{
if (B[i][j] == max_b)
B[i][j]=min_a;
}
}
}
ARCHIVOS DE TEXTO
8. Realizar un programa con archivo que pida ingresar el nombre del archivo a
crear, se pueda ingresar dos nmeros y adems en el archivo guarde las
operaciones bsicas y verificar si el nmero obtenido en cada operacin es
primo o no.
SOLUCIN:
#include<iostream>
#include<fstream>
#include<conio.h>

using namespace std;

void esprimo(ofstream &curso,int suma);

int main()
{ char Texto[15];
int a, b, suma,resta,div,k,i;
cout<<"Ingrese el nombre del archivo ";
cin>>Texto;

ofstream curso;

curso.open(Texto);
if (curso.fail())
{
cerr<<"No se puede abrir"<<endl;
cout<<"verifique si exite"<<endl;
getch();
exit(1);
}
curso<<"Algoritmos y Programacion ";
cout<<"Ingrese dos numeros";
cin>>a>>b;

suma = a + b;
resta= a - b;
if(b!=0)
div=a/b;
else
curso<<"no existe";

curso<<"la suma es "<<suma<<endl;

curso<<"la resta es "<<resta<<endl;
curso<<"la division es "<<div<<endl;
curso<<"la suma\t";
esprimo(curso,suma);
curso<<"la resta\t";
esprimo(curso,resta);
curso<<"la divisin\t";
 esprimo(curso,div);

cout<<"El archivo se abrio con exito "<<endl;

getch();
return 0;
}
void esprimo(ofstream &curso,int num)
{
int k=0;
for(int i=2;i<num;i++)
if(num%i!=0)
k++;
if(k>1||num==1)
curso<<"no es primo"<<endl;
else

curso<<"es un numero primo"<<endl;

}
9. Realizar un programa el que abra un archivo datos, en el que se almacenar
datos de una cantidad de alumnos , cdigo, nota de examen parcial y final,
promedio de prcticas y laboratorio, y segn su promedio debe mostrar si est
aprobado o no, luego se puede buscar un alumno por cdigo y mostrar si est
registrado

#include <fstream>
#include <iostream>
#include <stdlib.h>
#include <iomanip>
using namespace std;
const int N=80;
struct alumno
{
char cod[10],obs[15];
int ep,ef,pp,pl;
float pf;

};
void leer(ofstream &f1,alumno x[],int n)
{f1.open("datos.txt");
if(f1.fail())
cout<<"erro";
else
{
for(int i=0;i<n;i++)
{
cout<<"procesando datos del alumno"<<i+1<<endl;
 fflush(stdin);
cout<<"codigo";gets(x[i].cod);
cout<<"examen parcial";cin>>x[i].ep;
cout<<"examenfinal";cin>>x[i].ef;
cout<<"prom pract";cin>>x[i].pp;
cout<<"prom lab";cin>>x[i].pl;
x[i].pf=(x[i].ep+x[i].ef+x[i].pp+x[i].pl)/4;
if(x[i].pf>10)
strcpy(x[i].obs,"aprobado");
else
strcpy(x[i].obs,"desaprobado");

f1<<x[i].cod<<"\t"<<x[i].ep<<"\t"<<x[i].ef<<"\t"<<x[i].pp<<"\t"<<x[i].pl<<"\t"<<
x[i].pl<<"\t"<<x[i].pf<<"\t"<<x[i].obs<<endl;
}
}
f1.close();
}
void mostrar(ifstream &f2)
{
char c1[10],ob[15];
int ep1,ef1,pp1,pl1;
float pf1;
f2.open("notas,txt");
f2>>c1;
while(f2.peek()!=EOF)
{
f2>>ep1>>ef1>>pp1>>pl1>>pf1>>ob;

cout<<c1<<"\t"<<ep1<<"\t"<<ef1<<"\t"<<pp1<<"\t"<<pl1<<"\t"<<pf1<<"\t"<<o
b<<endl;
f2>>c1;

}
f2.close();
}
void buscar(ifstream &f3)
{
char c1[10],ob[15],mcod[15];
int ep1,ef1,pp1,pl1;
bool t=false;
float pf1;
cout<<"ingrese codigo a buscar";gets(mcod);
f3.open("notas.txt");
f3>>c1;
if(f3.fail())
cout<<"erro";
 else
{
while(f3.eof()==false&&(t==false))
{
f3>>ep1>>ef1>>pp1>>pl1>>pf1>>ob;
if(strcmp(c1,mcod)==0)

{cout<<c1<<"\t"<<ep1<<"\t"<<ef1<<"\t"<<pp1<<"\t"<<pl1<<"\t"<<pf1<<"\t"<<
ob<<endl;
t=true;
}
}
f3.close();
if(!t)
cout<<"alumno no resgistrado"<<endl;
}
}
int main()
{
alumno a[N];
int m;
cout<<"nmero de alumnos a procesar";
cin>>m;
ofstream arch;
ifstream arch1,arch2;
leer(arch,a,m);
mostrar(arch1);
buscar(arch2);
system("pause");
return 0;
}

ARCHIVOS BINARIOS

10. Escribir un programa que abra el archivo (archivos binarios) acta de notas,en el
que se pueda almacenar una cierta cantidad de alumnos, lo que se guardaran
con su cdigo y su promedio ponderado.( Escribir objetos a un archivo binario
reinterpret_cast<char *> )
#include <fstream>
#include <string.h>
#include <stdio.h>
#include <conio.h>
#include <iostream>
const int MAX = 50;
using namespace std;
 struct alumno {
char codigo[10];
char nombre[40];
float promedio;
} acta_notas[MAX];
int main()
{
ofstream salida("acta.dat", ios::out | ios::binary);
int num;
cout<<"Cuantos alunmos desea incluir en el acta? ";
cin>>num; fflush(stdin);

char cod[10], nom[40];

float prom;
// escribiendo al archivo
for (int i = 0; i < num; i++)
{ cout<<"Ingrese codigo: "; gets(cod); fflush(stdin);
strcpy(acta_notas[i].codigo, cod); fflush(stdin);
cout<<"Ingrese apellidos y nombres: "; gets(nom);
strcpy(acta_notas[i].nombre, nom); fflush(stdin);
cout<<"Ingrese promedio ponderado: "; cin>>prom;
fflush(stdin);
acta_notas[i].promedio = prom;
salida.write(reinterpret_cast<char*>(&acta_notas[i]),sizeof(alumno));
fflush(stdin);
}
cout<<"Fin de la entrada de datos!...";
salida.close();
getche();
return 0;
}

11. Escribir y leer un arreglo de float en binario .

#include <fstream>
#include <iostream>
#include <conio.h>
/* Escribir y leer un arreglo de float en binario */
using namespace std;
int main() //binario1.cpp
{ float nums[]={10.25, 25.333, 14.0, 3.1415, 0.08025,7.0};
int i;
// escribiendo al archivo
ofstream salida("array.dat", ios::out | ios::binary);
if (!salida)
{ cout << "No se puede abrir archivo!..."<<endl;
exit(1);
 }
salida.write(( char*) &nums, sizeof nums);
salida.close();
// Mostrar el contenido de3l archivo
for (i = 0; i < sizeof(nums)/sizeof(float); i++)
nums[i] = 0;
// leyendo el archivo
ifstream entrada("array.dat", ios::in | ios::binary);
entrada.read(( char *) &nums, sizeof nums);
for (i = 0; i < sizeof(nums)/sizeof(float); i++)
cout << nums[i] <<" ";
// cerrar archivo
entrada.close();
getche();
return 0;
}

CLASES VIRTUALES
//Ej14_03.cpp

// Programa que realiza un vector seguro de cualquier tipo

#include <iostream>
using namespace std;

template <class tipo>

class vector {
private:
static tipo ERROR;
static tipo Seguro; // Reservamos esta posicin por seguridad
// para el mtodo []

tipo * v;
int Tam;

void Construir(int t) {
Tam= t;
if (Tam)
v= new tipo[Tam];
else
v= NULL;
}

void Construir_Copia(const vector & Origen) {

Construir(Origen.Tam);
for(int i= 0; i < Tam; i++)
 v[i]= Origen.v[i];
}

void Destruir() {
if (v != NULL) delete []v;
}

public:
static void Poner_Error(tipo i) {
ERROR= i;
}

vector(int t= 0) {
Construir(t);
}

vector(const tipo * p, int t) {

Construir(t);
for(int i= 0; i < Tam; i++)
v[i]= p[i];
}

vector(const vector & s) {

Construir_Copia(s);
}

~vector() {
Destruir();
}

tipo & operator [] (int );

const vector & operator = (const vector & Origen) {

Destruir();
Construir_Copia(Origen);
return *this;
}

operator const tipo * () const { // Convierte a puntero

return v;
}
};

template <class tipo>

tipo vector<tipo>::ERROR;
template <class tipo>
tipo vector<tipo>::Seguro;
template <class tipo>
inline tipo & vector<tipo>::operator [] (int i) {
if ((i < Tam) && (i >= 0))
return v[i];
else {
cout << endl << "Exceso de los lmites del vector al "
"acceder al elemento " << i
<< " de un vector de longitud " << Tam << endl;
return Seguro= ERROR;
}
}

int main() {
vector<int>::Poner_Error(-1);
vector<int> v(10);
int i, Elem;

i= 1;
v[i]= 2;
Elem= v[i];
cout << Elem; // 2, lgicamente
v[1000]= 3;
system("pause");
}
POLIMORFISMO