Cel połączenia w C i C++

Możesz użyć unions do tworzenia struktur, takich jak poniżej, które zawierają pole, które mówi nam, który składnik Unii jest rzeczywiście używany:

struct VAROBJECT
{
    enum o_t { Int, Double, String } objectType;

    union
    {
        int intValue;
        double dblValue;
        char *strValue;
    } value;
} object;

Zachowanie jest nieokreślone z punktu widzenia języka. Rozważ, że różne platformy mogą mieć różne ograniczenia w wyrównywaniu pamięci i endianness. Kod w maszynie big endian kontra little endian będzie aktualizował wartości w strukturze w różny sposób. Poprawienie zachowania w języku wymagałoby, aby wszystkie implementacje używały tej samej endianness (i ograniczenia wyrównania pamięci...).

Jeśli używasz C++ (używasz dwóch tagów) i naprawdę Ci zależy jeśli chodzi o przenośność, możesz po prostu użyć struktury i podać setter, który pobiera uint32_t i odpowiednio ustawia pola poprzez operacje na maskach bitowych. To samo można zrobić w C z funkcją.

Edit : spodziewałem się, że programista zapisze odpowiedź do głosowania i zamknie tę. Jak podkreślono w niektórych komentarzach, endianness jest rozpatrywany w innych częściach standardu, pozwalając każdej implementacji zdecydować, co zrobić, a wyrównanie i wyściełanie mogą być również obsługiwane inaczej. Ważnym punktem są tutaj ścisłe zasady aliasingu, do których programator pośrednio się odwołuje. Kompilator może przyjmować założenia dotyczące modyfikacji (lub braku modyfikacji) zmiennych. W przypadku Unii kompilator może zmienić kolejność instrukcji i przenieść odczyt każdego składnika koloru nad zapis do zmiennej kolor.

Najbardziej powszechnym użyciem union, z którym regularnie się spotykam, jest aliasing.

Rozważ co następuje:

union Vector3f
{
  struct{ float x,y,z ; } ;
  float elts[3];
}

vec.x=vec.y=vec.z=1.f ;

Lub poprzez dostęp integer do tablicy

for( int i = 0 ; i < 3 ; i++ )
  vec.elts[i]=1.f;

W niektórych przypadkach dostęp po imieniu jest najbardziej oczywistą rzeczą, jaką możesz zrobić. W innych przypadkach, szczególnie gdy oś jest wybierana programowo, łatwiej jest uzyskać dostęp do oś według indeksu numerycznego-0 dla x, 1 dla y i 2 dla z.

Jak mówisz, jest to ściśle nieokreślone zachowanie, choć będzie "działać" na wielu platformach. Prawdziwym powodem używania związków jest tworzenie zapisów wariantowych.

union A {
   int i;
   double d;
};

A a[10];    // records in "a" can be either ints or doubles 
a[0].i = 42;
a[1].d = 1.23;

Oczywiście, potrzebujesz też jakiegoś dyskryminatora, aby powiedzieć, co w rzeczywistości zawiera wariant. Zauważ, że w C++ związki nie są zbyt użyteczne, ponieważ mogą zawierać tylko typy POD-efektywnie te bez konstruktorów i destruktorów.

W C to był dobry sposób na zaimplementowanie czegoś w rodzaju wariantu.

enum possibleTypes{
  eInt,
  eDouble,
  eChar
}


struct Value{

    union Value {
      int iVal_;
      double dval;
      char cVal;
    } value_;
    possibleTypes discriminator_;
} 

switch(val.discriminator_)
{
  case eInt: val.value_.iVal_; break;

W czasach pamięci litlle struktura ta zużywa mniej pamięci niż struktura, która ma cały element.

Przy okazji C zapewnia

    typedef struct {
      unsigned int mantissa_low:32;      //mantissa
      unsigned int mantissa_high:20;
      unsigned int exponent:11;         //exponent
      unsigned int sign:1;
    } realVal;

Aby uzyskać dostęp do wartości bitowych.

W C++, wariant Boost zaimplementuj bezpieczną wersję Unii, mającą na celu zapobieganie niezdefiniowanym zachowaniom w jak największym stopniu.

Jego działania są identyczne z enum + union konstruktem (stos też przypisany itp.), ale używa listy szablonów typów zamiast enum :)

Chociaż jest to ściśle nieokreślone zachowanie, w praktyce będzie ono działać z prawie każdym kompilatorem. Jest to tak szeroko stosowany paradygmat, że każdy szanujący się kompilator będzie musiał zrobić "właściwą rzecz" w takich przypadkach. Z pewnością jest to preferowane niż typ-punning, który może również generować uszkodzony kod z niektórych kompilatorów.

