Data Types, Variables, Constants: Fundamentals & Usage in C

Core Concepts: Data Types, Variables, and Constants

1. Data Types: The Blueprint of Data

Data types define the kind of data a variable can hold and the operations it supports. In C, they are categorized into basic (primitive) and derived types.

Basic Data Types

Why does this matter?

• Precision: float vs. double affects financial calculations (e.g., NEPSE stock prices).
• Memory: Smaller types (e.g., char) save memory in large datasets (e.g., Daraz product IDs).

(Shows how int occupies 4 bytes, float 4 bytes, and char 1 byte, with bit patterns for 42, 3.14, and 'A'.)

2. Variables: Named Storage Locations

Variables are containers that store data. They must be declared before use.

Rules for Variable Names

• Start with a letter or underscore (_).
• No spaces or special characters (except _).
• Case-sensitive (age ≠ Age).
• Cannot be a C keyword (e.g., int, float).

Example: Declaring Variables

int age = 25;          // Integer variable
float salary = 35000.50; // Floating-point variable
char grade = 'A';      // Character variable

Trace: Variable Initialization

In the real world

• Ncell Billing System: Uses int for call duration (minutes) and float for billing amounts (e.g., 3.50 NPR/minute).
• Daraz Inventory: Stores product quantities as int (e.g., stock[1001] = 50 for 50 units of a product).
• Bank Loan Calculations: Uses double for precise interest rates (e.g., 5.75% annual interest).

3. Constants: Immutable Values

Constants are fixed values that cannot be modified after initialization. They improve code readability and prevent accidental changes.

stateDiagram-v2
  [*] --> ReadOnly
  ReadOnly --> [*]: const variable
  state "ReadOnly" as RO
  RO --> RO : Attempt to modify
  note right of RO: Compile-time error
  note left of RO: Stored in read-only memory segment

Behavior of const variables in C (e.g., TAXRATE = 0.13 in Khalti transactions)

Types of Constants

1. Literal Constants: Direct values in code.

   int max_students = 100; // Literal constant
   

2. Symbolic Constants: Defined using #define (preprocessor directive).

   #define PI 3.14159
   #define MAX_SPEED 120
   

3. const Keyword: Ensures a variable’s value cannot be changed.

   const float TAX_RATE = 0.13; // VAT rate in Nepal
   

Example: Using Constants in a Program

#include <stdio.h>
#define DISCOUNT 0.10 // 10% discount for bulk orders

int main() {
    const int ORDER_LIMIT = 50; // Minimum order for discount
    int order_quantity = 60;
    float total = 1000.0;

    if (order_quantity >= ORDER_LIMIT) {
        total *= (1 - DISCOUNT);
    }
    printf("Final amount: %.2f\n", total);
    return 0;
}

Trace: Execution Flow

(Shows const variables in read-only memory segments, while regular variables can be modified.)

4. Type Modifiers: Extending Data Types

Modifiers alter the range or behavior of basic data types.

Example: Using unsigned for Counts

unsigned int product_count = 1000; // Cannot be negative

Why?

• NEPSE Stock Ticker: Uses unsigned int for share quantities (e.g., 1000 shares of NABIL).
• Khalti Transactions: Uses unsigned long for transaction IDs to avoid overflow.

5. Type Conversion: Explicit and Implicit

Implicit Conversion (Automatic)

Occurs when operands of different types are mixed. C promotes smaller types to larger ones to avoid data loss.

int a = 5;
float b = 3.14;
float result = a + b; // `a` is converted to `float` implicitly

Trace: Implicit Conversion

Explicit Conversion (Casting)

Forces a type change using (type) syntax.

float price = 99.99;
int discount = (int)price; // Truncates decimal part

Example: NTC Electricity Bill Calculation

float units_consumed = 250.5;
int billable_units = (int)units_consumed; // Truncate to 250 units
float cost = billable_units * 4.50;       // 4.50 NPR/unit
printf("Bill: %.2f NPR\n", cost);         // Output: 1125.00 NPR

flowchart TD
    A["Operation: int + float"] --> B["Implicit: int → float"]
    C["Operation: float → int"] --> D["Explicit: (int)float"]
    B --> E["Result: float"]
    D --> F["Result: int (truncated)"]

6. Variable Scope and Lifetime

Scope: Where a Variable is Accessible

Example: Scope in Action

#include <stdio.h>
int global = 10; // Global variable

void func() {
    int local = 20; // Local variable
    printf("Local: %d, Global: %d\n", local, global);
}

int main() {
    printf("Global in main: %d\n", global);
    func();
    return 0;
}

Output:

Global in main: 10
Local: 20, Global: 10

In the real world

• Pathao Driver App: Uses local variables for real-time trip details (e.g., float distance = 5.2; inside calculate_fare()).
• NTC Call Center: Global variables store system-wide constants (e.g., const float PENALTY_RATE = 0.20; for late payments).

In the real world

• Ncell Billing System: Uses int for call duration (minutes) and float for billing amounts (e.g., 3.50 NPR/minute) to balance precision and memory efficiency.
• Daraz Inventory: Stores product quantities as int (e.g., stock[1001] = 50 for 50 units of a product) to ensure non-negative counts and fast arithmetic.
• NTC Electricity Bill Calculation: Uses explicit casting (int) to truncate fractional units (e.g., 250.5 → 250 units) before applying the 4.50 NPR/unit rate.

Exam Tip

1. Memorize Key Ranges: Know the approximate ranges of int, float, and double for questions on overflow/underflow.
2. Practice Declarations: Write declarations for all basic types and modifiers (e.g., unsigned short int).
3. Trace Variable Changes: For programs with assignments/loops, show the state of variables after each step (like the traces above).
4. Constant Usage: Always use #define or const for magic numbers (e.g., 3.14 → #define PI 3.14).
5. Type Conversion Pitfalls: Watch for implicit conversions in arithmetic (e.g., int / int truncates decimals).
6. Scope Questions: Identify whether a variable is local/global and its lifetime in multi-function programs.

Worked Example for Exam Practice Problem: Write a program to calculate the total cost of a Daraz order with a 10% discount if the order exceeds 500 NPR. Use constants for the discount rate and threshold. Solution:

#include <stdio.h>
#define DISCOUNT_RATE 0.10
#define MIN_AMOUNT 500.0

int main() {
    float item_price = 250.0;
    int quantity = 3;
    float total = item_price * quantity;

    if (total >= MIN_AMOUNT) {
        total *= (1 - DISCOUNT_RATE);
    }
    printf("Total cost: %.2f NPR\n", total);
    return 0;
}

Trace:

Visual Summary

mindmap
  root((Data Types, Variables, Constants))
    Basic Types
      int["int: -2^31 to 2^31-1"]
      float["float: ±3.4e-38 to ±3.4e38"]
      char["char: -128 to 127 (signed)"]
    Modifiers
      unsigned["unsigned int: 0 to 2^32-1"]
      short["short int: -32768 to 32767"]
      long["long int: -2^63 to 2^63-1"]
    Variables
      Declaration["int age = 25;"]
      Scope["Local vs. Global"]
    Constants
      Literal["#define PI 3.14"]
      const["const float TAX = 0.13;"]
    Conversion
      Implicit["int + float → float"]
      Explicit["(int)float → truncated"]