Asignar a un puntero 64000bytes

[macc]

                                Como se asigna a un puntero 64000 bytes sin que de error en C/C++. se supone que deberia hacerse asi: unsigned char *puntero = (unsigned char *)malloc(64000);  pero da un error por que dice (constant is long), asi que cambio 64000 por 64000L pero me dice (Conversion may lose significant digits ). Ese error no lo puedo quitar de ninguna manera? es que creo que por culpa de eso se me cuelgan los programas es cuanto muestro 2 o 3 imagenes distintas.                                

[synchrnzr]

                                ¿En qué compilador? En VC++ dudo mucho que te lo dé, ya que malloc() recibe un argumento de tipo size_t que a su vez está definido como un unsigned int y un unsigned int, aunque sea de 16 bits puede llegar a 65536...

Si le pones la L es una especie de typecast en el que le dices que el número es un long y por eso al reducirlo a unsigned int te da el warning.

Sync :guay:

PC (por cierto): no te preocupes, no te peta por eso, te lo garantizo :ojo:

[ Este Mensaje fue editado por: synchrnzr el 2002-06-18 18:25 ]                                

[macc]

                                Es con borland c++ 5.02v. Estoy empezando con esto de los graficos y estoy con el 13h como debe de ser, desde abajo. pero muestro 2 simples imagenes PCX distintas con la misma funcion y si la llamo desde la funcion main y pongo un delay o un getch la seguda no se muestra bien. y si le pongo pa que me muestre 3 se peta del todo "NO SE PUEDE CARGAR COMMAND.COM, error en asignacion de memoria". Pero lo raro es que si muestro todas seguidas (no me da tiempo a verlas todas) se ve perfectamente la ultima y no errores de asignacion de memoria. Por eso creia que era por ese error. gracias de todas formas
                               

[sés]

                                Para quitar el warning (que no error), pon esto:

char *p;

p = (char *)malloc( (size_t)64000 );

                               

[macc]

                                Con eso se quita el warning, aunque se me sigue jodiendo, pero vamos asi estara mejor.
Gracias por todo.
                               

[seryu]

                                Ya ni me acuerdo, pero me temo que eso es un problema con la forma tan cutre que tiene msdos de manejar la memoria.

Si no lo arreglas cuando te en casa t lo miro.                                

[synchrnzr]

                                Yo que ti revisaría los punteros y los accesos a la memoria que has reservado. Apuesto a que si no escribes nada en esas áreas de memoria que has reservado con malloc, no te peta nada (si no me crees comenta las líneas en las que accedes a esas posiciones para escritura y verás... XDDD)

Ni que decir tiene que no te olvides los free... :ojo:

Sync :guay:

[ Este Mensaje fue editado por: synchrnzr el 2002-06-18 19:29 ]                                

[Grugnorr]

                                No recuerdo ya casi nada del modo 13h, pero juraría que sin un extendedor de memoria(DOS4GW??) no podías asignar 64000(320*200), busca algún tutorial por la red, pero prueba a poner justo uno menos 63999... Qué tiempos...prefiero los nuevos tiempo :lengua:
                               

[ProD]

                                Pues si estás usando c++ que carajo haces con el malloc? usa el new

char *pChar = new char[64000];

por cierto en ms-dos modo real.. no puedes asignar más de 64kb de memoria... así que cambiate a compilador y usa el watcom C/C++ que tiene extesor de dos y te deja la memoria en modo flat!! ale que te cunda.
                               

[synchrnzr]

                                Mmmm... Pos yo no recuerdo haber tenido problemas con 64000 bytes. No olvidemos que 64Kb no son 64000 bytes sino 65536, ese límite sí que me consta que es insalvable sin utilizar extensores...

Además, él mismo dice que le compila bien y asumo que ya debe comprobar que el malloc le devuelve un apuntador correctamente (verdad, macc? XDDD)

Ese problema tuyo tiene pinta de memory leak totalmente.

Sync :guay:

[ Este Mensaje fue editado por: synchrnzr el 2002-06-19 10:04 ]                                

