SoloCodigo

Creo que la version de windows que tenga la computadora no influye en el arranque, que es anterior a la carga del sistema operativo. Asi que lo unico que se me ocurre es que en la otra computadora inicialmente aparezca el bloque numerico activado y por eso toma la tecla . que dices como . y no como Supr. Intenta pulsar la tecla Supr o Del que normalmente se situa por donde estan las teclas Ins,Inicio,Fin ... o Home,End.., Suerte

Aqui teneis un enunciado de una practica de programacion en c++ que explica el formato BMP. Creo q es mas claro, el link:

http://polaris.lcc.uma.es/~ccottap/docencia/LP/prac10/

Muchas gracias juank, ya e resuelto el problema, lo q estaba haciendo era valido, el problema que hacia q mi programa diese error en tiempo de ejecucion era q no manejaba bien los argumentos de la funcion main. Yo pensaba que era por que no hacia bien la conversion de cadena de caracteres de un argv[n] , y el problema real es q accedia a un n fuera de rango, de todas formas tu comentario me a ayudado a clarificar mis ideas al respecto del manejo de cadenas, muchas gracias. Un saludo.

//Aqui esta el programa que funciona

// Programa que pasa un numero < 1000 a cadena
// de caracteres.

/*
El proceso que haría  este programa
para el ejemplo del numero 832:

NUMERO MENOR QUE 1000?
 |
SI
 |
 832 : 10 = 83.2 -> numero[3] = 2 (ascii 48 + 2)
 83  : 10 = 8.3  -> numero[2] = 3 (ascii 48 + 3)
 8   : 10 = 0.8  -> numero[1] = 8 (ascii 48 + 8)
 0   : 10 = 0    -> numero[0] = 0 (ascii 48)

 por lo que  nos queda un array con:
 
 --------------------------
 | 0 | 8 | 3 | 2 | char(0) |
 --------------------------
*/



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

int main()
{ int i;
char numero[5]; // longitud de la cadena + 1

int num; // aqui recogemos el numero
cout << "Introduce el numero menor de 1000: ";
cin >> num;

if (num <1000)
{

/* descuartizamos el numero
y metemos cada digito en una
posicion del array
*/  
i=3 ;
while (i >= 0)
{  
numero = char(48 + (num % 10));
num = num / 10;
i = i-1;
}
numero[4]=char(0); // colocamos el fin de cadena

cout <<"El numero introducido es " << numero <<endl;
}
else
{
cout <<endl << " He dicho menor de 1000 " <<endl;
}

system("PAUSE");
return 0;
}

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

void cambia_color (int COLOR)
{
HANDLE h; //manejador
h = GetStdHandle(STD_OUTPUT_HANDLE); //lo cargamos como manejador estandar de salida
SetConsoleTextAttribute (h,COLOR); //cambiamos el color de la pantalla
}

const int FONDO_VERDE_LETRA_BLANCA = 0x2F; //numero constante representado en HEX
/*
0x2F
esto es un numero compuesto por dos numeros hexadecimales:
0x significa que el numero es hexadecimal
2 es el 0010 que para el ordenador en esa posicion es FONDO verde,
F es el 1111 que en esa posicion, es LETRA en blanco
*/

const int FONDO_BLANCO_LETRA_VERDE = 0xF2; //otro numero representado en HEX
/*
0xF2
en este caso, el F esta en la posicion del FONDO por lo que el fondo es blanco
y el 2 es para LETRA verde.

Los colores van desde el
0 que es el negro  hasta el
F que es el blanco
*/

int main()
{
cambia_color( FONDO_VERDE_LETRA_BLANCA );//le da el valor 0x2F a COLOR
/*
por lo que
SetConsoleTextAttribute (h,COLOR);
será:
SetConsoleTextAttribute (h,0x2F);
en este caso
*/
cout <<"Hola Mundo" <<endl;

//si quieres restaurar el color normal:
cambia_color( 0x0F );
      system("PAUSE");
      return 0;
}

puedes usar la libreria conio.c para cambiar los colores. Crea una funcion que se encargue de cambiar el color.

seria algo asi como:

#include <conio.c>

void cambia_color (int COLOR)
{
HANDLE h;
h =  GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute (h,COLOR);
}

