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?

Something like a `std::bitset<15>` maybe? You cannot change the underlying datatype though. — πάντα ῥεῖ, Sep 30 '21 at 06:00
[This answer](https://stackoverflow.com/a/7416858/509868) to the linked question looks like a good answer to this question. Why do you say that you found "nothing that works on all sizes"? Something special that you want your new type to do? — anatolyg, Sep 30 '21 at 06:03
@anatolyg I just wanted to know if it could work on all sizes for clarity — Packa, Sep 30 '21 at 06:05
What do you mean by "all"? Is e.g. 100000 an example size you want to support? — anatolyg, Sep 30 '21 at 06:06
Every object takes up space that is a multiple of `char`, and a `char` is most commonly eight bits. — molbdnilo, Sep 30 '21 at 06:54

score 5 · Answer 1 · answered Sep 30 '21 at 06:01

5

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.

answered Sep 30 '21 at 06:01

Jeremy Friesner

70,199
15
131
234

1

is it possible to use typedef with this? – Packa Sep 30 '21 at 06:03
Hmm, it seems it isn't possible: https://stackoverflow.com/questions/14536736/typedef-a-bitfield-variable – Jeremy Friesner Sep 30 '21 at 06:05
Notice that the underlying type (as the structure) is not 15 bytes. – Jarod42 Sep 30 '21 at 08:19

score 3 · Answer 2 · answered Sep 30 '21 at 06:51

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;
}

score 1 · Answer 3 · answered Sep 30 '21 at 06:03

1

bitfields feature will do the trick ...

uint32_t customInt : 15;

answered Sep 30 '21 at 06:03

score 1 · Answer 4 · answered Sep 30 '21 at 06:21

You can try using bitfields, like many people mentioned. However, bitfields don't have a proper type. If you want to make your arbitrary-sized integers object-oriented, you can stuff the bitfield into a template:

template <int size> struct my_uint
{
    uint32_t value: size;
};
typedef my_uint<13> uint13_t; // some people use "using" syntax to do this
typedef my_uint<14> uint14_t;
typedef my_uint<15> uint15_t;

However, now you lost arithmetic operators, and you have to implement (overload) them yourself. You have to ask yourself many questions about what you really want to do with these new types:

Do you want to overload operators like +, *, etc? Which ones?
Do you want to support arrays?
What is the maximum size you want to support? In my example, it's 32.
Do you want to support implicit constructors, e.g. uint15_t(uint32_t)?
How to support overflow?

There is no way to make your new types behave like built-in types - you can come close but cannot quite do it. That is, if you write a big program where you work with uint15_t and later you decide to switch to uint16_t, there will be subtle changes caused by uint16_t being a built-in type (e.g. consider rules about implicit conversions).

Weird Data Types - C++

4 Answers4