Introduction to C Language Characters

📚 Understanding the C Language Character Set and Tokens

💡 The character set and tokens in C form the foundational elements of the language, enabling the construction of meaningful programs through structured components.

Character Set in C

• Alphabets: C supports both lowercase (a-z) and uppercase (A-Z) English letters, totaling 52 characters.
• Digits: The language contains 10 digits (0-9) used to create numerical values.
• Special Symbols: A variety of symbols, such as ~, @, #, $, %, and more, are included to perform operations and format output.

⚡ Key Fact: The C language supports a total of 256 characters, encompassing alphabets, digits, and special symbols.

Tokens in C

• Token: The smallest unit in a C program, representing a single instruction or component.
• Types of Tokens: Tokens can be made up of keywords, identifiers, operators, special symbols, constants, strings, and data values.

📝 Definition: Token — An individual unit in a C program that can represent keywords, identifiers, operators, or constants.

Keywords and Identifiers

• Keywords: Reserved words in C that have specific meanings, always written in lowercase. There are 32 keywords such as int, float, if, else, etc.
• Identifier: A name given to variables, functions, arrays, etc. Identifiers must start with a letter or underscore and cannot contain special symbols or whitespace.

❓ Quick Check: How many keywords are there in C, and can identifiers start with a digit?

⚙️ Understanding Operators in C Programming

💡 Operators are essential building blocks in C programming, enabling various operations on data types and influencing control flow.

Arithmetic Operators

• Addition: The + operator adds two operands. For example, a + b computes the sum of a and b.
• Subtraction: The - operator subtracts one operand from another. For instance, a - b gives the difference.
• Multiplication: The * operator multiplies two operands, e.g., a * b results in the product.

⚡ Key Fact: In C, integer division occurs when both operands are integers, truncating any decimal.

Relational Operators

• Equal to: The == operator checks if two operands are equal, returning 1 if true and 0 otherwise. For example, 5 == 5 returns 1.
• Not equal to: The != operator checks if two operands are not equal, returning 1 if they are different. For example, 5 != 5 returns 0.
• Greater than: The > operator checks if the first operand is greater than the second, returning 1 if true.

📝 Definition: Relational Operators — Operators that compare two values and return a boolean result.

Logical Operators

• Logical AND (&&): Returns 1 if both conditions are true, otherwise returns 0. For example, a && b returns 1 only if both a and b are non-zero.
• Logical OR (||): Returns 1 if at least one condition is true. For instance, a || b returns 1 if either a or b is non-zero.
• Logical NOT (!): Returns 1 if the condition is false, otherwise returns 0. For example, !a returns 1 if a is 0.

❓ Quick Check: What does 1 > 5 && 5 < 10 evaluate to?

Assignment Operators

• Basic Assignment (=): Assigns the value on the right to the variable on the left, e.g., a = 10.
• Addition Assignment (+=): Adds the right operand to the left operand and assigns the result, e.g., a += b is equivalent to a = a + b.
• Subtraction Assignment (-=): Subtracts the right operand from the left operand and assigns the result, e.g., a -= b is equivalent to a = a - b.

📊 Key Stat: Using += can simplify code and improve readability by reducing redundancy.

Bitwise Operators

• Bitwise AND (&): Performs AND operation on each bit of two numbers. For example, 5 & 9 results in 1.
• Bitwise OR (|): Performs OR operation on each bit. For instance, 5 | 9 results in 13.
• Bitwise XOR (^): Performs XOR operation on each bit. For example, 5 ^ 9 results in 12.

⚡ Key Fact: The left and right shift operators (<< and >>) correspond to multiplying and dividing by 2, respectively.

Conditional Operator

• Ternary Operator: The conditional operator (? :) evaluates a condition and returns one of two values based on that condition. For example, large = (a > b) ? a : b assigns the larger of a or b to large.

🧠 Memory Hook: Think of the conditional operator as a compact if...else statement.

sizeof Operator

• sizeof: This unary operator returns the size of a variable or data type in bytes. For example, sizeof(int) typically returns 4 on most systems.

⚡ Key Fact: The result of sizeof is of type size_t, which is an unsigned integral type.