y puedes usar los colores standares como BLUE, RED y demas al modo de cambia_color(BLUE); o puedes definirlos al estilo const int VERDE = 0x0A; donde 0 es donde va el valor hexadecimal del color del fondo y la A el color de la letra.

dentro del bucle puedes  poner q si se cumple cambie a un color, imprima lo que sea y despues cambie al color normal. con esto creo q ya esta solucionado. si quieres q explique algo con mas detalle aqui estoy;)

/*Pues eso, que despues de leer tu curiosidad, me he animado a realizarlo y este es el resultado*/

/*
Programa Decodificador Morse LK
Realizado por LamKros.
lamkros@mixmail.com

Descripcion: Dado un signo morse lo traduce a caracteres.
Funciona para el abecedario y los numeros, si el signo es menor de 6 digitos
y si no se introducen caracteres no deseados.

El autor da su consentimiento para que el codigo
sea modificado, ampliado o mejorado por cualquier persona

He utilizadado como estructura para la decodificacion un arbol binario,
en el cual la rama izquierda es el punto y la rama derecha la raya.

Asi, la W es .--, porque en el arbol nos desplazamos al nodo de la izquierda,
despues hacia la derecha y otra vez a la derecha.

Bueno, que lo disfruteis;)
*/

         //Realizado por Lamkros

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


        //Realizado por Lamkros

const int MAXMORSE = 5;
const char FINCAD = char(0);
const char ESPACIO = ' ';
const char PUNTO = '.';
const char RAYA = '-';
const char SIN_CARACTER = 'x';


typedef struct TNodo *TMorse;
struct TNodo
       {
       char valor;
       TMorse punto;
       TMorse raya;
       };

typedef char TDato [MAXMORSE+1];
       //Realizado por Lamkros

void CrearMorse(TMorse &m);
void CrearNodosVacios(TMorse &m,int i);
void RellenarValores (TMorse &m);
void MostrarCaracteres(TMorse &m);
void DestruirMorse(TMorse &m);
char BuscarMorse(TMorse &m,TDato dato,int i);


       //De Lamkros para todos

int main()
    {
    TMorse m;
    TDato dato;
    m=NULL;
    //int i=0,j=0;
    char car;
    CrearMorse(m);
    bool fin=false;
    cout << "t Decodificador Morse LK"<<endl<<endl;
    cout << "t Funciona correctamente hasta 5 digitos"<<endl ;
    cout << "t Pulsar Q para salir"<<endl <<endl;
    while (!(fin))
    {
    cout << "t Insertar signo: ";
    cin >> dato;
    if (toupper(dato[0])=='Q')
    {fin = true;}
    else
    {
    car = BuscarMorse(m,dato,0);
    if (car=='x')
    {
    cout << "SIGNO NO VALIDO"<<endl;
    }
    else
    {cout <<car <<" "<<endl;}
    }
    }
    system("PAUSE");
    DestruirMorse(m);
    return 0;
    }

       //Realizado por Lamkros
void CrearMorse(TMorse &m)
     {
     int i=0;
     CrearNodosVacios(m,i);
     RellenarValores (m);
     }
      //Resuelto por Lamkros

void CrearNodosVacios(TMorse &m,int i)
     {
     if (i==(MAXMORSE+1))
     {m=NULL;}
     else
     {
     m=new(TNodo);
     CrearNodosVacios(m->punto,i+1);
     CrearNodosVacios(m->raya ,i+1);
     }
     }
     //Ideado por Lamkros
     
