Cesar Systems

Herramientas Informaticas

FRACCIONES EN JAVA

Java-Runtime-Environment-logo
Les dejo un apunte donde manejamos fracciones

   1: package unidad3;
   2:  
   3: import javax.swing.JOptionPane;
   4:  
   5: public class Fraccion 
   6: {
   7: private int num;
   8: private int den;
   9:  
  10: Fraccion()
  11:     {
  12:     num=0;
  13:     den=1;
  14:     }
  15:  
  16: public Fraccion(int num, int den) 
  17:     {
  18:     super();
  19:     this.num = num;
  20:     this.den = den;
  21:     }
  22:  
  23: /** No la uses no funciona a veces el programa se cicla con esta funcion */
  24: public void divisores()
  25:     {
  26:     int numeroPrimo=2;
  27:     int numero=den;
  28:     while(numero!=1)
  29:         {
  30:         if(numero%numeroPrimo==0)
  31:             {
  32:             numero=numero/numeroPrimo;
  33:             System.out.println("divicion entre numero primo es "+numeroPrimo);
  34:             }
  35:         numeroPrimo++;
  36:         
  37:         }
  38:     
  39:     }
  40: /*Maximo común divisor. Busca el numero de mayor valor que pueda dividir al numerador y denominador de la fraccion con la condicion de que no deje residuo */
  41: public int mcd()
  42:     {
  43:     int a=num;
  44:     int b=den;
  45:     int n=1;
  46:     int z=1;;
  47:     if(a>b)
  48:         {
  49:         while(z<=b)
  50:             {
  51:             if(a%z==0 && b%z==0)
  52:                 {
  53:                 n=z;
  54:                 }
  55:             z++;
  56:             }
  57:         }
  58:     if(a<b)
  59:         {
  60:         while(z<=a)
  61:             {
  62:             if(a%z==0 && b%z==0)
  63:                 {
  64:                 n=z;
  65:                 }
  66:             z++;
  67:             }
  68:         }
  69:     return n;
  70:     }
  71: /**Simplifica la fraccion a numeros mas pequeños pero equivalentes */ 
  72: public void simplificar()
  73:     {
  74:     int ns=num/mcd();
  75:     int ds=den/mcd();
  76:     System.out.println(ns+"/"+ds);
  77:     }
  78: /**Suma la fraccion objeto con otra fraccion para guardarla en otra fraccion */
  79: public Fraccion sumar(Fraccion a)
  80:     {
  81:     Fraccion s=new Fraccion((num*a.den)+(den*a.num),den*a.den);
  82:     return s;
  83:     }
  84: /**Multiplica la fraccion objeto con otra fraccion objeto para guardarla en otra fraccion objeto */
  85: public Fraccion multiplicar(Fraccion a)
  86:     {
  87:     Fraccion m=new Fraccion(num*a.num,den*a.den);
  88:     return m;
  89:     }
  90: /**Divide la fraccion objeto con otra fraccion objeto para guardarla en otra fraccion objeto */
  91: public Fraccion divicion(Fraccion a)
  92:     {
  93:     Fraccion d=new Fraccion(num*a.den,den*a.num);
  94:     return d;
  95:     }
  96: /**Muestra la fraccion completa */
  97: public void mostrarFraccion()
  98:     {
  99:     System.out.println(num+"/"+den);
 100:     }
 101:  
 102: public String toString()
 103: {
 104:     return num+"/"+den;
 105: }
 106:  
 107: }

POTENCIA MATEMATICA EN JAVA

Java-Runtime-Environment-logo
Que tal compañeros  les dejo un apunte, es una función para sacar la potencia, aquí
se manejan excepciones.

   1: package unidad5;
   2:  
   3: public class Potencia {
   4:     
   5:     public static long potencia(long numero, long exponente)
   6:         {
   7:         long resultado=1;
   8:         if(exponente<0)    throw new IllegalArgumentException("Exponente incorrecto");
   9:         for(int x=0; x<exponente; x++)
  10:             {
  11:             resultado=resultado*numero;
  12:             }
  13:         return resultado;
  14:         }
  15:     public static void main(String[] args){
  16:         try{
  17:             System.out.println(potencia(3,3));
  18:         }catch(IllegalArgumentException e){
  19:             System.out.println("");
  20:         }catch(IllegalArgumentException e){
  21:             System.out.println("Exponente incorrecto");
  22:         }
  23:     }
  24:  
  25: }

