4.5.4  Acceso a miembros de estructuras

§1  Sinopsis

La gramática C++ dispone de dos operadores para referenciar a los miembros de estructuras y uniones. So conocidos como operadores de selección de miembro:

§1.1  .    Selector directo   ( 4.9.16)

Una expresión del tipo sT.obj representa el miembro obj de sT, que suponemos es la instancia de una estructura. La expresión es un Lvalue siempre que sT no lo sea, y obj no sea una matriz.

§1.2  ->   Selector indirecto ( 4.9.16)

Una expresión del tipo stPt -> obj representa el miembro obj de sT siempre que stPt sea un puntero a dicha instancia. La expresión es un Lvalue siempre que obj no sea una matriz. Esta expresión es equivalente, y preferible, a (*stPt).obj.

El uso de uno u otro es indiferente, depende de que se tenga un identificador de la estructura, en cuyo caso puede usarse el selector directo (expresión sT.obj ), o un puntero, en cuyo caso puede usarse el indirecto (expresión: stPt->obj )

§2  Ejemplo

struct Str {        // declara estructura Str
   int i;
   char a;
} s, *sptr = &s;    // declara s tipo Str, y sptr puntero a s
...
s.i = 3;            // asigna 3 al miembro i de s
sptr -> a = 'B';    // asigna 'B' al miembro a.s

§3  Acceso a miembros de estructuras anidadas

Si existen estructuras anidadas, es decir, si la estructura B contiene un campo a de tipo estructura A, los sub-miembros de a pueden ser accedidos mediante una doble aplicación del operador de selección. Por ejemplo:

struct A {
   int j;  double x;
};

struct B {
   int i;  double d;
   struct A a;
} s, *sptr = &s;
...
s.i = 3;             // asigna 3 al miembro i de B
s.a.j = 2;           // asigna 2 al miembro j de A
sptr->d = 1.2;       // asigna 1.2 al miembro d de B
sptr->a.x = 3.1;     // asigna 3.1 al miembro x de A

§4  Ejemplo

#include <stdio.h>
#include <math.h>
#include <iostream>
using namespace std;
 
struct punto {int x; int y;};  // definición de estructura
double isqrt(int valor);       // prototipo de función isqrt
 
int main(void) {         // ==============
   punto p1 = {2,3}, p2 = {4,5}, *ptr1 = &p1;
   printf ("%3d,%3d\n", p1.x, p1.y);
   printf ("%3d,%3d\n", ptr1->x, ptr1->y);

   double dist;
   dist = isqrt(p1.x * p1.x + p1.y * p1.y );
   printf("Distancia: %5.5f\n", dist);

}

double isqrt(int num) {  // definición de función isqrt
   return pow((double)num, (double).5);
}

Salida:

  2, 3
  2, 3
Distancia: 3.60555

Nota: el ANSI C dispone en la Librería Estándar de la función sqrt() que calcula directamente la raíz cuadrada, pero esta función no es estándar en ANSI C++, por lo que usamos pow() que si lo és (acepta dos duble); para ello definimos una nueva función isqrt() que calcula directamente la raíz cuadrada de un int utilizando pow(x, .5).