# data[].attributes.body
Apuntadores y arreglos

# data[].attributes.attachment_link.title
APUNTADORES Y ARREGLOS en C | Fundamentos de programación EP-25

# data[].attributes.body
En general

# data[].attributes.attachment_link.title
Programación en C - APUNTADORES - Parte 1

# data[].attributes.body
Las comparaciones de apuntadores son válidas solamente entre apuntadores que apunte mismo arreglo. Bajo estas circunstancias, los operadores relaciónales ==, ! =, >, <, >= y <= funcionan adecuadamente. Los elementos inferiores del arreglo (esto es, los que tigJI un subíndice menor) siempre tienen direcciones menores que los elementos superiores *2 ! arreglo. Por lo tanto, si ptr1 y ptr2 apuntan a elementos del mismo arreglo, la comparacion
ptr1 > ptr2
es cierta si ptr1 apunta a un miembro anterior del arreglo que al que apunta ptr2.

# data[].attributes.body
Se aplica el mismo concepto para el decremento de un apuntador como para el incremento. decremento de un apuntador es, de hecho, un caso de incremento sumando un valor negativo. Si se decrementa un apuntador con los operadores - - o -=, la aritmética de apuntadores se ajusta automáticamente al tamaño de los elementos del arreglo.

# data[].attributes.body
Cuando se incrementa un apuntador se está incrementando su valor. Por ejemplo, cuando incrementa un apuntador en 1, la aritmética de apuntadores incrementa automáticamen- ^ el valor del apuntador para que apunte al siguiente elemento del arreglo. Dicho de otra forma, el C sabe el tipo de dato al que apunta el apuntador (a partir de la declaración del apuntador) e incrementa la dirección guardada en el apuntador en el tamaño del tipo de dato.

# data[].attributes.headline
• Cómo se accesan estos elementos de arreglos sucesivos usando un apuntador?

# data[].attributes.subject
• Cómo se accesan estos elementos de arreglos sucesivos usando un apuntador?

# data[].attributes.body
e un apuntador debe ser aumentado en 2 para accesar los elementos sucesivos de un arreglo tipo int, y en 4 para accesar los elementos sucesivos de un arreglo tipo f loat. Se puede generalizar y decir que para accesar elementos sucesivos de un arreglo de un tipo de datos particular, el apuntador debe ser incrementado en sizeof (tipo_de_dato).

# data[].attributes.body
Los elementos de arreglo son guardados en posiciones secuenciales de memoria, estando el primer elem ^ en la dirección más baja. Los siguientes elementos del arreglo (aquellos que tienen un ínnr^ mayor que 0) son guardados en direcciones más altas. Qué tan altas, depende del tipo de dato del arreglo (char, int, float, etc.).
Una simple variable int puede ocupar dos bytes de memoria. Por lo tanto, ca^ elemento del arreglo está ubicado dos bytes por encima del elemento anterior, y la dirección de cada elemento del arreglo es mayor en dos que la dirección del elemento anterior. Por otro lado, un tipo float puede ocupar cuatro bytes. En un arreglo de tipo float cada elemento del arreglo está ubicado cuatro bytes por encima del elemento anterior, y la dirección de cada elemento es mayor en cuatro que la dirección del elemento anterior.

# data[].attributes.body
Un nombre de arreglo sin corchetes es un apuntador al primer elemento del arreglo. Por lo tanto, si se ha declarado un arreglo datos [ ], datos es la dirección del primer elemento del arreglo.
Sin embargo, se puede declarar una variable de apuntador e inicializarla para que apunte hacia el arreglo.
lnicializa la variable de apuntador p_arreglo con la dirección del primer elemento de arreglo [ ]. Debido a que p_arreglo es una variable de apuntador, puede ser modificada Para 9Ue apunte a cualquier otro lugar. A diferencia de arreglo, p__arreglo no está atada para que apunte al primer elemento de arreglo [ ].

# data[].attributes.body
En la mayoría de las PC un int ocupa dos bytes, un f loat ocupa cuatro bytes y así sucesivamente. Cada byte individual de memoria tiene su propia dirección, Por lo que una variable que ocupa varios bytes, de hecho ocupa varias direcciones

# data[].attributes.body
Accesar el contenido de una variable usando el nombre de la variable es llamado acceso directo. Accesar el contenido de una variable usando un apuntador a la variable es llamado acceso indirecto o indirección.

# data[].attributes.body
Aquí entra nuevamente enjuego el operador (*) de indirección. Cuando el * precede al nombre de un apuntador, hace referencia a la variable a la que apunta.
Continuemos con el ejemplo anterior, donde el apuntador p__tasa ha sido inicializado para que apunte a la variable ta s a . Si se escribe * p _ tasa se hace referencia a la variable ta s a . Si se quiere imprimir el valor de ta s a (que es de 100 en este ejemplo) se podría escribir como se muestra en la imagen(Los dos enunciados son equivalentes)

# data[].attributes.body
Ahora que ya se ha declarado un apuntador, ¿qué se puede hacer con él? No puede hace nada con él mientras no haga que apunte a algo.
La dirección no se almacena mágicamente en el apuntador, sino que el programa h'1 ñoñería ahí usando el operador de dirección de, (&). Cuando es puesto antes del nombre na variable, el operador de dirección de regresa la dirección de la variable. Por lo tanto, se inicializa un apuntador

# data[].attributes.body
Un apuntador es una variable numérica y, de manera similar a todas las variables, debe ser inicializada antes de que pueda ser usada. Los nombres de variables de apuntador siguen las mismas reglas que otras variables y deben ser únicos.

# data[].attributes.body
El siguiente paso es guardar la dirección de la variable tasa en la variable p_tasa. Debido a (lue Potasa ahora contiene la dirección de tasa, indica su posición de almacenamiento en memoria. En la manera de hablar del C, p_t asa apunta a t a s a, o es un apuntador a t a s a.

# data[].attributes.body
El primer paso es declarar una variable para guardar la dirección de tasa. Démosle el nombre, por ejemplo, p_tasa. Al principio p_tasa se encuentra sin inicializar. Se ha reservado espacio de almacenamiento para p_t asa, pero su valor se encuentra indeterminado.

# data[].attributes.body
Si se sabe la dirección de una variable, se puede crear una segunda variable donde se guarde la dirección de la primera.

# data[].attributes.body
La RAM de la PC consiste en muchos miles de posiciones de almacenamiento secuenciales, y cada posición se identifica por una dirección única.
Cuando se declara una variable en un programa C, el compilador reserva una posición & memoria con una dirección única para guardar esa variable. El compilador asocia ^ dirección con el nombre de la variable. Cuando el programa usa el nombre de la vaíi|jM accesa automáticamente la posición de memoria adecuada. Está siendo usada la direcci011 de la ubicación pero se encuentra oculta y uno no tiene necesidad de saberlo.

# data[].attributes.body
Un apuntador es una variable que contiene la dirección de memoria de otra variable. Los apuntadores se utilizan para dar claridad y simplicidad a las operaciones a nivel de memoria. Lenguaje C es un lenguaje de alto nivel porque permite programar a bajo nivel.