Union - Объединения

    #include <iostream.h>
 
    void main(void)
 
    {
       union distance
 
       {
          int miles;
          long meters;
       } walk;
 
       walk.miles = 5;
       cout << "Пройденное расстояние в милях " << walk.miles << endl;
       walk.meters = 10000;
       cout << "Пройденное расстояние в метрах " << walk.meters << endl;
    }

union element{
char* el;
Set* s;
}
struct Set_Element{
enum ElType{ATOM,SET};
int type;
Element el;

struct SetElement {
  enum { ATOM, SET } type; // токен типа, содержащий тип текущих хранимых данных
  
  // Собсно данные: или атом, или множество. Фишка в том, что можно хранить или
  // множество, или атом. Если достать что-то другое, то получим мусор и вообще капец.
  // Всё из-за того, что хранятся они в одном и том же месте памяти.
  //
  // Хранить сразу значения или указатели на них, решайте сами, тут однозначно не скажешь.
  union {
    char atom;
    Set set;
  };
 
  SetElement(char value)
  {
    atom = value;
    type = ATOM;
  }
 
  SetElement(const Set &value)
  {
    set = value;
    type = SET;
  }
 
  SetElement& operator=(char value)
  {
    atom = value;
    type = ATOM;
    return *this;
  }
 
  SetElement& operator=(const Set &value)
  {
    set = value;
    type = SET;
    return *this;
  }
 
  bool operator==(const SetElement &other)
  {
    if (this->type != other.type) {
      return false;
    }
    else {
      if (this->type == ATOM) {
        return this->atom == other.atom;
      }
      else {
        return this->set == other.set;
      }
    }
  }
};

SetElement element1('x'); // элемент-атом
SetElement element2(someSet); // элемент-множество
if (element1.type == SetElement::ATOM) { // можно сделать методы isAtom() и isSet()
  std::cout << element1.atom;
}
element1 = element2; // element1 теперь тоже элемент-множество

typedef struct{ 
  byte bmRequestType;//0
  byte bRequest;     //1
  word wValue;       //2-3
  word wIndex;       //4-5
  word wLength;      //6-7
} SETUP_PACKET;

word         wRequest;

typedef union
{
  SETUP_PACKET setup;
  byte         b[8];
  word         wRequest;
} UsbSetupPacket;

UsbSetupPacket SetupPacket;

  for (i=0; i<8; i++)
   SetupPacket.b[i]= Usb_read_byte();

