C++ Programming 2. C++ Fundamentals 16 mins read 23,406 views

C++ Operators Reference: Categories, Syntax, and Practical Usage

Operators are an important part of C++ programming. They allow you to perform calculations, compare values, assign data, check conditions, and manipulate indivi...
Published: Nov 1, 2026Last Updated: Nov 21, 2026Curriculum: Class 12 / AP Physics / JEE-NEETReviewed by: OperateTools Editorial Board
Quick Summary & Direct Answer (AEO / GEO Extraction)

What is C++ Operators Reference: Categories, Syntax, and Practical Usage? Operators are an important part of C++ programming. They allow you to perform calculations, compare values, assign data, check conditions, and manipulate indivi...

Audience & Scope: Students, educators, and candidates preparing for academic examinations and technical assessments in C++ Programming.
What operator categories are supported in C++ and how do precedence and associativity dictate evaluation order?
<p data-pm-slice="1 1 []">Operators are an important part of C++ programming. They allow you to perform calculations, compare values, assign data, check conditions, and manipulate individual bits.</p><p data-pm-slice="1 1 []"><br></p><p>For example, when you write <code dir="ltr">a + b</code>, the plus (<code dir="ltr">+</code>) symbol tells C++ to add the values of two variables. Similarly, operators such as <code dir="ltr">==</code>, <code dir="ltr">&amp;&amp;</code>, and <code dir="ltr">++</code> perform comparison, logical, and increment operations.</p><p>But C++ has many different operators, and each one has a specific purpose.</p><p><br></p><p>In this tutorial, you will learn about C++ operators, their categories, syntax, symbols, and practical uses. You will also explore examples of arithmetic, relational, logical, assignment, bitwise, conditional, and other operators.</p><p><br></p><p>Whether you are learning C++ for the first time or looking for a quick reference, this guide will help you understand how operators work.</p>

Explanation & In-Depth Details

<h2 class="h4 fw-bold text-dark mb-3"><span style="font-size: 1.15rem;">What Are Operators in C++?</span></h2><p>An operator in C++ is a symbol or keyword that performs a particular operation on one or more values or variables.</p><p>The values on which an operator works are called operands.</p><p>For example:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span> <span class="js-id">a</span> <span class="js-op">=</span> <span class="js-num">10</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">b</span> <span class="js-op">=</span> <span class="js-num">20</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">result</span> <span class="js-op">=</span> <span class="js-id">a</span> <span class="js-op">+</span> <span class="js-id">b</span><span class="js-op">;</span></code></pre></div><p>In this example:</p><ul><li><p><code>a</code> and <code>b</code> are operands.</p></li><li><p><code>+</code> is the addition operator.</p></li><li><p><code>=</code> is the assignment operator.</p></li><li><p><code>result</code> stores the calculated value.</p></li></ul><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Result</span><span class="js-op">:</span> <span class="js-num">30</span></code></pre></div><p>Operators are used throughout C++ programs to perform calculations, make decisions, and manipulate data.</p><h2>Categories of Operators in C++</h2><p>C++ provides several categories of operators. Each category is designed for a different type of operation.</p><p>The main categories include:</p><ol start="1"><li><p>Arithmetic operators</p></li><li><p>Relational operators</p></li><li><p>Logical operators</p></li><li><p>Assignment operators</p></li><li><p>Increment and decrement operators</p></li><li><p>Bitwise operators</p></li><li><p>Conditional operator</p></li><li><p>Comma operator</p></li><li><p>Member access operators</p></li><li><p>Pointer operators</p></li><li><p>Memory management operators</p></li><li><p>Type and size operators</p></li></ol><p>Let's understand each category with its syntax and practical examples.</p><h2>1. Arithmetic Operators in C++</h2><p>Arithmetic operators are used to perform mathematical calculations such as addition, subtraction, multiplication, division, and finding remainders.</p><p>These operators are commonly used in calculators, billing applications, financial programs, and mathematical operations.</p><h3>Arithmetic Operators Reference</h3><table><tbody><tr><th>Operator</th><th>Name</th><th>Description</th><th>Example</th></tr><tr><td><code>+</code></td><td>Addition</td><td>Adds two values</td><td><code>a + b</code></td></tr><tr><td><code>-</code></td><td>Subtraction</td><td>Subtracts one value from another</td><td><code>a - b</code></td></tr><tr><td><code>*</code></td><td>Multiplication</td><td>Multiplies two values</td><td><code>a * b</code></td></tr><tr><td><code>/</code></td><td>Division</td><td>Divides one value by another</td><td><code>a / b</code></td></tr><tr><td><code>%</code></td><td>Modulus</td><td>Returns the remainder</td><td><code>a % b</code></td></tr></tbody></table><h3>Example: Arithmetic Operators</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>

<span class="js-id">int</span> <span class="js-id">a</span> <span class="js-op">=</span> <span class="js-num">20</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">b</span> <span class="js-op">=</span> <span class="js-num">10</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Addition: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">a</span> <span class="js-op">+</span> <span class="js-id">b</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Subtraction: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">a</span> <span class="js-op">-</span> <span class="js-id">b</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Multiplication: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">a</span> <span class="js-op">*</span> <span class="js-id">b</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Division: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">a</span> <span class="js-op">/</span> <span class="js-id">b</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Modulus: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">a</span> <span class="js-op">%</span> <span class="js-num">3</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Addition</span><span class="js-op">:</span> <span class="js-num">30</span>
<span class="js-id">Subtraction</span><span class="js-op">:</span> <span class="js-num">10</span>
<span class="js-id">Multiplication</span><span class="js-op">:</span> <span class="js-num">200</span>
<span class="js-id">Division</span><span class="js-op">:</span> <span class="js-num">2</span>
<span class="js-id">Modulus</span><span class="js-op">:</span> <span class="js-num">2</span></code></pre></div><h3>Practical Uses of Arithmetic Operators</h3><ul><li><p>Calculate product prices and totals.</p></li><li><p>Find the average of students' marks.</p></li><li><p>Calculate discounts and percentages.</p></li><li><p>Perform mathematical calculations.</p></li><li><p>Determine whether a number is even or odd using <code>%</code>.</p></li></ul><p>For example, to check whether a number is even:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span> <span class="js-id">number</span> <span class="js-op">=</span> <span class="js-num">20</span><span class="js-op">;</span>

