Доступ к элементам массива по имени

Я пишу код, который передает много многопараметрических переменных. Например, я мог бы передать «ориентацию», которая равна шести двойным (три декартовы координаты и три поворота вокруг осей). Было бы разумно определить структуру Orientation и использовать ее в качестве типа аргумента. Однако из-за ограничений API эти параметры должны храниться как и часто передаваться в функции как указатели на массивы параметров:

// The sane version, using a struct
double distance_from_origin(const Orientation & o) {
return sqrt(o.x * o.x + o.y * o.y + o.z * o.z);
}

// The version I must write due to API constraints
double distance_from_origin(const double * const p) {
return sqrt(p[0] * p[0] + p[1] * p[1] + p[2] * p[2]);
}

Очевидно, что это подвержено ошибкам. У меня есть три возможных решения, с одним из них.

Я могу использовать #define или const globals где-то в заголовке, чтобы использовать псевдонимы для индексов.

const size_t x = 0;
const size_t y = 1;
const size_t z = 2;

double distance_from_origin(const double * const p) {
return sqrt(p[x] * p[x] + p[y] * p[y] + p[z] * p[z]);
}

Это гарантирует x всегда согласован, но загрязняет глобальное пространство имен. Я мог бы скрыть это в пространстве имен, но тогда это было бы более неудобно для использования.

Идея, упомянутая ранее Вот:

struct Orientation {double x, y, z, rot_x, rot_y, rot_z};

Orientation& asOrientation(double * p) {
return *reinterpret_cast<Orientation*>(p);
}

double distance_from_origin(const double * const p) {
Orientation& o = asOrientation(p)
return sqrt(o.x * o.x + o.y * o.y + o.z * o.z);
}

Это имеет более приятный синтаксис, но опирается на правила структурной упаковки C / C ++. я считать что это безопасно, пока Orientation это стручок Я нервничаю, полагаясь на это.

struct Orientation {
Orientation(double * p): x{p[0]}, y{p[1]}, z{p[2]}, rot_x{p[3]},
rot_y{p[4]}, rot_z{p[5]} {}

double &x, &y, &z, &rot_x, &rot_y, &rot_z
};

double distance_from_origin(const double * const p) {
Orientation o{p};
return sqrt(o.x * o.x + o.y * o.y + o.z * o.z);
}

Это больше не зависит от правил упаковки структуры и имеет приятный синтаксис. Тем не менее, он опирается на оптимизация компилятора чтобы убедиться, что у него нет накладных расходов.

На основе этот комментарий GManNickG.

constexpr double& x(double * p) {return p[0];}
constexpr double& y(double * p) {return p[1];}
constexpr double& z(double * p) {return p[2];}
// ... etc.

double distance_from_origin(const double * const p) {
return sqrt(x(p) * x(p) + y(p) * y(p) + z(p) * z(p));
}

1. Решение 3 кажется мне лучшим. Есть ли у него потенциальный недостаток, который
   Я скучаю, не полагаясь на оптимизацию компилятора?

2. Есть ли другое решение, которое превосходит любое из этих трех?