4.1 Introduction to Programming

4.1 Introduction to Programming

Introduction to Programming Fundamentals

Programming is the process of designing and building an executable computer program to accomplish a specific computing task or solve a particular problem. It involves writing instructions in a programming language that a computer can interpret and execute. This foundational unit introduces the core building blocks common to most procedural and structured programming languages, such as C. Understanding these elements—from the smallest lexical tokens to the structured flow of an algorithm—is essential for developing logical thinking, problem-solving skills, and the ability to translate real-world problems into precise, step-by-step computational solutions.

---

1. Basic Building Blocks: Tokens

Tokens are the smallest individual units in a program, analogous to words and punctuation in a natural language. A compiler recognizes these tokens during the lexical analysis phase.

1.1 Keywords (Reserved Words)

1. Definition: Predefined, reserved words that have special, fixed meanings in the language. They cannot be used as variable names or identifiers.

2. Characteristics:

   • They are always written in lowercase in languages like C.

   • They define the structure and flow of the program.

3. Examples (in C):

   • Control Flow: if, else, switch, case, for, while, do, break, continue, goto, return

   • Data Types: int, float, double, char, void, short, long, signed, unsigned

   • Storage Classes: auto, register, static, extern

   • Structure & Union: struct, union, typedef, enum

   • Others: const, sizeof, volatile

1.2 Identifiers

1. Definition: Names given by the programmer to various program elements like variables, functions, arrays, structures, etc.

2. Rules for Forming Identifiers:

   • Can consist of letters (a-z, A-Z), digits (0-9), and the underscore (_) character.

   • Must begin with a letter or an underscore.

   • Cannot be a keyword.

   • Are case-sensitive (e.g., sum, Sum, and SUM are different).

   • Should be meaningful (e.g., total_amount is better than ta).

3. Valid Examples: counter, _temp, student_name, calculateAverage, PI

4. Invalid Examples: 2nd_value (starts with digit), my-name (hyphen not allowed), float (is a keyword)

1.3 Literals (Constants)

1. Definition: Fixed values that are directly used in a program and cannot be changed during execution. They are also known as constants.

