borland/turbo C++

Jamás olvidare los programas que hize en tercer semestre.

Estos son algunos de los programas que se entregaron a la profesora, me hubiera gustado arreglarlos antes de publicarlos… bueno, ya los arreglara alguien mas.

lista doblemente ligada circular

#include <iostream.h>
#include <conio.h>
class nodo
{
public:
nodo(int v, nodo *sig=0, nodo *ant=0):valor(v), siguiente(sig), anterior(ant){}
private:
int valor;
nodo *siguiente;
nodo *anterior;
friend class lista;
};
typedef nodo *pnodo;
class lista
{
public:
lista():plista(0){}
~lista();
void Insertar(int v);
int ListaVacia(){return plista==0;}
void Mostrar();
void Borrar(int v);
private:
pnodo plista;
};
lista::~lista()
{
pnodo aux;
do
{
aux=plista;
plista=plista->siguiente;
delete aux;
}
while(!plista);
}
void lista::Insertar(int v)
{
pnodo Nodo;
if (ListaVacia())
{
Nodo=new nodo(v);
plista=Nodo;
plista->anterior=Nodo;
}
else
{
Nodo=new nodo(v, plista->siguiente, plista);
plista->siguiente->anterior=Nodo;
}
plista->siguiente=Nodo;
}
void lista::Borrar(int v)
{
pnodo nodo;
nodo=plista;
if(nodo)
do
{
nodo=nodo->siguiente;
}
while(nodo->valor != v && nodo != plista);
if(!nodo || nodo->valor != v )
{
cout<<”Valor “<<v<<” no hallado!!!”<<endl;return;
}
else
{
nodo->anterior->siguiente=nodo->siguiente;
nodo->siguiente->anterior=nodo->anterior;
delete nodo;
}
}

void lista::Mostrar(void)
{
pnodo nodo;
nodo=plista;
do
{
cout << nodo->valor<<” -> “;
nodo=nodo->siguiente;
}
while(nodo != plista);
cout << endl;
nodo=plista;
do
{
cout << nodo->valor << ” -> “;
nodo=nodo->anterior;
}
while(nodo != plista);
cout << endl;
}
int main ()
{
lista Lista;
clrscr();
Lista.Insertar(20);
Lista.Insertar(10);
Lista.Insertar(40);
Lista.Insertar(30);
Lista.Insertar(50);
Lista.Insertar(60);
Lista.Mostrar();
Lista.Borrar(30);
Lista.Mostrar();
cin.get();
return 0;
}

lista doblemente ligada con contador

#include <iostream.h>
#include <conio.h>
#define ASCENDENTE 1
#define DESCENDENTE 0

class nodo{
public:
nodo(int v, nodo *sig=0, nodo *ant=0,int c=1):
valor(v), siguiente(sig),anterior(ant),contador(c){}
private:
int valor;
int contador;
nodo *siguiente;
nodo *anterior;
friend class lista;
};

typedef nodo *pnodo;

class lista{
public:
lista():plista(0){}//plista=NULL
~lista();
void Insertar(int v);
void Borrar(int v);
int ListaVacia(){return plista==0;}
void Mostrar(int);
void Siguiente();
void Anterior();
void Primero();
void Ultimo();
int Actual(){return plista!=0;}
int ValorActual(){return plista->valor;}
private:
pnodo plista;
};

lista::~lista()
{
pnodo aux;
Primero();
while(plista)
{
aux=plista;
plista=plista->siguiente;
delete aux;
}
}

void lista::Insertar(int v)
{
pnodo nuevo;
int contador=1;
Primero();

if(ListaVacia() || plista->valor > v)
{
nuevo=new nodo(v,plista);
if(!plista){
plista=nuevo;
nuevo->contador=1;}
else
plista->anterior=nuevo;
}
else
{
while(plista->siguiente && plista->siguiente->valor < v)
Siguiente();
if(plista->siguiente && plista->siguiente->valor == v)
plista->siguiente->contador=plista->siguiente->contador+1;
else
if(plista->valor == v)
plista->contador=plista->contador+1;
else
{
nuevo=new nodo(v,plista->siguiente,plista);
plista->siguiente=nuevo;
nuevo->contador=1;
if(nuevo->siguiente)
nuevo->siguiente->anterior=nuevo;
}
}

}

