CSE 240: The Guide

Programming Paradigms

A paradigm is a model or pattern for how we express computation. The two main branches are Imperative (how to execute) and Declarative (what to execute).

• Imperative/Procedural: The classic approach. You provide a step-by-step sequence of commands that change the program's state. (e.g., C, FORTRAN)
• Object-Oriented (OOP): An extension of imperative programming. Data and the code that operates on that data are bundled into "objects". (e.g., C++, Java, C#)
• Functional/Applicative: Treats computation as the evaluation of mathematical functions. It avoids changing state and mutable data (no side-effects). (e.g., Scheme, LISP)
• Logic/Declarative: You define a set of facts and rules. The computer uses logic to figure out the solution. The focus is on the goal, not the algorithm. (e.g., Prolog)

Macros vs. Functions

Both macros and functions are ways to reuse code, but they work very differently.

A macro is a preprocessor directive. It's a simple text substitution that happens *before* compilation. It's like a find-and-replace for your code.

// Macro definition
#define MAX(x, y) ((x) > (y) ? (x) : (y))

int a = 5, b = 10;
int m = MAX(a, b); // Preprocessor changes this to: int m = ((a) > (b) ? (a) : (b));

• Pros: Faster execution as there is no function call overhead. Code is "inlined".
• Cons (Side Effects): Arguments are evaluated every time they appear. MAX(a++, b++) will increment the variables multiple times, leading to unexpected behavior. The programmer is responsible for correctness. Parentheses are crucial to avoid operator precedence issues.

A function involves a proper function call. Execution jumps to the function's code, arguments are pushed to the stack, and a value is returned. It's safer but has a small performance overhead.

Data Types & Type Checking

A data type defines a set of allowed values and the operations that can be performed on them. C/C++ have several primitive types:

• char: A single character (typically 1 byte).
• int: An integer. Can be modified with short, long, signed, unsigned.
• float, double: Floating-point numbers with different precision.
• void: Represents the absence of a type.
• C++ adds bool (true/false) and wchar_t (wide character).

Type Checking ensures that operations are valid for the given types.

• Static Typing (C/C++): Types are checked at compile-time. Catches errors early.
• Dynamic Typing (Python, JS): Types are checked at run-time. More flexible, but errors might only appear during execution.
• Strong vs. Weak Typing: Refers to how strictly type rules are enforced. C++ is strongly typed (you can't add an int to a string without explicit conversion), while C is weaker (char and int can sometimes be used interchangeably).

Pointers: The Core Concept

A pointer is a variable that stores the memory address of another variable. The value of a pointer is an integer representing a location in memory.

• Referencing (`&`): The "address-of" operator. It gets the memory address of a variable. int* p = &myVar;
• Dereferencing (`*`): The "value-at-address" operator. It gets the value stored at the memory address the pointer is holding. int value = *p;

Pointers allow for indirect modification of data, which is essential for dynamic memory, data structures, and efficient function parameter passing.

int x = 10;   // A regular integer variable
int* ptr;   // A pointer to an integer

ptr = &x;   // ptr now holds the memory address of x

*ptr = 20;  // Dereference ptr to change the value AT that address.
            // This changes x to 20!

printf("Value of x is: %d\n", x); // Prints 20

Defining New Types: `struct`, `enum`, `typedef`

You can create your own custom data types.

• struct: A composite type that groups together variables of different types under a single name. Similar to a class in Java but traditionally only contains data.

struct Contact {
    char name[50];
    int phone;
};

struct Contact person1;
strcpy(person1.name, "Ada Lovelace");
person1.phone = 12345;

• enum: Creates a type where variables can only hold a specific set of named integer constants.

enum Day { MON, TUE, WED, THU, FRI, SAT, SUN }; // MON=0, TUE=1, ...
enum Day today = WED;

• typedef: Creates a synonym or alias for an existing type, making code more readable.

typedef unsigned long ulong;
ulong bigNumber = 1000000UL;

// Often used with structs to avoid typing 'struct' repeatedly
typedef struct Contact Person;
Person person2;

Parameter Passing

How data is passed to functions is crucial.

• Pass-by-Value: The function receives a *copy* of the argument's value. Changes inside the function do not affect the original variable. This is the default in C/C++.
• Pass-by-Address (Pointer): The function receives the memory *address* of the argument. By dereferencing this pointer, the function can directly modify the original variable.
• Pass-by-Alias (Reference - C++ only): The function receives an *alias* for the original variable. Syntactically it looks like pass-by-value, but it behaves like pass-by-address, allowing direct modification of the original.

// Pass-by-Value (y is a copy)
// Pass-by-Address (*x points to original)
void func(int *x, int y) {
    *x = *x + y; // Modifies the original variable x points to
    y = 2;       // Modifies only the local copy of y
}

int main() {
    int a = 10, b = 10;
    func(&a, b);
    // After call: a is 20, b is still 10
    printf("a: %d, b: %d\n", a, b); 
}

File I/O and Buffering

Reading from/writing to a disk is very slow. To improve performance, file operations use a buffer—a temporary storage area in memory. When you open a file with fopen(), a buffer is created. Data is read from the disk into the buffer in large chunks, or written from your program to the buffer. The buffer is only flushed (written) to the actual disk file when it's full or when you explicitly close the file with fclose().

Recursion

A function is recursive if it calls itself. A recursive solution must have two parts:

1. Base Case: A stopping condition that does not make a recursive call. This prevents infinite loops.
2. Recursive Step: The part of the function that calls itself, but on a smaller or simpler version of the problem.

// Recursive factorial function
int factorial(int n) {
    // Base Case
    if (n == 0) {
        return 1;
    }
    // Recursive Step
    else {
        return n * factorial(n - 1); // Solves a smaller problem
    }
}

While elegant, recursive calls use the stack for each call. Deep recursion can lead to a "stack overflow" error.

Object-Oriented Programming (OOP) in C++

OOP is a paradigm centered around objects. A class is a blueprint for creating objects. An object is an instance of a class.

Key Principles:

• Encapsulation: Bundling data (member variables) and the methods (member functions) that operate on the data into a single unit (the class).
• Information Hiding: Restricting access to certain members of an object. This is done with access specifiers: public, protected, and private. Data members are almost always kept private.
• Abstraction: Hiding the complex implementation details and showing only the essential features of the object.

Manual Memory Management & Garbage Collection

C++ does not have an automatic garbage collector. You, the programmer, are responsible for memory management.

• Memory Leak: Occurs when you allocate memory on the heap (with new or malloc) but forget to deallocate it (with delete or free). The memory remains reserved and unusable for the rest of the program's life.
• Dangling Pointer: A pointer that points to a memory location that has already been freed. Accessing a dangling pointer leads to undefined behavior.

The Rule of Thumb: For every new, there must be a corresponding delete. For every new[] (array allocation), there must be a corresponding delete[].

The best way to delete a dynamic data structure like a linked list or tree is to traverse it and delete each node one by one. For a tree, a post-order traversal is ideal for deletion, as it deletes children before their parent.