FACTORIAL EN JAVA

Java-Runtime-Environment-logo
Bueno compañeros les dejo una función hecha en en JAVA que da como resultado el factorial espero y le sirva

   1: package utilerias;
   2:  
   3: public class Mate 
   4: {
   5: public static int factorial(int x)
   6:     {
   7:     int y;
   8:     int f=1;
   9:     for(y=1; y<=x; y++)
  10:         {
  11:         f=f*y;
  12:         }
  13:     return f;
  14:     }
  15: }

Al usarse

   1: package utilerias;
   2:  
   3: public class Prueba {
   4:  
   5:     public static void main(String[] args) 
   6:     {
   7:     System.out.println(Mate.factorial(5));
   8:     }
   9:  
  10: }
Etiquetas de Technorati: ,,

Microsoft Visual Studio Express 2012 para windows 8

Microsoft Visual Studio Express 2012 RC para Windows 8 proporciona las herramientas básicas necesarias para crear aplicaciones estilo Metro de Windows innovadoras y atractivas.

PAGINA DE DESCARGA

Introducción

Puede usar las herramientas de Visual Studio Express 2012 RC para Windows 8 para crear aplicaciones estilo Metro de Windows innovadoras y atractivas. Las herramientas incluyen un completo editor de código, un eficaz depurador, un generador de perfiles especializado y extensa compatibilidad con lenguajes de programación que le permiten compilar aplicaciones escritas en HTML5/JavaScript, C++, C# o Visual Basic. Visual Studio Express 2012 RC para Windows 8 incluye también un simulador de dispositivos para probar las aplicaciones estilo Metro en varios factores de forma.

Requisitos del sistema

Sistemas operativos admitidos:

  • Windows 8 Release Preview Windows 8 Release Preview

  

•Arquitecturas compatibles:

  •  32 bits (x86)
  •  64 bits (x64)

Requisitos de hardware:

  • Procesador a 1,6 GHz o más rápido
  • 1 GB de RAM (1,5 GB si se ejecuta en una máquina virtual)
  • 4.0 GB de espacio disponible en el disco duro
  • Unidad de disco duro de 5400 rpm
  • Tarjeta de vídeo compatible con DirectX 9 con una resolución de pantalla de 1024 x 768 o superior

Simulación en C++

SIMULACION EN C++

DESCARGAR CODIGO FUENTE COMPLETO

DESCARGAR CABECERA
Este archivo va en la carpeta INCLUDE

 
SIMULA.CPP
 
   1: #include 

   2: #include 

   3: #include 

   4:  

   5: typedef struct simulacion

   6: {

   7: int tiemposimulacion;

   8: int tiemposervicio;

   9: int probabilidad;

  10:  

  11: int relog;

  12:  

  13: int cajero;

  14:  

  15: int tiemposerviciototal;

  16: int clientesatendidos;

  17: };

  18:  

  19: void parametros(simulacion *p);

  20: int aleatorio(simulacion *a)

  21: {

  22: int x;

  23: float y;

  24: randomize();

  25: y=random(100);

  26: y=y*3.1416;

  27: x=y;

  28: y=y-x;

  29: y=y*100;

  30: if(a->probabilidad<=y)

  31:     {

  32:     return(1);

  33:     }

  34: else

  35:     {

  36:     return(0);

  37:     }

  38: }

  39:  

  40:  

  41: void llegacliente(cola *c)

  42: {

  43: if(aleatorio<=aleatorio)

  44:     {

  45:     push(c);

  46:     }

  47: }

  48:  

  49: void enmarcha(simulacion *e, cola *c)

  50: {

  51: inicializarcola(c);

  52: e->relog=0;

  53: e->cajero=0;

  54: e->clientesatendidos=0;

  55: e->tiemposerviciototal=0;

  56: int v=0;

  57: clrscr();

  58:  

  59: while(e->relog!=e->tiemposimulacion+1)

  60:     {

  61:     clrscr();

  62:     for(int v=0; v<max; v++)

  63:         {

  64:         *(c->cola+v)=*(c->cola+v)+1;

  65:         }

  66:     gotoxy(1,1);    cout<<"Minutos trancurridos: "<relog;

  67:     (e->relog)++;

  68:  

  69:     gotoxy(40,1);    cout<<"Probabilidad "<probabilidad;

  70:  

  71:     gotoxy(1,20);    cout<<"Clientes atendidos "<clientesatendidos;

  72:  

  73:     gotoxy(40,20);    cout<<"Tiempo de espera total "<tiemposerviciototal;

  74:     if(aleatorio(e)==0)

  75:         {

  76:         insertar(c);

  77:         for(int v=0; v<30; v++)

  78:             {

  79:             gotoxy(1,3);    cout<<"Ha llegado un cliente";

  80:             }

  81:         }

  82:  

  83:     if(e->cajero==0)

  84:         {

  85:         gotoxy(1,4);    borrar(c);

  86:         e->cajero=e->tiemposervicio;

  87:         }

  88:     (e->cajero)--;

  89:  

  90:  

  91:     if(e->cajero==0 && colavacia(c)==0)

  92:         {

  93:         (e->clientesatendidos)++;

  94:         e->tiemposerviciototal=e->tiemposerviciototal+*(c->cola+c->frente);

  95:         }

  96:  

  97:     getch();

  98:     }

  99: }

 100:  

 101:  

 102:  

 103: main()

 104: {

 105: clrscr();

 106: cola fila;

 107: tipodatocola colas[max];

 108: fila.cola=&colas[0];

 109:  

 110: simulacion simula;

 111: parametros(&simula);

 112: enmarcha(&simula, &fila);

 113: }

 114:  

 115:  

 116:  

 117:  

 118: void parametros(simulacion *p)

 119: {

 120: cout<<"Tiempo de duracion de la simulacion: ";            cin>>p->tiemposimulacion;

 121: cout<<"Tiempo limite del servicio del servidor: ";        cin>>p->tiemposervicio;

 122: cout<<"probabilidad de llegada de un cliente en un minuto ";    cin>>p->probabilidad;

 123: }

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

 

