How do I store array of bits of size, such as size % 8 != 0?

Question

I work with some data, it is represented as a sequence of bits,
number(378) of which isn't divisible by 8.

What are possible ways to work with such sequence?
I need to store it, process it, append one sequence to the other.

Options I considered:

1. round up to the nearest number % 8 == 0, and use array of chars of that size.
2. use bitfield, as far as I know memory alignment for bitfield is implementation defined.

Update:
Properties of bit sequences I am working with:
it is a codeWord that is produced from the given word using Reed-Solomon encoding algorithm.
Hence to work with bits as independent values is of no real use for me, my main concern is how to store codeWords and to append a new codeWord to the existing ones, as in order to reduce effect of burst errors I create interleaving matrix

Answer 1

Another option is, to use std::vector. The std::vector of type bool is specialized on bool to only use ⌈v.size()/8⌉ bytes. But I am not saying you should use this. This specialization is the reason v.begin() is not just a raw pointer, but some type dependent iterator. In all other cases v.begin() of a vector is always a pointer to the element.

In case the length of the bitarray is very long, but you expect only very few bits to be set, you should also concider, to use std::set<int> instead, that stores the indices of the bits that are supposed to be true.

Answer 2

There are several ways to represent a bit sequence in C++.

One, intended for sequences of a fixed size, is std::bitset:

// Create array
std::bitset<378> bitArray;
// Access a bit
bitArray[14] = 1;
// Check whether a bit is set
if (bitArray.test(14))

If you need dynamically resizable sequences, you should consider std::vector. If storage size is important and some access time overhead is not an issue, consider std::vector<bool> which is guaranteed by the standard to store each bool as a single bit in a tightly packed array.

If you don't care about packing tightly, you could also define your own Bit enumeration (or just use a char):

enum Bit : unsigned char
{
  Zero = 0, One = 1
}
std::vector<Bit> bitArray;