-
Notifications
You must be signed in to change notification settings - Fork 13
Expand file tree
/
Copy pathbit-operators.html
More file actions
194 lines (154 loc) · 52.6 KB
/
bit-operators.html
File metadata and controls
194 lines (154 loc) · 52.6 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
<!DOCTYPE html>
<html lang="en-US">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>C++ | Bit Operators</title>
<meta name="generator" content="VuePress 1.8.2">
<link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png">
<link rel="icon" type="image/png" sizes="16x16" href="/favicon-16x16.png">
<link rel="manifest" href="/site.webmanifest">
<link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png">
<link rel="mask-icon" href="/safari-pinned-tab.svg" color="#5bbad5">
<meta name="description" content="| - bitwise OR, ^ - bitwise XOR (exclusive OR), & - bitwise AND, << - left shift, >> - right shift, ~ - bitwise NOT (unary complement)">
<meta property="og:site_name" content="DevTut">
<meta property="og:title" content="C++ | Bit Operators">
<meta property="og:description" content="| - bitwise OR, ^ - bitwise XOR (exclusive OR), & - bitwise AND, << - left shift, >> - right shift, ~ - bitwise NOT (unary complement)">
<meta property="og:type" content="article">
<meta property="og:url" content="/cpp/bit-operators.html">
<meta property="og:image" content="/logo.png">
<meta name="twitter:title" content="C++ | Bit Operators">
<meta name="twitter:description" content="| - bitwise OR, ^ - bitwise XOR (exclusive OR), & - bitwise AND, << - left shift, >> - right shift, ~ - bitwise NOT (unary complement)">
<meta name="twitter:url" content="/cpp/bit-operators.html">
<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:image" content="/logo.png">
<meta name="theme-color" content="#ffffff">
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="apple-mobile-web-app-status-bar-style" content="black">
<meta name="msapplication-TileImage" content="/mstile-150x150.png">
<meta name="msapplication-TileColor" content="#da532c">
<meta name="google-site-verification" content="76_rKXgwMVIjd-axJC_1zPV9OS4mEjvtgjYOWVkAdnQ">
<link rel="preload" href="/assets/css/0.styles.60619e34.css" as="style"><link rel="preload" href="/assets/js/app.1779e102.js" as="script"><link rel="preload" href="/assets/js/3.2cfa8016.js" as="script"><link rel="preload" href="/assets/js/621.7f015814.js" as="script">
<link rel="stylesheet" href="/assets/css/0.styles.60619e34.css">
</head>
<body>
<div id="app" data-server-rendered="true"><div class="theme-container"><header class="navbar"><div class="sidebar-button"><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" role="img" viewBox="0 0 448 512" class="icon"><path fill="currentColor" d="M436 124H12c-6.627 0-12-5.373-12-12V80c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12z"></path></svg></div> <a href="/" class="home-link router-link-active"><!----> <span class="site-name">DevTut</span></a> <div class="links"><form id="search-form" role="search" class="algolia-search-wrapper search-box"><input id="algolia-search-input" class="search-query"></form> <nav class="nav-links can-hide"> <a href="https://github.com/devtut/generate" target="_blank" rel="noopener noreferrer" class="repo-link">
GitHub
<span><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> <span class="sr-only">(opens new window)</span></span></a></nav></div></header> <div class="sidebar-mask"></div> <aside class="sidebar"><nav class="nav-links"> <a href="https://github.com/devtut/generate" target="_blank" rel="noopener noreferrer" class="repo-link">
GitHub
<span><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> <span class="sr-only">(opens new window)</span></span></a></nav> <ul class="sidebar-links"><li><section class="sidebar-group depth-0"><p class="sidebar-heading open"><span>C++</span> <!----></p> <ul class="sidebar-links sidebar-group-items"><li><a href="/cpp/" aria-current="page" class="sidebar-link">Disclaimer</a></li><li><a href="/cpp/getting-started-with-cpp.html" class="sidebar-link">Getting started with C++</a></li><li><a href="/cpp/literals.html" class="sidebar-link">Literals</a></li><li><a href="/cpp/operator-precedence.html" class="sidebar-link">operator precedence</a></li><li><a href="/cpp/floating-point-arithmetic.html" class="sidebar-link">Floating Point Arithmetic</a></li><li><a href="/cpp/bit-operators.html" aria-current="page" class="active sidebar-link">Bit Operators</a><ul class="sidebar-sub-headers"><li class="sidebar-sub-header"><a href="/cpp/bit-operators.html#bitwise-or" class="sidebar-link">| - bitwise OR</a></li><li class="sidebar-sub-header"><a href="/cpp/bit-operators.html#bitwise-xor-exclusive-or" class="sidebar-link">^ - bitwise XOR (exclusive OR)</a></li><li class="sidebar-sub-header"><a href="/cpp/bit-operators.html#bitwise-and" class="sidebar-link">& - bitwise AND</a></li><li class="sidebar-sub-header"><a href="/cpp/bit-operators.html#left-shift" class="sidebar-link"><< - left shift</a></li><li class="sidebar-sub-header"><a href="/cpp/bit-operators.html#right-shift" class="sidebar-link">>> - right shift</a></li><li class="sidebar-sub-header"><a href="/cpp/bit-operators.html#bitwise-not-unary-complement" class="sidebar-link">~ - bitwise NOT (unary complement)</a></li></ul></li><li><a href="/cpp/bit-manipulation.html" class="sidebar-link">Bit Manipulation</a></li><li><a href="/cpp/bit-fields.html" class="sidebar-link">Bit fields</a></li><li><a href="/cpp/arrays.html" class="sidebar-link">Arrays</a></li><li><a href="/cpp/iterators.html" class="sidebar-link">Iterators</a></li><li><a href="/cpp/basic-input-output-in-c.html" class="sidebar-link">Basic input/output in c++</a></li><li><a href="/cpp/loops.html" class="sidebar-link">Loops</a></li><li><a href="/cpp/file-i-o.html" class="sidebar-link">File I/O</a></li><li><a href="/cpp/cpp-streams.html" class="sidebar-link">C++ Streams</a></li><li><a href="/cpp/stream-manipulators.html" class="sidebar-link">Stream manipulators</a></li><li><a href="/cpp/flow-control.html" class="sidebar-link">Flow Control</a></li><li><a href="/cpp/metaprogramming.html" class="sidebar-link">Metaprogramming</a></li><li><a href="/cpp/const-keyword.html" class="sidebar-link">const keyword</a></li><li><a href="/cpp/mutable-keyword.html" class="sidebar-link">mutable keyword</a></li><li><a href="/cpp/friend-keyword.html" class="sidebar-link">Friend keyword</a></li><li><a href="/cpp/type-keywords.html" class="sidebar-link">Type Keywords</a></li><li><a href="/cpp/basic-type-keywords.html" class="sidebar-link">Basic Type Keywords</a></li><li><a href="/cpp/variable-declaration-keywords.html" class="sidebar-link">Variable Declaration Keywords</a></li><li><a href="/cpp/keywords.html" class="sidebar-link">Keywords</a></li><li><a href="/cpp/returning-several-values-from-a-function.html" class="sidebar-link">Returning several values from a function</a></li><li><a href="/cpp/polymorphism.html" class="sidebar-link">Polymorphism</a></li><li><a href="/cpp/references.html" class="sidebar-link">References</a></li><li><a href="/cpp/value-and-reference-semantics.html" class="sidebar-link">Value and Reference Semantics</a></li><li><a href="/cpp/c-function-call-by-value-vs-call-by-reference.html" class="sidebar-link">C++ function "call by value" vs. "call by reference"</a></li><li><a href="/cpp/copying-vs-assignment.html" class="sidebar-link">Copying vs Assignment</a></li><li><a href="/cpp/pointers.html" class="sidebar-link">Pointers</a></li><li><a href="/cpp/pointers-to-members.html" class="sidebar-link">Pointers to members</a></li><li><a href="/cpp/the-this-pointer.html" class="sidebar-link">The This Pointer</a></li><li><a href="/cpp/smart-pointers.html" class="sidebar-link">Smart Pointers</a></li><li><a href="/cpp/classes-structures.html" class="sidebar-link">Classes/Structures</a></li><li><a href="/cpp/function-overloading.html" class="sidebar-link">Function Overloading</a></li><li><a href="/cpp/operator-overloading.html" class="sidebar-link">Operator Overloading</a></li><li><a href="/cpp/function-template-overloading.html" class="sidebar-link">Function Template Overloading</a></li><li><a href="/cpp/virtual-member-functions.html" class="sidebar-link">Virtual Member Functions</a></li><li><a href="/cpp/inline-functions.html" class="sidebar-link">Inline functions</a></li><li><a href="/cpp/special-member-functions.html" class="sidebar-link">Special Member Functions</a></li><li><a href="/cpp/non-static-member-functions.html" class="sidebar-link">Non-Static Member Functions</a></li><li><a href="/cpp/constant-class-member-functions.html" class="sidebar-link">Constant class member functions</a></li><li><a href="/cpp/c-containers.html" class="sidebar-link">C++ Containers</a></li><li><a href="/cpp/namespaces.html" class="sidebar-link">Namespaces</a></li><li><a href="/cpp/header-files.html" class="sidebar-link">Header Files</a></li><li><a href="/cpp/using-declaration.html" class="sidebar-link">Using declaration</a></li><li><a href="/cpp/std-string.html" class="sidebar-link">std::string</a></li><li><a href="/cpp/std-array.html" class="sidebar-link">std::array</a></li><li><a href="/cpp/std-vector.html" class="sidebar-link">std::vector</a></li><li><a href="/cpp/std-map.html" class="sidebar-link">std::map</a></li><li><a href="/cpp/std-optional.html" class="sidebar-link">std::optional</a></li><li><a href="/cpp/std-function-to-wrap-any-element-that-is-callable.html" class="sidebar-link">std::function: To wrap any element that is callable</a></li><li><a href="/cpp/std-forward-list.html" class="sidebar-link">std::forward_list</a></li><li><a href="/cpp/std-pair.html" class="sidebar-link">std::pair</a></li><li><a href="/cpp/std-atomics.html" class="sidebar-link">std::atomics</a></li><li><a href="/cpp/std-variant.html" class="sidebar-link">std::variant</a></li><li><a href="/cpp/std-iomanip.html" class="sidebar-link">std::iomanip</a></li><li><a href="/cpp/std-any.html" class="sidebar-link">std::any</a></li><li><a href="/cpp/std-set-and-std-multiset.html" class="sidebar-link">std::set and std::multiset</a></li><li><a href="/cpp/std-integer-sequence.html" class="sidebar-link">std::integer_sequence</a></li><li><a href="/cpp/using-std-unordered-map.html" class="sidebar-link">Using std::unordered_map</a></li><li><a href="/cpp/standard-library-algorithms.html" class="sidebar-link">Standard Library Algorithms</a></li><li><a href="/cpp/the-iso-c-standard.html" class="sidebar-link">The ISO C++ Standard</a></li><li><a href="/cpp/inline-variables.html" class="sidebar-link">Inline variables</a></li><li><a href="/cpp/random-number-generation.html" class="sidebar-link">Random number generation</a></li><li><a href="/cpp/date-and-time-using-chrono-header.html" class="sidebar-link">Date and time using header</a></li><li><a href="/cpp/sorting.html" class="sidebar-link">Sorting</a></li><li><a href="/cpp/enumeration.html" class="sidebar-link">Enumeration</a></li><li><a href="/cpp/iteration.html" class="sidebar-link">Iteration</a></li><li><a href="/cpp/regular-expressions.html" class="sidebar-link">Regular expressions</a></li><li><a href="/cpp/implementation-defined-behavior.html" class="sidebar-link">Implementation-defined behavior</a></li><li><a href="/cpp/exceptions.html" class="sidebar-link">Exceptions</a></li><li><a href="/cpp/lambdas.html" class="sidebar-link">Lambdas</a></li><li><a href="/cpp/value-categories.html" class="sidebar-link">Value Categories</a></li><li><a href="/cpp/preprocessor.html" class="sidebar-link">Preprocessor</a></li><li><a href="/cpp/data-structures-in-c.html" class="sidebar-link">Data Structures in C++</a></li><li><a href="/cpp/templates.html" class="sidebar-link">Templates</a></li><li><a href="/cpp/expression-templates.html" class="sidebar-link">Expression templates</a></li><li><a href="/cpp/curiously-recurring-template-pattern-crtp.html" class="sidebar-link">Curiously Recurring Template Pattern (CRTP)</a></li><li><a href="/cpp/threading.html" class="sidebar-link">Threading</a></li><li><a href="/cpp/thread-synchronization-structures.html" class="sidebar-link">Thread synchronization structures</a></li><li><a href="/cpp/the-rule-of-three-five-and-zero.html" class="sidebar-link">The Rule of Three, Five, And Zero</a></li><li><a href="/cpp/raii-resource-acquisition-is-initialization.html" class="sidebar-link">RAII: Resource Acquisition Is Initialization</a></li><li><a href="/cpp/rtti-run-time-type-information.html" class="sidebar-link">RTTI: Run-Time Type Information</a></li><li><a href="/cpp/mutexes.html" class="sidebar-link">Mutexes</a></li><li><a href="/cpp/recursive-mutex.html" class="sidebar-link">Recursive Mutex</a></li><li><a href="/cpp/semaphore.html" class="sidebar-link">Semaphore</a></li><li><a href="/cpp/futures-and-promises.html" class="sidebar-link">Futures and Promises</a></li><li><a href="/cpp/atomic-types.html" class="sidebar-link">Atomic Types</a></li><li><a href="/cpp/type-erasure.html" class="sidebar-link">Type Erasure</a></li><li><a href="/cpp/explicit-type-conversions.html" class="sidebar-link">Explicit type conversions</a></li><li><a href="/cpp/unnamed-types.html" class="sidebar-link">Unnamed types</a></li><li><a href="/cpp/type-traits.html" class="sidebar-link">Type Traits</a></li><li><a href="/cpp/return-type-covariance.html" class="sidebar-link">Return Type Covariance</a></li><li><a href="/cpp/layout-of-object-types.html" class="sidebar-link">Layout of object types</a></li><li><a href="/cpp/type-inference.html" class="sidebar-link">Type Inference</a></li><li><a href="/cpp/typedef-and-type-aliases.html" class="sidebar-link">Typedef and type aliases</a></li><li><a href="/cpp/type-deduction.html" class="sidebar-link">type deduction</a></li><li><a href="/cpp/trailing-return-type.html" class="sidebar-link">Trailing return type</a></li><li><a href="/cpp/alignment.html" class="sidebar-link">Alignment</a></li><li><a href="/cpp/perfect-forwarding.html" class="sidebar-link">Perfect Forwarding</a></li><li><a href="/cpp/decltype.html" class="sidebar-link">decltype</a></li><li><a href="/cpp/sfinae-substitution-failure-is-not-an-error.html" class="sidebar-link">SFINAE (Substitution Failure Is Not An Error)</a></li><li><a href="/cpp/undefined-behavior.html" class="sidebar-link">Undefined Behavior</a></li><li><a href="/cpp/overload-resolution.html" class="sidebar-link">Overload resolution</a></li><li><a href="/cpp/move-semantics.html" class="sidebar-link">Move Semantics</a></li><li><a href="/cpp/pimpl-idiom.html" class="sidebar-link">Pimpl Idiom</a></li><li><a href="/cpp/auto.html" class="sidebar-link">auto</a></li><li><a href="/cpp/copy-elision.html" class="sidebar-link">Copy Elision</a></li><li><a href="/cpp/fold-expressions.html" class="sidebar-link">Fold Expressions</a></li><li><a href="/cpp/unions.html" class="sidebar-link">Unions</a></li><li><a href="/cpp/design-pattern-implementation-in-c.html" class="sidebar-link">Design pattern implementation in C++</a></li><li><a href="/cpp/singleton-design-pattern.html" class="sidebar-link">Singleton Design Pattern</a></li><li><a href="/cpp/user-defined-literals.html" class="sidebar-link">User-Defined Literals</a></li><li><a href="/cpp/memory-management.html" class="sidebar-link">Memory management</a></li><li><a href="/cpp/c-11-memory-model.html" class="sidebar-link">C++11 Memory Model</a></li><li><a href="/cpp/scopes.html" class="sidebar-link">Scopes</a></li><li><a href="/cpp/static-assert.html" class="sidebar-link">static_assert</a></li><li><a href="/cpp/constexpr.html" class="sidebar-link">constexpr</a></li><li><a href="/cpp/one-definition-rule-odr.html" class="sidebar-link">One Definition Rule (ODR)</a></li><li><a href="/cpp/unspecified-behavior.html" class="sidebar-link">Unspecified behavior</a></li><li><a href="/cpp/argument-dependent-name-lookup.html" class="sidebar-link">Argument Dependent Name Lookup</a></li><li><a href="/cpp/attributes.html" class="sidebar-link">Attributes</a></li><li><a href="/cpp/recursion-in-c.html" class="sidebar-link">Recursion in C++</a></li><li><a href="/cpp/arithmitic-metaprogramming.html" class="sidebar-link">Arithmitic Metaprogramming</a></li><li><a href="/cpp/callable-objects.html" class="sidebar-link">Callable Objects</a></li><li><a href="/cpp/client-server-examples.html" class="sidebar-link">Client server examples</a></li><li><a href="/cpp/const-correctness.html" class="sidebar-link">Const Correctness</a></li><li><a href="/cpp/parameter-packs.html" class="sidebar-link">Parameter packs</a></li><li><a href="/cpp/build-systems.html" class="sidebar-link">Build Systems</a></li><li><a href="/cpp/concurrency-with-openmp.html" class="sidebar-link">Concurrency With OpenMP</a></li><li><a href="/cpp/resource-management.html" class="sidebar-link">Resource Management</a></li><li><a href="/cpp/storage-class-specifiers.html" class="sidebar-link">Storage class specifiers</a></li><li><a href="/cpp/linkage-specifications.html" class="sidebar-link">Linkage specifications</a></li><li><a href="/cpp/digit-separators.html" class="sidebar-link">Digit separators</a></li><li><a href="/cpp/c-incompatibilities.html" class="sidebar-link">C incompatibilities</a></li><li><a href="/cpp/side-by-side-comparisons-of-classic-c-examples-solved-via-c-vs-c-11-vs-c-14-vs-c-17.html" class="sidebar-link">Side by Side Comparisons of classic C++ examples solved via C++ vs C++11 vs C++14 vs C++17</a></li><li><a href="/cpp/compiling-and-building.html" class="sidebar-link">Compiling and Building</a></li><li><a href="/cpp/common-compile-linker-errors-gcc.html" class="sidebar-link">Common compile/linker errors (GCC)</a></li><li><a href="/cpp/more-undefined-behaviors-in-c.html" class="sidebar-link">More undefined behaviors in C++</a></li><li><a href="/cpp/unit-testing-in-c.html" class="sidebar-link">Unit Testing in C++</a></li><li><a href="/cpp/c-debugging-and-debug-prevention-tools-techniques.html" class="sidebar-link">C++ Debugging and Debug-prevention Tools & Techniques</a></li><li><a href="/cpp/optimization-in-c.html" class="sidebar-link">Optimization in C++</a></li><li><a href="/cpp/optimization.html" class="sidebar-link">Optimization</a></li><li><a href="/cpp/profiling.html" class="sidebar-link">Profiling</a></li><li><a href="/cpp/refactoring-techniques.html" class="sidebar-link">Refactoring Techniques</a></li><li><a href="/cpp/internationalization-in-c.html" class="sidebar-link">Internationalization in C++</a></li><li><a href="/cpp/contributors.html" class="sidebar-link">The Contributors</a></li></ul></section></li></ul> </aside> <main class="page"> <div class="theme-default-content content__default"><h1 id="bit-operators"><a href="#bit-operators" class="header-anchor">#</a> Bit Operators</h1> <h2 id="bitwise-or"><a href="#bitwise-or" class="header-anchor">#</a> | - bitwise OR</h2> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token number">5</span><span class="token punctuation">;</span> <span class="token comment">// 0101b (0x05)</span>
<span class="token keyword">int</span> b <span class="token operator">=</span> <span class="token number">12</span><span class="token punctuation">;</span> <span class="token comment">// 1100b (0x0C)</span>
<span class="token keyword">int</span> c <span class="token operator">=</span> a <span class="token operator">|</span> b<span class="token punctuation">;</span> <span class="token comment">// 1101b (0x0D)</span>
std<span class="token double-colon punctuation">::</span>cout <span class="token operator"><<</span> <span class="token string">"a = "</span> <span class="token operator"><<</span> a <span class="token operator"><<</span> <span class="token string">", b = "</span> <span class="token operator"><<</span> b <span class="token operator"><<</span> <span class="token string">", c = "</span> <span class="token operator"><<</span> c <span class="token operator"><<</span> std<span class="token double-colon punctuation">::</span>endl<span class="token punctuation">;</span>
</code></pre></div><p><strong>Output</strong></p> <p><code>a = 5, b = 12, c = 13</code></p> <p><strong>Why</strong></p> <p>A bit wise <code>OR</code> operates on the bit level and uses the following Boolean truth table:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token boolean">true</span> OR <span class="token boolean">true</span> <span class="token operator">=</span> <span class="token boolean">true</span>
<span class="token boolean">true</span> OR <span class="token boolean">false</span> <span class="token operator">=</span> <span class="token boolean">true</span>
<span class="token boolean">false</span> OR <span class="token boolean">false</span> <span class="token operator">=</span> <span class="token boolean">false</span>
</code></pre></div><p>When the binary value for <code>a</code> (<code>0101</code>) and the binary value for <code>b</code> (<code>1100</code>) are <code>OR</code>'ed together we get the binary value of <code>1101</code>:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token number">0</span> <span class="token number">1</span> <span class="token number">0</span> <span class="token number">1</span>
<span class="token keyword">int</span> b <span class="token operator">=</span> <span class="token number">1</span> <span class="token number">1</span> <span class="token number">0</span> <span class="token number">0</span> <span class="token operator">|</span>
<span class="token operator">--</span><span class="token operator">--</span><span class="token operator">--</span><span class="token operator">--</span><span class="token operator">-</span>
<span class="token keyword">int</span> c <span class="token operator">=</span> <span class="token number">1</span> <span class="token number">1</span> <span class="token number">0</span> <span class="token number">1</span>
</code></pre></div><p>The bit wise OR does not change the value of the original values unless specifically assigned to using the bit wise assignment compound operator <code>|=</code>:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token number">5</span><span class="token punctuation">;</span> <span class="token comment">// 0101b (0x05)</span>
a <span class="token operator">|=</span> <span class="token number">12</span><span class="token punctuation">;</span> <span class="token comment">// a = 0101b | 1101b</span>
</code></pre></div><h2 id="bitwise-xor-exclusive-or"><a href="#bitwise-xor-exclusive-or" class="header-anchor">#</a> ^ - bitwise XOR (exclusive OR)</h2> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token number">5</span><span class="token punctuation">;</span> <span class="token comment">// 0101b (0x05)</span>
<span class="token keyword">int</span> b <span class="token operator">=</span> <span class="token number">9</span><span class="token punctuation">;</span> <span class="token comment">// 1001b (0x09)</span>
<span class="token keyword">int</span> c <span class="token operator">=</span> a <span class="token operator">^</span> b<span class="token punctuation">;</span> <span class="token comment">// 1100b (0x0C)</span>
std<span class="token double-colon punctuation">::</span>cout <span class="token operator"><<</span> <span class="token string">"a = "</span> <span class="token operator"><<</span> a <span class="token operator"><<</span> <span class="token string">", b = "</span> <span class="token operator"><<</span> b <span class="token operator"><<</span> <span class="token string">", c = "</span> <span class="token operator"><<</span> c <span class="token operator"><<</span> std<span class="token double-colon punctuation">::</span>endl<span class="token punctuation">;</span>
</code></pre></div><p><strong>Output</strong></p> <p><code>a = 5, b = 9, c = 12</code></p> <p><strong>Why</strong></p> <p>A bit wise <code>XOR</code> (exclusive or) operates on the bit level and uses the following Boolean truth table:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token boolean">true</span> OR <span class="token boolean">true</span> <span class="token operator">=</span> <span class="token boolean">false</span>
<span class="token boolean">true</span> OR <span class="token boolean">false</span> <span class="token operator">=</span> <span class="token boolean">true</span>
<span class="token boolean">false</span> OR <span class="token boolean">false</span> <span class="token operator">=</span> <span class="token boolean">false</span>
</code></pre></div><p>Notice that with an XOR operation <code>true OR true = false</code> where as with operations <code>true AND/OR true = true</code>, hence the exclusive nature of the XOR operation.</p> <p>Using this, when the binary value for <code>a</code> (<code>0101</code>) and the binary value for <code>b</code> (<code>1001</code>) are <code>XOR</code>'ed together we get the binary value of <code>1100</code>:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token number">0</span> <span class="token number">1</span> <span class="token number">0</span> <span class="token number">1</span>
<span class="token keyword">int</span> b <span class="token operator">=</span> <span class="token number">1</span> <span class="token number">0</span> <span class="token number">0</span> <span class="token number">1</span> <span class="token operator">^</span>
<span class="token operator">--</span><span class="token operator">--</span><span class="token operator">--</span><span class="token operator">--</span><span class="token operator">-</span>
<span class="token keyword">int</span> c <span class="token operator">=</span> <span class="token number">1</span> <span class="token number">1</span> <span class="token number">0</span> <span class="token number">0</span>
</code></pre></div><p>The bit wise XOR does not change the value of the original values unless specifically assigned to using the bit wise assignment compound operator <code>^=</code>:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token number">5</span><span class="token punctuation">;</span> <span class="token comment">// 0101b (0x05)</span>
a <span class="token operator">^=</span> <span class="token number">9</span><span class="token punctuation">;</span> <span class="token comment">// a = 0101b ^ 1001b</span>
</code></pre></div><p>The bit wise XOR can be utilized in many ways and is often utilized in bit mask operations for encryption and compression.</p> <p><strong>Note:</strong> The following example is often shown as an example of a nice trick. But should not be used in production code (there are better ways <code>std::swap()</code> to achieve the same result).</p> <p>You can also utilize an XOR operation to swap two variables without a temporary:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token number">42</span><span class="token punctuation">;</span>
<span class="token keyword">int</span> b <span class="token operator">=</span> <span class="token number">64</span><span class="token punctuation">;</span>
<span class="token comment">// XOR swap</span>
a <span class="token operator">^=</span> b<span class="token punctuation">;</span>
b <span class="token operator">^=</span> a<span class="token punctuation">;</span>
a <span class="token operator">^=</span> b<span class="token punctuation">;</span>
std<span class="token double-colon punctuation">::</span>cout <span class="token operator"><<</span> <span class="token string">"a = "</span> <span class="token operator"><<</span> a <span class="token operator"><<</span> <span class="token string">", b = "</span> <span class="token operator"><<</span> b <span class="token operator"><<</span> <span class="token string">"\n"</span><span class="token punctuation">;</span>
</code></pre></div><p>To productionalize this you need to add a check to make sure it can be used.</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">void</span> <span class="token function">doXORSwap</span><span class="token punctuation">(</span><span class="token keyword">int</span><span class="token operator">&</span> a<span class="token punctuation">,</span> <span class="token keyword">int</span><span class="token operator">&</span> b<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token comment">// Need to add a check to make sure you are not swapping the same</span>
<span class="token comment">// variable with itself. Otherwise it will zero the value.</span>
<span class="token keyword">if</span> <span class="token punctuation">(</span><span class="token operator">&</span>a <span class="token operator">!=</span> <span class="token operator">&</span>b<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token comment">// XOR swap</span>
a <span class="token operator">^=</span> b<span class="token punctuation">;</span>
b <span class="token operator">^=</span> a<span class="token punctuation">;</span>
a <span class="token operator">^=</span> b<span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token punctuation">}</span>
</code></pre></div><p>So though it looks like a nice trick in isolation it is not useful in real code.
xor is not a base logical operation,but a combination of others:
a^c=~(a&c)&(a|c)</p> <p>also in 2015+ compilers variables may be assigned as binary:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> cn<span class="token operator">=</span><span class="token number">0b0111</span><span class="token punctuation">;</span>
</code></pre></div><h2 id="bitwise-and"><a href="#bitwise-and" class="header-anchor">#</a> & - bitwise AND</h2> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token number">6</span><span class="token punctuation">;</span> <span class="token comment">// 0110b (0x06)</span>
<span class="token keyword">int</span> b <span class="token operator">=</span> <span class="token number">10</span><span class="token punctuation">;</span> <span class="token comment">// 1010b (0x0A)</span>
<span class="token keyword">int</span> c <span class="token operator">=</span> a <span class="token operator">&</span> b<span class="token punctuation">;</span> <span class="token comment">// 0010b (0x02)</span>
std<span class="token double-colon punctuation">::</span>cout <span class="token operator"><<</span> <span class="token string">"a = "</span> <span class="token operator"><<</span> a <span class="token operator"><<</span> <span class="token string">", b = "</span> <span class="token operator"><<</span> b <span class="token operator"><<</span> <span class="token string">", c = "</span> <span class="token operator"><<</span> c <span class="token operator"><<</span> std<span class="token double-colon punctuation">::</span>endl<span class="token punctuation">;</span>
</code></pre></div><p><strong>Output</strong></p> <p><code>a = 6, b = 10, c = 2</code></p> <p><strong>Why</strong></p> <p>A bit wise <code>AND</code> operates on the bit level and uses the following Boolean truth table:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code>TRUE AND TRUE <span class="token operator">=</span> TRUE
TRUE AND FALSE <span class="token operator">=</span> FALSE
FALSE AND FALSE <span class="token operator">=</span> FALSE
</code></pre></div><p>When the binary value for <code>a</code> (<code>0110</code>) and the binary value for <code>b</code> (<code>1010</code>) are <code>AND</code>'ed together we get the binary value of <code>0010</code>:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token number">0</span> <span class="token number">1</span> <span class="token number">1</span> <span class="token number">0</span>
<span class="token keyword">int</span> b <span class="token operator">=</span> <span class="token number">1</span> <span class="token number">0</span> <span class="token number">1</span> <span class="token number">0</span> <span class="token operator">&</span>
<span class="token operator">--</span><span class="token operator">--</span><span class="token operator">--</span><span class="token operator">--</span><span class="token operator">-</span>
<span class="token keyword">int</span> c <span class="token operator">=</span> <span class="token number">0</span> <span class="token number">0</span> <span class="token number">1</span> <span class="token number">0</span>
</code></pre></div><p>The bit wise AND does not change the value of the original values unless specifically assigned to using the bit wise assignment compound operator <code>&=</code>:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token number">5</span><span class="token punctuation">;</span> <span class="token comment">// 0101b (0x05)</span>
a <span class="token operator">&=</span> <span class="token number">10</span><span class="token punctuation">;</span> <span class="token comment">// a = 0101b & 1010b</span>
</code></pre></div><h2 id="left-shift"><a href="#left-shift" class="header-anchor">#</a> << - left shift</h2> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token number">1</span><span class="token punctuation">;</span> <span class="token comment">// 0001b</span>
<span class="token keyword">int</span> b <span class="token operator">=</span> a <span class="token operator"><<</span> <span class="token number">1</span><span class="token punctuation">;</span> <span class="token comment">// 0010b</span>
std<span class="token double-colon punctuation">::</span>cout <span class="token operator"><<</span> <span class="token string">"a = "</span> <span class="token operator"><<</span> a <span class="token operator"><<</span> <span class="token string">", b = "</span> <span class="token operator"><<</span> b <span class="token operator"><<</span> std<span class="token double-colon punctuation">::</span>endl<span class="token punctuation">;</span>
</code></pre></div><p><strong>Output</strong></p> <p><code>a = 1, b = 2</code></p> <p><strong>Why</strong></p> <p>The left bit wise shift will shift the bits of the left hand value (<code>a</code>) the number specified on the right (<code>1</code>), essentially padding the least significant bits with 0's, so shifting the value of <code>5</code> (binary <code>0000 0101</code>) to the left 4 times (e.g. <code>5 << 4</code>) will yield the value of <code>80</code> (binary <code>0101 0000</code>). You might note that shifting a value to the left 1 time is also the same as multiplying the value by 2, example:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token number">7</span><span class="token punctuation">;</span>
<span class="token keyword">while</span> <span class="token punctuation">(</span>a <span class="token operator"><</span> <span class="token number">200</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
std<span class="token double-colon punctuation">::</span>cout <span class="token operator"><<</span> <span class="token string">"a = "</span> <span class="token operator"><<</span> a <span class="token operator"><<</span> std<span class="token double-colon punctuation">::</span>endl<span class="token punctuation">;</span>
a <span class="token operator"><<=</span> <span class="token number">1</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
a <span class="token operator">=</span> <span class="token number">7</span><span class="token punctuation">;</span>
<span class="token keyword">while</span> <span class="token punctuation">(</span>a <span class="token operator"><</span> <span class="token number">200</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
std<span class="token double-colon punctuation">::</span>cout <span class="token operator"><<</span> <span class="token string">"a = "</span> <span class="token operator"><<</span> a <span class="token operator"><<</span> std<span class="token double-colon punctuation">::</span>endl<span class="token punctuation">;</span>
a <span class="token operator">*=</span> <span class="token number">2</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</code></pre></div><p>But it should be noted that the left shift operation will shift <em>all</em> bits to the left, including the sign bit, example:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token number">2147483647</span><span class="token punctuation">;</span> <span class="token comment">// 0111 1111 1111 1111 1111 1111 1111 1111</span>
<span class="token keyword">int</span> b <span class="token operator">=</span> a <span class="token operator"><<</span> <span class="token number">1</span><span class="token punctuation">;</span> <span class="token comment">// 1111 1111 1111 1111 1111 1111 1111 1110</span>
std<span class="token double-colon punctuation">::</span>cout <span class="token operator"><<</span> <span class="token string">"a = "</span> <span class="token operator"><<</span> a <span class="token operator"><<</span> <span class="token string">", b = "</span> <span class="token operator"><<</span> b <span class="token operator"><<</span> std<span class="token double-colon punctuation">::</span>endl<span class="token punctuation">;</span>
</code></pre></div><p>Possible output: <code>a = 2147483647, b = -2</code></p> <p>While some compilers will yield results that seem expected, it should be noted that if you left shift a signed number so that the sign bit is affected, the result is <strong>undefined</strong>. It is also <strong>undefined</strong> if the number of bits you wish to shift by is a negative number or is larger than the number of bits the type on the left can hold, example:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token number">1</span><span class="token punctuation">;</span>
<span class="token keyword">int</span> b <span class="token operator">=</span> a <span class="token operator"><<</span> <span class="token operator">-</span><span class="token number">1</span><span class="token punctuation">;</span> <span class="token comment">// undefined behavior</span>
<span class="token keyword">char</span> c <span class="token operator">=</span> a <span class="token operator"><<</span> <span class="token number">20</span><span class="token punctuation">;</span> <span class="token comment">// undefined behavior</span>
</code></pre></div><p>The bit wise left shift does not change the value of the original values unless specifically assigned to using the bit wise assignment compound operator <code><<=</code>:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token number">5</span><span class="token punctuation">;</span> <span class="token comment">// 0101b</span>
a <span class="token operator"><<=</span> <span class="token number">1</span><span class="token punctuation">;</span> <span class="token comment">// a = a << 1;</span>
</code></pre></div><h2 id="right-shift"><a href="#right-shift" class="header-anchor">#</a> >> - right shift</h2> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token number">2</span><span class="token punctuation">;</span> <span class="token comment">// 0010b</span>
<span class="token keyword">int</span> b <span class="token operator">=</span> a <span class="token operator">>></span> <span class="token number">1</span><span class="token punctuation">;</span> <span class="token comment">// 0001b</span>
std<span class="token double-colon punctuation">::</span>cout <span class="token operator"><<</span> <span class="token string">"a = "</span> <span class="token operator"><<</span> a <span class="token operator"><<</span> <span class="token string">", b = "</span> <span class="token operator"><<</span> b <span class="token operator"><<</span> std<span class="token double-colon punctuation">::</span>endl<span class="token punctuation">;</span>
</code></pre></div><p><strong>Output</strong></p> <p><code>a = 2, b = 1</code></p> <p><strong>Why</strong></p> <p>The right bit wise shift will shift the bits of the left hand value (<code>a</code>) the number specified on the right (<code>1</code>); it should be noted that while the operation of a right shift is standard, what happens to the bits of a right shift on a <em>signed negative</em> number is <em>implementation defined</em> and thus cannot be guaranteed to be portable, example:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token operator">-</span><span class="token number">2</span><span class="token punctuation">;</span>
<span class="token keyword">int</span> b <span class="token operator">=</span> a <span class="token operator">>></span> <span class="token number">1</span><span class="token punctuation">;</span> <span class="token comment">// the value of b will be depend on the compiler</span>
</code></pre></div><p>It is also undefined if the number of bits you wish to shift by is a negative number, example:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token number">1</span><span class="token punctuation">;</span>
<span class="token keyword">int</span> b <span class="token operator">=</span> a <span class="token operator">>></span> <span class="token operator">-</span><span class="token number">1</span><span class="token punctuation">;</span> <span class="token comment">// undefined behavior</span>
</code></pre></div><p>The bit wise right shift does not change the value of the original values unless specifically assigned to using the bit wise assignment compound operator <code>>>=</code>:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token number">2</span><span class="token punctuation">;</span> <span class="token comment">// 0010b</span>
a <span class="token operator">>>=</span> <span class="token number">1</span><span class="token punctuation">;</span> <span class="token comment">// a = a >> 1;</span>
</code></pre></div><h2 id="bitwise-not-unary-complement"><a href="#bitwise-not-unary-complement" class="header-anchor">#</a> ~ - bitwise NOT (unary complement)</h2> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">unsigned</span> <span class="token keyword">char</span> a <span class="token operator">=</span> <span class="token number">234</span><span class="token punctuation">;</span> <span class="token comment">// 1110 1010b (0xEA)</span>
<span class="token keyword">unsigned</span> <span class="token keyword">char</span> b <span class="token operator">=</span> <span class="token operator">~</span>a<span class="token punctuation">;</span> <span class="token comment">// 0001 0101b (0x15)</span>
std<span class="token double-colon punctuation">::</span>cout <span class="token operator"><<</span> <span class="token string">"a = "</span> <span class="token operator"><<</span> <span class="token generic-function"><span class="token function">static_cast</span><span class="token generic class-name"><span class="token operator"><</span><span class="token keyword">int</span><span class="token operator">></span></span></span><span class="token punctuation">(</span>a<span class="token punctuation">)</span> <span class="token operator"><<</span>
<span class="token string">", b = "</span> <span class="token operator"><<</span> <span class="token generic-function"><span class="token function">static_cast</span><span class="token generic class-name"><span class="token operator"><</span><span class="token keyword">int</span><span class="token operator">></span></span></span><span class="token punctuation">(</span>b<span class="token punctuation">)</span> <span class="token operator"><<</span> std<span class="token double-colon punctuation">::</span>endl<span class="token punctuation">;</span>
</code></pre></div><p><strong>Output</strong></p> <p><code>a = 234, b = 21</code></p> <p><strong>Why</strong></p> <p>A bit wise <code>NOT</code> (unary complement) operates on the bit level and simply flips each bit. If it's a <code>1</code>, it's changed to a <code>0</code>, if it's a <code>0</code>, it's changed to a <code>1</code>. The bit wise NOT has the same effect as XOR'ing a value against the max value for a specific type:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">unsigned</span> <span class="token keyword">char</span> a <span class="token operator">=</span> <span class="token number">234</span><span class="token punctuation">;</span> <span class="token comment">// 1110 1010b (0xEA)</span>
<span class="token keyword">unsigned</span> <span class="token keyword">char</span> b <span class="token operator">=</span> <span class="token operator">~</span>a<span class="token punctuation">;</span> <span class="token comment">// 0001 0101b (0x15)</span>
<span class="token keyword">unsigned</span> <span class="token keyword">char</span> c <span class="token operator">=</span> a <span class="token operator">^</span> <span class="token operator">~</span><span class="token number">0</span><span class="token punctuation">;</span>
</code></pre></div><p>The bit wise NOT can also be a convenient way to check the maximum value for a specific integral type:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">unsigned</span> <span class="token keyword">int</span> i <span class="token operator">=</span> <span class="token operator">~</span><span class="token number">0</span><span class="token punctuation">;</span>
<span class="token keyword">unsigned</span> <span class="token keyword">char</span> c <span class="token operator">=</span> <span class="token operator">~</span><span class="token number">0</span><span class="token punctuation">;</span>
std<span class="token double-colon punctuation">::</span>cout <span class="token operator"><<</span> <span class="token string">"max uint = "</span> <span class="token operator"><<</span> i <span class="token operator"><<</span> std<span class="token double-colon punctuation">::</span>endl <span class="token operator"><<</span>
<span class="token string">"max uchar = "</span> <span class="token operator"><<</span> <span class="token generic-function"><span class="token function">static_cast</span><span class="token generic class-name"><span class="token operator"><</span><span class="token keyword">short</span><span class="token operator">></span></span></span><span class="token punctuation">(</span>c<span class="token punctuation">)</span> <span class="token operator"><<</span> std<span class="token double-colon punctuation">::</span>endl<span class="token punctuation">;</span>
</code></pre></div><p>The bit wise NOT does not change the value of the original value and does not have a compound assignment operator, so you can not do <code>a ~= 10</code> for example.</p> <p>The <em>bit wise</em> NOT (<code>~</code>) should not be confused with the <em>logical</em> NOT (<code>!</code>); where a bit wise NOT will flip each bit, a logical NOT will use the whole value to do its operation on, in other words <code>(!1) != (~1)</code></p> <h4 id="remarks"><a href="#remarks" class="header-anchor">#</a> Remarks</h4> <p>Bit shift operations are not portable across all processor architectures, different processors can have different bit-widths. In other words, if you wrote</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">int</span> a <span class="token operator">=</span> <span class="token operator">~</span><span class="token number">0</span><span class="token punctuation">;</span>
<span class="token keyword">int</span> b <span class="token operator">=</span> a <span class="token operator"><<</span> <span class="token number">1</span><span class="token punctuation">;</span>
</code></pre></div><p>This value would be different on a 64 bit machine vs. on a 32 bit machine, or from an x86 based processor to a PIC based processor.</p> <p>Endian-ness does not need to be taken into account for the bit wise operations themselves, that is, the right shift (<code>>></code>) will shift the bits towards the least significant bit and an XOR will perform an exclusive or on the bits. Endian-ness only needs to be taken into account with the data itself, that is, if endian-ness is a concern for your application, it's a concern regardless of bit wise operations.</p></div> <footer class="page-edit"><div class="edit-link"><a href="https://github.com/devtut/generate/edit/master/docs/cpp/bit-operators.md" target="_blank" rel="noopener noreferrer">Edit this page on GitHub</a> <span><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> <span class="sr-only">(opens new window)</span></span></div> <!----></footer> <div class="page-nav"><p class="inner"><span class="prev">
←
<a href="/cpp/floating-point-arithmetic.html" class="prev">
Floating Point Arithmetic
</a></span> <span class="next"><a href="/cpp/bit-manipulation.html">
Bit Manipulation
</a>
→
</span></p></div> </main></div><div class="global-ui"><!----></div></div>
<script src="/assets/js/app.1779e102.js" defer></script><script src="/assets/js/3.2cfa8016.js" defer></script><script src="/assets/js/621.7f015814.js" defer></script>
</body>
</html>