CSE 240: C & C++ Mastery Guide

Module 1: Paradigms, Errors, Processing & Macros

Programming Paradigms

• Imperative (Non-Declarative): Focuses on how to execute.
  • Procedural: C, FORTRAN. Based on functions/procedures.
  • Object-Oriented (OOP): C++, Java. Encapsulates data and behavior.
• Declarative: Focuses on what to execute.
  • Functional: LISP, Scheme. Avoids state changes and side effects.
  • Logic: Prolog. Uses facts and rules.

---

Program Error Types

• Contextual Error: A "type error" found by the compiler. E.g., `int x = "hello";`
• Semantic Error: A logic error found at runtime. E.g., division by zero.

---

Macros in C/C++

Macros perform text substitution during pre-processing. They avoid function call overhead but are prone to side effects.

// Define a macro to find the maximum value.
// Note the parentheses around the arguments and the whole expression to avoid operator precedence issues.
#define MAX(x, y) ((x) > (y) ? (x) : (y))

// --- SIDE EFFECT EXAMPLE ---
int a = 5;
int z = MAX(a++, 10);

// The preprocessor expands this to:
int z = ((a++) > (10) ? (a++) : (10)); 
// If a++ > 10 is true, 'a' would be incremented twice! This is unexpected behavior.
            

Module 2: Data Types & Basic I/O

Imperative Data & State

Data is represented by state: a collection of variables and their values. Key concepts:

• Address: An integer representing a memory location.
• Pointer: A variable that stores an address.
• Scope: The region of code where a variable is accessible.

---

Basic I/O

C-Style: `scanf` and `printf`

#include <stdio.h>
int num;
printf("Enter a number: ");
// scanf needs the ADDRESS (&) of a variable to store the input.
scanf("%d", &num); // %d is the format specifier for an integer.
printf("You entered: %d\n", num);
            

C++ Style: `cin` and `cout`

#include <iostream>
int num;
std::cout << "Enter a number: ";
std::cin >> num;
std::cout << "You entered: " << num << std::endl;
            

Module 3: Pointers, Arrays, Structs & New Types

Pointers

A variable that stores the memory address of another variable.

• & (Address-of Operator): Gets the memory address of a variable.
• * (Dereference Operator): Gets the value at the address a pointer is holding.

int score = 100;
int* scorePtr = &score; // Pointer holds the address of score.

// To change score's value via the pointer, you must dereference it.
*scorePtr = 150;
printf("New score: %d\n", score); // Prints "New score: 150"
            

---

Structs

A composite data type that groups variables. Access members with the dot operator (.).

struct Player {
    char name[50];
    int health;
};

void main() {
    struct Player p1;
    strcpy(p1.name, "Zelda");
    p1.health = 100;
}
            

Module 4: Padding, Files, Parameters & Linked Lists

Structure Padding

Compilers add invisible bytes within structs to align members to memory addresses that are multiples of the word size (e.g., 4 bytes). This improves CPU access speed.

---

Parameter Passing

• Pass-by-Value: Function gets a copy. Original variable is unchanged.
• Pass-by-Address (Pointer): Function gets the address. Can modify the original variable via dereferencing.
• Pass-by-Alias (Reference - C++): Function gets an alias. Modifies the original variable directly.

---

Linked Lists

A dynamic data structure where nodes are linked using pointers.

Node Structure & Traversal

struct Node {
    int data;
    struct Node* next; // Self-referential pointer.
};

// To traverse without losing the list, use a temporary pointer.
void printList(struct Node* head) {
    struct Node* temp = head;
    while (temp != NULL) {
        printf("%d -> ", temp->data);
        temp = temp->next; // Advance the temporary pointer.
    }
}
            

Module 5: Recursion & Recursive Data Structures

Recursion

A function that calls itself. Every recursive solution must have:

• A base case (stopping condition) to prevent infinite loops.
• A recursive step that moves the problem closer to the base case.

int factorial(int n) {
    // Base Case: The simplest problem we can solve.
    if (n <= 1) {
        return 1;
    }
    // Recursive Step: Solve a smaller version of the same problem.
    else {
        return n * factorial(n - 1);
    }
}
            

---

Binary Search Trees (BST)

A node-based structure where for any node, all keys in the left subtree are smaller, and all keys in the right subtree are larger.

• Search Complexity: $O(\log n)$ for a balanced tree. Very efficient. Degrades to $O(n)$ if unbalanced.
• Traversals:
  • Inorder (Left, Root, Right): Produces a sorted list of the data.
  • Preorder (Root, Left, Right)
  • Postorder (Left, Right, Root)

Module 6: OOP Basics & Memory Management

Memory Management in C/C++

• Stack: For local variables. Fast, automatic, limited size. Memory is freed when a function returns.
• Heap: For dynamic memory (malloc/new). Flexible, large, but requires manual management (free/delete).
• Memory Leak: Forgetting to free/delete heap memory.
• Dangling Pointer: A pointer to memory that has already been freed.

---

Classes, Constructors & Destructors (C++)

A class is a blueprint for objects.

• Constructor: Special function called when an object is created. Used for initialization.
• Destructor: Special function (~ClassName) called when an object is destroyed. Used for cleanup, especially freeing heap memory.

class Character {
public:
    // Constructor: allocates memory on the heap for the name.
    Character(const char* newName) {
        name = new char[strlen(newName) + 1];
        strcpy(name, newName);
    }

    // Destructor: frees the heap memory to prevent a leak.
    ~Character() {
        delete[] name;
    }
private:
    char* name;
};