Reinterpret_cast array of bits as byte [closed]

You cannot use reinterpret_cast to convert from an array of bool to an integer. Apart from anything else the memory layout of an integer and a bool array are different.

However C++ has a std::bitset class which seems to do what you want, e.g.

#include <bitset> std::bitset<8> c = "11111111"; uint8_t d = c.to_ulong(); 

A std::bitset has a fixed size (eight in the above example) but judging by the code you posted that is not a problem. Conversion routines to and from integers and strings exist, as well as methods to manipulate individual bits, bitwise logical operations and shift operations.

Bitset reference

Note your input value already IS an array of bits!
Anyway here is an example of what I mean (based on a class I had lying around). Kind of does what bitset does, but you can see a bit of what is under the hood (pun intended)
Demo : https://godbolt.org/z/YY7EKq5cd

#include <cassert> #include <cstdint> #include <concepts> #include <limits> #include <type_traits> #include <iostream> template <std::unsigned_integral type_t> class Bits final { public: using value_type = type_t; constexpr Bits() noexcept : m_value{0} {} explicit constexpr Bits(type_t value) noexcept : m_value{value} {} constexpr Bits operator|(Bits rhs) const noexcept { return Bits{m_value | rhs.m_value}; } constexpr Bits operator&(Bits rhs) const noexcept { return Bits{m_value & rhs.m_value}; } constexpr Bits operator^(Bits rhs) const noexcept { return Bits{m_value ^ rhs.m_value}; } constexpr Bits operator~() const noexcept { return Bits{~m_value}; } constexpr Bits& operator|=(Bits rhs) noexcept { m_value |= rhs.m_value; return *this; } constexpr Bits& operator&=(Bits rhs) noexcept { m_value &= rhs.m_value; return *this; } constexpr Bits& operator^=(Bits rhs) noexcept { m_value ^= rhs.m_value; return *this; } constexpr bool test(std::size_t bit) const noexcept { return (m_value & (type_t{1} << bit)) != 0; } constexpr void set(std::size_t bit) noexcept { m_value |= (type_t{1} << bit); } constexpr void clear(std::size_t bit) noexcept { m_value &= ~(type_t{1} << bit); } constexpr void toggle(std::size_t bit) noexcept { m_value ^= (type_t{1} << bit); } constexpr std::size_t popcount() const noexcept { return std::popcount(m_value); } constexpr std::size_t count_trailing_zeros() const noexcept { return std::countr_zero(m_value); } constexpr std::size_t count_leading_zeros() const noexcept { return std::countl_zero(m_value); } constexpr type_t value() const noexcept { return m_value; } constexpr void set_value(type_t v) noexcept { m_value = v; } // Proxy for bit reference using set/clear class bitref { Bits& bits_; std::size_t idx_; public: bitref(Bits& bits, std::size_t idx) : bits_(bits), idx_(idx) {} operator bool() const { return bits_.test(idx_); } bitref& operator=(bool v) { if (v) bits_.set(idx_); else bits_.clear(idx_); return *this; } }; constexpr bitref operator[](int idx) { if (idx != 0 && idx != 1) throw std::out_of_range("Bits[]: only 0 or 1 allowed"); return bitref(*this, idx); } constexpr bool operator[](int idx) const { if (idx != 0 && idx != 1) throw std::out_of_range("Bits[]: only 0 or 1 allowed"); return test(idx); } private: type_t m_value; }; int main() { Bits<std::uint16_t> b; assert(b.value() == 0); b[0] = true; b[1] = false; assert(b[0] == true); assert(b[1] == false); b[1] = true; assert(b[1] == true); try { b[2] = true; assert(false); } catch (const std::out_of_range&) {} std::cout << "Bits[] operator test passed!\n"; return 0; }