struct {
    uint8_t /* Reserved */ : 3;
    uint8_t foo : 3;
    uint8_t bar : 3;
} bits;

// assertion fails due to 1 extra bit
static_assert(sizeof(bits) == sizeof(uint8_t));

struct {
    uint8_t /* Reserved */ : 3;
    uint8_t foo : 3;
    uint8_t bar : 1;
} bits;
// assertion passes, but I want it to fail, because one bit is padding
static_assert(sizeof(bits) == sizeof(uint8_t)); 

struct {
    [[deprecated("This field should not be used")]] uint8_t Reserved1 : 2;
    uint8_t foo : 3;
    uint8_t bar : 3;
} bits;
// If `Reserved1` had a bitsize of 3, it would have padding and this would fail
static_assert(std::has_unique_object_representations_v<decltype(bits)>);

static_assert(sizeof(bits) == sizeof(uint8_t));

struct {
    int a: 3;
    short b: 3;
} bits;
static_assert(sizeof(bits) == 1);

// This list is being used to define the bit-field members
// and to compute the sum of bits.
#define LIST \
  E(char, , 3) \
  E(char, foo, 3) \
  E(char, bar, 1)
// Define what an entry in the list means.
#define E(type, name, size) type name: size;
struct {
// LIST expands to char: 3; char foo: 3; char bar: 1;
    LIST
} bits;
// Re-define what an entry means.
#undef E
#define E(type, name, size) +size
// LIST expands to +3 +3 +1
constexpr int bits_bits = LIST;
#undef E
#undef LIST
// This assertion passes, since we have 7 bits in total.
static_assert(bits_bits == 7);
// This assertion fails, but would have passed if we had 8 bits.
// We could also check if bits_bits is a multiple of 8 with
// bits_bits % 8 == 0.
static_assert(sizeof(bits) * 8 == bits_bits);

struct {
    uint8_t /* Reserved */ : 3;
    uint8_t foo : 3;
    uint8_t bar : 1;
#ifdef DEBUG
    uint8_t BOOM : 1;
#endif
} bits;
#ifdef DEBUG
static_assert(sizeof(bits) > sizeof(uint8_t)); // Will assert in debug mode because there are insufficient bits
#else
static_assert(sizeof(bits) == sizeof(uint8_t)); // Will NOT assert
#endif

#include <array>
// create a constexpr to see if all bit field constants
// add up to the size of the underlying type.
// if not then assert at compile time
template<typename underlying_t, std::size_t...sz>
static constexpr auto checked_bit_fields()
{
	// the numbers will be returned as an array
	std::array<std::size_t, sizeof...(sz)> bit_layout{ sz... };
	// (sz + ...) is fold expression calculating the sum of the bit fields
	// 8 * sizeof calculates the size in bits of the underlying type.
	static_assert((sz + ...) == 8ul * sizeof(underlying_t));
	return bit_layout;
}
struct bits_t
{
private:
	// the template parameters with number of bits per field.
	// if the sum of the bitfield sizes do not match the underlying type size
	// the code will not compile (test it out)
	static constexpr auto bits = checked_bit_fields<uint8_t, 2, 3, 3>();
	// regretably the standard does not allow for a structured binding here
	// so I could not do [unused,foo_bits,bar_bits] = checked_bit_fields<uint8_t,2,2,3>(); 
	// an we need to access the bit field sizes from the array
public:
	uint8_t : bits[0]; // == 2
	uint8_t foo : bits[1]; // == 3
	uint8_t bar : bits[2]; // == 3 
};
int main()
{
	bits_t bits;
	bits.foo = 3;
	return 0;
}