Cita: me podrias explicar la referencia ke aces aki?
*(imagen+i)=i;
for(int i=0; i<ancho*alto; i++) *(imagen+i)=i;
Lo voy a desglosar en partes:
Primero hay que recordar que un apuntador es simplemente un número que indica un determinado sector en la memoria, por ejemplo si tengo un apuntador con valor = 1024 es porque está apuntando al sector 1024 de la memoria.
imagen+i // imagen es un apuntador a un sector de memoria asignado por malloc, es decir es un número, esa memoria es en realidad memoria lineal, por ejemplo si malloc me ha asignado el sector 1024 y he pedido 1024 bytes de memoria, la memoria entre el sector 1024 y 2048 me pertenece, al sumarle i al apuntador lo que estoy haciendo es recorrer la memoria, si i==512 entonces imagen+i es un apuntador a 1536 que está dentro de mi sector de memoria.
*(imagen+i) // aquí lo que se está haciendo es acceder al contenido de la memoria en la posición imagen+i, es lo mismo que el siguiente código:
Código:
int i=612;
int *apuntador;
apuntador=&i; // Se le asigna a "apuntador" la dirección de memoria donde está el valor de i
printf("%d\n", *apuntador); // Si se le quita el * escribe la posición en memoria donde se encuentra i
NOTA: los paréntesis son muy importantes porque si fuese *imagen+i se estaría tomando el valor guardado en imagen y sumándole i a ese valor.
*(imagen+i)=i // está asignando a la posición de memoria imagen+i el valor de i
Cita: eso no se referiria solo al compuesto "i" del puntero de dos dimensiones?
No te entiendo bien, la memoria siempre es lineal sin importar lo que contenga:
imagen=(int*)malloc(ancho*alto*sizeof(int));
se está solicitando memoria por un tamaño x en este caso ancho*alto*tamaño de int, por ejemplo con ancho y alto igual a 2 tendríamos: 2*2*4 (siendo 4 el tamaño en bytes de un int en un equipo de 32bits) por lo tanto se está pidiendo memoria para almacenar 16 bytes, malloc sólo está retornando un apuntador a un sector de la memoria donde hay al menos 16 bytes libres.
for(int i=0; i<ancho*alto; i++)
Estoy recorriendo toda la memoria asignada ( i<ancho*alto ), suponiendo ancho y alto igual a 3, 3*3=9 por lo que estoy asignando a los 9 int del arreglo el valor de i
Cita: Es decir no lo pones como aqui --> *(img + (i + (j*ncols))));
Bueno en este caso sólo quise aplicarlo a tu código, como vi que estabas accediendo a la memoria como si fuese una matriz, mantuve la idea para que se adaptara a lo que necesitaras, tal vez puedes resolver el ejercicio leyendo la memoria de la forma simple *(imagen+i), pero como dije:
Cita: No he revisado que haga bien el trabajo que pone en el ejercicio, sólo me he limitado a revisar que los datos se lean bien desde "imagen"
Cita: Es decir no lo pones como aqui --> *(img + (i + (j*ncols))));
No entendo eso y tb si m podrias explicar de esto ultimo como se aria referencia a ello??
imaginemos que la siguiente lista es la memoria:
[0][1][2][3][4][5][6][7][8][9][A][B][C][D][E][F]
Esta memoria es el contenido de una matriz de 4 x 4, y queremos acceder al sector x=3 y=2 de la matriz, hay que convertir estos valores en la posición en memoria, sabemos que el tamaño de la matriz es de 4 x 4, entonces:
memoria vista como matriz:
[0][1][2][3] // Fila 0
[4][5][6][7] // Fila 1
[8][9][A][B] // Fila 2 ( esta es la que queremos )
[C][D][E][F] // Fila 3
Fíjate que cada fila tiene 4 columnas (el ancho) por lo que y*ancho (2*4) es el número de elementos que hay antes de la fila que necesitamos ( 8 ) si se le suma la posición en x ya estamos en la posición que necesitamos 8+3=11;
En la posición 11 de la memoria está la [B]
No se me ha ocurrido otra forma de explicarlo, espero que este claro.
Cita: a mi me abian enseñado asi *(img+i *ancho+j)
Para poder usar ese método los datos tendrían que estar en la memoria de la siguiente forma, para el ejemplo anterior:
[0][4][8][C][1][5][9][D][2][6][A][E][3][7][B][F]