[macc]

                                el unico puntero que no libero es el que le asigno directamente a la zona de memoria que usa la tarjeta por que el espacio ya esta reservado(digo yo). y el que yo hago lo libero al final. Las definiciones de punteros las hago asi:
//antes de las funciones
unsigned char *vga = (unsigned char *)MK_FP(0xa000,0);
unsigned char *vgaAux;
//con este en una funcion voy creando la imagen
memset(vgaAux + ((defx * j) + i) , codigo, rep);
//y al final de esa funcion lo muevo a la memoria de video
memcpy(vga , vgaAux, (size_t)64000);
//en el main reservo memoria para este puntero
vgaAux = (unsigned char *)malloc((size_t)64000);
//y lo libero al final del main
free(vgaAux);
//he probado a asignarle memoria en la definicion al principio del programa pero sigue igual, asi que debe de estar el error en algunas de las definiciones o asignaciones que aqui muestro
                               

[ASK]

                                Quitate de cosas, si quieres toneladas de memoria en MS-DOS, usa DJGPP.

http://www.delorie.com/djgpp

Saludos.                                

[sés]

                               

//con este en una funcion voy creando la imagen
memset(vgaAux + ((defx * j) + i) , codigo, rep);

 Tiene pinta de fallar aquí, comprueba que no te salgas de la zona de memoria reservada.                                

[samsaga2]

                                Comprueba que el malloc lo haces antes de usar vgaAux. Comprueba tambien (con un debugger) que ((defx * j) + i) nunca sea mayor que 63999. Comprueba tambien que el punteor codigo apunte a algo que existe y tenga como minimo un tamaño de rep. Comprueba tambien que el malloc no te este devolviendo NULL por falta o fragmentación de memoria.
Y si todo eso no funciona, échale mano al debugger y comprueba linea por linea la ejecución.

//antes de las funciones
unsigned char *vga = (unsigned char *)MK_FP(0xa000,0);
unsigned char *vgaAux;
//con este en una funcion voy creando la imagen
memset(vgaAux + ((defx * j) + i) , codigo, rep);
//y al final de esa funcion lo muevo a la memoria de video
memcpy(vga , vgaAux, (size_t)64000);
//en el main reservo memoria para este puntero
vgaAux = (unsigned char *)malloc((size_t)64000);
//y lo libero al final del main
free(vgaAux);                                

[Vendrethz]

                                Hola a todos.

En mi humilde opinión, creo que el problema reside en el hecho que MS-DOS funciona en modo real, y por tanto, no puede direccionar segmentos mayores que 64KB. Por eso fallaría al reservar tanto espacio, ya que en esos 64KB puede que también se encuentren los datos estáticos o la pila, lo cual nos deja con menos de 64000 bytes para datos dinámicos. Esto explicaría por qué falla aún al comienzo del programa ya que los datos estáticos ya están ahí cuando comenzamos.

Puedes probar a usar la función farmalloc(unsigned long nbytes) que traen los compiladores de Borland, que permite usar bloques superiores a los 64KB. Quizá sea esa la solución a tu problema. Revisa también el modelo de memoria que estás usando (se te quedará corto con tiny y probablemente con small).


//antes de las funciones
unsigned char *vga = (unsigned char *)MK_FP(0xa000,0);
unsigned char *vgaAux;
//con este en una funcion voy creando la imagen
memset(vgaAux + ((defx * j) + i) , codigo, rep);
//y al final de esa funcion lo muevo a la memoria de video
memcpy(vga , vgaAux, (size_t)64000);
//en el main reservo memoria para este puntero
vgaAux = (unsigned char *)farmalloc(64000);

// ** Comprueba siempre que no sea NULL **
if(vgaAux==NULL)
 {
 printf("Memoria insuficiente! (vgaAux)n");
 // ...
 }

//y lo libero al final del main
free(vgaAux);


Suerte :ojo:

PD: Por cierto, aún así te recomiendo que aprendas DirectX u OpenGL en vez de partirte el cráneo aprendiendo a programar multimedia en DOS pues, lo queramos o no, la verdad es que ya está totalmente obsoleto. :triste: