C Language Operadores de Acceso


Ejemplo

Los operadores de acceso miembro (DOT . Y la flecha -> ) se utilizan para acceder a un miembro de una struct .

Miembro de objeto

Se evalúa en el lvalor que denota el objeto que es miembro del objeto accedido.

struct MyStruct
{
    int x;
    int y;
};

struct MyStruct myObject;
myObject.x = 42;
myObject.y = 123;

printf(".x = %i, .y = %i\n", myObject.x, myObject.y); /* Outputs ".x = 42, .y = 123". */

Miembro de objeto apuntado

Azúcar sintáctica para la desreferenciación seguida por el acceso de miembros. Efectivamente, una expresión de la forma x->y es una abreviatura de (*x).y - pero el operador de flecha es mucho más claro, especialmente si los punteros de la estructura están anidados.

struct MyStruct
{
    int x;
    int y;
};

struct MyStruct myObject;
struct MyStruct *p = &myObject;

p->x = 42;
p->y = 123;

printf(".x = %i, .y = %i\n", p->x, p->y); /* Outputs ".x = 42, .y = 123". */
printf(".x = %i, .y = %i\n", myObject.x, myObject.y); /* Also outputs ".x = 42, .y = 123". */

Dirección de

El unario & operador es la dirección del operador. Evalúa la expresión dada, donde el objeto resultante debe ser un valor l. Luego, se evalúa en un objeto cuyo tipo es un puntero al tipo del objeto resultante y contiene la dirección del objeto resultante.

int x = 3;
int *p = &x;
printf("%p = %p\n", (void *)&x, (void *)p); /* Outputs "A = A", for some implementation-defined A. */

Desreferencia

El operador unario * referencia a un puntero. Se evalúa en el lvalor resultante de la desreferenciación del puntero que resulta de evaluar la expresión dada.

int x = 42;
int *p = &x;
printf("x = %d, *p = %d\n", x, *p); /* Outputs "x = 42, *p = 42". */

*p = 123;
printf("x = %d, *p = %d\n", x, *p); /* Outputs "x = 123, *p = 123". */

Indexación

La indexación es azúcar sintáctica para la adición de punteros seguida de la eliminación de referencias. Efectivamente, una expresión de la forma a[i] es equivalente a *(a + i) , pero se prefiere la notación explícita del subíndice.

int arr[] = { 1, 2, 3, 4, 5 };
printf("arr[2] = %i\n", arr[2]); /* Outputs "arr[2] = 3". */

Intercambiabilidad de la indexación.

Agregar un puntero a un entero es una operación conmutativa (es decir, el orden de los operandos no cambia el resultado), por lo tanto, pointer + integer == integer + pointer .

Una consecuencia de esto es que arr[3] y 3[arr] son equivalentes.

printf("3[arr] = %i\n", 3[arr]); /* Outputs "3[arr] = 4". */

El uso de una expresión 3[arr] lugar de arr[3] generalmente no se recomienda, ya que afecta la legibilidad del código. Tiende a ser popular en concursos de programación ofuscados.