El orden de los datos en la memoria

Question

Algunas preguntas simples.

const int gFirst; 
const int gSecond; 

struct Data 
{ 
    static int First; 
    static int Second; 

    int first; 
    int second; 
}; 

Data data; 

¿Se garantiza que las siguientes afirmaciones son ciertas?

1. &gFirst < &gSecond
2. &Data::First < &Data::Second
3. &data.first < &data.second

Answer 1

1) Este resultado es no especificado.
2) Este resultado no está especificado. *
3) Sí.

La sección relevante en la norma es §5.9/2. comparaciones relacionales entre los punteros p y q solamente se especifican cuando:

• p y q punto al mismo objeto o función, seleccione uno allá del final de la misma matriz, o ambos son nulos. En este caso, p <= q y p >= q son verdaderos, y p < q y p > q son falsos.
• p y q apuntan a los datos no estáticos miembros del mismo objeto, el puntero al miembro declarado posteriormente se compara con mayor. (Tenga en cuenta que esta comparación no puede ser entre especificadores de acceso.)
• p y q apuntan a elementos dentro de la misma matriz o uno más allá del final de la matriz, el puntero al elemento con el subíndice superior o uno pasado el final de la matriz compara mayor.
• p y q señalan a los miembros de datos del mismo objeto de unión, en cuyo caso se comparan iguales.

En todos los demás casos, el resultado no se especifica.

_{* Debido a que son estáticos, (obviamente) no obtienen las reglas de "miembro no estático". Se definirán en alguna unidad de traducción, y por lo tanto son como cualquier otro puntero. (Sin especificar.)}

---

Nota! Hay una manera de conseguir orden total, y que es a través de std::less<void*>

Esto está en §20.3.3/8 (y todos los demás objetos de función comparativos.):

Para las plantillas greater, less , greater_equal y less_equal, las especializaciones para cualquier tipo de puntero producen un orden total, incluso si los operadores incorporados <, >, <=, >= no lo hacen.

Así, mientras que no se sabe si es std::less<void*>(&gFirst, &gSecond)true o false, se le garantiza:

std::less<void*>(&gFirst, &gSecond) == 
    std::greater<void*>(&gSecond, &gFirst); 
std::less<void*>(&Data::First, &Data::Second) == 
    std::greater<void*>(&Data::Second, &Data::First); 

que puede resultar útil.

Answer 2

La respuesta:

1) Not guaranteed. 
    But probably. 
    But the order of initialization is guaranteed. 
2) No. 
    You just have the declaration here. 
    You need to to define the instances in a source file. 
    Then they will behave the same way as the objects in (1). 
3) Yes.