COLAS.H

   1: //COLAS

   2: //JULIO CESAR LEYVA RODRIGUEZ

   3: #include 

   4: #include 

   5: #define max 100

   6: typedef int tipodatocola;

   7: typedef struct cola

   8: {

   9: tipodatocola *cola;                             

  10: int frente;

  11: int final;

  12: int contador;

  13: };

  14:  

  15: //INICIALIZAR COLA

  16: void inicializarcola(cola *inicializar)

  17: {

  18: inicializar->frente=max-1;

  19: inicializar->final=-1;

  20: gotoxy(40,5);    cout<<"SE HA INICIALIZADO LA COLA";

  21: }

  22:  

  23: //COLA LLENA

  24: int colallena(cola *llena)

  25: {

  26: if(llena->final==llena->frente-1)

  27:     {

  28:     return(1);

  29:     }

  30: else

  31:     {

  32:     return(0);

  33:     }

  34: }

  35:  

  36: //COLA VACIA

  37: int colavacia(cola *v)

  38: {

  39: if((v->frente==v->final) || (v->final==-1 && v->frente==max-1))

  40:     {

  41:         return(1);

  42:     }

  43: else

  44:     {

  45:     return(0);

  46:         }

  47: }

  48:  

  49: void push(cola *z)

  50: {

  51: if(z->final==max-1)

  52:     {                       

  53:     (z->final)=-1;

  54:     *(z->cola+z->final+1)=0;

  55:     }          

  56: else

  57:     {                                                                      

  58:     (z->final)++;

  59:         *(z->cola+z->final)=0;

  60:         }

  61: }

  62:  

  63: void insertar(cola *i)

  64: {

  65: tipodatocola cliente;

  66: if(colallena(i)==1)

  67:     {            

  68:     cout<<"La cola esta llena";

  69:     }

  70: else

  71:     {

  72:     push(i);

  73:     }

  74: }        

  75:  

  76: tipodatocola pop(cola *c)

  77: {

  78: tipodatocola dato;

  79: if(c->frente==max-1 && c->final>-1)

  80:     {       

  81:     c->frente=0;

  82:     dato=*(c->cola+c->frente);

  83:     return(dato);

  84:     }

  85: else                             

  86:     {

  87:     c->frente=c->frente+1;

  88:     dato=*(c->frente+c->cola);

  89:     return(dato);

  90:         }

  91: }

  92:  

  93: void borrar(cola *borrar)

  94: {

  95: if(colavacia(borrar)==1)

  96:     {

  97:     cout<<"La cola esta vacia";

  98:     }

  99: else

 100:     {

 101:     cout<<"El cliente a pasado al cajero con "<<pop(borrar)<<" minutos de espera";

 102:     }

 103: }

 104:  

 105: void visualizarcola(cola *v)

 106: {

 107: if(colavacia(v)==1)

 108:     {

 109:     cout<<"No hay datos";

 110:     }

 111: else

 112:     {

 113:     for(int x=v->frente; xfinal; x++)

 114:         {

 115:         if(x==max-1)

 116:             {

 117:             x=0;

 118:                         }

 119:         gotoxy(x+20,25);    cout<cola+1;

 120:         }

 121:         }

 122:  

 123: }    

 124:       

 125:  

 126:  

 127:  

 128: //MENU

 129: void menu(cola *menu) 

 130: {                                                      

 131: int op;

 132: do

 133:  

 134:     {

 135:     clrscr();

 136:     cout<<"Frente "<frente;

 137:         cout<<"nFinal "<final;

 138:         cout<<"nCola "<cola+menu->frente);

 139:      gotoxy(1,5);    cout<<"MENU";

 140:     gotoxy(1,6);    cout<<"1. INICIALIZAR";

 141:     gotoxy(1,7);    cout<<"2. INSERTAR";

 142:     gotoxy(1,8);    cout<<"3. BORRAR";

 143:     gotoxy(1,9);    cout<<"ELIGA UNA OPCION [   ]";

 144:     gotoxy(20,9);    cin>>op;

 145:     switch(op)

 146:         {

 147:         case 1:

 148:             inicializarcola(menu);

 149:             getch();

 150:             break;

 151:         case 2:

 152:             insertar(menu);

 153:             getch();

 154:             break;

 155:         case 3:

 156:                 borrar(menu);

 157:             getch();

 158:                         break;

 159:         case 4:

 160:             visualizarcola(menu);

 161:             getch();

 162:                         break;

 163:         }

 164:     }

 165:     while(op!=5);

 166: }

 167:  

Pilas en C++

   1: //PILAS

   2:  

   3: #include 

   4: #include 

   5: #include 

   6: #define max 5

   7:  

   8: typedef int tipodatopila;

   9:                          

  10: tipodatopila pila[max];

  11: int tope;

  12:  

  13: void visualizarpila(tipodatopila *pila);

  14: void inicializarpila(int *tope);

  15: void menu(int *tope, tipodatopila *pila);

  16: int pilavacia(int *tope);

  17: int pilallena(int *tope);

  18: void push(int *tope, tipodatopila *pila, tipodatopila *dato);

  19: void alta(int *tope);

  20: tipodatopila pop(int *tope, tipodatopila *pila)

  21: {

  22: tipodatopila b=*(tope)+*(pila);

  23: *(tope)=*(tope)-1;

  24: return(b);

  25:  

  26: }

  27: void baja(int *tope, tipodatopila *pila)

  28: {

  29: if(pilavacia(tope)==1)

  30:     {

  31:     gotoxy(40,4);    cout<<"LA PILA ESTA VACIA";

  32:     }                              

  33: else

  34:     {

  35:     gotoxy(40,4);    cout<<"EL DATO ELIMINADO FUE "<<pop(tope,pila);

  36:     }

  37: }

  38:                   

  39:  

  40: main()

  41: {

  42: menu(&tope,&pila[0]);

  43: }

  44:  

  45: void menu(int *tope, tipodatopila *pila)

  46: {

  47: int op;

  48:  

  49: do

  50:     {

  51:         clrscr();

  52:         gotoxy(10,10);    visualizarpila(pila);

  53:     gotoxy(30,2);     cout<<"PILAS";

  54:     gotoxy(10,4);     cout<<"1. INICIALIZAR PILA";

  55:     gotoxy(10,5);     cout<<"2. ALTA";

  56:     gotoxy(10,6);     cout<<"3. BAJA";

  57:     gotoxy(10,7);     cout<<"4. SALIR";

  58:     gotoxy(10,8);     cout<<"ELIGA UNA OPCION [   ]";

  59:     gotoxy(29,8);    cin>>op;

  60:     switch(op)

  61:         {

  62:         case 1:

  63:             inicializarpila(tope);

  64:             break;

  65:            case 2:

  66:             alta(tope);

  67:                         getch();

  68:             break;

  69:         case 3:

  70:                         baja(tope,pila);

  71:             getch();

  72:             break;

  73:         case 4:

  74:                         clrscr();

  75:             cout<<"ADIOS ;D";

  76:             getch;

  77:             break;                      

  78:  

  79:         default:

  80:             cout<<"HAZ TECLADO UNA LETRA";

  81:                         break;   

  82:  

  83:         }

  84:                 

  85:     }while(op!=4); 

  86:  

  87: }

  88:  

  89:  

  90:  

  91:  

  92:  

  93:  

  94:  

  95:  

  96:  

  97:  

  98:  

  99:  

 100:  

 101:  

 102:  

 103:  

 104:  

 105:  

 106:  

 107:  

 108:  

 109: int pilallena(int *tope)

 110: {

 111: if(*(tope)==max-1)

 112:     {

 113:     return(1);

 114:     }

 115: else

 116:     {

 117:     return(0);

 118:     }

 119: }

 120:  

 121: //Pila vacia

 122: int pilavacia(int *tope)

 123: {

 124: if(*(tope)==-1)

 125:     {

 126:     return(1);

 127:     }

 128: else

 129:     {

 130:     return(0);

 131:     }

 132: }

 133:  

 134:  

 135:  

 136:  

 137:  

 138:  

 139:  

 140: //Funcion inicializar pila

 141: void inicializarpila(int *tope)

 142: {

 143: *(tope)=-1;

 144: }

 145:  

 146: //Visualizar pila

 147: void visualizarpila(tipodatopila *pila)

 148: {

 149: for(int f=0; f<max; f++)

 150:     {

 151:     cout<<"n"<<*(pila+f);

 152:     }

 153: }

 154:  

 155: void push(int *tope, tipodatopila *pila, tipodatopila *dato)

 156: {

 157: *(tope)=*(tope)+1;

 158: *(pila+*tope)=*dato;

 159: }

 160:  

 161: void alta(int *tope)

 162: {

 163: tipodatopila dato;

 164: if(pilallena(tope)==1)

 165:     {

 166:     gotoxy(40,4);    cout<<"LA PILA ESTA LLENA";

 167:     }

 168: else

 169:     {

 170:     gotoxy(40,5);    cout<<"INSERTE EL DATO ";    cin>>dato;

 171:     gotoxy(40,6);    push(tope,pila,&dato);

 172:     }

 173: }

 