void RellenarValores (TMorse &m)
     {TMorse ptr;
     ptr=m;
     if (ptr!=NULL)
     {
     /*
     ptr
     punto->
     raya->
     valor
     */
     
     ptr->valor                                     = SIN_CARACTER;
     ptr->punto->valor                              = 'E';
     
     ptr->punto->punto->valor                       = 'I';
     ptr->punto->punto->punto->valor                = 'S';
     ptr->punto->punto->punto->punto->valor         = 'H';
     ptr->punto->punto->punto->punto->punto->valor  = '5';
     ptr->punto->punto->punto->punto->raya->valor   = '4';
     ptr->punto->punto->punto->raya->valor          = 'V';
     ptr->punto->punto->punto->raya->punto->valor   = SIN_CARACTER;
     ptr->punto->punto->punto->raya->raya->valor    = '3';
     
     ptr->punto->punto->raya->valor                 = 'U';
     ptr->punto->punto->raya->punto->valor          = 'F';
     ptr->punto->punto->raya->punto->punto->valor   = SIN_CARACTER;
     ptr->punto->punto->raya->punto->raya->valor    = SIN_CARACTER;
     ptr->punto->punto->raya->raya->valor           = SIN_CARACTER;
     ptr->punto->punto->raya->raya->punto->valor    = SIN_CARACTER;
     ptr->punto->punto->raya->raya->raya->valor     = '2';
     
     
     ptr->punto->raya->valor                        = 'A';
     ptr->punto->raya->punto->valor                 = 'R';
     ptr->punto->raya->punto->punto->valor          = 'L';
     ptr->punto->raya->punto->punto->punto->valor   = SIN_CARACTER;
     ptr->punto->raya->punto->punto->raya->valor    = SIN_CARACTER;
     ptr->punto->raya->punto->raya->valor           = SIN_CARACTER;
     ptr->punto->raya->punto->raya->punto->valor    = SIN_CARACTER;
     ptr->punto->raya->punto->raya->raya->valor     = SIN_CARACTER;
     
     ptr->punto->raya->raya->valor                  = 'W';
     ptr->punto->raya->raya->punto->valor           = 'P';
     ptr->punto->raya->raya->punto->punto->valor    = SIN_CARACTER;
     ptr->punto->raya->raya->punto->raya->valor     = SIN_CARACTER;
     ptr->punto->raya->raya->raya->valor            = 'J';
     ptr->punto->raya->raya->raya->punto->valor     = SIN_CARACTER;
     ptr->punto->raya->raya->raya->raya->valor      = '1';
     
     
     ptr->raya->valor                               = 'T';
     
     ptr->raya->punto->valor                        = 'N';
     ptr->raya->punto->punto->valor                 = 'D';
     ptr->raya->punto->punto->punto->valor          = 'B';
     ptr->raya->punto->punto->punto->punto->valor   = '6';
     ptr->raya->punto->punto->punto->raya->valor    = SIN_CARACTER;
     ptr->raya->punto->punto->raya->valor           = 'X';
     ptr->raya->punto->punto->raya->punto->valor    = SIN_CARACTER;
     ptr->raya->punto->punto->raya->raya->valor     = SIN_CARACTER;
     
     ptr->raya->punto->raya->valor                  = 'K';
     ptr->raya->punto->raya->punto->valor           = 'C';
     ptr->raya->punto->raya->punto->punto->valor    = SIN_CARACTER;
     ptr->raya->punto->raya->punto->raya->valor     = SIN_CARACTER;
     ptr->raya->punto->raya->raya->valor            = 'Y';
     ptr->raya->punto->raya->raya->punto->valor     = SIN_CARACTER;
     ptr->raya->punto->raya->raya->raya->valor      = SIN_CARACTER;
     
     
     ptr->raya->raya->valor                         = 'M';
     ptr->raya->raya->punto->valor                  = 'G';
     ptr->raya->raya->punto->punto->valor           = 'Z';
     ptr->raya->raya->punto->punto->punto->valor    = '7';
     ptr->raya->raya->punto->punto->raya->valor     = SIN_CARACTER;
     ptr->raya->raya->punto->raya->valor            = 'Q';
     ptr->raya->raya->punto->raya->punto->valor     = SIN_CARACTER;
     ptr->raya->raya->punto->raya->raya->valor      = SIN_CARACTER;
     
     ptr->raya->raya->raya->valor                   = 'O';
     ptr->raya->raya->raya->punto->valor            = SIN_CARACTER;
     ptr->raya->raya->raya->punto->punto->valor     = '8';
     ptr->raya->raya->raya->punto->raya->valor      = SIN_CARACTER;
     ptr->raya->raya->raya->raya->valor             = SIN_CARACTER;
     ptr->raya->raya->raya->raya->punto->valor      = '9';
     ptr->raya->raya->raya->raya->raya->valor       = '0';
     
     }
     }
     //Pensado por Lamkros