  switch (SetupPacket.wRequest)  
  {
    case GET_STATUS_DEVICE:

 if (SetupPacket.setup.wValue ==0x00  )     //  FEATURE_ENDPOINT_HALT
      {
       wIndex = (SetupPacket.setup.wIndex & 0x7F );

union
  {
   ArrChar char[4];
   Value int; 
  }

Set st;
element.s=&st
for(int i=0;i<sizeof(st);i++)
   printf("0x%x  ",element.el[i]);

#include <vector>
#include <iostream>
 
template <typename T>
class Set {
public:
  Set();
  Set(const Set<T> &other);
 
  // добавление
  Set<T>& add(const T &element);
  Set<T>& add(const Set<T> &set);
 
  // проверка вхождения
  bool contains(const T &element);
  bool contains(const Set<T> &set);
 
  // проверка вхождения и в хранимых подмножествах
  bool deepContains(const T &element);
  bool deepContains(const Set<T> &set);
 
  bool operator==(const Set<T> &other);
 
  template <class R>
  friend
  std::ostream& operator<<(std::ostream &stream, const Set<R> &set);
 
private:
  struct SetElement {
    enum { ATOM, SET } type;
    union {
      T atom;
      Set<T> *set; // <- хранится как указатель
    };
 
    SetElement(const T &element);
    SetElement(const Set<T> &set);
    SetElement(const Set<T>::SetElement &other);
    ~SetElement();
 
    bool operator==(const Set<T>::SetElement &other);
    bool operator==(const T &element);
    bool operator==(const Set<T> &set);
  };
 
  // Вообще стоит сделать что-то умнее вектора. Обычно тут
  // используется какое-нибудь самобалансирующееся дерево,
  // чтобы время на поиск вхождения было минимальным.
  std::vector<SetElement> data;
 
  static void printout(std::ostream &stream, const Set<T>::SetElement &element);
};
 
template <class T>
Set<T>::SetElement::SetElement(const T &element)
{
  type = ATOM;
  atom = element;
}
 
template <class T>
Set<T>::SetElement::SetElement(const Set<T> &set)
{
  type = SET;
  this->set = new Set<T>(set);
}
 
template <class T>
Set<T>::SetElement::SetElement(const Set<T>::SetElement &other)
{
  this->type = other.type;
  if (type == ATOM) {
    atom = other.atom;
  }
  else {
    // Полностью копируем хранимое внутри множество
    this->set = new Set<T>(*(other.set));
  }
}
 
// Так как элементы-подмножества хранятся как указатели,
// то их необходимо убивать вручную. Блааго, vector вызывает
// деструкторы, так что из самого Set<T> всё удалится
// автоматически.
template <class T>
Set<T>::SetElement::~SetElement()
{
  if (type == SET) {
    delete set;
  }
}
 
template <class T>
bool Set<T>::SetElement::operator==(const Set<T>::SetElement &other)
{
  if (this->type != other.type) {
    return false;
  }
  else {
    if (this->type == ATOM) {
      return this->atom == other.atom;
    }
    else {
      return *(this->set) == *(other.set);
    }
  }
}
 
template <class T>
bool Set<T>::SetElement::operator==(const T &element)
{
  if (type != ATOM) {
    return false;
  }
  else {
    return atom == element;
  }
}
 
template <class T>
bool Set<T>::SetElement::operator==(const Set<T> &set)
{
  if (type != SET) {
    return false;
  }
  else {
    return *(this->set) == set;
  }
}
 
template <class T>
Set<T>::Set()
{}
 
// vector сам повызывает конструкторы копирования и сделает deep-copy
template <class T>
Set<T>::Set(const Set<T> &other)
  : data(other.data)
{}
 
template <class T>
Set<T>& Set<T>::add(const T &element)
{
  if (!contains(element)) {
    data.push_back(SetElement(element));
  }
  return *this;
}
 
template <class T>
Set<T>& Set<T>::add(const Set<T> &set)
{
  if (!contains(set)) {
    data.push_back(SetElement(set));
  }
  return *this;
}
 
template <class T>
bool Set<T>::contains(const T &element)
{
  bool yes = false;
  for (int i = 0; i < data.size(); ++i) {
    if (data[i] == element) {
      yes = true;
      break;
    }
  }
  return yes;
}
 
template <class T>
bool Set<T>::contains(const Set<T> &set)
{
  bool yes = false;
  for (int i = 0; i < data.size(); ++i) {
    if (data[i] == set) {
      yes = true;
      break;
    }
  }
  return yes;
}
 
template <class T>
bool Set<T>::deepContains(const T &element)
{
  bool yes = false;
  for (int i = 0; i < data.size(); ++i) {
    if (data[i].type == Set<T>::SetElement::ATOM) {
      if (data[i] == element) {
        yes = true;
        break;
      }
    }
    else {
      // Если наткнулись на множество, то рекурсивно проверяем,
      // есть ли искомый внутри него.
      if (data[i].set->deepContains(element)) {
        yes = true;
        break;
      }
    }
  }
  return yes;
}
 
template <class T>
bool Set<T>::deepContains(const Set<T> &set)
{
  bool yes = false;
  for (int i = 0; i < data.size(); ++i) {
    if (data[i].type == Set<T>::SetElement::SET) {
      // На элементы-значения можно вообще не смотреть,
      // а для множеств искомое может быть как равно им,
      // так и быть внутри них.
      if ((data[i] == set) || (data[i].set->deepContains(set))) {
        yes = true;
        break;
      }
    }
  }
  return yes;
}
 
// Офигенно медленная O(n^2) реализация сравнения,
// но сойдет как иллюстрация.
template <class T>
bool Set<T>::operator==(const Set<T> &other)
{
  if (this->data.size() != other.data.size()) {
    return false;
  }
  else {
    bool okay = true;
    for (int i = 0; i < data.size(); ++i) {
      if (other.data[i].type == Set<T>::SetElement::ATOM) {
        if (!contains(other.data[i].atom)) {
          okay = false;
          break;
        }
      }
      else {
        if (!contains(*(other.data[i].set))) {
          okay = false;
          break;
        }
      }
    }
    return okay;
  }
}
 
template <class T>
std::ostream& operator<<(std::ostream &stream, const Set<T> &set)
{
  bool first = true;
  stream << "{";
  for (int i = 0; i < set.data.size(); ++i) {
    if (!first) {
      stream << ", ";
    }
    Set<T>::printout(stream, set.data[i]);
    first = false;
  }
  stream << "}";
  return stream;
}
 
template <class T>
void Set<T>::printout(std::ostream &stream, const typename Set<T>::SetElement &element)
{
  if (element.type == Set<T>::SetElement::ATOM) {
    stream << element.atom;
  }
  else {
    stream << *(element.set);
  }
}
 
int main()
{
  Set<int> set1;
  set1.add(1).add(2).add(3).add(1);
 
  std::cout << "set1 = " << set1 << "\n";
  for (int i = 0; i < 5; ++i) {
    std::cout << "set1 contains(" << i << ") => " << set1.contains(i) << "\n";
  }
  std::cout << "\n";
 
  Set<int> set2;
  set2.add(9).add(set1);
  std::cout << "set2 = " << set2 << "\n";
  std::cout << "set2 contains(1) => " << set2.contains(1) << "\n"
            << "set2 contains(9) => " << set2.contains(9) << "\n"
            << "set2 contains(2) => " << set2.contains(2) << "\n"
            << "set2 deepContains(2) => " << set2.deepContains(2) << "\n"
            << "set2 contains(set1) => " << set2.contains(set1) << "\n"
            << "set2 deepContains(set1) => " << set2.deepContains(set1) << "\n";
  std::cout << "\n";
 
  Set<int> set3;
  set3.add(3).add(2).add(1);
  std::cout << "set3 = " << set3 << "\n";
  std::cout << "set1 == set3 => " << (set1 == set3) << "\n";
  std::cout << "\n";
 
  Set<int> set4;
  set4.add(set3).add(9);
  std::cout << "set4 = " << set4 << "\n";
  std::cout << "set2 == set4 => " << (set2 == set4) << "\n";
  std::cout << "\n";
}