L'ordre des données en mémoire

Question

Quelques questions simples.

const int gFirst; 
const int gSecond; 

struct Data 
{ 
    static int First; 
    static int Second; 

    int first; 
    int second; 
}; 

Data data; 

Est-il garanti que les déclarations suivantes sont vraies?

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

Answer 1

1) Ce résultat est non spécifiée.
2) Ce résultat n'est pas spécifié. *
3) Oui.

La section pertinente de la norme est §5.9/2. Comparaisons relationnelles entre les pointeurs p et q ne sont spécifiées lorsque:

• p et q pointent vers le même objet ou de la fonction, le point à une après la fin de la même matrice, ou les deux sont nulles. Dans ce cas, p <= q et p >= q sont vrais, et p < q et p > q sont faux.
• p et q pointent vers des membres de données non statiques du même objet, le pointeur vers le membre déclaré le plus tard est supérieur. (Notez que cette comparaison ne peut pas se faire entre les spécificateurs d'accès.)
• p et q pointer vers des éléments du même tableau ou après la fin du tableau, le pointeur vers l'élément avec l'indice le plus élevé ou vers la fin de le tableau compare plus grand.
• p et q pointent vers des membres de données du même objet union, auquel cas ils se comparent égaux.

Dans tous les autres cas, le résultat n'est pas spécifié.

_{* Parce qu'ils sont statiques, ils n'obtiennent (évidemment) pas les règles du "membre non-statique". Ils seront définis dans une unité de traduction, et sont donc comme n'importe quel autre pointeur. (Non spécifié.)}

---

Remarque! Il est un moyen d'obtenir la commande totale, et qui est par std::less<void*>

Ceci est en §20.3.3/8 (et tous les autres objets de la fonction de comparaison.):

Pour les modèles greater, lessgreater_equal et less_equal, les spécialisations pour n'importe quel type de pointeur donnent un ordre total, même si les opérateurs intégrés <, >, <=, >= ne le font pas.

Ainsi, alors que vous ne savez pas si std::less<void*>(&gFirst, &gSecond) est true ou false, vous êtes assuré:

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

Ce qui peut se révéler utile.

Answer 2

La réponse:

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.