void MostrarCaracteres(TMorse &m)
     {
     if (m!=NULL)
     {
     cout <<m->valor;
     MostrarCaracteres(m->punto);
     MostrarCaracteres(m->raya);
     }
     }
     //Diseñado por Lamkros


char BuscarMorse(TMorse &m,TDato dato,int i)
     {
     if (m!=NULL)
     {
     if (dato ==FINCAD)
     {return m->valor;}
     else
     {
     if (dato ==PUNTO)
     {BuscarMorse(m->punto,dato,i+1);}
     else  if (dato==RAYA)
     {BuscarMorse(m->raya,dato,i+1);}
     else
     {return SIN_CARACTER;}
     }
     }
     }


void DestruirMorse(TMorse &m)
     {
     if (m!=NULL)
     {
     DestruirMorse(m->punto);
     DestruirMorse(m->raya);
     delete(m);
     }
     }
     //Hecho por Lamkros

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

int main()
{
int opc;
system("CLS");
cout <<endl <<"Quien descubrio America?: ";
cout <<endl <<"1. Felipe Gonzalez";
cout <<endl <<"2. El Fari";
cout <<endl <<"3. Penelope Cruz";
cout <<endl <<"4. Colon";
cout <<endl <<"Introduzca una opcion: ";
cin >>opc;

switch (opc)
       {
       case 1:
       cout <<endl <<"Si claro, jejeje";
       break;
       case 2://como este case no tiene break sigue y hace tambien case 3 hasta el break
       case 3:
       cout <<endl <<"Tu ves mucho la tele";
       break;
       case 4:
       cout <<endl <<"Acertastes;)";
       break;
       default: //en otro caso
       cout <<endl<<" Opcion incorrecta ";
       break;
       }
      cout <<endl;
      system("PAUSE");
      return 0;
}

/*
Aqui tienes un mini-programa como una solucion
Espero que te sirva
*/

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

/*Realizado por Lamkros*/

int main()
{int i,j,t;
bool ok=true;
int vector[21];
i=0;
srand(time(0));  //inicializa el rand

while (i<=20)
{ok=true;
t=(rand()%75)+1; //Calculo en num aleatorio
j=0;
while ((ok)&&(j<i)) //Compruebo que no esta ya
{
if (vector[j]==t)
{ok = false;}
else
{++j;}
}
if (ok)  // Si no está incremento i y le doy al vector su valor t
{vector=t;
++i;}

}

//Imprime todos los valores
for (i=0;i<=20;++i)
{cout <<endl<<vector<<", ";}
 
system("PAUSE");
return 0;
}

//Suerte;)

A q

/*
Aqui tienes un ejemplo de como haria una base de datos
si cierto es que no es la forma optima, es una alternativa
relativamente sencilla y nunca va estar llena a no ser que
te quedes sin memoria
*/

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

//Estructura de Datos

/*Esta es una base de datos con lista enlazada*/

const int MAXCAD = 20;

typedef char TCadena [MAXCAD+1];


typedef struct TDato
        {
       int codigo;
       TCadena nombre;
       TCadena apellidos;
       };

typedef struct TNodo *TBD;

struct TNodo //
       {
       TDato dato;
       TBD sig;
       };

TBD CrearBDVacia();
void DestruirBD(TBD &l);

void InsertarDato(TBD &l,TDato dato);
void BorrarDato(TBD &l,int codigo);
void LeerDato (TBD &l,int codigo,TDato &dato,bool &ok);
void GuardarFichero (TCadena nombreFichero,TBD &l);
void CargarFichero (TCadena nombreFichero,TBD &l);

int main()
    {
    TBD l;
    l=CrearBDVacia();
    //Aqui iria el programa

    /*No se debe olvidar liberar los datos que hemos creado de forma dinamica
    y que solo nosotros estamos autorizados a eliminar de la memoria
    y que en caso de no eliminarlos se quedaran en la RAM como basura
    hasta que se libere esta.
    */
    DestruirBD(l);
    system("PAUSE");
    return 0;
    }


