klasy zmienne - dostosowanie

Question

Powiel możliwe:
Classes store data members in sequential memory?

Chciałem tylko zapytać, dlaczego następujących jest poprawna:

template<class T> 
class Vec3 { 
public: 
    // values 
    T x,y,z; 

    // returns i-th komponent (i=0,1,2) (RHS array operator) 
    const T operator[] (unsigned int i) const { 
    return *(&x+i); 
    } 
} 

lub innymi słowy: Dlaczego jest to zawsze gwarantowane, że x, y i z zawsze są wielkościami (T) w pamięci. Czy nie mogą być kiedykolwiek otwory fragmentacji pomiędzy dwoma z tych varibles, pozwalając tym operatorowi zwracać fałszywą wartość?

Answer 1

Jest nie zagwarantować, że x, y i z są zawsze sizeof(T) jednostki od siebie w pamięci. Między dodanymi bajtami mogą znajdować się dopełnienia.
Został pominięty jako szczegół implementacji.
Gwarantowane jest tylko to, że nie będzie dopełnienia pomiędzy początkiem klasy/struktury a jej pierwszym elementem dla struktur/klas POD. Nie można zagwarantować, że implementacja operator[] w kodzie będzie działać zawsze.

odniesienia:
C++ 11: 9,2 członków klasy [class.mem]

14) Nonstatic zgromadzonych danych z pomocą (nie-Union) o tej samej klasy kontroli dostępu (punkt 11) są przydzielane tak, aby późniejsi członkowie mieli wyższe adresy w obrębie obiektu klasy. Kolejność przydzielania niestatycznych danych członkom o różnej kontroli dostępu jest nieokreślona (11). Wymogi dotyczące dopasowania do wdrożenia mogą być następujące: powodują, że dwóch sąsiednich członków nie będzie przydzielanych bezpośrednio po sobie;, więc może wymagać przestrzeni do zarządzania funkcjami wirtualnymi (10.3) i wirtualnymi klasami podstawowymi (10.1).

Answer 2

W celu uniknięcia fragmentacji otwory można kontrolować wyrównanie w ten sposób:

#ifdef compiling_with_msvc 
#pragma pack(1) 
#endif 
template<class T> 
class Vec3 { 
public: 
    // values 
    T x,y,z; 

    // returns i-th komponent (i=0,1,2) (RHS array operator) 
    const T operator[] (unsigned int i) const { 
     return *(&x+i); 
    } 
#ifdef compiling_with_gcc 
}__attribute__((packed)); 
#else 
}; 
#endif 

Jeśli można użyć C++11 compiler można kontrolować wyrównanie w standard way.

Ale jeśli nie dbają o reprezentację pamięci klasy, pomyśl o użycie union:

template <typename T> 
union Vec3 
{ 
    T x, y, z; 
    struct 
    { 
     T value[3]; 
    } vector; 
}; 

z Unią, nie trzeba się martwić o dopasowaniu w celu acces każdy składnik z []:

Vec3<unsigned int> v3; 

v3.vector.value[0] = 1; 
v3.vector.value[1] = 2; 
v3.vector.value[2] = 3;