2. Types:

   • Integer Literals: Whole numbers (e.g., 25, -100, 0, 045 (octal), 0x2F (hexadecimal)).

   • Floating-point (Real) Literals: Numbers with decimal points or exponents (e.g., 3.14159, -0.001, 2.5e3 (=2500.0)).

   • Character Literals: A single character enclosed in single quotes (e.g., 'A', '7', '$', '\n' (newline)).

   • String Literals: A sequence of characters enclosed in double quotes (e.g., "Hello, World!", "A" (note: 'A' vs "A")).

   • Escape Sequences: Special character literals starting with a backslash \ (e.g., \n newline, \t tab, \\ backslash, \" double quote).

1.4 Operators

1. Definition: Symbols that tell the compiler to perform specific mathematical, relational, or logical operations.

2. Categories (Detailed in Section 6): Arithmetic (+, -, *, /, %), Assignment (=), Relational (<, >, ==, !=), Logical (&&, ||, !), etc.

---

2. Operators and Their Precedence

The order in which operations are evaluated in an expression is determined by operator precedence and associativity.

2.1 Operator Precedence Table (General for C-like languages, from highest to lowest)

Category	Operators	Associativity
Parentheses	() (Function call), [] (Array subscript)	Left to Right
Unary	++, --, +, - (unary), !, ~, * (indirection), & (address-of), sizeof, (type) (cast)	Right to Left
Multiplicative	*, /, %	Left to Right
Additive	+, - (binary)	Left to Right
Shift	<<, >>	Left to Right
Relational	<, <=, >, >=	Left to Right
Equality	==, !=	Left to Right
Bitwise AND	&	Left to Right
Bitwise XOR	^	Left to Right
Bitwise OR	|	Left to Right
Logical AND	&&	Left to Right
Logical OR	||	Left to Right
Conditional	?:	Right to Left
Assignment	=, +=, -=, *=, /=, %=, etc.	Right to Left
Comma	,	Left to Right

2.2 Key Concepts

1. Precedence: Determines which operator is evaluated first in an expression with multiple operators. Higher precedence operators are evaluated before lower ones.

   • Example: In a + b * c, * has higher precedence than +, so b * c is computed first.

2. Associativity: Determines the order of evaluation when operators of the same precedence appear in an expression.

   • Left-to-Right: Most operators (e.g., a + b + c => (a + b) + c).

   • Right-to-Left: Unary, assignment, and conditional operators (e.g., a = b = c => a = (b = c)).

3. Use of Parentheses: Parentheses () have the highest precedence and can be used to override the default precedence and explicitly define the order of evaluation. (a + b) * c forces the addition first.

---

3. Formatted and Unformatted Input/Output (I/O)

Input/Output operations are how a program communicates with the outside world (user, files).

3.1 Formatted I/O Functions

1. Definition: Functions that allow precise control over the format of data being read from or written to the standard console. They use format specifiers (%d, %f, %c, %s).

2. Output: printf()

   • Syntax: printf("format string", argument1, argument2, ...);

   • Example: printf("Value of x = %d and y = %.2f", x, y);

   • Common Format Specifiers:

     • %d or %i - Integer

     • %f - Float/Double

     • %c - Character

     • %s - String

     • %lf - Double (for scanf)

     • %u - Unsigned integer

     • %p - Pointer address

3. Input: scanf()

   • Syntax: scanf("format string", &variable1, &variable2, ...);

   • Crucial Note: The address-of operator (&) is required for basic variables (except strings represented as character arrays, where the array name is itself an address).

   • Example: scanf("%d %f", &num, &value);

3.2 Unformatted I/O Functions

1. Definition: Functions that handle data as streams of characters without any specific formatting. They are simpler and often used for single characters or strings.

2. For Characters:

   • Input: getchar(), getch(), getche() (read a single character from stdin).

   • Output: putchar() (write a single character to stdout).

   • Example:

     char ch;
     ch = getchar(); // Reads a character
     putchar(ch);    // Prints that character

3. For Strings:

   • Input: gets() (unsafe, deprecated), fgets() (safe - preferred).

   • Output: puts() (writes a string followed by a newline).

   • Example:

     char name[50];
     fgets(name, 50, stdin); // Reads a line safely
     puts(name);              // Prints the string

---

4. Programming Paradigms: Structured vs. Object-Oriented

4.1 Structured (Procedural) Programming

1. Core Concept: The program is divided into a set of functions or procedures that perform specific tasks. Data and functions are separate.

2. Characteristics:

   • Top-Down Design: Program is broken down from the main problem into smaller sub-problems (functions).

   • Emphasis on Algorithms: Focus is on the sequence of steps to solve the problem.

   • Data Flow: Data is often passed between functions via parameters.

   • Languages: C, Pascal, FORTRAN.

3. Advantages: Simple, logical, efficient for smaller tasks, easier to trace program flow.

4. Limitations: Data is globally accessible, leading to potential security and maintenance issues in large programs. Code reusability is limited.

4.2 Object-Oriented Programming (OOP) - Overview

1. Core Concept: The program is organized around objects that combine data (attributes/properties) and the functions (methods/behaviors) that operate on that data.

2. Key Principles (Pillars of OOP):

   • Encapsulation: Bundling data and methods into a single unit (class/object) and restricting direct access to some components.

   • Abstraction: Hiding complex implementation details and showing only essential features.

   • Inheritance: Creating new classes (derived) from existing ones (base), promoting code reusability.

   • Polymorphism: Ability of a single interface (function/method) to work for different data types or classes.

3. Languages: C++, Java, Python, C#.

4. Advantages: Better for large, complex software. Promotes code reuse, modularity, and easier maintenance. Models real-world entities effectively.

---

5. Problem Solving: Algorithm and Flowchart

5.1 Algorithm Development

1. Definition: A step-by-step, unambiguous, finite set of instructions to solve a specific problem or perform a computation. It is a plan for the program.

2. Characteristics:

   • Input: Zero or more well-defined inputs.

   • Output: At least one produced output.

   • Definiteness: Each step is clear and precise.

   • Finiteness: Must terminate after a finite number of steps.

   • Effectiveness: Each step must be basic enough to be carried out.

3. Example (Algorithm to find the largest of two numbers):

   1. Start.

   2. Read two numbers, A and B.

   3. If A > B, then set MAX = A.

   4. Else, set MAX = B.

   5. Print MAX.

   6. Stop.

5.2 Flowchart Representation

1. Definition: A graphical representation of an algorithm using standard symbols. It shows the flow of control.

2. Standard Symbols:

   • Terminal (Oval): Start/End of the program.

   • Process (Rectangle): Represents a computational step (e.g., calculation, assignment).

   • Input/Output (Parallelogram): For input and output operations.

   • Decision (Diamond): Represents a conditional branch (Yes/No, True/False).

   • Flowlines (Arrows): Show the direction of process flow.

   • Connector (Circle): Connects different parts of a flowchart.

3. Advantages: Easy to understand, good for communication and debugging logic errors before coding.

---

6. Data Types, Variables, and Constants

6.1 Data Types

1. Primitive (Fundamental) Data Types:

   • int: Stores integer numbers (e.g., int count = 10;).

   • float: Stores single-precision floating-point numbers (e.g., float pi = 3.14;).

   • double: Stores double-precision floating-point numbers, greater range and precision (e.g., double precise = 3.1415926535;).

   • char: Stores a single character (e.g., char grade = 'A';).

   • void: Represents "no type". Used for functions that return nothing or pointers to generic data.

2. Derived Data Types: Created from primitive types (Overview).

   • Arrays: Collection of elements of the same type (e.g., int marks[5];).

   • Pointers: Variables that store memory addresses (e.g., int *ptr;).

   • Structures (struct): Collection of variables of different types under one name.

   • Unions (union): Similar to structure, but all members share the same memory location.

6.2 Variables

1. Definition: A named memory location used to store data that can be changed during program execution.

2. Declaration: Informs the compiler about the variable's name and type.

   • Syntax: data_type variable_name; (e.g., int age;)

3. Initialization: Assigning an initial value at the time of declaration.

   • Syntax: data_type variable_name = value; (e.g., float total = 0.0;)

6.3 Constants

1. Definition: Named memory locations whose value cannot be altered after definition.

2. Using const keyword:

   • Syntax: const data_type CONSTANT_NAME = value;

   • Example: const float PI = 3.14159;

   • Attempting to change PI later will cause a compiler error.

3. Using #define Preprocessor Directive:

   • Syntax: #define CONSTANT_NAME value (No semicolon, no type specified).

   • Example: #define MAX_SIZE 100

   • This performs a textual substitution before compilation.

---

7. Operators in Detail

7.1 Arithmetic Operators

1. Purpose: Perform mathematical calculations.

2. Operators:

   • + (Addition)

   • - (Subtraction)

   • * (Multiplication)

   • / (Division) - Note: Integer division truncates the fractional part (e.g., 5 / 2 = 2).

   • % (Modulus) - Returns the remainder of integer division (e.g., 5 % 2 = 1). Operands must be integers.

7.2 Assignment Operators

1. Purpose: Assign a value to a variable.

2. Simple Assignment: = (e.g., x = 5;)

3. Compound Assignment: Combine an operation with assignment.

   • += (Add AND assign): x += 3; is equivalent to x = x + 3;

   • -=, *=, /=, %= (and others for bitwise operators).

7.3 Relational (Comparison) Operators

1. Purpose: Compare two values. The result is a Boolean value (true (1) or false (0) in C).

2. Operators:

   • == (Equal to)

   • != (Not equal to)

   • > (Greater than)

   • < (Less than)

   • >= (Greater than or equal to)

   • <= (Less than or equal to)

3. Used in: if conditions, while loops, etc. (e.g., if (a > b) { ... })

7.4 Logical Operators

1. Purpose: Combine or invert Boolean expressions.

2. Operators:

   • && (Logical AND): True only if both operands are true.

   • || (Logical OR): True if at least one operand is true.

   • ! (Logical NOT): Unary operator that reverses the logical state. !(true) is false.

---

8. Basic Input/Output Statements - Putting It Together

8.1 A Simple Program Skeleton

#include <stdio.h> // Header file for Standard I/O functions

int main() {       // Main function - program execution starts here
    // Variable Declarations
    int num1, num2, sum;
    
    // Input Statements
    printf("Enter first number: ");
    scanf("%d", &num1);
    printf("Enter second number: ");
    scanf("%d", &num2);
    
    // Processing Statement
    sum = num1 + num2; // Using Arithmetic and Assignment operators
    
    // Output Statement
    printf("The sum of %d and %d is: %d\n", num1, num2, sum);
    
    return 0; // Indicates successful termination
}

8.2 Key Takeaways from the Example

1. #include <stdio.h>: Essential for using printf and scanf.

2. int main(): The mandatory starting point.

3. Variable Declaration: int num1, num2, sum;

4. Formatted Output (Prompt): printf("Enter...");

5. Formatted Input: scanf("%d", &num1); Note the &.

6. Arithmetic & Assignment: sum = num1 + num2;

7. Formatted Output (Result): printf("The sum...", num1, num2, sum);

8. return 0;: Standard way to end main().

Conclusion: This unit provides the essential vocabulary and grammar of programming. Mastery of tokens, data types, operators, I/O, and the logical structuring of algorithms through flowcharts is the critical first step. These concepts are universal and form the bedrock upon which all subsequent programming knowledge—whether in structured languages like C or object-oriented languages—is built.