L'ordine dei dati nella memoria

Question

Alcune semplici domande.

const int gFirst; 
const int gSecond; 

struct Data 
{ 
    static int First; 
    static int Second; 

    int first; 
    int second; 
}; 

Data data; 

È garantito che le seguenti affermazioni sono vere?

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

Answer 1

1) Questo risultato non è specificato.
2) Questo risultato non è specificato. *
3) Sì.

La sezione pertinente nello standard è §5.9/2. confronto relazionali tra i puntatori p e q sono specificate solo quando:

• p e q punto allo stesso oggetto o funzione, scegliere uno oltre l'estremità della stessa matrice o entrambi sono nulli. In questo caso, p <= q e p >= q sono veri e p < q e p > q sono falsi.
• p e q puntare a membri di dati non statici dello stesso oggetto, il puntatore al membro dichiarato successivo confronta maggiore. (Nota, questo confronto non può essere tra gli specificatori di accesso.)
• p e q puntare a elementi all'interno dello stesso array o uno oltre la fine dell'array, il puntatore all'elemento con il subscript più alto o ad uno oltre la fine di l'array è più grande.
• p e q puntare a membri di dati dello stesso oggetto unione, nel qual caso vengono confrontati uguali.

In tutti gli altri casi, il risultato non è specificato.

_{* Poiché sono statici, non ottengono (ovviamente) le regole del "membro non statico". Saranno definiti in alcune unità di traduzione e quindi sono come qualsiasi altro puntatore. (Non specificato.)}

---

Nota! C'è un modo per ottenere ordinamento totale, e che è via std::less<void*>

Questo è in §20.3.3/8 (e tutti gli altri oggetti funzione comparativi.):

Per i modelli greater, less , greater_equal e less_equal, le specializzazioni per qualsiasi tipo di puntatore generano un ordine totale, anche se gli operatori incorporati <, >, <=, >= no.

Così, mentre non si sa se è std::less<void*>(&gFirst, &gSecond)true o false, si sono garantiti:

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

che può rivelarsi utile.

Answer 2

La risposta:

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.