<span class="js-kw">if</span> <span class="js-op">(</span><span class="js-id">number</span> <span class="js-op">%</span> <span class="js-num">2</span> <span class="js-op">==</span> <span class="js-num">0</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Even Number"</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><h2>2. Relational Operators in C++</h2><p>Relational operators are used to compare two values.</p><p>They return a Boolean result: <code>true</code> or <code>false</code>.</p><p>These operators are useful when checking conditions in <code>if</code>, <code>while</code>, and <code>for</code> statements.</p><h3>Relational Operators Reference</h3><table><tbody><tr><th>Operator</th><th>Name</th><th>Description</th><th>Example</th></tr><tr><td><code>==</code></td><td>Equal to</td><td>Checks whether values are equal</td><td><code>a == b</code></td></tr><tr><td><code>!=</code></td><td>Not equal to</td><td>Checks whether values differ</td><td><code>a != b</code></td></tr><tr><td><code>&gt;</code></td><td>Greater than</td><td>Checks whether the left value is greater</td><td><code>a &gt; b</code></td></tr><tr><td><code>&lt;</code></td><td>Less than</td><td>Checks whether the left value is smaller</td><td><code>a &lt; b</code></td></tr><tr><td><code>&gt;=</code></td><td>Greater than or equal to</td><td>Checks whether the left value is greater or equal</td><td><code>a &gt;= b</code></td></tr><tr><td><code>&lt;=</code></td><td>Less than or equal to</td><td>Checks whether the left value is smaller or equal</td><td><code>a &lt;= b</code></td></tr></tbody></table><h3>Example: Relational Operators</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>

<span class="js-id">int</span> <span class="js-id">a</span> <span class="js-op">=</span> <span class="js-num">20</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">b</span> <span class="js-op">=</span> <span class="js-num">10</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">boolalpha</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Equal: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">(</span><span class="js-id">a</span> <span class="js-op">==</span> <span class="js-id">b</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Not Equal: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">(</span><span class="js-id">a</span> <span class="js-op">!=</span> <span class="js-id">b</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Greater: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">(</span><span class="js-id">a</span> <span class="js-op">&gt;</span> <span class="js-id">b</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Less: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">(</span><span class="js-id">a</span> <span class="js-op">&lt;</span> <span class="js-id">b</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Greater or Equal: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">(</span><span class="js-id">a</span> <span class="js-op">&gt;=</span> <span class="js-id">b</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Less or Equal: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">(</span><span class="js-id">a</span> <span class="js-op">&lt;=</span> <span class="js-id">b</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Equal</span><span class="js-op">:</span> <span class="js-num">false</span>
<span class="js-id">Not</span> <span class="js-id">Equal</span><span class="js-op">:</span> <span class="js-num">true</span>
<span class="js-id">Greater</span><span class="js-op">:</span> <span class="js-num">true</span>
<span class="js-id">Less</span><span class="js-op">:</span> <span class="js-num">false</span>
<span class="js-id">Greater</span> <span class="js-id">or</span> <span class="js-id">Equal</span><span class="js-op">:</span> <span class="js-num">true</span>
<span class="js-id">Less</span> <span class="js-id">or</span> <span class="js-id">Equal</span><span class="js-op">:</span> <span class="js-num">false</span></code></pre></div><h3>Practical Uses of Relational Operators</h3><ul><li><p>Compare students' marks.</p></li><li><p>Check a person's age.</p></li><li><p>Compare product prices.</p></li><li><p>Validate minimum and maximum limits.</p></li><li><p>Check whether a value matches a condition.</p></li></ul><h2>3. Logical Operators in C++</h2><p>Logical operators are used to combine or reverse conditions.</p><p>They are especially useful when a program needs to check more than one condition at a time.</p><p>C++ provides three main logical operators.</p><h3>Logical Operators Reference</h3><table><tbody><tr><th>Operator</th><th>Name</th><th>Description</th><th>Example</th></tr><tr><td><code>&amp;&amp;</code></td><td>Logical AND</td><td>True when both conditions are true</td><td><code>a &gt; 5 &amp;&amp; b &lt; 20</code></td></tr><tr><td>`</td><td></td><td>`</td><td>Logical OR</td><td>True when at least one condition is true</td><td>`a &gt; 5</td><td></td><td>b &lt; 20`</td></tr><tr><td><code>!</code></td><td>Logical NOT</td><td>Reverses a Boolean value</td><td><code>!(a &gt; 5)</code></td></tr></tbody></table><h3>Example: Logical Operators</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>

<span class="js-id">int</span> <span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">25</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">salary</span> <span class="js-op">=</span> <span class="js-num">30000</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">boolalpha</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">(</span><span class="js-id">age</span> <span class="js-op">&gt;=</span> <span class="js-num">18</span> <span class="js-op">&amp;&amp;</span> <span class="js-id">salary</span> <span class="js-op">&gt;=</span> <span class="js-num">20000</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">(</span><span class="js-id">age</span> <span class="js-op">&lt;</span> <span class="js-num">18</span> <span class="js-op">||</span> <span class="js-id">salary</span> <span class="js-op">&gt;=</span> <span class="js-num">20000</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">!(</span><span class="js-id">age</span> <span class="js-op">&gt;=</span> <span class="js-num">18</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">true</span>
<span class="js-num">true</span>
<span class="js-num">false</span></code></pre></div><h3>Explanation</h3><ul><li><p>AND (<code>&amp;&amp;</code>) checks whether both conditions are true.</p></li><li><p>OR (<code>||</code>) checks whether at least one condition is true.</p></li><li><p>NOT (<code>!</code>) reverses the result of a condition.</p></li></ul><h3>Practical Uses of Logical Operators</h3><ul><li><p>Check user login credentials.</p></li><li><p>Validate age and eligibility.</p></li><li><p>Check multiple conditions in a program.</p></li><li><p>Control access to restricted features.</p></li><li><p>Validate form inputs.</p></li></ul><p><strong>Important:</strong> C++ uses short-circuit evaluation for <code>&amp;&amp;</code> and <code>||</code>. For example, if the first condition in an AND expression is false, the second condition is not evaluated.</p><h2>4. Assignment Operators in C++</h2><p>Assignment operators are used to assign values to variables.</p><p>The most basic assignment operator is <code>=</code>.</p><p>C++ also provides compound assignment operators that perform an operation and assign the result back to the same variable.</p><h3>Assignment Operators Reference</h3><table><tbody><tr><th>Operator</th><th>Name</th><th>Example</th><th>Equivalent form</th></tr><tr><td><code>=</code></td><td>Assignment</td><td><code>a = 10</code></td><td>Assigns 10</td></tr><tr><td><code>+=</code></td><td>Addition assignment</td><td><code>a += 5</code></td><td><code>a = a + 5</code></td></tr><tr><td><code>-=</code></td><td>Subtraction assignment</td><td><code>a -= 5</code></td><td><code>a = a - 5</code></td></tr><tr><td><code>*=</code></td><td>Multiplication assignment</td><td><code>a *= 2</code></td><td><code>a = a * 2</code></td></tr><tr><td><code>/=</code></td><td>Division assignment</td><td><code>a /= 2</code></td><td><code>a = a / 2</code></td></tr><tr><td><code>%=</code></td><td>Modulus assignment</td><td><code>a %= 3</code></td><td><code>a = a % 3</code></td></tr><tr><td><code>&amp;=</code></td><td>Bitwise AND assignment</td><td><code>a &amp;= 3</code></td><td><code>a = a &amp; 3</code></td></tr><tr><td>`</td><td>=`</td><td>Bitwise OR assignment</td><td>`a</td><td>= 3`</td><td>`a = a</td><td>3`</td></tr><tr><td><code>^=</code></td><td>Bitwise XOR assignment</td><td><code>a ^= 3</code></td><td><code>a = a ^ 3</code></td></tr><tr><td><code>&lt;&lt;=</code></td><td>Left shift assignment</td><td><code>a &lt;&lt;= 1</code></td><td><code>a = a &lt;&lt; 1</code></td></tr><tr><td><code>&gt;&gt;=</code></td><td>Right shift assignment</td><td><code>a &gt;&gt;= 1</code></td><td><code>a = a &gt;&gt; 1</code></td></tr></tbody></table><h3>Example: Assignment Operators</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>

<span class="js-id">int</span> <span class="js-id">number</span> <span class="js-op">=</span> <span class="js-num">10</span><span class="js-op">;</span>

<span class="js-id">number</span> <span class="js-op">+=</span> <span class="js-num">5</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"After += : "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">number</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-id">number</span> <span class="js-op">-=</span> <span class="js-num">3</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"After -= : "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">number</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-id">number</span> <span class="js-op">*=</span> <span class="js-num">2</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"After *= : "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">number</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-id">number</span> <span class="js-op">/=</span> <span class="js-num">4</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"After /= : "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">number</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">After</span> <span class="js-op">+=</span> <span class="js-op">:</span> <span class="js-num">15</span>
<span class="js-id">After</span> <span class="js-op">-=</span> <span class="js-op">:</span> <span class="js-num">12</span>
<span class="js-id">After</span> <span class="js-op">*=</span> <span class="js-op">:</span> <span class="js-num">24</span>
<span class="js-id">After</span> <span class="js-op">/=</span> <span class="js-op">:</span> <span class="js-num">6</span></code></pre></div><h3>Practical Uses of Assignment Operators</h3><ul><li><p>Update account balances.</p></li><li><p>Increase product quantities.</p></li><li><p>Calculate running totals.</p></li><li><p>Update scores in games.</p></li><li><p>Modify counters in loops.</p></li></ul><h2>5. Increment and Decrement Operators in C++</h2><p>Increment and decrement operators are used to increase or decrease the value of a variable by one.</p><p>They are frequently used in loops and counting operations.</p><h3>Increment and Decrement Operators Reference</h3><table><tbody><tr><th>Operator</th><th>Name</th><th>Description</th></tr><tr><td><code>++a</code></td><td>Prefix increment</td><td>Increases the value before using it</td></tr><tr><td><code>a++</code></td><td>Postfix increment</td><td>Uses the original value before increasing it</td></tr><tr><td><code>--a</code></td><td>Prefix decrement</td><td>Decreases the value before using it</td></tr><tr><td><code>a--</code></td><td>Postfix decrement</td><td>Uses the original value before decreasing it</td></tr></tbody></table><h3>Example: Increment and Decrement</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>

<span class="js-id">int</span> <span class="js-id">a</span> <span class="js-op">=</span> <span class="js-num">10</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Original: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">a</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Prefix Increment: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">++</span><span class="js-id">a</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Postfix Increment: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">a</span><span class="js-op">++</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"After Increment: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">a</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Prefix Decrement: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">--</span><span class="js-id">a</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Postfix Decrement: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">a</span><span class="js-op">--</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Final Value: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">a</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Original</span><span class="js-op">:</span> <span class="js-num">10</span>
<span class="js-id">Prefix</span> <span class="js-id">Increment</span><span class="js-op">:</span> <span class="js-num">11</span>
<span class="js-id">Postfix</span> <span class="js-id">Increment</span><span class="js-op">:</span> <span class="js-num">11</span>
<span class="js-id">After</span> <span class="js-id">Increment</span><span class="js-op">:</span> <span class="js-num">12</span>
<span class="js-id">Prefix</span> <span class="js-id">Decrement</span><span class="js-op">:</span> <span class="js-num">11</span>
<span class="js-id">Postfix</span> <span class="js-id">Decrement</span><span class="js-op">:</span> <span class="js-num">11</span>
<span class="js-id">Final</span> <span class="js-id">Value</span><span class="js-op">:</span> <span class="js-num">10</span></code></pre></div><h3>Practical Uses of Increment and Decrement</h3><ul><li><p>Count the number of iterations in a loop.</p></li><li><p>Increase or decrease a counter.</p></li><li><p>Move through array indexes.</p></li><li><p>Track the number of users or products.</p></li><li><p>Update game scores.</p></li></ul><h2>6. Bitwise Operators in C++</h2><p>Bitwise operators perform operations on the individual bits of integer values.</p><p>They are commonly used in embedded programming, networking, system development, and low-level programming.</p><h3>Bitwise Operators Reference</h3><table><tbody><tr><th>Operator</th><th>Name</th><th>Description</th></tr><tr><td><code>&amp;</code></td><td>Bitwise AND</td><td>Sets a bit when both corresponding bits are 1</td></tr><tr><td>`</td><td>`</td><td>Bitwise OR</td><td>Sets a bit when either corresponding bit is 1</td></tr><tr><td><code>^</code></td><td>Bitwise XOR</td><td>Sets a bit when corresponding bits differ</td></tr><tr><td><code>~</code></td><td>Bitwise NOT</td><td>Inverts the bits</td></tr><tr><td><code>&lt;&lt;</code></td><td>Left shift</td><td>Shifts bits to the left</td></tr><tr><td><code>&gt;&gt;</code></td><td>Right shift</td><td>Shifts bits to the right</td></tr></tbody></table><h3>Example: Bitwise Operators</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>

<span class="js-id">int</span> <span class="js-id">a</span> <span class="js-op">=</span> <span class="js-num">5</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">b</span> <span class="js-op">=</span> <span class="js-num">3</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"AND: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">(</span><span class="js-id">a</span> <span class="js-op">&amp;</span> <span class="js-id">b</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"OR: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">(</span><span class="js-id">a</span> <span class="js-op">|</span> <span class="js-id">b</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"XOR: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">(</span><span class="js-id">a</span> <span class="js-op">^</span> <span class="js-id">b</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Left Shift: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">(</span><span class="js-id">a</span> <span class="js-op">&lt;&lt;</span> <span class="js-num">1</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Right Shift: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">(</span><span class="js-id">a</span> <span class="js-op">&gt;&gt;</span> <span class="js-num">1</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">AND</span><span class="js-op">:</span> <span class="js-num">1</span>
<span class="js-id">OR</span><span class="js-op">:</span> <span class="js-num">7</span>
<span class="js-id">XOR</span><span class="js-op">:</span> <span class="js-num">6</span>
<span class="js-id">Left</span> <span class="js-id">Shift</span><span class="js-op">:</span> <span class="js-num">10</span>
<span class="js-id">Right</span> <span class="js-id">Shift</span><span class="js-op">:</span> <span class="js-num">2</span></code></pre></div><h3>Binary Explanation</h3><p>The binary representation of 5 is <code>0101</code>, and the binary representation of 3 is <code>0011</code>.</p><table><tbody><tr><th>Operation</th><th>Binary result</th><th>Decimal result</th></tr><tr><td><code>5 &amp; 3</code></td><td><code>0001</code></td><td>1</td></tr><tr><td>`5</td><td>3`</td><td><code>0111</code></td><td>7</td></tr><tr><td><code>5 ^ 3</code></td><td><code>0110</code></td><td>6</td></tr><tr><td><code>5 &lt;&lt; 1</code></td><td><code>1010</code></td><td>10</td></tr><tr><td><code>5 &gt;&gt; 1</code></td><td><code>0010</code></td><td>2</td></tr></tbody></table><p>These examples use positive integers and a four-bit illustration. Actual C++ integer operations use the full width of the operand type.</p><h2>7. Conditional Operator in C++</h2><p>The conditional operator <code>?:</code> is also called the ternary operator because it works with three operands.</p><p>It provides a short way to select one of two expressions based on a condition.</p><h3>Syntax</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">condition</span> <span class="js-op">?</span> <span class="js-id">value_if_true</span> <span class="js-op">:</span> <span class="js-id">value_if_false</span><span class="js-op">;</span></code></pre></div><h3>Example: Conditional Operator</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>

<span class="js-id">int</span> <span class="js-id">a</span> <span class="js-op">=</span> <span class="js-num">20</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">b</span> <span class="js-op">=</span> <span class="js-num">10</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">largest</span> <span class="js-op">=</span> <span class="js-op">(</span><span class="js-id">a</span> <span class="js-op">&gt;</span> <span class="js-id">b</span><span class="js-op">)</span> <span class="js-op">?</span> <span class="js-id">a</span> <span class="js-op">:</span> <span class="js-id">b</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Largest Number: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">largest</span><span class="js-op">;</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Largest</span> <span class="js-id">Number</span><span class="js-op">:</span> <span class="js-num">20</span></code></pre></div><h3>Practical Uses</h3><ul><li><p>Find the largest or smallest of two numbers.</p></li><li><p>Choose between two values.</p></li><li><p>Display different messages based on a condition.</p></li><li><p>Perform simple conditional assignments.</p></li></ul><h2>8. Comma Operator in C++</h2><p>The comma operator <code>,</code> evaluates multiple expressions from left to right and produces the value of the rightmost expression.</p><h3>Syntax</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">expression1</span><span class="js-op">,</span> <span class="js-id">expression2</span><span class="js-op">,</span> <span class="js-id">expression3</span><span class="js-op">;</span></code></pre></div><h3>Example: Comma Operator</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>

<span class="js-id">int</span> <span class="js-id">a</span><span class="js-op">,</span> <span class="js-id">b</span><span class="js-op">,</span> <span class="js-id">result</span><span class="js-op">;</span>

<span class="js-id">result</span> <span class="js-op">=</span> <span class="js-op">(</span><span class="js-id">a</span> <span class="js-op">=</span> <span class="js-num">10</span><span class="js-op">,</span> <span class="js-id">b</span> <span class="js-op">=</span> <span class="js-num">20</span><span class="js-op">,</span> <span class="js-id">a</span> <span class="js-op">+</span> <span class="js-id">b</span><span class="js-op">);</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Result: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">result</span><span class="js-op">;</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Result</span><span class="js-op">:</span> <span class="js-num">30</span></code></pre></div><p>The comma operator is useful when you specifically need multiple expressions to be evaluated in sequence. Do not confuse it with commas used to separate function arguments or variable declarations.</p><h2>9. Member Access Operators in C++</h2><p>Member access operators are used to access the data members and functions of objects.</p><p>C++ provides two commonly used member access operators.</p><h3>Member Access Operators Reference</h3><table><tbody><tr><th>Operator</th><th>Name</th><th>Purpose</th></tr><tr><td><code>.</code></td><td>Dot operator</td><td>Accesses members through an object</td></tr><tr><td><code>-&gt;</code></td><td>Arrow operator</td><td>Accesses members through a pointer</td></tr></tbody></table><h3>Example: Dot Operator</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-kw">class</span> <span class="js-id">Student</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-id">int</span> <span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">20</span><span class="js-op">;</span>
<span class="js-op">};</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>

<span class="js-id">Student</span> <span class="js-id">s</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Age: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">s</span><span class="js-op">.</span><span class="js-id">age</span><span class="js-op">;</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Age</span><span class="js-op">:</span> <span class="js-num">20</span></code></pre></div><h3>Example: Arrow Operator</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-kw">class</span> <span class="js-id">Student</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-id">int</span> <span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">20</span><span class="js-op">;</span>
<span class="js-op">};</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>

<span class="js-id">Student</span> <span class="js-id">s</span><span class="js-op">;</span>

<span class="js-id">Student</span><span class="js-op">*</span> <span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-op">&amp;</span><span class="js-id">s</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Age: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">ptr</span><span class="js-op">-&gt;</span><span class="js-id">age</span><span class="js-op">;</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Age</span><span class="js-op">:</span> <span class="js-num">20</span></code></pre></div><p>The arrow operator accesses a member through a pointer. It is equivalent to dereferencing the pointer and then using the dot operator.</p><h2>10. Pointer Operators in C++</h2><p>Pointers are variables that store memory addresses.</p><p>C++ provides operators that allow you to work with pointers.</p><h3>Pointer Operators Reference</h3><table><tbody><tr><th>Operator</th><th>Name</th><th>Purpose</th></tr><tr><td><code>&amp;</code></td><td>Address-of</td><td>Gets the address of a variable</td></tr><tr><td><code>*</code></td><td>Dereference</td><td>Accesses the object pointed to by a pointer</td></tr></tbody></table><h3>Example: Pointer Operators</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>

<span class="js-id">int</span> <span class="js-id">number</span> <span class="js-op">=</span> <span class="js-num">100</span><span class="js-op">;</span>

<span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-op">&amp;</span><span class="js-id">number</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Value: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">number</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Address: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">&amp;</span><span class="js-id">number</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Pointer Value: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">*</span><span class="js-id">ptr</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Example Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Value</span><span class="js-op">:</span> <span class="js-num">100</span>
<span class="js-id">Address</span><span class="js-op">:</span> <span class="js-op">(</span><span class="js-id">memory</span> <span class="js-id">address</span><span class="js-op">)</span>
<span class="js-id">Pointer</span> <span class="js-id">Value</span><span class="js-op">:</span> <span class="js-num">100</span></code></pre></div><p>The actual memory address will vary each time the program runs.</p><h3>Practical Uses of Pointer Operators</h3><ul><li><p>Access objects through memory addresses.</p></li><li><p>Work with dynamically allocated objects.</p></li><li><p>Pass data to functions through pointers.</p></li><li><p>Build linked lists and other data structures.</p></li><li><p>Work with arrays and low-level memory operations.</p></li></ul><h2>11. Memory Management Operators in C++</h2><p>C++ provides <code>new</code> and <code>delete</code> operators for dynamic memory allocation and deallocation.</p><p>They allow a program to create objects whose lifetime is managed dynamically.</p><h3>Memory Management Operators Reference</h3><table><tbody><tr><th>Operator</th><th>Purpose</th></tr><tr><td><code>new</code></td><td>Allocates memory and creates an object</td></tr><tr><td><code>delete</code></td><td>Destroys an object and releases its allocated memory</td></tr><tr><td><code>new[]</code></td><td>Allocates an array dynamically</td></tr><tr><td><code>delete[]</code></td><td>Destroys a dynamically allocated array and releases its memory</td></tr></tbody></table><h3>Example: Using new and delete</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>

<span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">number</span> <span class="js-op">=</span> <span class="js-kw">new</span> <span class="js-id">int</span><span class="js-op">(</span><span class="js-num">100</span><span class="js-op">);</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Value: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">*</span><span class="js-id">number</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-id">delete</span> <span class="js-id">number</span><span class="js-op">;</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Value</span><span class="js-op">:</span> <span class="js-num">100</span></code></pre></div><h3>Example: Using new[] and delete[]</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>

<span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">numbers</span> <span class="js-op">=</span> <span class="js-kw">new</span> <span class="js-id">int</span>[<span class="js-num">3</span>]<span class="js-op">{</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">20</span><span class="js-op">,</span> <span class="js-num">30</span><span class="js-op">};</span>

<span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">i</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">;</span> <span class="js-id">i</span> <span class="js-op">&lt;</span> <span class="js-num">3</span><span class="js-op">;</span> <span class="js-id">i</span><span class="js-op">++)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">numbers</span>[<span class="js-id">i</span>] <span class="js-op">&lt;&lt;</span> <span class="js-str">" "</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-id">delete</span>[] <span class="js-id">numbers</span><span class="js-op">;</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">10</span> <span class="js-num">20</span> <span class="js-num">30</span></code></pre></div><p><strong>Important:</strong> Always release memory allocated using <code>new</code> with the matching <code>delete</code>, and memory allocated using <code>new[]</code> with <code>delete[]</code>.</p><p>In modern C++, prefer standard containers such as <code>std::vector</code> and smart pointers when they fit your requirements. They help manage object lifetimes automatically.</p><h2>12. Type and Size Operators in C++</h2><p>C++ provides operators and language features that help you inspect the size or type information of expressions and objects.</p><h3>Common Type and Size Operations</h3><table><tbody><tr><th>Operator or feature</th><th>Purpose</th><th>Example</th></tr><tr><td><code>sizeof</code></td><td>Finds the size of a type or object in bytes</td><td><code>sizeof(int)</code></td></tr><tr><td><code>typeid</code></td><td>Provides runtime type information</td><td><code>typeid(value)</code></td></tr><tr><td><code>alignof</code></td><td>Finds the alignment requirement of a type</td><td><code>alignof(double)</code></td></tr></tbody></table><p><code>sizeof</code> and <code>alignof</code> are language operators. <code>typeid</code> is an operator that requires the <code>&lt;typeinfo&gt;</code> header for its standard declaration.</p><h3>Example: sizeof Operator</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Size of int: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">sizeof</span><span class="js-op">(</span><span class="js-id">int</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Size of float: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">sizeof</span><span class="js-op">(</span><span class="js-id">float</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Size of double: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">sizeof</span><span class="js-op">(</span><span class="js-id">double</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Size of char: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">sizeof</span><span class="js-op">(</span><span class="js-id">char</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Typical Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Size</span> <span class="js-kw">of</span> <span class="js-id">int</span><span class="js-op">:</span> <span class="js-num">4</span>
<span class="js-id">Size</span> <span class="js-kw">of</span> <span class="js-id">float</span><span class="js-op">:</span> <span class="js-num">4</span>
<span class="js-id">Size</span> <span class="js-kw">of</span> <span class="js-id">double</span><span class="js-op">:</span> <span class="js-num">8</span>
<span class="js-id">Size</span> <span class="js-kw">of</span> <span class="js-id">char</span><span class="js-op">:</span> <span class="js-num">1</span></code></pre></div><p>Actual sizes depend on the C++ implementation, except that <code>sizeof(char)</code> is always 1 byte.</p><h2>Complete C++ Program Using Different Operators</h2><p>Now let's combine several common operators in one program.</p><h3>C++ Code</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>

<span class="js-id">int</span> <span class="js-id">a</span> <span class="js-op">=</span> <span class="js-num">10</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">b</span> <span class="js-op">=</span> <span class="js-num">5</span><span class="js-op">;</span>

<span class="js-cm">// Arithmetic operator</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Addition: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">a</span> <span class="js-op">+</span> <span class="js-id">b</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-cm">// Relational operator</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Greater: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">(</span><span class="js-id">a</span> <span class="js-op">&gt;</span> <span class="js-id">b</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-cm">// Logical operator</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Logical: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">(</span><span class="js-id">a</span> <span class="js-op">&gt;</span> <span class="js-num">5</span> <span class="js-op">&amp;&amp;</span> <span class="js-id">b</span> <span class="js-op">&lt;</span> <span class="js-num">10</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-cm">// Assignment operator</span>
<span class="js-id">a</span> <span class="js-op">+=</span> <span class="js-num">5</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Updated A: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">a</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-cm">// Increment operator</span>
<span class="js-op">++</span><span class="js-id">a</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Incremented A: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">a</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-cm">// Bitwise operator</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Bitwise AND: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">(</span><span class="js-id">a</span> <span class="js-op">&amp;</span> <span class="js-id">b</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-cm">// Conditional operator</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Result: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">(</span><span class="js-id">a</span> <span class="js-op">&gt;</span> <span class="js-id">b</span> <span class="js-op">?</span> <span class="js-str">"Greater"</span> <span class="js-op">:</span> <span class="js-str">"Smaller"</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><h3>Output</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Addition</span><span class="js-op">:</span> <span class="js-num">15</span>
<span class="js-id">Greater</span><span class="js-op">:</span> <span class="js-num">1</span>
<span class="js-id">Logical</span><span class="js-op">:</span> <span class="js-num">1</span>
<span class="js-id">Updated</span> <span class="js-id">A</span><span class="js-op">:</span> <span class="js-num">15</span>
<span class="js-id">Incremented</span> <span class="js-id">A</span><span class="js-op">:</span> <span class="js-num">16</span>
<span class="js-id">Bitwise</span> <span class="js-id">AND</span><span class="js-op">:</span> <span class="js-num">0</span>
<span class="js-id">Result</span><span class="js-op">:</span> <span class="js-id">Greater</span></code></pre></div><h3>Explanation</h3><p>This program demonstrates several operator categories:</p><ul><li><p>Arithmetic operators calculate the sum.</p></li><li><p>Relational operators compare two numbers.</p></li><li><p>Logical operators check multiple conditions.</p></li><li><p>Assignment operators update variable values.</p></li><li><p>Increment operators increase a variable by one.</p></li><li><p>Bitwise operators work with individual bits.</p></li><li><p>Conditional operators select a result based on a condition.</p></li></ul><h2>Operator Precedence and Associativity in C++</h2><p>When an expression contains multiple operators, C++ follows specific rules to determine how operators are grouped.</p><p>These rules are called operator precedence and associativity.</p><h3>What Is Operator Precedence?</h3><p>Operator precedence determines which operators are grouped first in an expression.</p><p>For example:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span> <span class="js-id">result</span> <span class="js-op">=</span> <span class="js-num">10</span> <span class="js-op">+</span> <span class="js-num">5</span> <span class="js-op">*</span> <span class="js-num">2</span><span class="js-op">;</span></code></pre></div><p>Multiplication has higher precedence than addition.</p><p>Therefore, the expression is grouped as:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">10</span> <span class="js-op">+</span> <span class="js-op">(</span><span class="js-num">5</span> <span class="js-op">*</span> <span class="js-num">2</span><span class="js-op">)</span>
<span class="js-num">10</span> <span class="js-op">+</span> <span class="js-num">10</span>
<span class="js-num">20</span></code></pre></div><h3>What Is Operator Associativity?</h3><p>Associativity determines how operators with the same precedence are grouped.</p><p>For example:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span> <span class="js-id">result</span> <span class="js-op">=</span> <span class="js-num">20</span> <span class="js-op">-</span> <span class="js-num">5</span> <span class="js-op">-</span> <span class="js-num">3</span><span class="js-op">;</span></code></pre></div><p>Subtraction has left-to-right associativity.</p><p>Therefore:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-op">(</span><span class="js-num">20</span> <span class="js-op">-</span> <span class="js-num">5</span><span class="js-op">)</span> <span class="js-op">-</span> <span class="js-num">3</span>
<span class="js-num">15</span> <span class="js-op">-</span> <span class="js-num">3</span>
<span class="js-num">12</span></code></pre></div><h3>Common Operator Precedence Reference</h3><table><tbody><tr><th>Priority</th><th>Operators</th><th>Associativity</th></tr><tr><td>Highest</td><td><code>()</code> <code>[]</code> <code>.</code> <code>-&gt;</code></td><td>Left to right</td></tr><tr><td></td><td><code>++</code> <code>--</code> <code>!</code> <code>~</code> unary <code>+</code> <code>-</code></td><td>Right to left</td></tr><tr><td></td><td><code>*</code> <code>/</code> <code>%</code></td><td>Left to right</td></tr><tr><td></td><td><code>+</code> <code>-</code></td><td>Left to right</td></tr><tr><td></td><td><code>&lt;&lt;</code> <code>&gt;&gt;</code></td><td>Left to right</td></tr><tr><td></td><td><code>&lt;</code> <code>&lt;=</code> <code>&gt;</code> <code>&gt;=</code></td><td>Left to right</td></tr><tr><td></td><td><code>==</code> <code>!=</code></td><td>Left to right</td></tr><tr><td></td><td><code>&amp;</code> <code>^</code> `</td><td>`</td><td>Left to right</td></tr><tr><td></td><td><code>&amp;&amp;</code> `</td><td></td><td>`</td><td>Left to right</td></tr><tr><td></td><td><code>?:</code></td><td>Right to left</td></tr><tr><td></td><td>Assignment operators</td><td>Right to left</td></tr><tr><td>Lowest</td><td><code>,</code></td><td>Left to right</td></tr></tbody></table><p>This is a simplified reference. The exact precedence table includes additional operators and distinctions between different operator forms.</p><p><strong>Tip:</strong> Use parentheses when writing complex expressions. They make your intentions clear and help prevent mistakes.</p><h2>Common Mistakes When Using C++ Operators</h2><p>Beginners often make small mistakes when working with operators. Here are some common problems to avoid.</p><h3>1. Confusing = and ==</h3><p>Incorrect:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-kw">if</span> <span class="js-op">(</span><span class="js-id">a</span> <span class="js-op">=</span> <span class="js-num">10</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Equal"</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>Correct:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-kw">if</span> <span class="js-op">(</span><span class="js-id">a</span> <span class="js-op">==</span> <span class="js-num">10</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Equal"</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>Use <code>=</code> for assignment and <code>==</code> for comparison.</p><h3>2. Confusing &amp;&amp; and &amp;</h3><p><code>&amp;&amp;</code> is a logical AND operator, while <code>&amp;</code> is a bitwise AND operator.</p><p>They perform different operations.</p><h3>3. Ignoring Integer Division</h3><p>Example:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span> <span class="js-id">result</span> <span class="js-op">=</span> <span class="js-num">10</span> <span class="js-op">/</span> <span class="js-num">3</span><span class="js-op">;</span></code></pre></div><p>The result is 3 because both operands are integers.</p><p>Use <code>10.0 / 3</code> when you need a decimal result.</p><h3>4. Using the Modulus Operator With Floating-Point Values</h3><p>The <code>%</code> operator is used with integral operands, not floating-point operands.</p><p>For floating-point remainder calculations, use <code>std::fmod()</code> from the <code>&lt;cmath&gt;</code> header.</p><h3>5. Incorrect Use of Increment Operators</h3><p>Avoid expressions that modify the same variable multiple times without proper sequencing.</p><p>For example, avoid:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span> <span class="js-id">result</span> <span class="js-op">=</span> <span class="js-id">a</span><span class="js-op">++</span> <span class="js-op">+</span> <span class="js-op">++</span><span class="js-id">a</span><span class="js-op">;</span></code></pre></div><p>Such expressions can have undefined behaviour because the modifications are not properly sequenced.</p><p>Use separate statements instead.</p><h3>6. Forgetting to Release Dynamically Allocated Memory</h3><p>If you use <code>new</code>, ensure that the allocated object is properly destroyed with <code>delete</code>, or use a suitable smart pointer.</p><p>For arrays allocated with <code>new[]</code>, use <code>delete[]</code>.</p><h2>Best Practices for Using Operators in C++</h2><p>Follow these simple practices when writing C++ programs:</p><ul><li><p>Choose the correct operator for each operation.</p></li><li><p>Use parentheses to make complex expressions easier to understand.</p></li><li><p>Use <code>==</code> for comparison and <code>=</code> for assignment.</p></li><li><p>Understand the difference between logical and bitwise operators.</p></li><li><p>Avoid complicated expressions with multiple side effects.</p></li><li><p>Check for division by zero.</p></li><li><p>Use appropriate data types for mathematical calculations.</p></li><li><p>Prefer standard containers and smart pointers for safer memory management.</p></li><li><p>Avoid unnecessary pointer manipulation.</p></li><li><p>Write clear and readable expressions.</p></li></ul><h2>Frequently Asked Questions About C++ Operators</h2><h3>1. What are operators in C++?</h3><p>Operators are symbols or keywords used to perform operations on values and variables. Examples include <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, <code>==</code>, and <code>&amp;&amp;</code>.</p><h3>2. How many types of operators are there in C++?</h3><p>C++ has several operator categories, including arithmetic, relational, logical, assignment, increment and decrement, bitwise, conditional, comma, pointer, and member access operators.</p><h3>3. What are arithmetic operators in C++?</h3><p>Arithmetic operators perform mathematical calculations. The main arithmetic operators are <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, and <code>%</code>.</p><h3>4. What are relational operators in C++?</h3><p>Relational operators compare two values and return a Boolean result. Examples include <code>==</code>, <code>!=</code>, <code>&gt;</code>, <code>&lt;</code>, <code>&gt;=</code>, and <code>&lt;=</code>.</p><h3>5. What are logical operators in C++?</h3><p>Logical operators combine or reverse conditions. C++ provides <code>&amp;&amp;</code> for AND, <code>||</code> for OR, and <code>!</code> for NOT.</p><h3>6. What is the difference between = and == in C++?</h3><p><code>=</code> assigns a value to a variable, while <code>==</code> checks whether two values are equal.</p><h3>7. What is the conditional operator in C++?</h3><p>The conditional operator <code>?:</code> selects one of two expressions depending on whether a condition is true or false.</p><h3>8. What are bitwise operators in C++?</h3><p>Bitwise operators perform operations on the individual bits of integer values. Examples include <code>&amp;</code>, <code>|</code>, <code>^</code>, <code>~</code>, <code>&lt;&lt;</code>, and <code>&gt;&gt;</code>.</p><h3>9. What is the sizeof operator in C++?</h3><p>The <code>sizeof</code> operator returns the size of a type or object in bytes.</p><h3>10. What is the difference between prefix and postfix increment?</h3><p>Prefix increment (<code>++a</code>) increases the variable before its updated value is used. Postfix increment (<code>a++</code>) produces the original value before increasing the variable.</p><h3>11. What is operator precedence in C++?</h3><p>Operator precedence determines how operators are grouped when an expression contains multiple operators.</p><h3>12. Can operators be overloaded in C++?</h3><p>Yes. C++ allows programmers to define how many existing operators behave with user-defined types through operator overloading. However, not every operator can be overloaded, and operator overloading cannot change an operator's precedence or associativity.</p>

Code Example

#include <iostream>
#include <compare>

struct PacketHeader {
    int sequenceNumber;
    int priority;

    // C++20 Spaceship Operator for automatic 3-way comparisons
    auto operator<=>(const PacketHeader&) const = default;
};

int main() {
    int a = 12; // 0000 1100
    int b = 25; // 0001 1001

    std::cout << "Bitwise AND (a & b): " << (a & b) << "
";
    std::cout << "Bitwise OR  (a | b): " << (a | b) << "
";
    std::cout << "Bitwise XOR (a ^ b): " << (a ^ b) << "
";
    std::cout << "Shift Left  (a << 2): " << (a << 2) << "
";

    // Ternary operator
    int maxVal = (a > b) ? a : b;
    std::cout << "Max value: " << maxVal << "
";

    // Spaceship operator
    PacketHeader p1{101, 1};
    PacketHeader p2{102, 1};
    if (p1 < p2) {
        std::cout << "Packet 1 has lower sequence than Packet 2
";
    }
    return 0;
}

Interview Question & Tips

Q: What is the C++20 three-way comparison (spaceship operator <=>) operator?
A: The `<=>` operator compares two objects in a single expression, returning `std::strong_ordering`, `std::weak_ordering`, or `std::partial_ordering` (less, equal, greater). Declaring it `= default` auto-generates all 6 relational operators (`<`, `<=`, `>`, `>=`, `==`, `!=`).

Q: Why should parentheses be used even when operator precedence is known?
A: Complex operator interactions (such as bitwise operators mixed with comparisons) can lead to subtle bugs and reduce readability for teammates.

Best Practices

1. Use explicit parentheses to make complex mathematical or bitwise expressions unambiguous.
2. Adopt the C++20 default spaceship operator `<=>` to implement complete class comparisons with minimal boilerplate.
3. Do not overload logical operators (`&&`, `||`, `,`) as custom overloads lose short-circuit evaluation semantics.
Academic Standards & Verified Citations

This study reference for C++ Operators Reference: Categories, Syntax, and Practical Usage is curated and verified against recognized curriculum benchmarks, peer-reviewed textbooks, and official technical documentation:

C++ Programming