[C con Clase] Duda con Punteros

[Steven Davidson]

Hola Yosvany,

On 2/25/2011 9:36 AM, Yosvany Llerena wrote:
> Hola a todos.
> Estoy trabajando con punteros y tengo muchas dudas:
> Por favo alguien que me alcre esta situacion con base en el código de
> ejemplo:
>
> int i,j, skip=22,k=221, samps=500;
> float *M,*m,*m1;
> float *C,*c;
> float *B,*b;
> float sum;
>
> /*....
> aqui Adiciono los valores de M,C,B
> ...*/
>
> for (i = 0; i<  samps; i++) {
>     for (j=k-skip, m=M, c=C, m1=M+skip, sum=0.0; j-->  0; *m++ = *m1++)
>        sum += *c++ * *m;
>     for (j=skip;j-->  0; *m++ = *B++)
>        sum += *c++ * *m;
>    *b++ = (sum<  0.0) ? sum - 0.5f : sum + 0.5f;
> }
>
> Quería saber que es lo que pasa cuando m o m1 llegan a la ultima
> posición de memoria. Tengo la sensación de que esta regresando al
> inicio del puntero, es esto cierto?.:-(
>

Sin conocer las dimensiones de cada bloque de memoria que los punteros 
apuntan - valga la redundancia -  no puedo darte una explicación 
detallada. También tengo que decir que es difícil leer este código, ya 
que usa muchas variables con nombres poco descriptivos.

Es cierto que en cada iteración de 'i', 'm' y 'm1' son reiniciados a 
apuntar al primer elemento apuntado por 'M' y por 'M+22' que viene a ser 
lo mismo que los elementos: 'M[0]' y 'M[22]', respectivamente.

Sin embargo, dentro del bucle 'for' de 'i', 'm' no es reiniciado, por lo 
que 'm' apunta al siguiente elemento después del primer bucle 'for' 
(anidado).

Analizando la cantidad de iteraciones de cada bucle anidado al igual que 
los elementos apuntados, obtenemos las siguientes conclusiones:

En el primer bucle anidado, realizamos 199 iteraciones, porque j := 
[199,0) lo cual implica, [199,1]. Por lo tanto, los punteros accederán 
al siguiente intervalo de elementos:

m[0]   -> m[198]
m1[22] -> m1[220]
c[0]   -> c[199]

Como los dos primeros punteros tienen que ver con 'M' y el último con 
'C', esto significa que accedemos a los siguientes elementos de 'M' y 'C':

M[0]  -> M[198]
M[22] -> M[220]
C[0]  -> C[199]

Esto sugiere que modificamos algunos elementos de 'M' durante este bucle.

En el segundo bucle anidado, realizamos 21 iteraciones, porque j empieza 
con 22 hasta llegar a uno antes de 0; es decir, j := [22,1]. El 
comportamiento de los punteros es el siguiente:

m[199] -> m[221]
B[0]   -> B[22]
c[199] -> c[221]

Esto es equivalente a:

M[199] -> M[221]
B[0]   -> B[22]
C[199] -> C[221]

En conjunto con el primer bucle de 'i', vemos que los elementos 
accedidos por 'B' y por 'b' son diferentes, ya que no son reiniciados en 
su interior. Por lo tanto, vemos el siguiente comportamiento por 
iteración de 'i':

i=0:
B[0] -> B[22]
b[0]

i=1:
B[22] -> B[44]
b[1]

i=2:
B[44] -> B[66]
b[2]
...
i=499:
B[10978] -> B[11000]
b[499]

Por lo tanto, asegúrate de que 'B' apunta a un bloque de memoria que 
contenga por lo menos 11001 elementos de tipo 'float'. Esto sugiere que 
este bloque contiene 44004 bytes (casi 43 KB), si 'float' ocupa 4 bytes.


Espero que todo esto te oriente.

Steven