C/Visual C - Punteros y Memoria

Yo estoy practicando es de los punteros, pero cuando quiero buscar su tamaño en memoria no sale muy bien:
Aqui les doy un ejemplo:
int tamaño(int *p)
{
int n = sizeof(p) / sizeof(p[0]);
return n;
}
main()
{
int otro_p[5];
printf("%d",tamaño(p));
getch();//Esto solo por diversion
}

Y esto es lo q sale:
2

Claro,si a Tamaño le pasas una variable "puntero a entero" te debuelve el tamaño de un puntero a entero que es 2 bytes si estás compilando en 16bits.Por eso muchas funciones, como memcpy necesitan una declaracion explicita del tamaño de lo que se copia.

Si, pero estaba tratando y si buscas las posiciones del array y encuentras el vacio, eso te puede decir el tamaño(bueno, eso funciona con char, pero con int es un poco mas complicado):
int tamaño(int *p)
{
int cont;
for(int i=0;p[i]!=0;i++)
cont++;
return cont;
}
int tamaño(char *s)
{
int cont;
for(int i=0;s[i]!=0;i++)
cont++;
return cont;
}
main()
{
char *s;
int *p;
printf("%d", tamaño(p));
printf("%d",tamaño(s));
printf("%d",tamaño("string"));
getch();
}
bueno, esto no lo he probado aun, pero podria funcionar y me sorprenderia mucho si no lo hiciera.
El problema es cuando aun no han puesto los valores y cuando se habla de estructuras.

En realidad hablar de char o int es lo mismo en lo referente a determinar el tamaño.

El problema es que determinar en tiempo de ejecución el tamaño de la memoria reservada a la que apunta el puntero es imposible. Solo podemos determinar las posiciones ocupadas siempre y cuando usemos el mecanismo que usan los string que no es más que marcar la última posición como nulo. Expongo un ejemplo clarificador:

char Texto[20]="Esto es un texto";
char *puntero=Texto;

strlen(p);
// Nos devolverá un valor de 16, pero en realidad solo es el tamaño del texto actual
// Es imposible obtener el valor 20 que es el tamaño total de Texto

Esto sería igualmente aplicable a otros tipos de datos y estructuras, si usamos valores nulos para el último elemento dentro del array, podremos obtener el número de elementos almacenados en ese momento, pero nunca podremos obtener el tamaño total, ya sea para arrays estaticos con tamaño determinado en tiempo de diseño como para arrays de memoria dinámica.

Bueno ... no es del todo cierto ...

Puedes probar esto:

#include <stdio.h>
#include <stdlib.h>

int main() {
int tmp[10];
int *ptmp = tmp;
char tmp1[120];
char *ptmp1 = tmp1;

printf("%u\n%u\n", sizeof(tmp), sizeof(ptmp));
printf("%u\n%u\n", sizeof(tmp1), sizeof(ptmp1));
return(0);
}

y verás la diferencia ...
El operador sizeof(), en c, se evalúa en tiempo de compilación, por eso es capaz de determinar correctamente el tamaño de algunas zonas, pero no de otras.

En este caso, sizeof(tmp) se evalúa correctamente, ya que es el propio compilador quien asigna el espacio de memoria ("estática") para tmp.

Respecto a los strings ... una cosa es el tamaño de la memoria reservada y otra es la longitud del string; de hecho nunca deben coincidir :D

Hola Tom:

Se me habia olvidado mencionar el operador sizeof, aunque creo que explicado así puede generar confusion a los principiantes. Me permitirás ampliar tu información :D

El operador sizeof() da el tamaño en Bytes de variables y estructuras con un tamaño estático asignado en tiempo de diseño. Para que lo entienda todo el mundo, el compilador lo que hace es calcular el tamaño, siempre en Bytes, de la variable y sustituirlo en lugar de la etiqueta sizeof. Ejemplo:

int tmp[10];
sizeof(tmp);

El compilador determina el tamaño en bytes de un entero (int) y lo multiplica por 10. Hay que tener en cuenta que el tamaño de un entero depende del compilador y el entorno para el que desarrolla, 16bits/32bits, obteniendo 2*10=20 o 4*10=40.

Asi es facil darse cuenta que solamente podemos conocer el tamaño de aquellas variables y estructuras que hayamos definido su tamaño previamente. El operador sizeof solamente nos evitará tener que realizar el calculo nosotros mismos y nos evitará cambiar dichos cálculos cada vez que cambiemos algún tamaño.

Aunque como bien indica Tom, podemos obtener el tamaño de tmp de la siguiente manera:

Tamaño_Array = sizeof(tmp) / sizeof(int);
// Tamaño_Array = 40 / 4 = 10 ( no necesitamos saber el tamaño de un entero )

Bueno, sizeof() es muy util en esos casos, pero cuando quieres saber el tamaño de un array con sizeof() en una funcion declarada por ejemplo:
int funcion(int array[])
{
return sizeof(array);
}
devuelve 2, en vez del valor real del array y claro esta que eso es muy inadecuado para trabajar con programas mas genericos, como controlar el uso de un numero indeterminado de links o de botones.
Eso se podria arreglar un poco si declaramos el tamaño del array, pero para siempre seria un poco tedioso trabajar de ese modo.