SoloCodigo

Eso no reserva nada ni asigna nada. Solo declaras una variable de tipo char * que esta apuntando a una direccion indefinida (muy probablemente invalida).

vale, reservas una dirección de memoria. Te reserva una direccion de memoria de 1 byte (estamos hablando de los char), pero supongamos que en la siguiente dirección, hay información valiosa, esa información te la cargas, x eso de utilizar el malloc, xq si la cosa va mal, t devuelve un error

Vaya, creo q ahora m exprese mejor

Es tal y como lo dije antes, estas confundido y por eso al intentar reformular seguis diciendo algo incorrecto.

No se reserva ningun tipo de memoria dinamica de esa manera. Solo declaras una variable de tipo char * cuyo valor es incierto y si accedes a ella es muy probable que genere una excepcion no controlada por ser una direccion invalida.

Esto es un error:

No hace falta pasar al "siguiente" byte ya que no estas reservando nada de nada. El VC++ te muestra este warning:

warning C4700: uninitialized local variable 'var' used

Normalmente los punteros se inicializan a 0 siempre y eso te daria una excepcion indefectiblemente.

vaya Eternal Idol, sabes mas que mi profesora de programación (no es que lo diga en tono irónico, es que lo digo en serio)

Por ahi dicen muchos que el que sabe hace y el que no enseña. Como todos los dichos tiene parte de verdad ...

Tendré que corregirme a mi mismo, que dije que hacer una declaración como char *variable, y luego hacer gets(variable) estaba mal, pero veo que no.

Por supuesto que eso tambien esta mal, ya que a gets se le debe pasar como parametro una direccion de memoria valida.

corrigeme si m ekivoco, pero t declaras un puntero (var), y luego dices, que el contenido de ese puntero (*var) cuya dirección es (var) sea 'A', es como si haces esto:

Su direccion es indefinida no es var, al ser una variable local va en la pila y tendra lo que haya en la misma en ese momento.

char *var, var2;
var2 = 'A';
*var=var2; //*var no es el contenido de "var"?

yo pensaba que eso estaba bien, pero parece que tengo un error de conceptos un poco grande.

Tampoco esta bien. La tercera linea es el problema. ¿A donde apunta var? Al inicializarla asi no lo sabes, proba a compilar ese codigo, seguro te da una excepcion no controlada.

Asi si funcionaria:

Hay una cosilla más para agregar.
El tamaño de "puntero a char" llamado "var" no es 1 bytes, es decir, no tiene el tamaño de un "char" sino de un "puntero a char"  que segun el sistema operativo, puede ser 16 (DOS),32bits = 4 bytes(Windows XP),64 bits (Vista version 64).

Efectivamente, ULONG_PTR para los amigos  

buf, ahora si que estoy perdido.... con lo feliz que era en mi ignorancia   , ahora estoy un poco confuso, a ver, los procesadores de 32 bits, por ej, son para procesar instruccines de 32 bits (instrucciones como if, for, etc), mientras que las variables se alojan en memoria (RAM, por lo general). Con los datos y las instrucciones, el procesador hace su trabajo, pero no entiendo que tiene que ver que el SO utilice software de 32 o 64 bits, para que reserve 64 bits para un caracter en el vista de 64 bits, por ejemplo

Otra vez, es que no se reserva memoria dinamica sino que una variable local esta en la pila y para poder APUNTAR a una direccion se necesita un determinado tamaño para poder direccionar a la misma:

Por ejemplo si tuvieras un puntero a la direccion 0xFF00FF00 no podes usar menos de 4 bytes para guardar esa direccion, por mas que sea un puntero a char y que solo el primer byte sea valido.

Y lo mismo si tenes una direccion que es 0xFF00FF00FF00FF00 no podes usar 4 bytes, necesitas 8.

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:


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:


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

char a='A';

Dependiendo de la máquina y del modelo de memoria que se utilice tenes las siguientes posibilidades:

¿Que plataformas conoces donde eso no ocupe un solo byte?

La verdad en todas las plataformas que trabajé vi eso, fijate:

Pero esas son variables en la pila, es tema del compilador, si haces esto:


A y B son consecutivos y no hay ningun cero tras cada caracter, logico. Si usas memoria dinamica la misma historia.

Ademas si lo que decis fuera cierto cadena de caracteres ocuparia 4 * caracter y eso no es asi ...

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.

PD: Y en el mejor de los casos, con instrucciones como:

mov byte ptr [edx], 41

el registro edx termina conteniendo: 0x00000041

Con esa instruccion el valor de edx no se modifica en lo mas minimo, se cambia UNICAMENTE el primer byte (char digamos entonces) de la direccion que contiene edx. Eso es igual a hacer: *var = 'A';

mov edx, 0x41 si tendria el efecto que comentas.

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....

Bueno, igual no es asi ... simplemente proba el codigo que deje, esos dos caracteres separados tienen direcciones consecutivas al no estar en la pila. No es una cuestion de tipo de datos ... por algo sizeof de un char devuelve uno y el compilador es capaz de leer y escribir ese caracter sin problemas, ocupe lo que ocupe por el alineamiento. Otro ejemplo interesante que esta bastante relacionado es este:


¿Cual es el tamaño de esa estructura? Con el VC++ independientemente del packing alignment (P.A.) siempre sizeof es 1.

Vamos a otra:

Con el P.A. por defecto y con el packing a 4 esa estructura ocupa 8 bytes. ¿Que pasa con un P.A. de 1? Ocupa 5 bytes.

Packing alignment:
#pragma pack (show)
#pragma pack (1)
#pragma pack (show)

Un char es un BYTE, incluso cuando esta en la pila ocupando 4 bytes sizeof devuelve 1 y permite trabajar con ese byte unicamente (al menos directamente). Y si ocupa 4 bytes en la pila es por el funcionamiento de la misma:

push 1 = 0x6A 0x1
¿Que pasa con la pila? esp -= 4; o sub esp, 4

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...

Es assembly y tiene sentido usar DWORD a veces por dos razones: el alineamiento a 32 bits y el uso de la pila.

Por cierto ahora que lo veo con el tipo de retorno hiciste trampa:


?x@@YADXZ (char __cdecl x(void)):
  00000000: 55                 push        ebp
  00000001: 8B EC              mov         ebp,esp
 00000003: B0 19              mov         al,19h
  00000005: 5D                 pop         ebp
  00000006: C3                 ret

No hice trampa...  "Main() must return int"...

Estaba en cursiva   Y al fin y al cabo era engañoso, usaba el registro eax por ser int el tipo de retorno (que forzabas mediante casting).