Smallest data type - can I define a one bit variable? [duplicate]

Answer 1

If you don't need millions of these flags or have extremely limited memory constraints, the best way is definitively an int.

This is because an int normally corresponds to the natural word size of your platform and can, properly aligned, be accessed quickly. The machine reads a word at a time anyways and using the single bits requires masking and shifting, that costs time. On your typical PC with gigabytes of RAM, this would be just silly.

If memory consumption really is an issue, there are bitfield structures.

Answer 2

If you really want, you can create a structure with a member variable , bit-fielded to 1 bit.

Remember, the data type of the member variable needs to be unsigned, as you need to store 0 and 1.

Answer 3

Generally, the smallest addressable chunk of data in C is a byte. You can not have a pointer to a bit, so you can not declare a variable of 1 bit size. But as Sourav Ghosh already pointed out, you can declare bitfields, where one bit is accessed directly.

Answer 4

The portable way is the definition of a variable which individual bits are used as flags.

    #define FLAG_FOO 0
    #define FLAG_BAR 1

    // in case platform does not support uint8_t
    typedef unsigned char uint8_t;

    uint8_t flags;

    void flag_foo_set()
    {
        flags |= (1 << FLAG_FOO);
    }

    void flag_foo_clr()
    {
        flags &= ~(1 << FLAG_FOO);
    }

    uint8_t flag_foo_get()
    {
        return flags & (1 << FLAG_FOO);
    }

While this can seem superfluos compared to C bit fields. It is portable to basically every ANSI C compiler.

Answer 5

You could create

typedef struct foo
{
    unsigned x:1;
} foo;

Where you have told the compiler that you'll only be using one bit of x.

But due to structure packing arrangements (the C standard is intentionally flexible in order that compilers can optimise according to the machine architecture), it may well turn out that this still occupies as much space in memory as a regular unsigned and an array of foos doesn't have to be bitwise contiguous.