void lista::Borrar(int v)
{
pnodo nodo;
nodo=plista;
while(nodo && nodo->valor < v)
nodo=nodo->siguiente;
while(nodo && nodo->valor > v)
nodo=nodo->anterior;
if(!nodo || nodo->valor != v)
{
cout<<”Valor “<<v<<” no hallado!!!”<<endl;return;
}
if(nodo->contador == 1)
{

if(nodo->anterior)
nodo->anterior->siguiente=nodo->siguiente;
if(nodo->siguiente)
nodo->siguiente->anterior=nodo->anterior;
if(nodo == plista)
{
if(plista->siguiente)
plista=plista->siguiente;
else
if(plista->anterior)
plista=plista->anterior;
else
plista=0;
delete nodo;
}
}
if(nodo && nodo->contador>1)
nodo->contador=nodo->contador-1;

}

void lista::Mostrar(int orden)
{

pnodo nodo;
if(orden == ASCENDENTE)
{
Primero();
nodo=plista;
while(nodo)
{
cout<<nodo->valor<<”(“<<nodo->contador<<”)”<<”->”;
nodo=nodo->siguiente;
}
}
else
{
Ultimo();
nodo=plista;
while(nodo)
{
cout<<nodo->valor<<”(“<<nodo->contador<<”)”<<”->”;
nodo=nodo->anterior;
}
}
cout<<endl;
}

void lista::Siguiente()
{
if(plista && plista->siguiente)
plista=plista->siguiente;
}

void lista::Anterior()
{
if(plista && plista->anterior)
plista=plista->anterior;
}

void lista::Primero()
{
while(plista && plista->anterior)
plista=plista->anterior;
}

void lista::Ultimo()
{
while(plista && plista->siguiente)
plista=plista->siguiente;
}

int main()
{
lista Lista;
// clrscr();
Lista.Insertar(10);
Lista.Insertar(20);
Lista.Insertar(60);
Lista.Insertar(20);
Lista.Insertar(10);
Lista.Insertar(50);
Lista.Insertar(50);
Lista.Insertar(60);
Lista.Mostrar(ASCENDENTE);
Lista.Mostrar(DESCENDENTE);
Lista.Primero();
cout<<”Primero : “<<Lista.ValorActual()<<endl;
Lista.Ultimo();
cout<<”Ultimo : “<<Lista.ValorActual()<<endl;
Lista.Borrar(20);
Lista.Borrar(10);
Lista.Borrar(15);
Lista.Borrar(45);
Lista.Borrar(50);
Lista.Borrar(40);
Lista.Mostrar(ASCENDENTE);
Lista.Mostrar(DESCENDENTE);
cin.get();
return 0;
}

lista de numeros simplemente ligada que ordena de mayor a menor

#include <iostream.h>
class nodo
{
public:
nodo(int v, nodo *sig = NULL)
{
valor = v;
siguiente = sig;
};
private:
int valor;
nodo *siguiente;
friend class lista;
};
typedef nodo *pnodo;

class lista
{
public:
lista(){actual=NULL;};
~lista();
void Insertar(int v);
void Borrar(int v);
int ListaVacia(){return actual==NULL;};
void Mostrar();
void Siguente();
void Primero(){actual=primero;};
int Actual(){ return actual != NULL;};
int ValorActual(){return actual->valor;};
private:
pnodo actual;
pnodo primero;
};

lista::~lista()
{
pnodo nodo;
while (actual->siguiente != actual)
{
nodo = actual->siguiente;
actual->siguiente = nodo->siguiente;
delete nodo;
}
delete actual;
actual = NULL;
}
void lista::Insertar(int v)
{
pnodo Nodo;
Nodo = new nodo (v);
if(actual == NULL)
{
actual = Nodo;
actual->siguiente=Nodo;
}
if(actual != NULL)
{
Nodo->siguiente=actual->siguiente;
actual->siguiente=Nodo;
//       Nodo->valor=v;
do{
if(Nodo->valor > Nodo->siguiente->valor)
{
actual->siguiente=Nodo->siguiente;
actual=actual->siguiente;
Nodo->siguiente=actual->siguiente;
actual->siguiente=Nodo;
if(Nodo->siguiente->valor < actual->valor)
actual=actual->siguiente;
}
else
actual=actual->siguiente;
}while (actual->valor < actual->siguiente->valor);
}
}
void lista::Borrar(int v)
{
pnodo nodo;
nodo = actual;
do
{
if(actual->siguiente->valor != v)
actual = actual->siguiente;
}
while(actual->siguiente->valor != v && actual != nodo);
if(actual->siguiente->valor == v)
{
if (actual == actual->siguiente)
{
delete actual;
actual = NULL;
}
else
{
nodo = actual->siguiente;
actual->siguiente = nodo->siguiente;
delete nodo;
}
}
}
void lista::Mostrar()
{
actual=actual->siguiente;
pnodo nodo;
nodo = actual;
do
{
cout<<nodo->valor << “->”;
nodo = nodo->siguiente;
}
while(nodo != actual);
cout<<endl;
}
void lista::Siguente()
{
if (actual)
actual=actual->siguiente;
}