Segundo examen C++

DESCARGAR CODIGO PRINCIPAL

DESCARGAR CABECERA DE CODIGO
Este archivo lo colocaras en la carpeta include, se necesita para correr el programa

EXAMEN2.CPP

   1: //EXAMEN 2 JULIO CESAR LEYVA RODRIGUEZ

   2:  

   3: #include 

   4: #include 

   5: #include 

   6:  

   7: #define renglones 5

   8: #define columnas 5

   9:  

  10: int arreglo[renglones][columnas];

  11: #include 

  12:  

  13:  

  14: void main()

  15: {

  16: inicializar(&arreglo[0][0]);

  17: numerosaleatorios(&arreglo[0][0]);

  18: mostrararreglo();

  19: sumardiagonales(&arreglo[0][0]);

  20: sumardiagonalesinvertida(&arreglo[0][0]);

  21: }

  22:  

FJULIO.H

   1: //FUNCIONES JULIO CESAR LEYVA RODRIGUEZ

   2: //MARTES 29 DE SEPTIEMBRE DEL 2009

   3:  

   4:  

   5: //SUMAR DIAGONALES DE UN ARREGLO

   6:  

   7: void sumardiagonales(int *d)

   8: {

   9: int c=0;

  10: for(int x=0; x<renglones; x++)

  11:     {

  12:     cout<<"n"<<*(d+x+c);

  13:     c=c+columnas;

  14:  

  15:     }

  16: }                                                     

  17:      

  18:  

  19: //SUMAR DIAGONALES DE UN ARREGLO INVERTIDO

  20:  

  21: void sumardiagonalesinvertida(int *d)

  22: {

  23: int c=columnas-1;

  24: for(int x=0; x<renglones; x++)

  25:     {

  26:     cout<<"n t"<<*(d+c);

  27:     c=c+columnas-1;

  28:                       

  29:     }              

  30: } 

  31:  

  32: //MUESTRAR EN PANTALLA EL ARREGLO

  33:  

  34: void mostrararreglo()

  35: {

  36: for(int x=0; x<renglones; x++)

  37:     {

  38:     for(int y=0; y<columnas; y++)

  39:         {

  40:         gotoxy(5+y,5+x); cout<<arreglo[x][y];

  41:         }

  42:     }

  43: }                                                      

  44:  

  45: //GENERAR NUMEROS ALEATORIOS EN UN ARREGLO

  46:  

  47: void numerosaleatorios(int *n)

  48: {

  49: randomize();

  50: for(int x=0; x<renglones*columnas; x++)

  51:     {

  52:     *(n+x)=random(9);

  53:     }

  54: }

  55:  

  56: //INICIALIZA UN ARREGLO

  57:  

  58: void inicializar(int *i)

  59: {

  60: for(int x=0; x<renglones*columnas; x++)

  61:     {

  62:     *(i+x)=0;

  63:     }

  64: }