Technicznie jest niezdefiniowany, ale w rzeczywistości większość(wszystkie?) Kompilatory traktują to dokładnie tak samo jak użycie reinterpret_cast z jednego typu do drugiego, czego wynikiem jest zdefiniowanie implementacji. Nie traciłbym snu z powodu twojego obecnego kodu.

Dla jeszcze jednego przykładu rzeczywistego wykorzystania związków, struktura CORBA serializuje obiekty za pomocą oznaczonego podejścia Unii. Wszystkie klasy zdefiniowane przez użytkownika są członkami jednej (ogromnej) Unii, a identyfikator integer mówi demarshaller jak interpretować Unię.

Zachowanie może być nieokreślone, ale to po prostu oznacza, że nie ma "standardu". Wszystkie przyzwoite Kompilatory oferują # pragmas do kontrolowania pakowania i wyrównywania, ale mogą mieć różne wartości domyślne. Ustawienia domyślne również ulegną zmianie w zależności od użytych ustawień optymalizacji.

Również związki nie są tylko dla oszczędzania miejsca. Mogą one pomóc nowoczesnym kompilatorom z typowaniem. Jeśli {[0] } wszystko kompilator nie może dokonać założeń co do tego, co robisz. Może trzeba będzie rzucić od tego, co wie o twoim typie i zacznij od nowa (wymuszanie zapisu do pamięci, co jest bardzo nieefektywne w dzisiejszych czasach w porównaniu do prędkości zegara procesora).

Inni wspominali o różnicach w architekturze (little-big endian).

Przeczytałem problem, że ponieważ pamięć dla zmiennych jest współdzielona, to zapisując do jednej, inne zmieniają się i, w zależności od ich typu, wartość może być bez znaczenia.

Np. Unia{ float f; int i; } x;

Pisanie do x. byłoby bezsensowne, gdybyś potem czytał z x. f-chyba, że to jest to, co zamierzałeś, aby spojrzeć na znak, wykładnik lub mantissa elementy pływaka.

Myślę, że istnieje również problem wyrównania: jeśli niektóre zmienne muszą być wyrównane słowami, możesz nie uzyskać oczekiwanego wyniku.

Np. Unia{ char c[4]; int i; } x;

Jeśli, hipotetycznie, na jakiejś maszynie znak musi być wyrównany słowami, to c [0] i c [1] dzieliłyby się pamięcią masową z i, ale nie z c[2] i c[3].

W języku C, jak zostało to udokumentowane w 1974 roku, wszystkie elementy struktury dzieliły wspólną przestrzeń nazw, a znaczenie "PTR->member" było zdefiniowane jako dodawanie przemieszczenie członka na " ptr " i uzyskanie dostępu do wynikowego adresu za pomocą typ członka. Ta konstrukcja umożliwiła użycie tego samego PST z członkiem nazwy zaczerpnięte z różnych definicji struktury, ale z tym samym przesunięciem; Programiści wykorzystywali tę zdolność do różnych celów.

Gdy członkowie struktury byli przypisane własne przestrzenie nazw, stało się to niemożliwe deklarowanie dwóch członków struktury o tym samym przemieszczeniu. Dodawanie związków do język umożliwił osiągnięcie tej samej semantyki, która była dostępne we wcześniejszych wersjach języka (choć niemożność nazwy wyeksportowane do kontekstu mogą nadal wymagać użycia find / replace to replace foo - > member into foo - > type1.członek). Co było ważne było nie tyle, że ludzie, którzy dodali związki mają jakiekolwiek szczególne docelowego wykorzystania w umyśle, ale raczej to, że zapewniają one środki, za pomocą których programiści kto oparł się na wcześniejszej semantyce, w jakimkolwiek celu , powinien jeszcze być w stanie osiągnąć tę samą semantykę, nawet jeśli musieli użyć innego składnia, aby to zrobić.

Możesz używać a unii z dwóch głównych powodów:

1. poręczny sposób dostępu do tych samych danych na różne sposoby, jak w twoim przykładzie
2. sposób na zaoszczędzenie miejsca, gdy istnieją różne elementy danych, z których tylko jeden może być "aktywny"

1 jest bardziej jak hack w stylu C do krótkiego pisania kodu na podstawie wiesz, jak działa architektura pamięci systemu docelowego. Jak już wspomniano, można normalnie uciec z nim, jeśli nie rzeczywiście cel wiele różne platformy. Wydaje mi się, że niektóre Kompilatory mogą pozwolić Ci również używać dyrektyw pakujących (wiem, że robią to na strukturach)?

Dobry przykład 2. można znaleźć w wariancie typu szeroko stosowanego w COM.