struct vector
{
    double& x(){return items[0]);
    double& y(){return items[1]);
    double& z(){return items[2]);
    double const& x()const{return items[0]);
    double const& y()const{return items[1]);
    double const& z()const{return items[2]);
private:
    double items[3];
};

АШ>const Vect v;

АШ>v.x = 10;
АШ>v.y = 20;
АШ>v.y = 30;
АШ>

template<typename T>
struct reference_member
{
    typedef T value_type;

    value_type *value;

    explicit reference_member(value_type &ref) : value(&ref) {}

    template<typename T1>
    reference_member& operator = (const T1 &other) 
    {
        *value = other;
        return (*this);
    }

    reference_member& operator = (const reference_member &other)
    {
        value = other.value;
        return (*this);
    }

    operator value_type const &() const {return (*value);}
};

struct point
{
    point() : x(c[0]), y(c[1]), z(c[2]) 
    {
    }

    point(double tx, double ty, double tz) : x(c[0]), y(c[1]), z(c[2]) 
    {
        x = tx;
        y = ty;
        z = tz;
    }

    double& operator[](size_t i) 
    {
        return c[i];
    }

    double const& operator[](size_t i) const 
    {
        return c[i];
    }

    double c[3];
    reference_member<double> x;
    reference_member<double> y;
    reference_member<double> z;
};

int main()
{
    point p(10, 290, 200);

    p.x = 10;
    int d = p.x;
    p[0] = 10;
    p.y = p.y;
    p.z = d;

    const point p1;

    p1.x = p1.x; // error
    p1.x = 10; // error

    int d1 = p1.x; // ok

    return 0;
}

struct point1 
{
   double x;
   double y;
   double z;
   ...
};

ЕК>class Vect
ЕК>{
ЕК>...
ЕК>private:
ЕК> double items[3];
ЕК> double& x=items[0];
ЕК> double& y=items[1]; 
ЕК> double& z=items[2];
ЕК>};

    class Vect
    {
            ...
    private:
        double items[3];
        enum {x,y,z};
        ...
        // юзаем как items[x], items[y] ...
    };

class Vect
{
public:
  double operator [] (int i) const {return arr[i];}
private:
  double arr[3];
  double &x(){return arr[0];}
  double &y(){return arr[1];}
  double &z(){return arr[2];}
};

class Vect
{
public:
    Vect() : x(items[0]), y(items[1]), z(items[2]) {}

private:
    double items[3];
    double& x;
    double& y;
    double& z;
};

RB>class Vect
RB>{
RB>public:
RB>    Vect() : x(items[0]), y(items[1]), z(items[2]) {}

RB>private:
RB>    double items[3];
RB>    double& x;
RB>    double& y;
RB>    double& z;
RB>};
RB>

const Vect v;

v.x = 10;
v.y = 20;
v.y = 30;

struct A1
{
  int a1;
};

struct A2
{
  int a1;
  float a2;
};

struct A3
{
  int a1;
  float a2;
  double a3;
};

9.2/12
Nonstatic data members of a (nonunion) class declared without an intervening accessspecifier
are allocated so that later members have higher addresses within a class object. The order 
of allocation of nonstatic data members separated by an accessspecifier is unspecified (11.1). 
Implementation alignment requirements might cause two adjacent members not to be 
allocated immediately after each other; so might requirements for space for managing 
virtual functions (10.3) and virtual base classes (10.1).

The layout of structures is determined only to a limited extent:
— no hole may occur at the beginning.
— consecutive members occupy increasing storage addresses.
— if necessary, a hole is placed on the end to make the structure big enough to pack tightly into arrays and maintain proper alignment.

Since some existing implementations, in the interest of enhanced access time, leave internal holes larger than absolutely necessary, it is not clear that a portable deterministic method can be given for traversing a structure member by member.

#include <stdio.h>

struct S
{
    long double d1;
    long double d2;
};

int main()
{
    printf("sizeof(long double) == %d\n", sizeof(long double));
    printf("sizeof(S) == %d\n", sizeof(S));
}

struct point
{
    double x;
    double y;
    double z;
};

double operator[](size_t i) {return (&x + i);}

struct vect
{
     double arr[3];
     enum { x, y, z };

     double operator[](size_t i) const { return arr[i]; }
     double f() const { return arr[x] * arr[z]; }
};

double const(&a)[N] = v1.m_Items;
double const(&b)[N] = v2.m_Items;
return Vect(
       a[x] * b[z] - a[z] * b[y]
     , a[z] * b[x] - a[x] * b[z]
     , a[y] * b[z] - a[z] * b[y]
     );

In computer software, an application binary interface (ABI) describes the low-level interface between an application program and the operating system, between an application and its libraries, or between component parts of the application. An ABI differs from an application programming interface (API) in that an API defines the interface between source code and libraries, so that the same source code will compile on any system supporting that API, whereas an ABI allows compiled object code to function without changes on any system using a compatible ABI.

А об ABI будут думать разрабочики компилятора под конкретные программно-аппаратные платформы. ИМХО в большинстве задач только разработчики компиляторов и должны думать ABI. И очень редко должны задумываться рпзрпботчики ПО