int main()
{
lista Lista;
Lista.Insertar(20);
Lista.Insertar(10);
Lista.Insertar(40);
Lista.Insertar(30);
Lista.Insertar(60);
Lista.Mostrar();
cout<<”Lista de elementos:”<<endl;
Lista.Borrar(10);
Lista.Borrar(30);
Lista.Mostrar();
cin.get();
return 0;
}

lista de numeros simplemente ligada con apuntadores (circular). muestra el primer y ultimo numero

#include <iostream.h>
class nodo
{
public:
nodo(int v, nodo *sig=NULL)
{
valor=v;
siguiente=sig;
}
private:
int valor;
nodo *siguiente;
friend class lista;
};
typedef nodo *pnodo;
class lista{
public:
lista(){primero=actual=NULL;}
~lista();
void Insertar(int v);
void Borrar(int v);
int ListaVacia(){return primero == NULL;}
void Mostrar();
void Siguiente(){if(actual)actual=actual->siguiente;}
void Primero(){actual=primero;}
void Ultimo(){Primero();if(!ListaVacia())while(actual->siguiente)Siguiente();}
int Actual(){return actual != NULL;}
int ValorActual(){return actual->valor;}
private:
pnodo primero;
pnodo actual;
};
lista::~lista()
{
pnodo aux;
while(primero)
{
aux=primero;
primero=primero->siguiente;
delete aux;
}
actual=NULL;
}
void lista::Insertar(int v)
{
pnodo anterior;
if(ListaVacia() || primero->valor >v)
{
primero=new nodo(v,primero);
}
else
{
anterior=primero;
while(anterior->siguiente && anterior->siguiente->valor <=v)
anterior=anterior->siguiente;
anterior->siguiente= new nodo(v,anterior->siguiente);
}
}
void lista::Borrar(int v)
{
pnodo anterior, nodo;
nodo=primero;
anterior=NULL;
while(nodo && nodo->valor <v)
{
anterior=nodo;
nodo=nodo->siguiente;
}
if(!nodo || nodo->valor !=v)
{
cout<<”El dato no se encuentra!!!”<<endl;
return;
}
else
{
if(!anterior)
primero=nodo->siguiente;
else
anterior->siguiente=nodo->siguiente,
delete nodo;
}
}
void lista::Mostrar()
{
pnodo aux;
aux=primero;
while(aux){
cout<<aux->valor<<”->”;//Aqui se midifica para los incrementos o decrementos del valor
aux=aux->siguiente;
}
cout<<endl;
}

void main()
{
lista Lista;
Lista.Insertar(20);
Lista.Insertar(10);
Lista.Insertar(40);
Lista.Insertar(30);
Lista.Mostrar();
cout<<”Lista de elementos:”<<endl;
Lista.Primero();
while(Lista.Actual())
{
cout<<Lista.ValorActual()<<endl;
Lista.Siguiente();
}
Lista.Primero();
cout<<”Primero: “<<Lista.ValorActual()<<endl;
Lista.Ultimo();
cout<<”Ultimo: “<<Lista.ValorActual()<<endl;
Lista.Borrar(10);
Lista.Borrar(15);
Lista.Borrar(45);
Lista.Borrar(30);
Lista.Borrar(40);
Lista.Mostrar();
cin.get();
}

generador de curp

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

