C Notes
HubApplications of C Programming LanguageFeatures of C Programming LanguageHistory of C Programming LanguageWhat is C Language?Why Learn C Programming in 2024?First C Program - Hello World in C with ExplanationGCC Compiler - Complete Guide to GNU C CompilerInstall C Compiler on Linux - GCC Setup Guide for All DistrosInstall C Compiler on macOS - Xcode Command Line Tools and Homebrew GCCInstall C Compiler on Windows - MinGW, MSYS2, and WSL GuideSetup VS Code for C Programming - Complete Configuration GuideC Syntax Rules — Complete GuideComments in C ProgrammingConstants in C ProgrammingData Types in CIdentifiers in C ProgrammingKeywords in C ProgrammingStructure of a C ProgramVariables in C ProgrammingArithmetic Operators in C ProgrammingAssignment Operators in C ProgrammingBitwise Operators in C ProgrammingIncrement and Decrement Operators in CLogical Operators in C ProgrammingRelational Operators in C ProgrammingTernary Operator in C ProgrammingBreak Statement in C ProgrammingContinue Statement in C ProgrammingDo-While Loop in C ProgrammingFor Loop in C ProgrammingGoto Statement in C Programmingif-else Statement in C Programmingif Statement in C ProgrammingNested if Statements in C ProgrammingSwitch Statement in C ProgrammingWhile Loop in C ProgrammingFunction Arguments in C - Pass by Value vs Pass by ReferenceFunction Call in C ProgrammingFunction Declaration (Prototype) in CFunction Definition in C ProgrammingIntroduction to Functions in C ProgrammingRecursion in C ProgrammingReturn Statement in C ProgrammingStorage Classes in C ProgrammingArray Operations in C - Searching, Sorting, Insert and DeleteArray Programs in C - Reverse, Rotate, Duplicates, MergeIntroduction to Arrays in C ProgrammingMultidimensional Arrays in C ProgrammingOne Dimensional Arrays in C ProgrammingPassing Arrays to Functions in CTwo Dimensional Arrays in C ProgrammingString Comparison in C - strcmp, strncmp, Case-InsensitiveString Functions in C - strlen, strcpy, strcat, strcmpC String Handling Library - Complete string.h ReferenceString Manipulation in C - Reverse, Uppercase, PalindromeString Programs in C - Anagram, Word Count, Vowels, FrequencyStrings in C Programming - Complete IntroductionDouble Pointers in C - Pointer to PointerPointer Arithmetic in C ProgrammingPointer Declaration and Initialization in CPointer Programs in C - Swap, String Reversal, Dynamic AllocationPointers and Arrays in C - The Relationship ExplainedPointers and Functions in C - Pass by ReferenceIntroduction to Pointers in C ProgrammingVoid Pointers in C - Generic Pointers Guidecalloc() in C – Contiguous Memory AllocationDynamic Arrays in C – Runtime-Sized Arraysfree() in C – Releasing Dynamic Memorymalloc() in C – Dynamic Memory AllocationMemory Management Best Practices in Crealloc() in C – Resizing Dynamic MemoryBinary Files in C – fread and fwriteFile Handling in C – IntroductionFile Handling Projects in C – Student Records & Phone BookFile Modes in C – Complete Guidefopen() and fclose() in C – Opening and Closing FilesReading Files in C – fgetc, fgets, fscanf, freadWriting Files in C – fputc, fputs, fprintf, fwriteConditional Compilation in C – #ifdef, #ifndef, #if#define Macros in C – Constants and Macro FunctionsHeader Files in C – Creating Custom Headers#include Directive in C – File InclusionMacro Functions in C – Parameterized MacrosC Preprocessor – Overview and DirectivesGraphs in C – Adjacency Matrix, Adjacency List, BFS, and DFSHash Tables in C – Implementation, Collision Handling, and ChainingLinked List in C – Singly, Doubly, and Circular with ImplementationQueue in C – Linear, Circular, and Priority Queue ImplementationStack in C – Array and Linked List Implementation with ApplicationsTrees in C – Binary Search Tree Implementation with TraversalsC Programming Best Practices – Coding Standards, Safety, and PerformanceBit Fields in C – Definition, Use Cases, and Protocol HeadersC Standard Library Overview – All Headers and Common FunctionsCommand Line Arguments in C – argc and argv ExplainedDebugging Techniques in C – GDB, Valgrind, and SanitizersFunction Pointers in C – Complete Guide with ExamplesMemory Layout of a C Program – Text, Data, BSS, Heap, StackBank Management System in C – Complete Project with File StorageFile Encryption Tool in C – XOR Cipher ImplementationLibrary Management System in C – Complete Project with Source CodeMini Compiler in C – Lexer and Parser for Simple ExpressionsSnake Game in C – Console-Based Game with Source CodeStudent Management System in C – Complete Project with Source CodeC Programming Cheatsheet – Complete Quick Reference GuideTop 50 C Programming Interview Questions with Answers (2025)Memory Management Interview Questions in C with AnswersOutput Prediction Questions in C – What Will This Program Print?Pointer Interview Questions in C – Tricky Problems with AnswersCommon C Programming Errors and Solutions – Debugging GuideImportant C Programs – 50+ Frequently Asked Programs with SolutionsQuick Revision Notes for C Programming – Complete C in 10 MinutesRecommended C Programming Books – From Beginner to ExpertFormat Specifiers in C - Complete Referencegetchar() and putchar() in C Programminggets() and puts() in C ProgrammingC Input Output Programs and Examplesprintf() Function in C Programmingscanf() Function in C ProgrammingArrays of Structures in C – Managing CollectionsEnums in C – Enumerated Data TypesNested Structures in C – Struct Within StructPointers to Structures in C – Arrow OperatorStructures in C – User-Defined Data Typestypedef in C – Creating Type AliasesUnions in C – Shared Memory Data Types
Learn all assignment operators in C including simple assignment, compound assignment operators (+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=). Understand their syntax, behavior, and practical usage.
Assignment operators store values in variables. While the simple assignment (=) is something every beginner uses from day one, C also provides compound assignment operators that combine an arithmetic or bitwise operation with assignment into a single, concise expression. They make code shorter, more readable, and in some cases, can be slightly more efficient.
Simple Assignment Operator (=)
The basic assignment operator stores the value of the right-hand expression into the left-hand variable. The left side must always be an lvalue — something that has a memory address (like a variable).
c example
#include <stdio.h>
int main() {
int x = 10; // Initialize x with 10
float pi = 3.14; // Initialize pi
char ch = 'A'; // Initialize ch
x = 25; // Reassign x
printf("x = %d\n", x);
// Assignment returns the assigned value
int a, b, c;
a = b = c = 100; // Right-to-left associativity
printf("a=%d, b=%d, c=%d\n", a, b, c);
// Assignment in expressions
int result;
printf("Assigned: %d\n", result = 42);
return 0;
}Output
x = 25 a=100, b=100, c=100 Assigned: 42
Important: The assignment operator has right-to-left associativity. In a = b = c = 100, it's evaluated as a = (b = (c = 100)).
Compound Assignment Operators
Compound assignment operators perform an operation and assignment in one step. The general form is:
Example
variable op= expression;
This is equivalent to:
Example
variable = variable op (expression);
| Operator | Example | Equivalent To | |||
|---|---|---|---|---|---|
+= | x += 5 | x = x + 5 | |||
-= | x -= 3 | x = x - 3 | |||
*= | x *= 2 | x = x * 2 | |||
/= | x /= 4 | x = x / 4 | |||
%= | x %= 3 | x = x % 3 | |||
&= | x &= 0xF | x = x & 0xF | |||
| ` | =` | `x | = 0x1` | `x = x | 0x1` |
^= | x ^= mask | x = x ^ mask | |||
<<= | x <<= 2 | x = x << 2 | |||
>>= | x >>= 1 | x = x >> 1 |
Arithmetic Compound Assignment
c example
#include <stdio.h>
int main() {
int x = 20;
x += 5; // x = x + 5 = 25
printf("After += 5: %d\n", x);
x -= 3; // x = x - 3 = 22
printf("After -= 3: %d\n", x);
x *= 2; // x = x * 2 = 44
printf("After *= 2: %d\n", x);
x /= 4; // x = x / 4 = 11
printf("After /= 4: %d\n", x);
x %= 3; // x = x % 3 = 2
printf("After %%= 3: %d\n", x);
return 0;
}Output
After += 5: 25 After -= 3: 22 After *= 2: 44 After /= 4: 11 After %= 3: 2
Bitwise Compound Assignment
c example
#include <stdio.h>
int main() {
unsigned int flags = 0xFF; // 11111111
flags &= 0x0F; // Clear upper nibble: 00001111
printf("After &= 0x0F: 0x%02X\n", flags);
flags |= 0x30; // Set bits 4 and 5: 00111111
printf("After |= 0x30: 0x%02X\n", flags);
flags ^= 0x05; // Toggle bits 0 and 2: 00111010
printf("After ^= 0x05: 0x%02X\n", flags);
unsigned int num = 8; // 1000
num <<= 2; // Left shift by 2: 100000 = 32
printf("8 <<= 2: %u\n", num);
num >>= 3; // Right shift by 3: 100 = 4
printf("32 >>= 3: %u\n", num);
return 0;
}Output
After &= 0x0F: 0x0F After |= 0x30: 0x3F After ^= 0x05: 0x3A 8 <<= 2: 32 32 >>= 3: 4
Why Use Compound Assignment?
There are several advantages beyond just saving keystrokes:
1. Readability
c example
// Less readable
totalSalesForCurrentQuarter = totalSalesForCurrentQuarter + monthlySales;
// More readable
totalSalesForCurrentQuarter += monthlySales;2. Evaluates Left Side Only Once
This matters when the left side has side effects:
Example
#include <stdio.h>
int index = 0;
int getIndex() {
printf("getIndex called\n");
return index++;
}
int main() {
int arr[5] = {10, 20, 30, 40, 50};
// Calls getIndex() only ONCE
arr[getIndex()] += 100;
printf("arr[0] = %d\n", arr[0]); // 110
// Without compound: would call getIndex() TWICE
// arr[getIndex()] = arr[getIndex()] + 100; // Bug! Different indices!
return 0;
}
Output
getIndex called arr[0] = 110
Practical Examples
Running Total
Example
#include <stdio.h>
int main() {
float total = 0;
int count = 0;
float prices[] = {29.99, 49.50, 15.75, 89.00, 12.25};
int n = 5;
for (int i = 0; i < n; i++) {
total += prices[i];
count++;
}
printf("Total: $%.2f\n", total);
printf("Average: $%.2f\n", total / count);
return 0;
}
Output
Total: $196.49 Average: $39.30
Power Calculation
Example
#include <stdio.h>
int main() {
int base = 2, exponent = 10;
long long result = 1;
for (int i = 0; i < exponent; i++) {
result *= base;
}
printf("%d^%d = %lld\n", base, exponent, result);
return 0;
}
Output
2^10 = 1024
String Processing with +=
Example
#include <stdio.h>
int main() {
char str[] = "Hello World";
int vowels = 0, consonants = 0, spaces = 0;
for (int i = 0; str[i] != '\0'; i++) {
char ch = str[i];
if (ch == ' ') {
spaces++;
} else if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u' ||
ch == 'A' || ch == 'E' || ch == 'I' || ch == 'O' || ch == 'U') {
vowels++;
} else {
consonants++;
}
}
printf("Vowels: %d, Consonants: %d, Spaces: %d\n", vowels, consonants, spaces);
return 0;
}
Output
Vowels: 3, Consonants: 7, Spaces: 1
Type Conversion in Assignment
When you assign a value of one type to a variable of another type, implicit conversion occurs:
c example
#include <stdio.h>
int main() {
// Float to int: truncation
int a;
a = 9.87;
printf("int = 9.87 → %d\n", a);
// Int to float: no loss (within precision)
float b;
b = 42;
printf("float = 42 → %f\n", b);
// Double to float: possible precision loss
float c;
c = 3.141592653589793;
printf("float = pi → %.15f\n", c);
// Large int to char: truncation
char d;
d = 321; // 321 % 256 = 65 = 'A'
printf("char = 321 → '%c' (%d)\n", d, d);
return 0;
}Output
int = 9.87 → 9 float = 42 → 42.000000 float = pi → 3.141592741012573 char = 321 → 'A' (65)
Common Mistakes
Confusing = with ==
c example
#include <stdio.h>
int main() {
int x = 5;
// Bug: assigns 0 to x, condition is false
if (x = 0) {
printf("This never prints\n");
}
// Bug: assigns 10 to x, condition is always true
x = 5;
if (x = 10) {
printf("This always prints! x is now %d\n", x);
}
return 0;
}Output
This always prints! x is now 10
Compound Assignment Precedence
Remember that x *= a + b means x = x * (a + b), NOT x = x * a + b:
c example
#include <stdio.h>
int main() {
int x = 3;
x *= 2 + 4; // x = 3 * (2 + 4) = 3 * 6 = 18
printf("x *= 2 + 4: %d\n", x);
int y = 3;
y = y * 2 + 4; // y = 6 + 4 = 10 (different!)
printf("y = y * 2 + 4: %d\n", y);
return 0;
}Output
x *= 2 + 4: 18 y = y * 2 + 4: 10
Assignment Operator Precedence
Assignment operators have very low precedence — almost everything else is evaluated first. They also associate right-to-left:
| Priority | Operators | |
|---|---|---|
| Very Low | =, +=, -=, *=, /=, %=, &=, ` | =, ^=, <<=, >>=` |
c example
#include <stdio.h>
int main() {
int a, b;
// Assignment has lower precedence than comparison
a = 5 > 3; // a = (5 > 3) = 1
printf("a = 5 > 3: %d\n", a);
// Right-to-left associativity
a = b = 10 + 5; // a = (b = 15) → both become 15
printf("a=%d, b=%d\n", a, b);
return 0;
}Output
a = 5 > 3: 1 a=15, b=15
Interview Questions
Q1: What is the difference between = and == in C?
= is the assignment operator — it stores a value in a variable. == is the equality operator — it compares two values and returns 1 (true) or 0 (false). Using = in an if condition is a common bug that assigns instead of comparing.
**Q2: What does x *= y + z expand to?**
It expands to x = x * (y + z), NOT x = x * y + z. The entire right-hand side expression is treated as one operand, so the addition happens before the multiplication with x.
Q3: Why is a[i++] += 5 preferred over a[i++] = a[i++] + 5?
With compound assignment, the left side (a[i++]) is evaluated only once, so i is incremented once. With the expanded form, i++ appears twice, causing undefined behavior because the order of evaluation is not guaranteed.
Q4: What is the associativity of assignment operators and why does it matter?
Assignment operators associate right-to-left. This allows chained assignments like a = b = c = 0, which is evaluated as a = (b = (c = 0)). First c gets 0, then b gets the result of that assignment (0), then a gets the result of that assignment (0).
Q5: Can you use compound assignment with pointers?
Yes, but only += and -= make sense with pointers. ptr += 3 advances the pointer by 3 elements (not 3 bytes). Other compound operators like *= don't work with pointers.
Summary
- The simple assignment
=stores a value; compound operators combine operation + assignment - Compound operators (
+=,-=,*=, etc.) are concise and evaluate the left side only once - Assignment has very low precedence and right-to-left associativity
x *= a + bmeansx = x * (a + b)— the whole right side is the operand- Never confuse
=(assignment) with==(comparison) — this is a classic C bug - Type conversion happens automatically during assignment (may truncate or lose precision)
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Assignment Operators in C Programming.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this C Programming topic.
Search Terms
c-programming, c programming, programming, operators, assignment, assignment operators in c programming
Related C Programming Topics
Continue learning this concept
OperatorsArithmetic Operators in C ProgrammingLearn all arithmetic operators in C including addition, subtraction, multiplication, division, and modulus. Understand integer division traps, operator precedence, and type casting with practical examples.OperatorsBitwise Operators in C ProgrammingComplete guide to bitwise operators in C: AND, OR, XOR, NOT, left shift, and right shift. Learn practical applications like flag manipulation, masking, and power-of-2 operations with examples.OperatorsIncrement and Decrement Operators in CMaster increment (++) and decrement (--) operators in C. Understand the difference between prefix and postfix, common pitfalls, undefined behavior, and practical usage in loops and expressions.OperatorsLogical Operators in C ProgrammingLearn logical operators in C: AND (&&), OR (||), and NOT (!). Understand short-circuit evaluation, truth tables, operator precedence, and practical examples for decision-making.OperatorsRelational Operators in C ProgrammingMaster relational (comparison) operators in C: equal to, not equal, greater than, less than, and their combinations. Learn how they return 0 or 1, common mistakes, and usage in conditions.OperatorsTernary Operator in C ProgrammingLearn the ternary (conditional) operator (?:) in C. Understand syntax, nested ternary expressions, when to use ternary vs if-else, and practical examples for concise conditional logic.