void GuardarFichero (TCadena nombreFichero,TBD &l)
     {
     TBD ptr;
     ptr=l;
     fstream f;
     f.open(nombreFichero,ios::out|ios::binary);
     while (ptr!=NULL)
           {
           f.write(ptr,sizeof(TNodo));
           ptr=ptr->sig;
           }
     f.close();
     }

void CargarFichero (TCadena nombreFichero,TBD &l)
     {
     TBD ptr;
     fstream f;
     ptr=l;
     f.open (nombreFichero,ios::in | ios::binary);
     if (!(f.bad()))
     {
     while (!(f.eof()))
     {
     f.read (&ptr,sizeof(TNodo));
     ptr=ptr->sig;
     }
     }
     f.close();
     }


TBD CrearBDVacia()
    {return NULL;}

void DestruirBD(TBD &l)
     {
     TBD ptr;
     ptr=l;
     while (ptr!=NULL)
     {
     l=l->sig;
     delete (ptr);
     ptr=l;
     }
     }

void InsertarDato(TBD &l,TDato dato)
     {
     /*Esto depende de como quieras ordenar los datos
     Si quieres ordenarlo de  A-Z se me ocurre que puedes
     ir metiendo el dato despues del ultimo dato que empiece por la misma vocal
     o algo asi  

     */
     TBD ptr,nuevonodo;
     nuevonodo=NULL;
     ptr=l;
     while ((ptr->dato.nombre[0]<dato.nombre[0])&&(ptr!=NULL))
     {
     ptr=ptr->sig;
     }
     nuevonodo=new(TNodo);
     nuevonodo->dato=dato;
     if (ptr!=NULL)
     {nuevonodo->sig=ptr->sig;}
     else
     {nuevonodo->sig = NULL;}
     ptr->sig = nuevonodo;
     }

void BorrarDato(TBD &l,int codigo)
{}


void LeerDato (TBD &l,int codigo,TDato &dato,bool &ok)
     {
     TBD ptr;
     ptr=l;
     while ((ptr!=NULL)&&(ptr->dato.codigo!=codigo))
     {
     ptr=ptr->sig;
     }
     if(ptr!=NULL)
     {
     dato=ptr->dato;
     ok=true;
     }
     else
     {ok=false;}
     }

     /*
     Esto es todo, si he cometido algun error,
     por favor, decirlo por aqui,
     espero que te sea util,

     lamkros@mixmail.com
   
 */texto Green

/* Visto el anterior ejemplo, aqui tienes una alternativa, a falta de uno, dos */

/*Realizado por LamKros*/

#include <iostream.h>
#include <stdlib.h>
#include <ctype.h> //Para utilizar toupper()

/*toupper pone a mayusculas un caracter*/


char Menu();
bool Confirmar_Salida();

int main()
{char opc;
bool fin = false;
do
{
system("CLS"); //Limpia la pantalla
opc = Menu();
switch (opc)
       {
       case 'A':
       // Aqui poner lo que quieres que haga la opcion A
       cout <<endl <<"Seleccionada la Opcion A" <<endl;
       break;
       case 'B':
       //Lo mismo con la opcion B
       cout <<endl <<"Seleccionada la Opcion B" <<endl;
       break;
       case 'C':
       //Con la C
       cout <<endl <<"Seleccionada la Opcion C" <<endl;
       break;
       case 'D':
       //Y asi todas las que quieras
       cout <<endl <<"Seleccionada la Opcion D" <<endl;
       break;
       case 'X'://Y la X por ejemplo para salir
       fin = Confirmar_Salida();
       break;
       }
      system("PAUSE");
}while (!(fin));
      return 0;
}

char Menu()
{char opc;
cout           << " <Titulo del Programa> " << endl <<endl;
cout           << "t A. Opcion A" << endl; //la t es para tabular
cout           << "t B. Opcion B" << endl;
cout           << "t C. Opcion C" << endl;
cout           << "t D. Opcion D" << endl;
cout           << "t X. Salir"    << endl;

cout    <<endl << "Introduce una opcion: " <<endl;
cin >> opc;
return toupper(opc);
}

bool Confirmar_Salida()
{char opc;
cout <<endl <<"Confirma que desea salir(S/N): ";
cin >> opc;
return (toupper(opc)=='S');
}