Weird Data Types - C++

Question

I know this sounds like a silly question, but I would like to know if it is possible in any way to make a custom variable size like this rather than using plain 8, 16, 32 and 64 bit integers:

uint15_t var; //as an example

I did some research online and I found nothing that works on all sizes (only stuff like 12 bit and 24 bit). (I was also wondering if bitfields would work with other data sizes too).

And yes, I know you could use a 16 bit integer to store a 15 bit value, but I just wanted to know if it is possible to do something like this.

How can I make and implement custom integer sizes?

Answer 1

Inside a struct or class, can use the bitfields feature to declare integers of the size you want for a member-variable:

unsigned int var : 15;

... it won't be very CPU-efficient (since the compiler will have to generate bitwise-operations on most accesses to that variable) but it will give you the desired 15-bit behavior.

Answer 2

To be able to use your bitfield int as a normal int but still get the behavior of a 15 bit int you can do it like this :

#include <cassert>
#include <utility>

template<typename type_t, std::size_t N>
struct bits_t final
{
    bits_t() = default;
    ~bits_t() = default;

    // explicitly implicit so it can convert automatically from underlying type
    bits_t(const type_t& value) :
        m_value{ value }
    {
    };

    // implicit conversion back to underlying type
    operator type_t ()
    {
        return m_value;
    }

private:
    type_t m_value : N;
};


int main()
{
    bits_t<int, 15> value;
    value = 16383;  // 0x3FFF
    assert(value == 16383);
    
    // overflow now at bit 15 :)
    value = 16384; // 0x4000, 16th bit is set.
    assert(value == -16384);

    return 0;
}