text: Note: This is a tough lesson. If you find yourself stuck, you can safely skip this lesson and come back to it later.
  Bit flags
  Using a whole byte to store a boolean leaves 7 of the 8 bits unused. While this generally is fine, in storage-intensive cases where we have lots of related boolean options, it can be useful to “pack” 8 individual booleans into a single byte for storage efficiency purposes. These individual bits are called bit flags. Since the bits can’t be accessed directly, we have to use the bitwise operators to set, clear, or query them.
  Note: We use hexadecimal numbers in this lesson. If you need a refresher on hexadecimal numbers, we discuss hex in lesson 2.8 -- Literals.
  For example:
  To query a bit state, we use bitwise AND:
  To set a bit (turn on), we use bitwise OR:
  To clear a bit (turn off), we use bitwise AND with an inverse bit pattern:
  To toggle a bit state, we use bitwise XOR:
  As a real-life example, in OpenGL (a 3d graphics library), some functions take one or more bit flags as a parameter:
  GL_COLOR_BUFFER_BIT and GL_DEPTH_BUFFER_BIT are defined as follows (in gl2.h):
  Here’s a small example:
  Why are bit flags useful?
  Astute readers will note that the above myflags example actually doesn’t save any memory. 8 booleans would normally take 8 bytes. But the above example uses 9 bytes (8 bytes to define the
  Alex,
  About quiz.
  1) Would suggest initialization: ‘unsigned char myArticleFlags (0x0);’
  2) Why copy initialization is preferred over direct and uniform initialization. ‘unsigned char option_viewed = 0x01;’ instead of ‘unsigned char option_viewed {0x01};’
  1) Done.
  2) It’s not. When initializing fundamental variables, any of the three initialization methods is fine. I tend to use copy initialization just out of habit.
  Using C++11 would the following code now be
  it’s output is as follows :-
  1
  2
  4
  8
  16
  32
  64
  128
  Does this signify that the whole byte is occupied instead of alloting each byte to a single char variable(options) ? Have u given each bye to single char option or a single bit has been alloted to each of the char variable?
  sorry…i meant that it is alloted a single byte to each of the char variable or a whole byte has been alloted to all of the options as a whole using bit flags ?
  Variable “me” is a char, which takes a whole byte. The flags also take an entire byte each. In the above code, you’re doing a bitwise AND on “me” and the flag, resulting in a new byte with the appropriate bits set, which is then being interpreted as an integer (since chars are integers)
  i understood that.Thank You. BUT, Then, How does bit flags save memory ?
  Plz Explain it to Me ! i always get stuck in this chapter….!!!
  If you only have one set of states you’re tracking, it doesn’t save any memory. In the example above, we end up using 9 bytes (8 bytes to define the bit flags and 1 byte to store them), as opposed to using 8 bytes if we just used a single boolean to store each state.
  However, if you have multiple objects that you need to store states for, then bit flags start yielding benefits. Let’s say you want to store a set of states for both yourself and your evil twin. Using booleans, you’d need 2 full sets of booleans (2 x 8 booleans), which would be 16 bytes. However, with bit flags, it would only cost 10 bytes (8 bytes to define the bit flags, and 1 byte per object to store the bits). So we’re already seeing savings. Those savings continue to increase with additional objects.
  But How? Without using bit flags also it would end up using 10 bytes….Cant The Second variable(me1) access the same options as it was accessed by the first variable(me) ?
  And One More Help From You…..
  Plz Define A Set Of Options(Like Above) But, That shouldnt Use Bitflags
  With bit flags, 2 variables (total cost = 10 bytes):
  Without bit flags (total cost = 16 bytes):
  Thats What I’m asking…..Can’t The Second Variable, that is, eviltwinflags access the meisMad Or Any of the options that have been used for "me" !?
  If yes, then see, it will also consume 10bytes only
  And One More Question !
  When i try to print isMad Or Any Option without printing it like (me & isMad), it prints it as an unrecognizable character……Why?
  > Can’t The Second Variable, that is, eviltwinflags access the meisMad Or Any of the options that have been used for “me” !?
  Yes, it can. That’s why bit flags are useful -- we only need to define the bit flags once, and then we can use them over and over.
  The bit flags are printing as funny characters because they’re printing as chars, and chars with values lower than 32 are “unprintable”, so your OS is subbing in some other symbol.
  Here, in This Code…
  false;
  bool meIsSad = false;
  bool meIsMad = false;
  bool meIsHappy = false;
  bool meIsLaughing = false;
  bool meIsAsleep = false;
  bool meIsDead = false;
  bool meIsCrying = false;
  bool evilTwinIsHungry = false;
  bool evilTwinIsSad = false;
  bool evilTwinIsMad = true;
  bool evilTwinIsHappy = false;
  bool evilTwinIsLaughing = false;
  bool evilTwinIsAsleep = false;
  bool evilTwinIsDead = false;
  bool evilTwinIsCrying = false;
  Can the eviltwinflags access the options that have been used for "me" !? I meant to ask this !
  For Eg. evil twin flags |= meIsMad | meIsHungry; //initial value of evil twin flags was zero
  > Can the eviltwinflags access the options that have been used for “me” !?
  In the bit flags case, yes. In the boolean case, no.
  This is fine if meIsMad and meIsHungry are bit flags. This is not fine if they are booleans. The difference is that the bit flags don’t actually hold any values -- they’re just bit position indicators. So they can be shared. The variable that holds the actual values (for me and my evil twin) needs to be unique, and can’t be shared.
  Don’t you think when we do (myflags & option4) it evaluates to ZERO, so how does it query the bit state, or, here, & is an overloaded operator ?
  I’m not sure I understand the question. myflags & option4 causes operator & to evaluate operands myflags and option4 to produce a bitwise result. It may evaluate to zero or non-zero depending on the value of myflags.
  And I think all the bitwise operators are overloaded when u use them to turn on, off, toggle or query their state !
  am I right or not? Plz tell me !
  No, they’re not overloaded in this context.
  So If I try to assign boolean values to evil twin flags….will it give an error ?
  Probably not, since booleans can be converted to chars or other integers. It just won’t do what you want.
  Thats what i meant to say :-
  bool meIsHungry = false;
  bool meIsSad = false;
  bool meIsMad = false;
  bool meIsHappy = false;
  bool meIsLaughing = false;
  bool meIsAsleep = false;
  bool meIsDead = false;
  bool meIsCrying = false;
  Inspite of using 2 sets of booleans for two vars we can just use one set for two variables….i aint talking about modifications here
  Same memory would be saved
  (8bytes + 2bytes) = 10Bytes would be used
  No. Each boolean represents a specific piece of memory that we’re using to store a value. That can’t be shared between two variables.
  And If We Try To Use Integers !?
  Doesn’t matter. You seem to be missing some fundamental points, so let me try one last time to see if I can make this clear. From the beginning.
  In order to store a value (of any type) we need a variable to do so.
  If order to store 2 values, we need 2 variables:
  We can’t use the same variable to hold two (or more) independent values, because as soon as we assign the variable a second value, it will lose its first value (and vice-versa). We need independent memory locations to hold independent values.
  Now consider the case where we want to store 8 independent boolean values:
  Because these need to be separate values, we have to use 8 boolean variables. If we needed two sets of these, we’d need 16 boolean variables.
  This works, but in the case of bool it’s a waste of memory. Because machines tend to be byte-addressable, a bool takes 1 byte (8 bits). But only 1 of those bits is actually used to store true or false -- the 7 bits go to waste.
  If only there were some way to use those other 7 bits. There is -- bitwise operators. By being clever with the bitwise operators, we can get and set the individual bits in a byte, which allows us to compact 8 unique boolean values into a single byte. For our single byte, we typically use an unsigned char.
  But in order to do this, we need to be able to identify each bit individually. We typically say a byte is 8 bits, so we can number the bits from left to right: 8 7 6 5 4 3 2 1. Then all we need to do is say: turn bit 5 on, turn bit 4 off, flip the state of bit 2.
  The bit numbers are reusable because they’re just bit positions. The unsigned char needs to be unique so we can store a unique set of 8 bits.
  Our bit flag variables act as the bit numbers (which is why they are reusable -- they just identify which bit we’re talking about, not the value we’re trying to get or set). The unsigned char (me or my evil twin) act as the variable that stores a unique set of 8 bits.
  If you have any minor clarifications needed about this, I’m happy to address. But if you still don’t get it, then I’d say move on. This isn’t critical to know and it won’t block you from proceeding.
  So The Conclusion is that we cannot re-assign fundamental data types to two variables but this is not the case with BitFlags…..Ok !
  Sorry I Didnt mean to say this…i know that we cannot use one variable to store two values…..this is basic….what i meant to ask is that :-
  for eg :-
  bool opt1 = false;
  bool opt2 = true;
  bool sopt1 = false;
  bool sopt2 = true;
  //Now Lets Declare two char vars :-
  unsigned char myflags = !opt1;
  unsigned char eviltwinflags = opt2;
  See Here There was no requirement to define sopt1&2….that’s what i meant to say that why we are declaring two sets of booleans if our work can be done by just using one set……
  Yes I Agree on one point that we can produce an aggregated result using bitwise operators;
  For Eg -- myflags |= opt1 | opt2;
  (opt1 and opt2 are bit flags here)…..
  I Hope Now u have understood my question !
  You would never do this. You’re mixing metaphors. The top set of 4 booleans is what you’d do without bit flags, since you’re using discrete variables to hold values.
  If you’re using bit flags, you need two things: a variable to hold the bits (myflags and eviltwinflags) AND the bit positions. We use symbolic constants to give meaning to the bit flags (e.g. isHappy, because that’s more meaningful than 0x4).
  You’d never use booleans as the bit positions because booleans only hold 2 values (0 and 1), which is 1 bit. If you used booleans as bit flags then you’d have no way to access the other 7 bits in your variable.
  For those of us for whom English is a foreign language it can be a little confusing the sentence "Write a line of code to unset the article as a favorite."
  Searching for the meaning of the verb "to unset". I have found that most reputable online dictionaries don’t even recognize this as a verb but only as an adjective with the following meanings:
  a) not fixed in a setting, unmounted (e.g. unset diamonds)
  b) not firmed or solidified (e.g. unset concrete)
  Some sources say that "to unset" means "(label) to make not set" (which is even more confusing). How can I set a bit in such a way as to make it "not set"?
  On the other hand, the verb "TO RESET" has a clear meaning in engineering, "to restore (a gauge, dial, etc) to zero". That meaning was borrowed by Computer Science where it means "clear to restore (the contents of a register or similar device) in a computer system to zero".
  TLDR unset = reset?
  In this context, unset = reset. Reset is a bit ambiguous because it’s unclear whether you’re resetting to 0 or resetting to the initial state, whatever that was. So “unset” is sometimes used to mean “return to the off state”.
  However, in this context, the word “clear” works just as well, so I’ve replaced “unset” with “clear”, which makes it clear(er) we’re setting bits back to 0.
  #include <bitset>
  #include <iostream>);
  bits.set(option_5);
  bits.flip(option_6);
  bits.reset(option_6);
  std::cout << "Bit 4 has value: " << bits.test(option_5) << ‘\n’;
  std::cout << "Bit 5 has value: " << bits.test(option_6) << ‘\n’;
  std::cout << "All the bits: " << bits << ‘\n’;
  std::cout << "size of bits " <<sizeof(bits) ;// _________shows 4 byte ____________//
  return 0;
  }
  i have a question ,i guess that size of "bits"(source code above) will need 1 byte( 8 bits) only,after i compiled the code it shows 4 byte.can you explain me ?Thanks for nice tutorial
  This comes down to how std::bitset is implemented, which may differ from compiler to compiler. But most likely, your version of std::bitset is allocating 32 bits (one word) for anything between 1 and 32 bits for efficiency purposes. This makes the code execute faster at the cost of potentially wasting some memory.
  Thanks a lot for your explanation,
  i got it.
  Hey,
  I had some questions about the part where you talk about memory usage.
  Here you write that this code will use 9bytes (8 for options & 1 for the flag itself), but I’m not entirely agreeing with that.
  Because you define the options as being const (and you never use address-of), wouldn’t that allow the compiler to inline the values?
  I know the c++ standard doesn’t force compilers to inline const statements, but I think most of them do!
  This would mean that, even for situations where you have only a few flags, the way with bits would still take less memory (but more computation time because of the binary operators…)
  Let me know if I am right or not! 🙂
  Maybe I should say, 9 bytes in the worst case. You’re right though, a good compiler would probably inline the const variables, making the code slightly bigger but reducing the memory footprint.
  Would the code be bigger though?
  Anyway I am just nitpicking..
  And this could be solved with enums and then there is no discussion! 😉
  Good question, actually. I was thinking about inline functions, which tend to make more code than non-inline functions because the code gets copied into many places instead of staying in a single place. But with literals, at least with fundamental types, this probably isn’t true (it might be for more complex types, like classes).
  Hi Alex, how come you use | to specify both options 4 and 5 to turn on, wouldn’t it be & because you would be saying option4 AND option 5?
  No. And in fact, bitwise logic tends to be the opposite of how we use terms in common language. In common language we tend to think of OR as a restriction (you can have “A” or “B”, you’re restricting the choice from a set” and AND as an aggregation (A and B is more than A or B alone).
  In bitwise logic, it’s the opposite. OR produces a result that includes all the bits in both operands, so A OR B includes all the bits from both A and B (an aggregation). AND produces a result that includes only the bits in both A or B (a restriction).
  This makes sense when you consider things from a bit by bit level, but it does make it a little hard to wrap your head around the first time.
  Just spent half an hour scratching head over the very first example:-
  Testing to see if an option is set using bitwise AND
  if (myflags & option4)
  I was thinking for ages that wouldn’t show if option4 was set as it would give 0000 0000, but it just dawned on me that we are testing if myflags has option option4 set and not checking to see if option4 is set, jeez and can be thick sometimes, lol.
  Hello again, Alex.
  Please could you tell us about bit fields - what they are and how to use them? I hope I’m not asking for too much…
  Bit fields allow you to create members of a struct that use less that 1 byte each. This can be useful if you want to compact multiple sub-byte members together to save space. However, with the amount of memory modern machines tend to have, bit fields aren’t used near as much these days, so I haven’t written a full lesson on them yet. I’ve added it to my to-do list for the future.
  Hi Alex and thanks again for this great site.
  If one is using std::bitset, is it possible to use typedefs to name custom types rather than having to type out std::bitset<blah> for every declaration, and if so would you consider this good practice?
  Thanks.
  P.S.: How do I get my photo to display in comments 🙂 ?
  Yes, you can use a typedef (or type alias). It’s fine to do this if you want.
  To get a photo to display in comments, you need to set up a gravatar with your associated email address. See gravatar.com.
  Hi Alex,
  After your first example, it may be helpful to post a link to the tutorial on literals. I had to go back as I forgot that hexadecimal counts as 0-9, then A-F in one digit, to go up to 15. I went back because I wanted to check how one digit would go past 9.
  Oh, I see that you already had a link to section 2.8 -- literals, later on. Maybe it’s better to put it straight after when it comes up first in the tutorial after the first example?
  Good call. I’ve added a note to the lesson. Thank you.
  why not just ,me= & isHappy? but me= &~isHappy; I do not understand the purpose of not operator there?
  Turning a bit on is easy -- we just do a logical OR. Turning a bit off is a little more difficult, since C++ doesn’t have a logical operator that maps directly to that behavior. So instead, we have to combine two logical operators to get the desired effect.
  Consider the statement me &= ~isHappy. We know isHappy has value 0000 1000, so ~isHappy has value 1111 0111. We don’t know what value “me” could have, it could be anything. So let’s just say the bits are represented by the letters abcd efgh. Our statement is now abcd efgh &= 1111 0111.
  For any given bit x, if you logical AND x with a 1, x will retain its value. If you logical AND x with a 0, x will be turned off. By using logical NOT on isHappy, we produce exactly the right bit pattern to use with logical AND in order to have all of the bits preserve their original values except the one we want to turn off.
  Typo… you miss the word " a " before "game" in the following statement "Imagine you’re creating game where there are monsters for the player to fight", I think it should be "Imagine you’re creating a game where there are monsters for the player to fight"
  And thanks again for the tutorial…
  PD: Sorry about my English but I speak Spanish
  Can the 1a, 1b, 1c questions be solved by using bitset ? And are bitwise operators totally replaceable with bitset ? Because it’ll be great if everything can be done using bitset.
  Yes, quiz questions 1a, 1b, and 1c could be solved that way. Variable myArticleFlags could be a std::bitset and the quiz code should still work (since std::bitset supports bitwise operators).
  However, if you’re using std::bitset, you’d want to consider defining the option_xxx values differently (since the bitset functions use indices rather than integer values).
  std::bitset is great, particularly if you want to tweak single bits. It doesn’t do quite as well if you need to query or set multiple bits at once.
  Can we query, set, reset multiple bits at once by using bitset ? If so, how ?
  You can, by using the &, |, and ^ operators. You can not via the set(), reset(), and flip() member functions.
  Alex,
  You’re missing the
  at the bottom of the RGBA color example.
  Thanks for the great work with these tutorials.
  Updated, thanks!
  Hi, Alex! I have a suggestion when turning off bits:
  When you have something like this:
  in case we need to modify more options at once, I found it better to use DeMorgan’s law, like this:
  This way you keep the consistency of listing multiple options with | operator like with other actions, and it’s slightly more readable. Maybe add that to the lesson? 🙂
  Also, thank you very much for these lessons. Very well organized, easy to follow, and most important, under constant maintenance and open to suggestions. Keep it up! 🙂
  Love it! That’s definitely better than what I had. I’ve added it to the lesson. Much appreciated.
  "); // we need 8 bits, start with bit pattern 0000 0010 "
  That means that our first option will be option_2 ?????
  Yes, this will start initialized with option_2.
  Thank you Alex!!!
  " Then you could use bit flags to pass in only the options you wanted:
  someFunction(option10 | option32); "
  In this case, where we have to define our options? at someFunction or main???
  Good question. In this case, both the caller and callee are going to need access to the options. Probably the best thing to do would be define them at the top of your file (just below the includes) (as global variables, which I cover at the start of chapter 4) or in a header file (which you can then #include).
  "
  // Define 8 separate flags (these can represent whatever you want)
  // Note: in C++11, better to use "uint8_t" instead of "unsigned char"
  const unsigned char option1 = 0x01; // hex for 0000 0001
  const unsigned char option2 = 0x02; // hex for 0000 0010
  const unsigned char option3 = 0x04; // hex for 0000 0100
  const unsigned char option4 = 0x08; // hex for 0000 1000
  const unsigned char option5 = 0x10; // hex for 0001 0000
  const unsigned char option6 = 0x20; // hex for 0010 0000
  const unsigned char option7 = 0x40; // hex for 0100 0000
  const unsigned char option8 = 0x80; // hex for 1000 0000
  // byte-size value to hold some combination of the above 8 options
  unsigned char myflags = 0; // all flags/options turned off to start
  "
  Could you please show me how to use this in a complete code??? I mean, i understoud how to query,tern on, etc…. but i didn’t understand how to define bit flags….
  I’ve updated the lesson with an example.
  Thank you very much Alex!!! So, we don’t assign those 8 options, we just define them to use them at the byte-size value right???
  Right. We define them in such a way that we can use them to isolate single bits within a byte.
  In bitset you can also access certain bit by myflags[n], where n is number of bit(from right to left: 0, 1, 2 etc). I think it comes handy in "if" sentences.
  Presumably there is a danger here if a variable is left un-initialised. For example with the quiz, if
  isn’t initialised, I run the risk of starting from some random configuration, don’t I?
  Yes, absolutely. Presumably you’d want to either initialize myArticleFlags with a value, or assign a value to it shortly after creation.
  I’ve updated the quiz question to initialize it to 0.
  You are amazing man!!! I hope you can do a tutorial like this, but oriented to graphical user interfaces, thanks a lot for this amazing material!!!
  Just curious, you say:
  "As a side note, different machine architectures may store bytes in a different order. RGBA can be stored as ARGB or BGRA depending on the architecture."
  What machine architectures would use that byte ordering? I’m only familiar with big and little endian. Granted, it’s been a while, but those orderings don’t strike me as an endian difference.
  tx!
  I think I misspoke -- ARGB is an intentional choice to represent the encoding differently, putting the alpha channel first rather than last. Other permutations (ABGR and BGRA) are the little-endian permutations of RGBA and ARGB.
  Hi, I am thoroughly enjoying these so far, and I’m learning a lot of the finer points of c++ that I didn’t at University. In the OpenGL example of bitfalgs, why is there a 4 used in the definition?
  [#define GL_DEPTH_BUFFER_BIT 0x00000100
  #define GL_STENCIL_BUFFER_BIT 0x00000400
  #define GL_COLOR_BUFFER_BIT 0x00004000]
  I’m struggling to figure out how I would manipulate that/ why it is used. I was also under the impression that any positive number is classed as true(1), so I’m stuck there as well and any enlightenment would be appreciated!
  These are hexadecimal numbers (you can tell by the 0x suffix), not binary. A hexadecimal digit is 4 bits (0 hex = 0000 binary, 4 hex = 0100 binary). 8 hexadecimal digits of 4 bits each = 32 bits = 4 bytes.
  When I check size of (sizeof()) the 8-bits bitflag "bits" (from the example above) i get that it takes 4 bytes. The size of int option_1 is 4 bytes too. Does it mean that I should use fixed width integrers?
  It would make sense to use fixed width integers for the options, but there isn’t much that you can do about std::bitset<8> taking 4 bytes.
  Is there a way to check that the solutions to the quiz worked correctly? How could I display the state of all the flags at the end of the commands?
  > Is there a way to check that the solutions to the quiz worked correctly?
  Ideally, you’d want to ensure the solutions work with a range of different inputs, and validate that they produce the expected output. You don’t necessarily need to print the state of all the flags, but whether that your set of inputs was converted to the set of expected outputs.
  > How could I display the state of all the flags at the end of the commands?
  You can use a for loop and logical AND to isolate and print each individual bit. Something like this:
  These tutorials are great! I’m super hyped learning about this! Thank you! ‘\n’ for newline instead of "\n". It executes fine.
  But "\n" consists of two characters -- ‘\'(ASCII code 92) and ‘n'(ASCII code 110).
  And since a char variable is represented within single quotes(”), using ‘ ‘\n’.
  Thus, my question is: Is the compiler interpreting ‘\n’ or "\n" as LF(ASCII code 10), or is something else going on here?
  I understand, this question is far off topic of C++. I was just curious.
  Yes, the compiler interprets ‘\n’ as ascii code 10 on Windows.
  There are other “slash commands” that the compiler interprets listed in lesson 2.7 -- Chars.
  Generally speaking, a character constant in the form of ‘ ‘\\’.)
  Each escape sequence maps to a specific character, with most of them mapping to a character that is either untypeable (such as ‘\n’ for the newline character, ASCII/Unicode 10 (0x0A), as you discovered), or otherwise difficult to represent (such as ‘\'’ ‘true’ ‘enum’ ‘