Primer examen C++ Apuntadores

 
   1: //EXAMEN PRIMER SEMESTRE

   2:  

   3: //JULIO CESAR LEYVA RODRIGUEZ

   4:  

   5: #include 

   6: #include 

   7: #include 

   8: #include 

   9: #include 

  10:  

  11: #define max 10

  12: int arreglo[max];

  13: int x;

  14: int *p;

  15:  

  16: void i(int *p);           

  17:  

  18: void buscar(int *p)

  19: {

  20: int n;

  21: int z;

  22: int c;

  23: cout<<"INGRESE EL NUMERO QUE DESEA BUSCAR: ";    cin>>n;

  24: c=0;

  25: for(z=0; z<max; z++)

  26:     {       

  27:  

  28:     if(*(p+z)==n)

  29:         {

  30:                 c=0;

  31:         cout<<"n EL NUMERO SE REPITE EN LA POSICION: "<<z+1;

  32:                 c++;

  33:         }

  34:  

  35:  

  36:     }

  37: if(c==0)

  38:         {

  39:         cout<<"EL NUMERO NO SE REPITE";

  40:         }

  41: }

  42:  

  43:  

  44:  

  45: main()

  46: {

  47: i(&arreglo[0]);

  48: for(x=0; x<max; x++)

  49:     {

  50:     cout<<arreglo[x]<<"n";

  51:         }

  52: buscar(&arreglo[0]);

  53: }

  54:  

  55:  

  56:  

  57:  

  58:  

  59: void i(int *p)

  60: {

  61: randomize();

  62: for(x=0; x<max; x++)

  63:     {           

  64:  

  65:         *(p+x)=random(100);

  66:  

  67:     }

  68: }

Generar numeros aleatorios C++

 
   1: //GENERAR NUMEROS ALEATORIOS SIN DUPLICADOS

   2: #include 

   3: #include 

   4: #include 

   5:  

   6: int x;               

   7: int y;

   8: int na;                                

   9: int a[10];

  10: int z;

  11:  

  12: main()

  13: {

  14: randomize();

  15: while(x<10)

  16:     {

  17:         int c=0;

  18:     na=random(10);

  19:     for(y=0; y<10; y++)

  20:         {

  21:         if(na==a[x])

  22:             {

  23:             c++;

  24:             }

  25:         }

  26:     if(c==0)

  27:         {

  28:         a[x]=na;

  29:         x++;

  30:                 }

  31:     else

  32:         {

  33:         na=random(10);

  34:                 }

  35:     }

  36: for(z=0; z<10; z++)

  37:     {

  38:         cout<<"n"<<a[z];

  39:         }

  40: }

Apuntadores con funciones en C++

Les dejo el archivo para descargar.

APUNTADO.CPP
   1:

   2:

   3: //JULIO CESAR LEYVA RODRIGUEZ

   4:

   5: //APUNTADORES CON FUNCIONES

   6:

   7:

   8:

   9: #include

  10: #include

  11: #include

  12: #include

  13:

  14: #define max 5

  15: int arreglo[max];

  16: int x;

  17: int *p;

  18:

  19: void i(int *p)

  20: {

  21:

  22: for(x=0; x<max; x++)

  23:     {

  24:

  25:         *(p+x)=random(9);

  26:

  27:     }

  28: }

  29:

  30:

  31: main()

  32: {

  33: i(&arreglo[0]);

  34: for(x=0; x<max; x++)

  35:     {

  36:     cout<<arreglo[x]<<"n";

  37:         }

  38: }

 

 

Página 134 de 143

Creado con WordPress & Tema de Anders Norén