📜 Control Flow Statements in C Programming

💡 Understanding control flow statements is crucial for writing efficient and logical C programs, allowing for decision-making and repetition in code execution.

If Statements

• if Statement: Used to execute a block of code only if a specified condition is true.
• if-else Statement: Allows for two possible paths of execution based on a condition; one for true and one for false.
• Nested if Statements: Allows for multiple conditions to be checked in a hierarchical manner, where an if statement can contain another if statement.

⚡ Key Fact: The if statement is fundamental in controlling the flow of execution based on conditions.

Switch Statements

• switch Statement: A control statement that allows a variable to be tested for equality against a list of values (cases). Each case is followed by a colon and must end with a break statement to prevent fall-through.
• default Case: A special case that executes if none of the specified cases match the expression value.

🧠 Memory Hook: Think of the switch statement as a multi-path road where each case is a different destination based on the input value.

Looping Statements

• while Loop: A control structure that repeatedly executes a block of code as long as a specified condition is true.
• do-while Loop: Similar to the while loop, but guarantees that the block of code is executed at least once before the condition is tested.
• for Loop: A control structure that allows for initialization, condition checking, and iteration in a compact syntax.

❓ Quick Check: What is the key difference between a while loop and a do-while loop?

Example Programs

1. Even or Odd Check:

   #include <stdio.h>
   void main() {
       int n;
       printf("Enter the value of n:");
       scanf("%d",&n);
       if(n % 2 == 0)
           printf("
   

Even"); else printf(" Odd"); }

2. **Largest of Three Numbers**:
```c
void main() {
    int a, b, c;
    printf("Enter the value of a, b and c:");
    scanf("%d%d%d", &a, &b, &c);
    if(a > b && a > c) {
        printf("
%d is largest", a);
    } else if(b > a && b > c) {
        printf("
%d is largest", b);
    } else {
        printf("
%d is largest", c);
    }
}

3. Sum of First n Natural Numbers:

   #include <stdio.h>
   void main() {
       int n, i, sum = 0;
       printf("Enter the value of n:");
       scanf("%d", &n);
       for(i = 1; i <= n; i++) {
           sum += i;
       }
       printf("
   

Sum = %d", sum); }

These examples illustrate how control flow statements are used to manage the execution path of a program based on conditions and iterations, forming the backbone of decision-making in programming.

## 🖥️ Key Concepts and Programming Constructs in C

> 💡 Understanding the fundamental constructs and features of C programming is crucial for effective coding and problem-solving.

| Concept/Term                | Explanation                                     | Example                                        |
|-----------------------------|-------------------------------------------------|------------------------------------------------|
| **Pre-processor Directives**| Instructions for the compiler before actual compilation. | `#include <stdio.h>`                          |
| **Loop Control Statements** | Statements that control the flow of loops.     | `for`, `while`, `do-while`                   |
| **Data Types**              | Classification of data that determines the type of values a variable can hold. | `int`, `float`, `char`                       |

### Variable Declaration in C
- **Variables**: In C, variables are declared by specifying the data type followed by the variable name, e.g., `int count;`.
- **Scope**: The scope of a variable determines where it can be accessed in the code.
- **Initialization**: Variables can be initialized at the time of declaration, e.g., `int count = 0;`.

> ⚡ **Key Fact:** Variables must be declared before they can be used in C.

### Difference Between Postfix and Prefix Increment
- **Postfix Increment (x++)**: Increments the value of x after its current value is used in an expression. For example, if `x = 5`, then `y = x++` results in `y = 5` and `x = 6`.
- **Prefix Increment (++x)**: Increments the value of x before its current value is used in an expression. For example, if `x = 5`, then `y = ++x` results in `y = 6` and `x = 6`.

> 📝 **Definition:** **Postfix Increment** — An operation that increases the value after its current value is used.

### Control Flow Statements: While vs. Do-While
- **While Statement**: Evaluates the condition before executing the loop body. If the condition is false initially, the body may not execute at all.
- **Do-While Statement**: Executes the loop body at least once before evaluating the condition. This guarantees that the body runs even if the condition is false.

> ❓ **Quick Check:** What is the key difference between the while and do-while loops in terms of execution?