De programación c: como trabajar matemáticas puntero en una matriz

¿Qué ocurre cuando se incrementa un puntero en la programación C? Decir que la variable puntero Dave referencia a una variable en dirección de memoria 0x8000. Si es así, considere la siguiente declaración:

Dave ++ -

¿Cuál sería el valor del puntero de Dave ser?

Su primera inclinación podría ser decir que Dave se incrementa en 1, lo cual es correcto. Sin embargo, el resultado del cálculo puede no ser 0x8001. Esto se debe a la dirección almacenada en una variable puntero se incrementa en uno unidad, no en un dígito.

¿Qué es una unidad?

Video: Trabajando las matemáticas con Scratch

Depende del tipo de variable. Si puntero Dave es un puntero char, de hecho, la nueva dirección podría ser 0x8001. Pero si Dave fueron un int o un flotador, la nueva dirección sería el mismo que

0x8000 + sizeof (int)

o

0x8000 + sizeof (float)

En la mayoría de los sistemas, es un entero de 4 bytes, por lo que podría suponer que Dave sería igual a 0x8004 después de la operación de incremento. Pero ¿por qué adivinar cuando se puede codificar?

Puntero matrices y Matemáticas ilustra un programa sencillo, algo que podría codificar y sin el uso de punteros: rellenar una matriz int con los valores del 1 al 10, y luego mostrar la matriz y sus valores. Pero en matrices y puntero de Matemáticas, un puntero se utiliza para llenar la matriz.

Matrices y MATH PUNTERO

#include int main () {int números [10] -INT x-int * pn-pn = Números / puntero * inicializar * // * Llenar array * / for (x = 0-XLT; 10-x ++) {* pn = x + 1-pn ++ -} / * Display array * / for (x = 0-XLT; 10-x ++) printf ("números [% d] =% dn", X + 1, los números de [x]) - retorno (0) -}

La línea 7 declara el puntero pn, y la línea 9 se inicializa. los & No se necesita aquí es porque los números de una matriz, no una variable individual. En ese momento, el puntero contiene la dirección base de la matriz. Tenga en cuenta que la matriz está vacía.

El bucle en líneas 12 a 16 se llena la matriz de números. El primer elemento está vacío, en la línea 14 usando la notación peeker para pn puntero. A continuación, en la línea 15, pn puntero se incrementa en una unidad. Ahora apunta al siguiente elemento de la matriz, y se repite el bucle.

Ejercicio 1: Copiar el código fuente a partir de matrices y puntero de Matemáticas en su editor. Generar y ejecutar.

Ejercicio 2: Modificar el código fuente del Ejercicio 1, de modo que la dirección de cada elemento de la matriz se muestra junto con su valor.

En la salida del Ejercicio 2, debería ver que cada dirección está separada por 4 bytes (suponiendo que el tamaño de un int es de 4 bytes en su máquina). De hecho, las direcciones probablemente todo el extremo en el hex dígitos 0, 4, 8, y C.

ejercicio 3: Completar la conversión de matrices y el puntero de Matemáticas, y lo que comenzó en el Ejercicio 2, haciendo que el segundo bucle muestra los valores de la matriz usando el lado de peeker variable de puntero pn.

Video: Tutorial de C++ en Espanol -39- Arreglo de Punteros

Ejercicio 4: Crear un nuevo proyecto que llena una matriz de caracteres mediante el uso de punteros similares a los mostrados en las matrices y puntero de Matemáticas. Establecer el tamaño de la matriz de caracteres a 27, de modo que puede contener 26 letras. Llenar la matriz con las letras ‘A’ a la ‘Z’ mediante el uso de la notación de puntero. Mostrar los resultados mediante el uso de la notación de puntero.

Aquí hay una gran pista:

* Pn = x + `A`-

Solución al ejercicio 4

#include int main () {char alfabeto [27] -INT x-char * pa-pa = alfabeto de / * inicializar puntero * // * Llenar array * / for (x = 0-XLT; 26-x ++) {* pa = x + `A`-pa ++ -} pa = alfabeto - / * array Display * / for (x = 0-XLT; 26-x ++) {putchar (* pa) -PA ++ -} putchar (` n `) - retorno (0) -}

El código fuente de la solución del ejercicio 4should ser bastante lúcido, la realización de cada tarea un paso a la vez. Pero hay que tener en cuenta que muchos programadores de C gusta combinar declaraciones, y tales combinaciones ocurren con frecuencia con los punteros.

Ejercicio 5: Combinar las dos declaraciones en el primer bucle de solución al ejercicio 4to ser sólo una declaración:

* Pa ++ = x + `A`-

Asegúrese de escribir en forma adecuada. Generar y ejecutar.

La salida es la misma. Lo que hace feo desorden que se describe aquí:

x +’A`This parte de la instrucción se ejecuta en primer lugar, sumando el valor de la variable x de la letra A. El efecto neto es que el código marcha el alfabeto como el valor de x aumenta.

* Pathé resultado de x +’A’ se coloca en la posición de memoria especificada por pa puntero.

++El valor de la variable de pa - la dirección de memoria - se incrementa en una unidad. Debido a que el ++ aparece después de la variable, se incrementa el valor después el valor en esa dirección se lee.

Mantener los dos estados separados todavía funciona. Pero no todos los programadores que lo hace! Muchos de ellos aman a acumularse punteros con el operador de incremento. Mirar hacia fuera para él! O, si usted lo entiende, lo utilizan.

Ejercicio 6: Arreglar su código fuente desde el ejercicio 5 para que el segundo bucle utiliza el monstruo * PA ++.

Con suerte, el pa * ++ puntero cosa tiene sentido. Si no es así, tomar una siesta y luego volver y examinar Head-implosión del programa.

MARIDOPROGRAMA EAD-implosión

#include int main () {char alpha = `A`-int x-char * pa-pa = &alfa- / * inicializar puntero * / for (x = 0-XLT; 26-x ++) putchar ((* pa) ++) - putchar ( `n`) - retorno (0) -}

El código fuente del listado 19-4 ofertas con una sola variable de tipo char y no una matriz. Por lo tanto, la inicialización del puntero en la línea 9 requiere la & prefijo. No se olvide de eso!

La línea 12 de este código contiene el moco (* PA) ++. Es similar a * PA ++, pero definitivamente no es. A diferencia * pa ++, que se asoma a un valor y luego incrementa el puntero, el (* pa) ++ construcción incrementa un valor que se asomó en- el puntero está sin cambios.

ejercicio 7: Editar, crear y ejecutar un nuevo programa con el código fuente del programa Head-implosión.

La operación (* PA) ++ funciona, gracias a los paréntesis. El programa recupera el valor representado por * pa primero y luego se incrementa ese valor. La variable puntero, pn, no se ve afectada por la operación.

Para ayudar a evitar la confusión sobre este tema aquí son los diversos chismes notación críptica puntero / peeker: