AVR Freaks

If IIRC you may need to be careful (i.e. not rely on) the order of the bits. The order on the AVR target does not match the order on GCC code that we compile for Renesas H8s.

#include 

template  struct sizeType;

template <> struct sizeType {
  typedef uint32_t type;
};

template <> struct sizeType {
  typedef uint16_t type;
};

template <> struct sizeType {
  typedef uint8_t type;
};

class BitProxy {
  uint8_t& data;
  uint8_t const bit;
  BitProxy(uint8_t& data1,  uint8_t bit1) : data(data1), bit(bit1) {}
  template  friend class BitArray;
 public:


  operator bool () const {
    uint8_t result = data & bit;
    return result;
  }

  template  operator T () const { return bool(*this); }
  bool operator ! () const { return !bool(*this); }
  bool operator == (bool b) const { return bool(*this) == b; }
  bool operator != (bool b) const { return bool(*this) != b; }
  bool operator ^  (bool b) const { return bool(*this) ^ b; }

  BitProxy& operator = (bool a) { 
    if (a) data |= bit; else data &= ~bit;
    return *this;
  }

  BitProxy& operator |= (bool a) { 
    if (a) data |= bit;;
    return *this;
  }

  BitProxy& operator &= (bool a) { 
    if (!a) data &= ~bit;
    return *this;
  }

  BitProxy& operator ^= (bool a) { 
    data ^= bit;
    return *this;
  }
};

template  class BitArray {
  uint8_t data[(size + 7) / 8];
 public:

  typedef typename sizeType<(size > 0xFFUL), (size > 0xFFFFUL)>::type SizeType;

  BitProxy operator [] (SizeType index) {
   return BitProxy(data[index / 8], 1 << (index % 8));
  }

  const BitProxy operator [] (SizeType index) const {
   return BitProxy(const_cast(data[index / 8]), 1 << (index % 8));
  }

};

#include 

BitArray<40> test;

bool demo() {
  test[10] = 1;
  test[20] = 1;
  return test[17];
}


void demo2() {
  if (test[22]) printf("Hello\n");
}

uint8_t demo3() {
  return test[30];
}

int i;

uint8_t demo4(const BitArray<40>& test) {
  return test[i];
}

In the end, does the compiler generate the same code in this C++ case as the far simpler C solution?