Why does this person used (1 << 0)?

Question

I'm reading a code about an implementation of a function, the person who wrote the code, wrote this in his .h:

#define FT_LS_LONG      (1 << 0)
#define FT_LS_RECURSIVE (1 << 1)
#define FT_LS_HIDDEN    (1 << 2)
#define FT_LS_REVERSE   (1 << 3)
#define FT_LS_TIME      (1 << 4)
#define FT_LS_LINE      (1 << 5)

Why did he used bitwise left shift and not something else? And, by what he could have replaced this part of the code? I'm aware that (1 << 0) == 0000 0001 (1 << 1) == 0000 0010, etc.. But I don't get how you can use those.

He meant, each bit represents a particular functionality. ex :: If two bits are set the function needs to perform two functionality. — kiran Biradar, Sep 09 '19 at 10:37
[This](https://stackoverflow.com/questions/15095350/define-something-1-0) might clarify what is the bitwise left operand used for — Néstor Carreño Gimeno, Sep 09 '19 at 10:37
*"Why did he used bitwise left shift and not something?"* -- what? — Marco Bonelli, Sep 09 '19 at 10:41

Danny Ruijters · Answer 1 · 2019-09-09T13:01:45.870

These constructs are typically used in flags that are combined into a single word. They can be combined using the bit-wise OR-operator, e.g.:

int flags = FT_LS_LONG | FT_LS_HIDDEN;

In the code above, the flags variable will be set to 0000 0101. The flags variable can then be tested using the bit-wise AND-operator, e.g.:

if (flags & FT_LS_LONG) { foo(); }

The if-statement will evaluate as true, and the foo() function will be called.

if (flags & FT_LS_TIME) { bar(); }

The if-statement will evaluate as false, and the bar() function will not be called.

Lundin · Answer 2 · 2019-09-09T12:37:04.187

3

It's self-documenting code. 1 could mean anything, while 1 << 0 is most definitely a bit mask. Note that the shift is evaluated at compile-time, since it is an integer constant expression.

A bit more code formatting would have made it all neater:

#define FT_LS_LONG      (1 << 0)
#define FT_LS_RECURSIVE (1 << 1)
#define FT_LS_HIDDEN    (1 << 2)
#define FT_LS_REVERSE   (1 << 3)
#define FT_LS_TIME      (1 << 4)
#define FT_LS_LINE      (1 << 5)

There's no doubt that these are bit masks used to mask different bits of data from the same byte.

Equivalent code could also have been written using hex literals too, it is just a matter of style:

#define FT_LS_LONG      0x01u
#define FT_LS_RECURSIVE 0x02u
#define FT_LS_HIDDEN    0x04u
#define FT_LS_REVERSE   0x08u
#define FT_LS_TIME      0x10u
#define FT_LS_LINE      0x20u

edited Sep 09 '19 at 12:37

answered Sep 09 '19 at 10:53

Lundin

195,001
40
254
396

Did you mean *"`1` could mean anything"*? – S.S. Anne Sep 09 '19 at 11:17
One difference between the two approaches is that the first one results in a `signed` type and the second one results in an `unsigned` type – Rishikesh Raje Sep 09 '19 at 11:34
Note that C calls `0x01u` a _hex constant_, not a _hex literal_. C specifies 2 literals: _string literal_ and _compound literal_. – chux - Reinstate Monica Sep 09 '19 at 13:29

Swedgin · Answer 3 · 2019-09-09T10:44:36.143

2

He probably has done it because it is more clear. FT_LS_LONG is represented by the first (zero'th) bit. He also could just leave it as # define FT_LS_LONG 1 but than it's less clear as all those macros's are contained within a single byte.

edited Sep 09 '19 at 10:44

answered Sep 09 '19 at 10:38

Swedgin

815
1
11
20

score -1 · Answer 4 · answered Sep 09 '19 at 10:41

Without looking at the original code it's hard to tell but this seems to be defining flags in a way that is readable. The alternative would be use #defines set to 0000001, 0000010,0000100 etc. which is less readable and error prone (if you miss a 0 or a 1 it will be hard to tell where the program is failing)

In the implementation I'd expect to see bit wise ands trying to figure out which flags are On or Off.

xception · Answer 5 · 2019-09-09T10:57:04.683

As other answers suggest this is typically because of using flags, however that's not necessarily the only reason.

For microcontrollers for example address space is extremely precious so they pack multiple properties in a single byte, sometimes they are just boolean flags, sometimes they might be something else, for example a clock division factor, and might consist of a few bits, but because the address space is extremely limited it is stored in the same peripheral configuration register as other flags and/or values so they might be for example 5 bits starting at bit 2 and you might find values such as 0b10101 << 2 or in hex 0x15 << 2.

In the microcontroller case it makes it easier to find in the documentation, you just look at the register and which bit it is in it... as in you don't have to count 0s in binary representation or convert it from hex or even worse from decimal to figure out the corresponding value.

Why does this person used (1 << 0)?

5 Answers5