Mensajes

Hola gente, buenos dias, tengo una duda con un código que es muy básico sin embargo quisiera entender porque actua como actua.

En C, cuando ingresabas un caracter al programa c tomaba ese caracter del buffer y dejaba el caracter nulo de terminación osea \0 eso en ciertas ocasiones ocasionaba que c pensara que en el buffer ya estaba ingresado una caracter y lo tomaba, obviamente para ello tenia que limpiarse con anticipación.

Bueno yo estoy aprendiendo ensamblador y sucede que cuando voy a dividir un numero que ha sido entrado desde el teclado, siempre ocurre que en el resultado hay 5 unidades más. Luego investigue en internet y encontre un código similar al mio pero que funcionaba de maravilla lo estuve estudiando y la diferencia que encontre es que tenia la linea para limpiexa del registro de ax:

xor ax,ax

Se me vino a la mente la posibilidad de que ocurriera algo similar en ensamblador, estuve investigando pero no encuentro nada que haga referencia al teclado, entradas, buffer o algo parecido a lo que imagino. Alguien podría explicarme que sucede realmente?, les dejo una copia de mi código y una copia del código que encontre en internet.


Código que encontre en internet:

Código [Seleccionar] Expandir

.model small
.stack 100
.data
msj1 db 'Numero 1: ','$'
msj2 db 13,10,'Numero 2: ','$'
msj6 db 13,10,'Division: ','$'
var1 db ?
var2 db ?
.code
.startup
mov ah,09h
lea dx, msj1 ;desplegar numero 1:
int 21h

mov ah,01h;leer caracter desde el teclado
int 21h;lee primer caracter
sub al,30h ;restar 30h para obtener el numero
mov var1,al ;lo guardo en var1
mov ah,09h
lea dx, msj2 ;desplegar numero 2:
int 21h

mov ah,01h;leer caracter desde el teclado
int 21h;lee primer caracter
mov bl, al ;mover a bl
;*****************DIVISION
xor ax,ax ;limpiamos el registro ax.
mov al,var1
div bl ; divide AX/BX el resultado lo almacena en AX, el residuo queda en DX
mov dl, al
add dl,30h
mov ah,02h
int 21h
.exit
end


Mi código:

Código [Seleccionar] Expandir

.model small
stack 100h
.data
num1 db 13,10,'Numero 1: $'
num2 db 13,10,'Numero 2: $'
resultado db 13,10,"Resultado:","$"
divisor db 0
dividendo db 0
.code
.startup
mov ah,09h
lea dx, num1 ;desplegar numero 1:
int 21h
mov ah, 01h
int 21h
mov dividendo, al
mov ah,09h
lea dx, num2
int 21h
mov ah, 01h
int 21h
mov divisor, al
mov bl, al
div bl
add al, 48
mov dl, al
mov ah, 02h
int 21h
mov ah,4ch
int 21h
end

Si es un error ortográfico muy feo, pero gracias por la explicación de las dobles comillas también tenia duda. Bueno pues lo marcare como resuelto, fue de gran ayuda tu respuesta.

Hola que tal, pues bueno actualmente no tengo ningún error en mi código usando malloc, sin embargo tengo una duda:

cuando utilizo esto:
char *MessageToSend;
MessageToSend=(char *)malloc(1 * sizeof(char);

porque al usar lo siguiente:

MessageToSend[0]="1";
MessageToSend[1]="1";
MessageToSend[2]="\0";

no me tirar error de que estoy desbordando el arreglo dinámico?

si lo hicieramos como si fuera un array estatico si tiraria el error, además tengo la duda de que si estoy reservando direcciones de memoria o estoy reservando posiciones de memoria, en este caso es de tipo char.

Espero haberme dado a entender.
****************************************************
Hola creo encontre la solución en este post:
http://www.foro.lospillaos.es/viewtopic.php?p=10767

Mariano Demarchi escribió:
> Programante escribió:
> >Tal vez la cadena no sea lo bastante larga. O estás desbordando otra
> >zona de memoria.
> >Si está reservada en el montón, tendrás al menos una página
> >(habitualmente 4096 bytes)
> >de espacio reservado para el proceso. Después puede que haya más espacio
> >reservado
> >para el programa (por ejemplo variables del entorno) y siga
> >sobreescribiendo alegremente
> >hasta que se acaba la cadena.
> Cuando se hace una llamada a malloc(), la memoria se reserva en el
> heap que es una porcion de memoria libre con este proposito, el
> alojamiento dinamico.
> Yo no se como funciona internamente malloc, esto depende de que
> algoritmo se ha usado lo cual puede cambiar de version en version de
> la libreria, pero hice algunas pruebas y siempre que hice
> (malloc(sizeof(int)*k),
> con k={1..6}, en sucesivas llamadas las posiciones de los bloques
> reservados difieren 32 bytes,
> con k={7..10}, en sucesivas llamadas las posiciones de los bloques
> reservados difieren 48 bytes,
> con k={11..}, en sucesivas llamadas las posiciones de los bloques
> reservados difieren 64 bytes
> hay que tener en cuenta que tengo ints de 4 bytes.
> Por otro lado cuando hago (malloc(sizeof(char)), se reservan cada 32
> bytes tambien.
> Entonces aparentemente malloc siempre reserva un minimo de 32 bytes,
> mas haya de que no se usen, o quizas solo se trata de una simple
> alineacion de palabras.
malloc() suele tener un tamaño mínimo de reserva por cuestiones de
implementación.
A lo que yo me refería era al espacio que le da el sistema.

Le pides un byte a malloc()
-Malloc decide que te va a dar 32
Malloc pide al SO una página de memoria
-El SO da una página de memoria a tu programa
Malloc separa 32 bytes y te los da a ti.

Simplemente escribiendo el array sólo obtendrás un fallo de segmentación
cuando te salgas de la página que te dio el SO.
Tendrás resultados incorrectos si cambias más allá de lo que te asignó
malloc (modificas otras variables reservadas dinámicamente, o la
estructura interna de la
reserva de memoria, que puede dar violaciones de segmento en free() por
ejemplo).

Es incorrecto escribir más de un byte en esa memoria (pues es lo único
que malloc() te garantiza "tuyo").

¿Alguien podria confirmarme si posiblemente haya encontrado mi respuesta?