class curp
{
private:
char res[15];
char *ap, *ap1;
char apellidop[15];
char apellidom[15];
char nombre1[15];
char sex[2];
char ano[2];
char mes[2];
char dia[2];
char lugar[2];
public:
//inicializar la cadena res[]
curp(){ap=ap1=NULL;}
obtenerdatos();
generarcurp();
imprimirdatos();
};
curp::obtenerdatos()
{
cout<<”\nIntroduzca su primer apellido: “;
cin>>apellidop;
cout<<”\nIntroduzca su segundo apellido”<<endl;
cout<<”Si no tiene segundo apellido escriba XX: “;
cin>>apellidom;
cout<<”\nIntroduzca su primer nombre: “;
cin>>nombre1;
cout<<”\nPresione 1 si se llama Maria o Jose y tiene un segundo nombre,”<<endl<<”2 si no es el caso “;
int a;
cin>>a;
switch(a)
{
case 1:
{
cout<<”\nIntroduzca su 2ndo nombre: “;
cin>>nombre1;
break;
}
case 2:
{
cout<<”\nprosiguiendo…”;
break;
}
default:
{
cout<<”\n\n Opcion incorrecta, terminando programa…”;
getch();
abort ();
break;
}
}
cout<<”\nIntroduzca los dos ultimos numeros de su año de nacimiento: “;
cin>>ano;
cout<<”\nIntroduzca el numero del mes de nacimiento(dos cifras): “<<endl;
cout<<”01 = Enero”<<endl;
cout<<”02 = Febrero”<<endl;
cout<<”03 = Marzo”<<endl;
cout<<”04 = Abril”<<endl;
cout<<”05 = Mayo”<<endl;
cout<<”06 = Junio”<<endl;
cout<<”07 = Julio”<<endl;
cout<<”08 = Agosto”<<endl;
cout<<”09 = Septiembre”<<endl;
cout<<”10 = Octubre”<<endl;
cout<<”11 = Noviembre”<<endl;
cout<<”12 = Diciembre”<<endl;
cin>>mes;
if(mes[0]>49)
{
cout<<”\n\n Ha intgresado mal el dato!!!”;
getch();
abort ();
}
cout<<”\nIntroduzca su dia de nacimiento (dos cifras): “;
cin>>dia;
if (dia[0]>51)
{
cout<<”\n\nEsa fecha no existe”;
getch();
abort ();
}
cout<<”\nIntroduzca su sexo: H = Hombre, M = Mujer ” ;
cin>>sex;
if (sex[0]!=72 && sex[0]!=77 && sex[0]!= 104 && sex[0]!=109)
{
cout<<”\n\nOpcion no valida”;
getch();
abort ();
}
};
curp::generarcurp()
{
curp resultado(curp& res);
ap1=res;
ap=apellidop;
*ap1=*ap;
ap1++;
ap++;
//problemas con while, cilco con if
if(*ap==65||*ap==69||*ap==73||*ap==79||*ap==85||*ap==97||*ap==101||*ap==105||*ap==111||*ap==117)
*ap1=*ap;
else
ap++;
if(*ap==65||*ap==69||*ap==73||*ap==79||*ap==85||*ap==97||*ap==101||*ap==105||*ap==111||*ap==117)
*ap1=*ap;
else
ap++;
if(*ap==65||*ap==69||*ap==73||*ap==79||*ap==85||*ap==97||*ap==101||*ap==105||*ap==111||*ap==117)
*ap1=*ap;
ap1++;
ap=apellidom;
*ap1=*ap;
ap1++;
ap=nombre1;
*ap1=*ap;
ap1++;
ap=ano;
*ap1=*ap;
ap1++;ap++;
*ap1=*ap;
ap1++;
ap=mes;
*ap1=*ap;
ap1++;ap++;
*ap1=*ap;
ap1++;
ap=dia;
*ap1=*ap;
ap1++;
ap++;
*ap1=*ap;
ap1++;
ap=sex;
*ap1=*ap;
ap1++;
int b;
cout<<”\nIngrese la clave de la izquierda correspondiente al lugar de nacimiento”<<endl;
cout<<”1 – Aguascalientes”<<”\t17 – Morelos”<<endl;
cout<<”2 – Baja California”<<”\t18 – Nayarit”<<endl;
cout<<”3 – Baja California Sur”<<”\t19 – Nuevo Leon”<<endl;
cout<<”4 – Campeche”<<”\t\t20 – Oaxaca”<<endl;
cout<<”5 – Chiapas”<<”\t\t21 – Puebla”<<endl;
cout<<”6 – Chihuahua”<<”\t\t22 – Queretaro”<<endl;
cout<<”7 – Coahuila”<<”\t\t23 – Quintana Roo”<<endl;
cout<<”8 – Colima”<<”\t\t24 – San Luis Potosi”<<endl;
cout<<”9 – Distrito Federal”<<”\t25 – Sinaloa”<<endl;
cout<<”10 – Durango”<<”\t\t26 – Sonora”<<endl;
cout<<”11 – Guanajuato”<<”\t\t27 – Tabasco”<<endl;
cout<<”12 – Guerrero”<<”\t\t28 – Tamaulipas”<<endl;
cout<<”13 – Hidalgo”<<”\t\t29 – Tlaxcala”<<endl;
cout<<”14 – Jalisco”<<”\t\t30 – Veracruz”<<endl;
cout<<”15 – Mexico”<<”\t\t31 – Yucatan”<<endl;
cout<<”16 – Michoacan”<<”\t\t32 – Zacatecas”<<endl;
cout<<”33 – Extranjero”<<endl;
cin>>b;
switch(b)
{
case 1:
{
*ap1=65;
ap1++;
*ap1=83;
break;
}
case 2:
{
*ap1=66;
ap1++;
*ap1=67;
break;
}
case 3:
{
*ap1=66;
ap1++;
*ap1=83;
break;
}
case 4:
{
*ap1=67;
ap1++;
*ap1=67;
break;
}
case 5:
{
*ap1=67;
ap1++;
*ap1=83;
break;
}
case 6:
{
*ap1=67;
ap1++;
*ap1=72;
break;
}
case 7:
{
*ap1=67;
ap1++;
*ap1=76;
break;
}
case 8:
{
*ap1=67;
ap1++;
*ap1=77;
break;
}
case 9:
{
*ap1=68;
ap1++;
*ap1=70;
break;
}
case 10:
{
*ap1=68;
ap1++;
*ap1=71;
break;
}
case 11:
{
*ap1=71;
ap1++;
*ap1=84;
break;
}
case 12:
{
*ap1=71;
ap1++;
*ap1=82;
break;
}
case 13:
{
*ap1=72;
ap1++;
*ap1=71;
break;
}
case 14:
{
*ap1=74;
ap1++;
*ap1=67;
break;
}
case 15:
{
*ap1=77;
ap1++;
*ap1=67;
break;
}
case 16:
{
*ap1=77;
ap1++;
*ap1=78;
break;
}
case 17:
{
*ap1=77;
ap1++;
*ap1=86;
break;
}
case 18:
{
*ap1=78;
ap1++;
*ap1=84;
break;
}
case 19:
{
*ap1=78;
ap1++;
*ap1=76;
break;
}
case 20:
{
*ap1=79;
ap1++;
*ap1=67;
break;
}
case 21:
{
*ap1=80;
ap1++;
*ap1=76;
break;
}
case 22:
{
*ap1=81;
ap1++;
*ap1=84;
break;
}
case 23:
{
*ap1=81;
ap1++;
*ap1=82;
break;
}
case 24:
{
*ap1=83;
ap1++;
*ap1=80;
break;
}
case 25:
{
*ap1=83;
ap1++;
*ap1=76;
break;
}
case 26:
{
*ap1=83;
ap1++;
*ap1=82;
break;
}
case 27:
{
*ap1=84;
ap1++;
*ap1=67;
break;
}
case 28:
{
*ap1=84;
ap1++;
*ap1=83;
break;
}
case 29:
{
*ap1=84;
ap1++;
*ap1=76;
break;
}
case 30:
{
*ap1=86;
ap1++;
*ap1=90;
break;
}
case 31:
{
*ap1=89;
ap1++;
*ap1=78;
break;
}
case 32:
{
*ap1=90;
ap1++;
*ap1=83;
break;
}
case 33:
{
*ap1=78;
ap1++;
*ap1=69;
break;
}

default:
{
cout<<”\n\n Ha intgresado mal el dato!!!”;
getch();
abort ();
break;
}
};
//ciclos con if
ap1++;
ap=apellidop;
ap++;
if(*ap==65||*ap==69||*ap==73||*ap==79||*ap==85||*ap==97||*ap==101||*ap==105||*ap==111||*ap==117)
{
ap++;
if(*ap==65||*ap==69||*ap==73||*ap==79||*ap==85||*ap==97||*ap==101||*ap==105||*ap==111||*ap==117)
ap++;
if(*ap!=65||*ap!=69||*ap!=73||*ap!=79||*ap!=85||*ap!=97||*ap!=101||*ap!=105||*ap!=111||*ap!=117)
*ap1=*ap;
else
*ap1=*ap;
}
else
*ap1=*ap;
ap1++;
ap=apellidom;
ap++;
if(*ap==65||*ap==69||*ap==73||*ap==79||*ap==85||*ap==97||*ap==101||*ap==105||*ap==111||*ap==117)
{
ap++;
if(*ap==65||*ap==69||*ap==73||*ap==79||*ap==85||*ap==97||*ap==101||*ap==105||*ap==111||*ap==117)
ap++;
if(*ap!=65||*ap!=69||*ap!=73||*ap!=79||*ap!=85||*ap!=97||*ap!=101||*ap!=105||*ap!=111||*ap!=117)
*ap1=*ap;
else
*ap1=*ap;
}
else
*ap1=*ap;
ap1++;
ap=nombre1;
ap++;
if(*ap==65||*ap==69||*ap==73||*ap==79||*ap==85||*ap==97||*ap==101||*ap==105||*ap==111||*ap==117)
{
ap++;
if(*ap==65||*ap==69||*ap==73||*ap==79||*ap==85||*ap==97||*ap==101||*ap==105||*ap==111||*ap==117)
ap++;
if(*ap!=65||*ap!=69||*ap!=73||*ap!=79||*ap!=85||*ap!=97||*ap!=101||*ap!=105||*ap!=111||*ap!=117)
*ap1=*ap;
else
*ap1=*ap;
}
else
*ap1=*ap;
ap1++;
*ap1=0;
}
curp::imprimirdatos()
{
cout<<endl<<”\t”<<res<<”03″;
getch();
}

void main(void)
{
cout<<” Generador de curp”<<endl;
curp a;
a.obtenerdatos();
a.generarcurp();
cout<<” La curp es:”<<endl;
a.imprimirdatos();
}

sobrecarga de operadores para calcular el promedio de 6 materias

#include <iostream.h>
#include <conio.h>
#include <string.h>
#include <iomanip.h>

struct alumno
{
char nombre[30];
long boleta;
int semestre;
float promedio;
float calificacion[6];
};
class grupo
{
private:
alumno a,*pa;
public:
grupo(float m=0, char* n=”Juanito”,long b=2007,char s=0,float p=0)
{ strcpy(a.nombre,n); a.boleta=b; a.semestre=s;a.promedio=p;pa=&a;
for(int i=0;i<6;i++)
a.calificacion[i]=m; }
//grupo calculapromedio(grupo&);
grupo operator++(int);
grupo operator–(int);
friend ostream &operator<<(ostream &,grupo &);
friend istream &operator>>(istream &,grupo &);
};
/*grupo grupo::calculapromedio()
{
for (int i=0; i<6; i++,pa++)
a.promedio = a.promedio + a.calificacion[i];
return(a.promedio);
} */
grupo grupo::operator++(int)
{
a.semestre++;
return *this;
}
grupo grupo::operator–(int)
{
pa=&a;
return *this;
}
ostream &operator<<(ostream &out, grupo &obj)
{
out<<”Nombre: “<<obj.pa->nombre<<endl
<<”Boleta: “<<obj.pa->boleta<<endl
<<”Semestre: “<<obj.pa->semestre<<endl
<<”Promedio: “<<obj.pa->promedio/6<<endl;
return out;
}
istream &operator>>(istream &in,grupo &obj)
{
cout<<”Nombre del Alumno”<<endl;
in>>obj.pa->nombre;
cout<<”Semestre”<<endl;
in>>obj.pa->semestre;
cout<<”Boleta”<<endl;
in>>obj.pa->boleta;
for(int i=0;i<6;i++)
{
cout<<”Calificacion ” << (i+1)<<endl;
cin>>obj.pa->calificacion[i];
obj.pa->promedio= obj.pa->promedio+obj.pa->calificacion[i];
}
return in;
}

void main (void)
{
grupo a[1], *pa=a;
//clrscr();
for(int i=0; i<1;i++, pa++)
cin>>(*pa);
pa=a;
for(int k=0; k<1;k++,pa++)
(*pa)++;
pa=a;
// clrscr();
//a.a.calculapromedio();
for(int j=0;j<1;j++,pa++)
cout <<(j+1)<<endl<<*pa<<endl;
int x;
getch();
}

conversion a un numero binario de 64

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

main()
{

int i,pos,j,k,temp;
double dividendo;
double cociente;
double residuo;
double numero;
double redondeo;
double decimal;
int potencia;
double exponente;

int arregloA[31]={0};

int arreglo[31]={0};

cout<<”\t Programa que realiza la conversion de un numero decimal \n \t al estandar IEEE 754″;
cout<<”\n\n\n El rango numerico es de -256 a 256″;
cout<<”\n \n \nIntroduzca el numero decimal que desea convertir a Binario: “;
cin>> numero;

if ((numero<(-256))||(numero>256))
{
cout<<”\n Numero fuera de rango…”;
int _exit(0);
return 0;
}
else
{
cout<<”\n Se realizara la conversion…”<<”\n”;
}

if(numero>0)
{
arreglo[0]=0;
}
else
{
numero=numero*(-1);
arreglo[0]=1;
}

if(numero<1)
{
dividendo=0;
decimal=numero;
}
else
{

if(numero==ceil(numero))
{
dividendo=numero;
decimal=0;
}
else
{
redondeo=ceil(numero);
decimal=(redondeo-numero);
decimal=1-decimal;
dividendo=numero-decimal;
}
}

cout<<”\n\nEl valor de la parte entera es: “<<dividendo;
cout<<”\n\nEl valor de la parte decimal es: “<<decimal<<”\n”;

for(i=8;i>0;i–)
{
if((decimal==0) && (numero==0))
{
arreglo[i]=0;
}
else
{
do
{
if((dividendo/2)==((ceil(dividendo/2)-0.5)))
{
cociente=(dividendo/2)-0.5;
residuo=dividendo-(2*cociente);
dividendo=cociente;
arreglo[i]=residuo;
}
else
{
cociente=dividendo/2;
if(cociente==1)
{
dividendo=1.0;
residuo=0.0;
arreglo[i]=residuo;
}
else
{
residuo=dividendo-cociente;
dividendo=cociente;
}
}
}while((cociente=!0) &&(residuo=!1));
}
}

for(i=9;i<32;i++)
{
if(decimal<1)
{

decimal=decimal*2;
if(decimal<1)
{
arreglo[i]=0;
}
else
{
arreglo[i]=1;
decimal=(decimal-1);
}
}
else
{
decimal=(1-decimal);

{
decimal=decimal*2;
if(decimal<1)
{
arreglo[i]=0;
}
else
{
arreglo[i]=1;
decimal=decimal-1;
}
}
}
}

for(i=8;i>0;i–)
{
if(arreglo[i]==1)
{
pos=i;
}

}
cout<<”la posicion es”<<pos;
potencia=8-pos;
cout<<”\nla potencia es”<<potencia<<”\n”;
exponente=potencia+127;

cout<<” S <–Exponente–><—-Mantisa———————————–>\n”;

for(i=0;i<32;i++)
cout<<” “<<arreglo[i];

cout<<”\n”;

cout<<” S <–Exponente–><—-Mantisa———————————–>\n”;

arregloA[0]=arreglo[0];
for(j>0;j<32;j++)
{
for(j=8;j>0;j–)
{
if((exponente<255)||(exponente>0))
{
do
{
dividendo=exponente;
if((dividendo/2)==((ceil(dividendo/2)-0.5)))
{
cociente=(dividendo/2)-0.5;
residuo=dividendo-(2*cociente);
dividendo=cociente;
arregloA[j]=residuo;
}
else
{
cociente=dividendo/2;
if(cociente==1)
{
dividendo=1.0;
residuo=0.0;
arregloA[j]=residuo;
}
else
{
residuo=dividendo-cociente;
dividendo=cociente;

}
}
}while((cociente=!0) &&(residuo=!1));
}
else
{
cout<<”el exponente esta fuera de rango…”;
}
}
for(j=9;j<32;j++)
{
arregloA[i]=arreglo[i];
}
cout<<” “<<arregloA[i];
}

cout<<”\n”;
getch();
return 0;

}