headers - Aliasing struct y array the C++ way

how to use.h in c

Question

Este es un seguimiento en C ++ para otra pregunta mía

En los viejos tiempos de la pre-ISO C, el siguiente código no habría sorprendido a nadie:

struct Point {
    double x;
    double y;
    double z;
};
double dist(struct Point *p1, struct Point *p2) {
    double d2 = 0;
    double *coord1 = &p1->x;
    double *coord2 = &p2->x;
    int i;
    for (i=0; i<3; i++) {
        double d = coord2[i]  - coord1[i];    // THE problem
        d2 += d * d;
    }
    return sqrt(d2);
}

Desafortunadamente, esta línea problemática usa la aritmética del puntero ( p[i] siendo por definición *(p + i)) fuera de cualquier matriz que explícitamente no está permitida por el estándar. El borrador 4659 para C ++ 17 dice en 8.7 [expr.add]:

Si la expresión P apunta al elemento x [i] de un objeto de matriz x con n elementos, las expresiones P + J y J + P (donde J tiene el valor j) apuntan al elemento (posiblemente hipotético) x [i + j] si 0 <= i + j <= n; de lo contrario, el comportamiento no está definido.

Y la nota (no normativa) 86 lo hace aún más explícito:

Se considera que un objeto que no es un elemento de matriz pertenece a una matriz de un solo elemento para este propósito. Un puntero pasado el último elemento de una matriz x de n elementos se considera equivalente a un puntero a un elemento hipotético x [n] para este fin.

La respuesta aceptada de la pregunta a la que se hace referencia utiliza el hecho de que el lenguaje C acepta los juegos de palabras a través de los sindicatos, pero nunca pude encontrar el equivalente en el estándar C ++. Así que supongo que una unión que contenga un miembro de estructura anónima y una matriz conduciría a un Undefined Behaviour en C ++, son idiomas diferentes ...

Pregunta:

¿Cuál podría ser una forma condicional de iterar a través de los miembros de una estructura como si fueran miembros de una matriz en C ++? Estoy buscando un camino en las versiones actuales (C ++ 17), pero las soluciones para versiones anteriores también son bienvenidas.

Renuncia:

Obviamente, solo se aplica a elementos del mismo tipo, y el relleno se puede detectar con una assert simple como se muestra en esa otra question , por lo que el relleno, la alineación y los tipos mixtos no son mi problema aquí.

Answer 1

En mi humilde opinión, la forma más fácil es simplemente implementar el operator[] . Puedes hacer una matriz de ayuda como esta o simplemente crear un interruptor ...

struct Point
{
    double const& operator[] (std::size_t i) const 
    {
        const std::array coords {&x, &y, &z};
        return *coords[i];
    }

    double& operator[] (std::size_t i) 
    {
        const std::array coords {&x, &y, &z};
        return *coords[i];
    }

    double x;
    double y;
    double z;
};

int main() 
{
    Point p {1, 2, 3};
    std::cout << p[2] - p[1];
    return 0;
}

Answer 2

Puede usar el hecho de que al lanzar un puntero a intptr_t haciendo aritmética y luego devolver el valor al tipo de puntero se implementa un comportamiento definido . Creo que funcionará en la mayoría de los compiladores:

template<class T>
T* increment_pointer(T* a){
  return reinterpret_cast<T*>(reinterpret_cast<intptr_t>(a)+sizeof(T));
  }

Esta técnica es la más eficiente, los optimizadores parecen no ser capaces de producir óptimos si se busca una tabla de un solo uso: assemblies-comparison

Answer 3

Use un conjunto de constexpr de puntero a miembro:

#include <math.h>

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

double dist(struct Point *p1, struct Point *p2) {
    constexpr double Point::* coords[3] = {&Point::x, &Point::y, &Point::z};

    double d2 = 0;
    for (int i=0; i<3; i++) {
        double d = p1->*coords[i] - p2->*coords[i];
        d2 += d * d;
    }
    return sqrt(d2);
}

Answer 4

struct Point {
  double x;
  double y;
  double z;
  double& operator[]( std::size_t i ) {
    auto self = reinterpret_cast<uintptr_t>( this );
    auto v = self+i*sizeof(double);
    return *reinterpret_cast<double*>(v);
  }
  double const& operator[]( std::size_t i ) const {
    auto self = reinterpret_cast<uintptr_t>( this );
    auto v = self+i*sizeof(double);
    return *reinterpret_cast<double const*>(v);
  }
};

esto se basa en que no hay empaquetamiento entre las double en su `struct. Afirmar eso es difícil.

Una estructura POD es una secuencia de bytes garantizados.

Un compilador debería ser capaz de compilar [] hasta las mismas instrucciones (o la falta de ellas) como un acceso de matriz sin formato o una aritmética de puntero. Puede haber algunos problemas donde esta optimización ocurre "demasiado tarde" para que ocurran otras optimizaciones, por lo tanto, vuelva a verificar el código sensible al rendimiento.

Es posible que la conversión a char* o std::byte* uintptr_t de uintptr_t sea ​​válida, pero hay un problema central acerca de si la aritmética del puntero está permitida en este caso.