|
|
Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.
Mensajes - Karman
1
« en: Miércoles 7 de Enero de 2009, 09:24 »
y como hacia tiempo que no actualizabas la pagina, no te escribi.
Mil gracias Karman!!!. es que ando con poco tiempo... entre el laburo y la facu... no me quedan ganas... je S2
2
« en: Miércoles 7 de Enero de 2009, 06:57 »
hace mucho que no posteo acá... pero esto es lo que buscas: en el H: // ------------------------------------------------------ // SharedMemoryLib.h // Shared memory functions HEADERS // by Ni Idea, modificated by Karman // ------------------------------------------------------ #ifndef _SHAREDMEM_H_ #define _SHAREDMEM_H_ #include <windows.h> #include <stdio.h> typedef struct _SharedMemory_{ HANDLE hFile; LPDWORD hView; }SharedMemory,*PSharedMemory; #ifdef _cplusplus extern "C" { #endif BOOL CreateSharedMemoryArea(PSharedMemory psm,LPSTR SMName,DWORD size); BOOL OpenSharedMemory(PSharedMemory psm,LPSTR SMName); BOOL DestroySharedMemoryArea(PSharedMemory psm); VOID WriteOnSharedMemory(PSharedMemory psm,DWORD data, DWORD position); VOID ReadFromSharedMemory(PSharedMemory psm,LPDWORD data, DWORD position); #ifdef _cplusplus } #endif #endif /* _SHAREDMEM_H_ */
y en el C: // ------------------------------------------------------ // Shared memory func. by Ni Idea, modificated by Karman // ------------------------------------------------------ #include <SharedMemLib.h> //-------------------------------------------------------- // //-------------------------------------------------------- BOOL CreateSharedMemoryArea(PSharedMemory psm,LPSTR SMName,DWORD size){ psm->hFile = CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,sizeof(DWORD)*size,SMName); if(!psm->hFile)return FALSE; psm->hView = MapViewOfFile(psm->hFile,FILE_MAP_ALL_ACCESS,0,0,0); if(!psm->hView){ CloseHandle(psm->hFile); return FALSE; } return TRUE; } //-------------------------------------------------------- // //-------------------------------------------------------- BOOL OpenSharedMemory(PSharedMemory psm,LPSTR SMName){ psm->hFile = OpenFileMapping(FILE_MAP_ALL_ACCESS,FALSE,SMName); if(!psm->hFile)return FALSE; psm->hView= MapViewOfFile(psm->hFile,FILE_MAP_ALL_ACCESS,0,0,0); if(!psm->hView){ CloseHandle(psm->hFile); return FALSE; } return TRUE; } //-------------------------------------------------------- // //-------------------------------------------------------- BOOL DestroySharedMemoryArea(PSharedMemory psm){ if(UnmapViewOfFile(psm->hView)&&CloseHandle(psm->hFile))return TRUE; return FALSE; } //-------------------------------------------------------- // //-------------------------------------------------------- VOID WriteOnSharedMemory(PSharedMemory psm,DWORD data, DWORD position){ psm->hView[position] = data; } //-------------------------------------------------------- // //-------------------------------------------------------- VOID ReadFromSharedMemory(PSharedMemory psm,LPDWORD data, DWORD position){ *data = psm->hView[position]; }
uso: #define shmemname "un nombre!!! xD" ... SharedMemory MyShMem; //Creamos un bloque de memoria compartida... if(!CreateSharedMemoryArea(&MyShMem,shmemname,2)){ MessageBox(NULL,"Fallo al alocar memoria...",0,0); return FALSE; } //Inicializamos... WriteOnSharedMemory(&MyShMem,variable,0); **** if(!OpenSharedMemory(&MyShMem,shmemname)) return FALSE; ReadFromSharedMemory(&MyShMem,(LPDWORD)&variable,0);
S2
3
« en: Sábado 21 de Junio de 2008, 03:54 »
bueno, son muchos los conceptos que se cruzan, en la práctica, cuanto más sencillo sea un lenguaje de aprender más limitaciones tendrá este y más recursos utilizará (vb solo corre en Windows, por lo cual necesitarías Windows y su licencia), porque no se puede crear un lenguaje inteligente todavía, esto que quiere decir? los lenguajes de 4º generación (vb, pb) se basan en conceptos o usos comunes y al generar los códigos no analizan si lo que se quiere hacer es un "hola mundo" o un programa para administrar una mega-empresa, con lo cual no se logra un grado de eficiencia (la eficiencia se mide con beneficio/costo), por ejemplo si vos necesitas un programa para capturar las transacciones de un supermercado, cajeros automáticos u otras empresas u organizaciones, (dependiendo de la complejidad) se podrían crear en C o C++ y el equipo para correr tu programa podría ser un pentium 1, mientras que si deseas utilizar un programa en vb, necesitarías equipos más grandes, y en una empresa que tiene 300 o más ordenadores, comprar 300 p1 es mucho más económico que comprar 300 P3 o P4, esa es una de las razones por la cual Vista no logró demasiada aceptación, (no cumple la regla beneficio/costo), además (de todas formas) más allá de existir lenguajes de ese tipo, existen librerías libres (si no importa la condición beneficio/costo) como wxWidgets o QT que permiten la realización de programas relativamente simples sobre C++ (añadiendo además la posibilidad de multiplataforma)...
S2
4
« en: Jueves 27 de Marzo de 2008, 04:38 »
TB está la programación lógica (prolog) que es utilizada para inteligencia artificial...
S2
5
« en: Miércoles 19 de Marzo de 2008, 15:21 »
fijate esta pequeña librería: Calculadora de funciones en strings del tipo: "2^5/(2*8)+9^(1/2)-(ln(e(1)))*(cos(25)-sin(60))" fue algo que me llevó mucho tiempo hacer y que lo hice sin nada de referencia así que posiblemente pueda ser optimizado...  source C Código /* Name: StrCalc.c Copyright: Exinferis Inc.- 1999-2006 URL: http://www.inexinferis.co.nr Author: Karman Date: 12/05/05 15:13 Version: 0.95 Description: Calculadora de Strings... Operandos: Enteros, Reales y () Operaciones Permitidas: Matemáticas: + - / * % ^ Funciones: asin(x) - ArcoSeno acos(x) - ArcoCoseno atan(x) - ArcoTangente abs(x) - Absoluto (+) sin(x) - Seno sinh(x) - Seno hiperbólico cos(x) - Coseno cosh(x) - Coseno hiperbólico tan(x) - Tangente tanh(x) - Tangente hiperbólica ln(x) - Logaritmo natural log(x) - Logaritmo base 10 e(x) - e a la n rand(x) - Número aleatorio rnd(x) - Redondeo int(x) - Truncado a entero Example: Calculate("2^5/(2*8)+9^(1/2)-(ln(e(1)))*(cos(90)-sin(90))"); */ #include "strcalc.h" //Modo radianes (rad=1) modo normal (rad=0) char rad=0; char *fstart=0,*errpos=0; //Funciones válidas FUNC func[]={ {"asin(",'a'},{"acos(",'b'},{"atan(",'d'},{"abs(",'j'},{"sin(",'s'}, {"sinh(",'f'},{"cos(",'c'},{"cosh(",'g'},{"tan(",'t'},{"tanh(",'h'}, {"ln(",'n'},{"log(",'l'},{"e(",'e'},{"rand(",'r'},{"rnd(",'u'},{"int(",'i'} }; //******************************************************** // Devuelve la posición del error... (si hubo alguno) //******************************************************** unsigned char GetFunctionErrorPos(void){ return (unsigned char)(errpos-fstart); } //******************************************************** // Devuelve el error... (si hubo alguno) //******************************************************** char *GetFunctionError(void){ return errpos; } //******************************************************** // Libera lista en caso de error... //******************************************************** void freelist(PCALCS prim){ PCALCS tmp; while(prim){ tmp=prim;prim=prim->sig;free(tmp); } } //******************************************************** // Calcula lista de operaciones-operandos... //******************************************************** double CalcOp(PCALCS pcy){ double res=0;PCALCS tpcy; while(pcy){ switch(pcy->op){ case '=':res=pcy->val;break; case '^':res=pow(res,pcy->val);break; case '%':res=fmod(res,pcy->val);break; case '*':res=res*pcy->val;break; case '/':res=res/pcy->val;break; case '+':res=res+pcy->val;break; case '-':res=res-pcy->val;break; //Arc trig. functions case 'a': if(rad)res=asin(pcy->val); else res=(asin(pcy->val)*180)/M_PI; break; case 'b': if(rad)res=acos(pcy->val); else res=(acos(pcy->val)*180)/M_PI; break; case 'd': if(rad)res=atan(pcy->val); else res=(atan(pcy->val)*180)/M_PI; break; //Trig. Functions case 's': if(rad)res=sin(pcy->val); else res=sin((pcy->val*M_PI)/180); break; case 'c': if(rad)res=cos(pcy->val); else res=cos((pcy->val*M_PI)/180); break; case 't': if(rad)res=tan(pcy->val); else res=tan((pcy->val*M_PI)/180); break; //Hip. Functions case 'f':res=sinh(pcy->val);break; case 'g':res=cosh(pcy->val);break; case 'h':res=tanh(pcy->val);break; //Other functions case 'n':res=log(pcy->val);break; case 'l':res=log10(pcy->val);break; case 'e':res=exp(pcy->val);break; case 'j':res=fabs(pcy->val);break; case 'r':res=fmod(rand(),pcy->val);break; case 'i':modf(pcy->val,&res);break; case 'u':res=ceill(pcy->val);break; default:res=0; } tpcy=pcy;pcy=pcy->sig;free(tpcy); } return res; } //******************************************************** // Obtiene el número del String... //******************************************************** double GetNum(char **txt){ double tmp=0;unsigned char des=0; while((**txt)&&(isdigit(**txt)||((**txt)=='.')||((**txt)==' '))){ //Controlamos espacios en blanco... if(**txt==' '){ while(**txt==' ')(*txt)++; continue; } if((**txt)=='.') if(des){ errpos=*txt; return 0; }else{ des=1; (*txt)++; continue; } if(des) tmp=tmp+((*((*txt)++)-0x30)/pow(10,des++)); else tmp=(tmp*10)+(*((*txt)++)-0x30); } if(des&&tmp==0){ errpos=*txt; return 0; } else return tmp; } //******************************************************** // Genera lista de Operadores-Operandos y administra // resultados... (recursivo) //******************************************************** static double Calc(char **py,char lop,double lval){ char *pyt,*opy,cp,trig,tmp[256]; unsigned char av,flen,nfunc=sizeof(func)/sizeof(func[0]); PCALCS prim=NULL,tp=NULL,atp=NULL,tq,tt; while(**py){ //Controlamos espacios en blanco... while(**py==' ')*py++; //Nuevo elemento... if(tp)atp=tp; tp=(PCALCS)malloc(sizeof(CALCS)); if(!prim)prim=tp;else tq->sig=tp; tq=tp;tp->sig=NULL; //Operación? if(lval){//Argumento enviado... tp->val=lval;tp->op='=';lval=0;continue; } //primer operación... if(isoper(**py))//Es una operación? switch(**py){ //Suma Resta prioridad 3... case '+':case '-': switch(lop){ case '*':case '^':case '%': atp->sig=NULL;free(tp); return CalcOp(prim); case '+': tp->op=*(*py)++; break; default: goto OnError;//Error... } break; //Multiplicación Divición prioridad 2... case '*':case '/': switch(lop){ case '^':case '%': atp->sig=NULL;free(tp); return CalcOp(prim); case '*':tp->op=*(*py)++;break; case '+': atp->val=Calc(&(*py),'*',atp->val); atp->sig=NULL;free(tp);tp=NULL;tq=atp; if(errpos!=fstart) goto OnError;//Error... continue; default: goto OnError;//Error... } break; //Modulo prioridad 1... case '%': switch(lop){ case '^': atp->sig=NULL;free(tp); return CalcOp(prim); case '%':tp->op=*(*py)++;break; case '+':case '*': atp->val=Calc(&(*py),'%',atp->val); atp->sig=NULL;free(tp);tp=NULL;tq=atp; if(errpos!=fstart) goto OnError;//Error... continue; default: goto OnError;//Error... } break; //Potencia prioridad 0... case '^': switch(lop){ case '^':tp->op=*(*py)++;break; case '+':case '*':case '%': atp->val=Calc(&(*py),'^',atp->val); atp->sig=NULL;free(tp);tp=NULL;tq=atp; if(errpos!=fstart) goto OnError;//Error... continue; default: goto OnError;//Error... } break; default: goto OnError;//Error... } else //Restantes opciones... tp->op='='; //Obtenemos argumento... if(isdigit(**py)||((**py)=='.')){ tp->val=GetNum(&(*py)); if(errpos!=fstart) goto OnError;//Error... }else{ trig=0; //Parentesis... if(**py=='(')goto CalcCont; //Funciones... for(av=0;av<nfunc;av++){ flen=strlen(func[av].fname); if(!strncmp(*py,func[av].fname,flen)){ (*py)+=flen-1;trig=func[av].func; goto CalcCont; } } //Tratamos Error... goto OnError;//Error... CalcCont://Calculamos contenido de "()" pyt=tmp;cp=1;(*py)++;opy=*py; while(**py){ if(**py=='(')++cp; if(**py==')')--cp; if(!cp)break; *(pyt++)=*(*py)++; } if(cp) goto OnError;//Error... *pyt=0;(*py)++;pyt=tmp; tp->val=Calc(&pyt,'+',0); if(errpos!=fstart){ *py=opy; goto OnError;//Error... } //Resolvemos funciones... if(trig){ tt=(PCALCS)malloc(sizeof(CALCS)); tt->sig=NULL; tt->op=trig; tt->val=tp->val; tp->val=CalcOp(tt); } } } return CalcOp(prim); OnError://Error... errpos=*py; freelist(prim); return 0; } //******************************************************** // Verifica String y llama a la función de cálculo... //******************************************************** double Calculate(char *arg){ fstart=errpos=arg; if(strlen(arg)>256){//256 caracteres Máximo... errpos=arg+256; return 0; } return Calc(&arg,'+',0); }
source H Código #ifndef _STRCALCLIB_H_ #define _STRCALCLIB_H_ #include <string.h> #include <stdlib.h> #include <ctype.h> #include <math.h> //Operaciones válidas #define isoper(a) (a=='+')||(a=='-')||(a=='*')||(a=='/')||(a=='^')||(a=='%') //******************************************************** // Registro de funciones... //******************************************************** typedef struct _FUNC_{ char fname[6],func; }FUNC; //******************************************************** // Lista de argumentos... //******************************************************** typedef struct calcs{ double val; char op; struct calcs *sig; }CALCS,*PCALCS; //******************************************************** // Funciones Exportadas... //******************************************************** double Calculate(char *arg); unsigned char GetFunctionErrorPos(void); char *GetFunctionError(void); #endif //_STRCALCLIB_H_
S2 PD: más info como funciona en mi pag...
6
« en: Sábado 17 de Noviembre de 2007, 01:56 »
En realidad no es esto lo quiero del todo no hay algo para programar en nivel mas bajo casi en ensamblador.... en plan de yo crear el cuadrado de la ventana y esas cosas
Para qué? sería como re-programar un sistema operativo, además... estas "ventanas" son totalmente modificables y configurables... para qué querer reinventar la pólvora? S2
7
« en: Viernes 16 de Noviembre de 2007, 14:08 »
8
« en: Martes 6 de Noviembre de 2007, 15:23 »
tu problema es un problema de diseño:
en tablero definís una matriz de células (genéricas) y cuando llamas a que imprima dicha matriz lo más obvio es que te lo imprima como células genéricas (no como especializadas), para que te las imprima como especializadas tenes varias opciones:
1º Que tu célula genérica solo contenga funciones virtuales puras, entonces en cada llamada a imprimir se llamará a las funciones derivadas, pero para eso tendrías que definir un nuevo tipo de célula (célula muerta?) que ocupe los casilleros vacíos<---- Polimorfismo
2º Definir un tercer tipo de célula (casilla por ejemplo) que derive de los dos tipos de células especializadas y que al imprimir analice el tipo y llame a uno u otro método, o imprima '_' <----- Derivación múltiple
3º (como te lo resolví) eliminar de las células especializadas las funciones redundantes y colocarlas únicamente en célula (la especialización es solo la identidad, pero el comportamiento creo que es el mismo, eso creo... cualquier cosa fijate) entonces al llamar a imprimir, la célula genérica se encarga de todo...
S2
9
« en: Martes 6 de Noviembre de 2007, 13:40 »
Es la única forma... pero podés usar algo como esto:
void clrbuf(void){
while( getch()!='\n' );
}
S2
10
« en: Martes 6 de Noviembre de 2007, 01:38 »
No, no son suficientes detalles... tu problema es un problema de implementación... hay que ver como estás implementando tus clases y las relaciones...
S2
11
« en: Lunes 5 de Noviembre de 2007, 13:16 »
casilla[k][l] = Celula; //<- Esta es la linea donde me pide una expresión primaria antes del;
qué quieres hacer con esto? para que asignas a un array de objetos la clase? ya tienes el objeto creado, prueba hacer un: casilla [j]->algo();
for (int i = 0; i < limi; i++){
for (int j = 0; j < limj; j++)
delete[] casilla[j];
delete []casilla;
}
S2
12
« en: Sábado 27 de Octubre de 2007, 19:02 »
Por cierto ahora que lo veo con el tipo de retorno hiciste trampa:
No hice trampa... "Main() must return int"... S2
13
« en: Sábado 27 de Octubre de 2007, 07:39 »
Ademas si lo que decis fuera cierto cadena de caracteres ocuparia 4 * caracter y eso no es asi ...
no... no dije que si tuviera una cadena cada elemento ocuparía un byte... ya que las cadenas se agrupan en bytes consecutivos y el procesador mediante el índice (byte) puede ir pasando de caracter a caracter.... QUOTE (Karman @ Octubre 26, 2007 03:09 pm)
es por eso que en muchos manuales te dicen que es recomendable usar solo variables int ya que de todas formas siempre utilizas 32 bits...
Me parece que estas confundiendo con el tema de "alineamiento" a 32 bits.
no... lo que yo digo es para definir variables comunes, como contadores, etc... no para el trabajo con strings... y recomendaban justamente eso por lo que te mostré en el código en assembler... S2
14
« en: Viernes 26 de Octubre de 2007, 15:09 »
La verdad en todas las plataformas que trabajé vi eso, fijate: char a,b,c; a='A'; printf("hola %c",a); b=a-1; printf("chau %c",b); c=a+b; printf("%c",c); return (int)b;
:004012FF BA 41000000 mov edx, 00000041:00401304 89542404 mov dword ptr [esp+04], edx :00401308 E863050000 Call 00401870 (* Reference To: msvcrt.printf, Ord:027Fh) :0040130D C7042408304000 mov dword ptr [esp], 00403008 :00401314 B8 40000000 mov eax, 00000040:00401319 89442404 mov dword ptr [esp+04], eax :0040131D E84E050000 Call 00401870 (* Reference To: msvcrt.printf, Ord:027Fh ) :00401322 C70424 81FFFFFF mov dword ptr [esp], FFFFFF81:00401329 E832050000 Call 00401860 (* Reference To: msvcrt.putchar, Ord:0281h) :0040132E C9 leave :0040132F B8 40000000 mov eax, 00000040:00401334 C3 ret es por eso que en muchos manuales te dicen que es recomendable usar solo variables int ya que de todas formas siempre utilizas 32 bits... S2 PD: Y en el mejor de los casos, con instrucciones como: mov byte ptr [edx], 41 el registro edx termina conteniendo: 0x00000041
15
« en: Viernes 26 de Octubre de 2007, 06:14 »
Para que entiendas el tema del tamaño de un puntero, un puntero es una variable (un espacio de memoria) que contiene la dirección de otra variable o (en su defecto) de ninguna, te pongo un ejemplo simple: char a='A'; Dependiendo de la máquina y del modelo de memoria que se utilice tenes las siguientes posibilidades: 16bits 32bits 64bits [00|56] [00|00|00|56] [00|00|00|00|00|00|00|56]
donde 56 = 'A' (no recuerdo si era ese valor... pero es un valor parecido si no), como ves, se desperdician varios bytes de memoria... pero eso es otro tema... la cosa es que nuestra famosa variable a se puede encontrar en la posición de memoria: 16bits 32bits 64bits [23df] [45ab87cd] [53463bfade4525fe]
entonces: char *p; debe ser capaz de almacenar dicha dirección, es por esto que p, será de 16, 32, 64, 128 o el modelo de memoria que se utilice... S2
16
« en: Viernes 26 de Octubre de 2007, 05:52 »
si tu problema únicamente es el redondeo, lo que te conviene hacer es:
d=n/100;
ceil(x) redondea el numero x al entero mas pequeno que no sea menor que x...
ej: ceil(9.2)=10
floor(x) redondea a x al entero mas grande no mayor de x...
ej: floor(9.2)=9
y luego lo vuelves a multiplicar por 100...
S2
17
« en: Viernes 12 de Octubre de 2007, 18:02 »
1º si no me equivoco el operador "+=" sirve para concatenar strings y no chars, (no estoy seguro), pero se me hace que tu error podría estar ahí cuando busca el fin de línea empieza a leer memoria contigua que no pertenece a la variable. Prueba así: char c[]={0,0}; c[0]=readchar(); while (not esSeparador (cin.peek (), MARCAFINAL)) { c[0]=readchar(); letras += c; } }
S2
18
« en: Jueves 4 de Octubre de 2007, 03:32 »
hola...
[Warning] passing arg 1 of `fscanf' makes pointer from integer without a cast
esto te dice que lo que estás pasando de parámetro 1 a fscanf es erróneo... si vemos la definición de fscanf:
int fscanf (FILE *stream, const char *template, ...)
se ve que el primer parámetro es la dirección a un identificador de archivo... pero vos no abriste ningún archivo... entonces deduzco que quisiste usar "scanf" y no fscanf, veamos la definición de scanf...
int scanf (const char *template, ...)
entonces lo que vos querés hacer se hace así:
scanf("%d",&opc);
PD: Cuando tengas un error y aparezca el nombre de una función como parte de la descripción, búscala en la web para saber cuales son sus argumentos...
S2
19
« en: Jueves 20 de Septiembre de 2007, 16:58 »
¿Por qué Dev-C++ crea un ejecutable diferente en mi pc que en la de mi amigo con exactamente el mismo codigo?
Existen solamente 3 respuestas a tu pregunta: 1- Versión distinta de codigo 2- Versión distinta de compilador 3- Parámetros distintos de compilación Lo que te lleva a: si las tres condiciones anteriores son falsas los ejecutables son iguales, y para comprobarlo existen varios programas que comparan códigos binarios (por ejemplo Ultra Compare <- Parte de Ultra Edit). El error, lo más probable, es que sea una falla tuya, y el programa funciona mientras no se ejecuten ciertas sentencias (lo que se denomina "Exploit"), o en un caso más dificil, que las dll que utiliza tu programa sean distintas en cada máquina... pero es dificil... S2
20
« en: Martes 18 de Septiembre de 2007, 02:44 »
wxTextCtrl::GetValue() devuelve un puntero a un objeto wxString, lo que deberías preguntar es si dicho string no es nulo mediante:
wxString::IsEmpty()
el código te quedaría:
if(WxEdit1->GetValue()->IsEmpty())
{
wxMessageBox("Debe escribir el nombre del fichero!!");
}
else
{
wxMessageBox("La ruta se guardo satisfactoriamente.");
}
}
S2
21
« en: Domingo 16 de Septiembre de 2007, 06:23 »
La verdad no sé muy bien como es en esa versión del Visual Studio, pero en la 2003 tenés que ir a proyecto->Propiedades de... ->General -> y setear todo para que no incluya dependencias externas: uso de mfc: utilizar librerías estandares y las demás tb (depende qué características utilices) espero te sirva de algo...  S2
22
« en: Domingo 9 de Septiembre de 2007, 03:58 »
la función la hice hace mucho... y funcionaba con el viejo Mingw... fijate lo que encontré en la librería stdlib.h: /* * NOTE: Officially the three following functions are obsolete. The Win32 API * functions SetErrorMode, Beep and Sleep are their replacements. */ _CRTIMP void __cdecl _beep (unsigned int, unsigned int); _CRTIMP void __cdecl _seterrormode (int); _CRTIMP void __cdecl _sleep (unsigned long);
Tendrías que probar con sus remplazos del Win32 API (en "Windows.h") si programás en windows o esas mismas funciones pero sin los "_" si lo hacés en linux... Saludos
23
« en: Jueves 6 de Septiembre de 2007, 16:01 »
si querés usar sonidos monotonos... fijate esta función, la creé hace unos cuantos años basándome en una función de QBASIC... //Devuelve las potencias de un número entero (usada por play) //Nota: la función pow() en "math.h" realiza también esta tarea pero //esta diseñada para números del tipo double... int pot(int x, int p)//funcion usada por play... {int x1;if(p)x1=x;else x1=1; for(int a=1;a<p;a++)x1=x1*x; return x1;} /*Reproduce notas musicales por el altavoz del sistema (solo letras en mayusculas) Comandos de octava y tono: O-Octava Establece la octava actual (0 - 6). A - G Toca la nota especificada en la octava actual. Comandos de duración y tempo: L-duración Define la duración de cada nota (1 - 64). L1 es redonda, L2 es blanca, etc.. P-pausa Hace una pausa (1 - 64). P1 es una pausa de redonda, P2 es una pausa de blanca. */ void play(char *mu)//#include stdlib.h & string .h { int t,tn,o,nota,a,va,xt,x[2]; tn=1536;o=4;//Parametros por defecto int ox[]={6,7,1,2,3,4,5}; for(int s=0;s<strlen(mu);s++){a=int(mu[s]); if(a==76||a==80){xt=0;va=0;//P y L for(int av=0;av<2;av++){x[av]=int(mu[s+(2-av)])-48; if(x[av]<=9)xt+=x[av]*pot(10,va++);} if(a==80)_sleep(tn/xt);else t=tn/xt;} //P if(a==79)o=(int(mu[++s])-48)%8;//O if(a>64&&a<72)//A,B,C,D,E,F,G {nota=pot(2,o+3)*(ox[a-65]+7)+16;_beep(nota,t);}}} /* Ejemplo: play("L12FP32L4DCD"); ... play("O0L5C"); */
S2
24
« en: Sábado 1 de Septiembre de 2007, 04:58 »
tu problema está acá: primero, guardás el caracter a buscar en un string: gets(t); gets almacena un estring, no un caracter, entonces estás comparando un caracter (s ) con un string (s) que en realidad tendría que ser t, pero que no deja de ser un string, la forma correcta de hacerlo sería:
char t; ... t= (char)getchar(); ... if(s[i]==t){ ...
Saludos
25
« en: Sábado 1 de Septiembre de 2007, 04:47 »
la forma correcta sería con cprintf, cputs, etc... pero desconozco si el conio.h que trae por defecto el devcpp las incluye... si no las incluye tendrías que bajarte alguno de los emuladores de CONIO que hay dando vueltas por la web... uno está justamente en mi sitio... je...
Saludos
|
|
|
Mostrar Mensajes
